{
  "order": 0,                               // 模板优先级
  "template": "sample*",               // 模板匹配的名称方式
  "settings": {...},                        // 索引设置
  "mappings": {...},                        // 索引中各字段的映射定义
  "aliases": {...}                          // 索引的别名
}

（1）模板优先级：优先级越高，越优先执行，优先级高的会覆盖优先级的索引。

（2）模板匹配：当新建的索引时，所有以sample开头索引的会自动匹配该索引模板。

（3）索引设置：一般定义的有主分片，拷贝分片，自定义分析器，刷新时间，

一般分析器中有过滤器、分词器、标记过滤器。

映射字符过滤器（mapping char filter）、HTML过滤器（HTML Strip char filter）、格式替换过滤器（Pattern Replace char filter）。html_strip 字符过滤器去除所有的 HTML 标签。

（4）索引映射定义：有动态映射，自定义映射。

（5）索引别名：利用索引别名，可以实现零停机时间重新索引。

二传统数据库与ES之间对比

关系数据库	es
DataBase	index
Table	type
Row	Document
Column	Field

注：type 在es 7.0以后会为es创建唯一一个映射类型_doc

三以下的内容来源是 es的官网

第一类：是关于index模板的API

在Index APIs 是创建索引的也就是相当于创建库，

一 Document APIs中的方法

1 CreateIndexRequest：这个请求时创建一个索引，在es中的索引相当于mysql 中创建一个数据库（create database XX）。

settings()方法中会设置主分区，拷贝分区，刷新时间。

mapping()方法配置映射的。

aliases()方法是给模板请别名。

以下是测试方法，请准备好开发环境(下载安装es及其es head可视化工具)

 1 public final static String ES_COLLECTION_NAME="first";
 2 public ResponseData buildIndexDB() throws IOException {
 3         CreateIndexRequest createIndexRequest=new CreateIndexRequest();
 4         createIndexRequest.index(ES_COLLECTION_NAME);
 5         //setting中会设置主分区，拷贝分区，刷新时间
 6         createIndexRequest.settings(Settings.builder().put("index.number_of_shards","3")
 7                           .put("index.number_of_replicas","2"));
 8         Map<String,Object> message=new HashMap<>();
 9         message.put("type","text");
10         Map<String,Object> properties=new HashMap<>();
11         properties.put("message",message);
12         Map<String,Object> mapping=new HashMap<>();
13         mapping.put("mapping",mapping);
14         //动态映射
15         createIndexRequest.mapping( "{
" +
16                         "  "properties": {
" +
17                         "    "message": {
" +
18                         "      "type": "text"
" +
19                         "    }
" +
20                         "  }
" +
21                         "}",
22                 XContentType.JSON);
23         //起别名
24         createIndexRequest.aliases("hanqiang");
25         //可以为索引设置setting,mapping,aliases
26         /*createIndexRequest.source("{
" +
27                 "    "settings" : {
" +
28                 "        "number_of_shards" : 1,
" +
29                 "        "number_of_replicas" : 0
" +
30                 "    },
" +
31                 "    "mappings" : {
" +
32                 "        "properties" : {
" +
33                 "            "message" : { "type" : "text" }
" +
34                 "        }
" +
35                 "    },
" +
36                 "    "aliases" : {
" +
37                 "        "twitter_alias" : {}
" +
38                 "    }
" +
39                 "}", XContentType.JSON);*/
40         RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
41         CreateIndexResponse 
42 createIndexResponse=esClient.indices().create(createIndexRequest,RequestOptions.DEFAULT);
43         String name=createIndexResponse.index();
44         System.out.println("获得创建的索引名称 "+name);
45         RestClientConfig.close(esClient);
46         return ResponseData.success();
47     }
48  public ResponseData createIndex() throws IOException {
49         CreateIndexRequest createIndexRequest=new CreateIndexRequest();
50         createIndexRequest.index(ES_COLLECTION_NAME);
51         //对于索引设置setting属性
52         createIndexRequest.settings(Settings.builder()
53                 //主分片的个数
54                 .put("index.number_of_shards",3)
55                 //主分片的拷贝分片个数
56                 .put("index.number_of_replicas",2)
57         );
58         Map<String,Object> message=new HashMap<>();
59         message.put("type","text");
60         // message.put("analyzer","lowercase_analyzer");
61         // message.put("index","analyzed");
62         Map<String,Object> propertise=new HashMap<>();
63         propertise.put("message",message);
64         Map<String,Object> mapping=new HashMap<>();
65         mapping.put("propertise",propertise);
66         createIndexRequest.mapping(String.valueOf(mapping));
67         //以下是通过source方法直接就可以设置   settings,mappings,aliases
68         /*createIndexRequest.source("{
" +
69                 "    "settings" : {
" +
70                 "        "number_of_shards" : 1,
" +
71                 "        "number_of_replicas" : 0
" +
72                 "    },
" +
73                 "    "mappings" : {
" +
74                 "        "properties" : {
" +
75                 "            "message" : { "type" : "text" }
" +
76                 "        }
" +
77                 "    },
" +
78                 "    "aliases" : {
" +
79                 "        "twitter_alias" : {}
" +
80                 "    }
" +
81                 "}", XContentType.JSON);*/
82         RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
83         //同步
84         CreateIndexResponse createIndexResponse=esClient.indices().create(createIndexRequest,RequestOptions.DEFAULT);
85         //获取索引名称
86         String name=createIndexResponse.index();
87         //插入一条数据
88         Users user=new Users();
89         user.setAge(10);
90         user.setName("han");
91         esClient.index(new IndexRequest(name).source(user, XContentType.JSON),RequestOptions.DEFAULT);
92         //用完，之后一定养成关闭数据库的好习惯。
93         RestClientConfig.close(esClient);
94         return ResponseData.success();
95     }

2 DeleteIndexRequest是删除索引模板。

timeout()设置超时时间。

masterNodeTimeout()主节点超时时间。

1  public ResponseData deleteIndex() throws IOException {
2         DeleteIndexRequest deleteIndexRequest=new DeleteIndexRequest(ES_COLLECTION_NAME);
3         RestHighLevelClient esClient= RestClientConfig.restHighLevelClient();
4         AcknowledgedResponse deleteIndexResponse=esClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
5         //用完，之后一定养成关闭数据库的好习惯。
6         RestClientConfig.close(esClient);
7         return ResponseData.success(deleteIndexResponse);
8     }

3 GetIndexRequest判断索引是否存在

1  public ResponseData existsIndex() throws IOException {
2         GetIndexRequest getIndexRequest=new GetIndexRequest(ES_COLLECTION_NAME);
3         RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
4         Boolean flag=esClient.indices().exists(getIndexRequest,RequestOptions.DEFAULT);
5         //用完，之后一定养成关闭数据库的好习惯。
6         RestClientConfig.close(esClient);
7         return ResponseData.success(flag);
8     }

第二类：是关于插入文本的API

1 IndexRequest 添加文本数据

 1 public ResponseData saveDocument() throws IOException {
 2         //连接数据库
 3         RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
 4         Map<String,Object> jsonMap=new HashMap(2);
 5         jsonMap.put("name","han");
 6         jsonMap.put("age","19");
 7         jsonMap.put("sex","男");
 8         jsonMap.put("numberId","11XXXXXXX1213x");
 9         IndexRequest in=new IndexRequest(ES_COLLECTION_NAME).source(jsonMap, XContentType.JSON);
10         IndexResponse indexResponse=esClient.index(in, RequestOptions.DEFAULT);
11         //用完，之后一定养成关闭数据库的好习惯。
12         RestClientConfig.close(esClient);
13         return ResponseData.success(indexResponse);
14     }

2 BulkRequest 批量插入

  public ResponseData bulkDocument() throws IOException {
        //连接数据库
        RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
        BulkRequest bulkRequest=new BulkRequest();
        for(int i=0;i<6;i++){
            Map<String,Object> jsonMap=new HashMap();
            jsonMap.put("name","han*"+i);
            jsonMap.put("age","19*"+i);
            jsonMap.put("sex","男*"+i);
            jsonMap.put("numberId","11XXXXXXX1213*"+i);
            bulkRequest.add(new IndexRequest(ES_COLLECTION_NAME).source(jsonMap,XContentType.JSON));
        }
        BulkResponse bulkResponse=esClient.bulk(bulkRequest,RequestOptions.DEFAULT);
        //用完，之后一定养成关闭数据库的好习惯。
        RestClientConfig.close(esClient);
        return ResponseData.success(bulkResponse);
    }

2.1 批量操作

 1  public ResponseData bulkCustomDocument() throws IOException {
 2         //连接数据库
 3         RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
 4         BulkRequest bulkRequest=new BulkRequest();
 5         //修改指定数据
 6         Map<String,Object> jsonMap=new HashMap<>(5);
 7         jsonMap.put("name","bulkCustomDocument方法的测试");
 8         jsonMap.put("age","18测试");
 9         jsonMap.put("sex","男测试");
10         jsonMap.put("numberId","1502222XXXXX2");
11         UpdateRequest updateRequest=new UpdateRequest(ES_COLLECTION_NAME,"Un0QDHUB_jnDNOQPxN3B");
12         updateRequest.doc(jsonMap);
13         bulkRequest.add(updateRequest);
14         //删除指定数据
15         DeleteRequest deleteRequest=new DeleteRequest(ES_COLLECTION_NAME,"U30QDHUB_jnDNOQPxN3B");
16         bulkRequest.add(deleteRequest);
17 
18         BulkResponse bulkResponse=esClient.bulk(bulkRequest,RequestOptions.DEFAULT);
19         //用完，之后一定养成关闭数据库的好习惯。
20         RestClientConfig.close(esClient);
21         return ResponseData.success(bulkResponse);
22     }

3 UpdateRequest 修改操作

 1  public ResponseData updateDocument() throws IOException {
 2         //连接数据库
 3         RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
 4         //修改数据
 5         Map<String,Object> jsonMap=new HashMap(5);
 6         jsonMap.put("name","qiaa测试");
 7         jsonMap.put("age","20测试");
 8         jsonMap.put("sex","女测试");
 9         jsonMap.put("numberId","111222XXXXX2");
10         UpdateRequest updateRequest=new UpdateRequest(ES_COLLECTION_NAME,"QX0ODHUB_jnDNOQP9t0P");
11         updateRequest.doc(jsonMap);
12 
13         UpdateResponse updateResponse =esClient.update(updateRequest,RequestOptions.DEFAULT);
14         //用完，之后一定养成关闭数据库的好习惯。
15         RestClientConfig.close(esClient);
16         return ResponseData.success(updateResponse);
17     }

4 DeleteRequest 删除操作

 1  public ResponseData deleteDocument() throws IOException{
 2         //连接数据库
 3         RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
 4 
 5         DeleteRequest deleteRequest=new DeleteRequest(ES_COLLECTION_NAME,"OJuOv3QBEFBKZIVoeLzv");
 6         DeleteResponse deleteResponse=esClient.delete(deleteRequest,RequestOptions.DEFAULT);
 7         //用完，之后一定养成关闭数据库的好习惯。
 8         RestClientConfig.close(esClient);
 9         return ResponseData.success(deleteResponse);
10     }

5 GetRequest判断是否存在

 1  public ResponseData getDocument() throws IOException {
 2         //连接数据库
 3         RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
 4 
 5         GetRequest getRequest=new GetRequest(ES_COLLECTION_NAME,"Un0QDHUB_jnDNOQPxN3B");
 6         //由于exists()仅返回true或false，因此我们建议您关闭提取功能_source和所有存储的字段，这样请求的内容会稍微减轻一些
 7         getRequest.fetchSourceContext(new FetchSourceContext(false));
 8         //禁用获取存储的字段。
 9         getRequest.storedFields("_none_");
10         GetResponse getResponse=esClient.get(getRequest,RequestOptions.DEFAULT);
11         //用完，之后一定养成关闭数据库的好习惯。
12         RestClientConfig.close(esClient);
13         return ResponseData.success(getResponse);
14     }

第三类：是关于搜索文本的API

1 SearchRequest 查询全部数据

 1  public ResponseData searchAll() throws IOException {
 2         RestHighLevelClient esClient= RestClientConfig.restHighLevelClient();
 3 
 4         SearchRequest searchRequest=new SearchRequest(ES_COLLECTION_NAME);
 5         SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
 6         searchSourceBuilder.query(QueryBuilders.matchAllQuery());
 7         searchRequest.source(searchSourceBuilder);
 8 
 9         SearchResponse searchResponse=esClient.search(searchRequest, RequestOptions.DEFAULT);
10         //关闭连接
11         RestClientConfig.close(esClient);
12         return ResponseData.success(searchResponse);
13     }

2 多条件查询

 1  public ResponseData manySearch() throws IOException {
 2         RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
 3 
 4         MultiSearchRequest multiSearchRequest=new MultiSearchRequest();
 5 
 6         SearchRequest first=new SearchRequest(ES_COLLECTION_NAME);
 7         SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
 8         searchSourceBuilder.query(QueryBuilders.matchQuery("sex","女测试"));
 9         first.source(searchSourceBuilder);
10         multiSearchRequest.add(first);
11 
12         SearchRequest two=new SearchRequest(ES_COLLECTION_NAME);
13         SearchSourceBuilder searchSourceBuilder1=new SearchSourceBuilder();
14         searchSourceBuilder1.query(QueryBuilders.matchQuery("age","20"));
15         two.source(searchSourceBuilder1);
16         multiSearchRequest.add(two);
17 
18         MultiSearchResponse searchResponse=esClient.msearch(multiSearchRequest,RequestOptions.DEFAULT);
19         //关闭连接
20         RestClientConfig.close(esClient);
21         return ResponseData.success(searchResponse);
22     }

3 CountRequest 计数查询

 1   public ResponseData countSearch() throws IOException {
 2         RestHighLevelClient esClient=RestClientConfig.restHighLevelClient();
 3 
 4         CountRequest countRequest=new CountRequest(ES_COLLECTION_NAME);
 5         SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
 6         searchSourceBuilder.query(QueryBuilders.matchAllQuery());
 7         countRequest.source(searchSourceBuilder);
 8 
 9         CountResponse countResponse=esClient.count(countRequest,RequestOptions.DEFAULT);
10         //关闭连接
11         RestClientConfig.close(esClient);
12         return ResponseData.success(countResponse);
13     }

这是一个公共方法连接和关闭es

 1 @Configuration
 2 @Slf4j
 3 public class RestClientConfig {
 4 
 5     public static RestHighLevelClient restHighLevelClient(){
 6         RestHighLevelClient client=new RestHighLevelClient(
 7                 RestClient.builder(new HttpHost("127.0.0.1",9200,"http")));
 8         //如果是集群
 9 //        RestHighLevelClient client = new RestHighLevelClient(
10 //                RestClient.builder(new HttpHost("127.0.0.1", 9200, "http")
11 //                        , new HttpHost("127.0.0.1", 9201, "http")
12 //                        , new HttpHost("127.0.0.1", 9202, "http")));
13         return client;
14     }
15     /**
16      * 关闭es连接
17      * @param client es客户端
18      * @throws IOException io异常
19      */
20     public static void close(RestHighLevelClient client) {
21         try {
22             client.close();
23         } catch (IOException e) {
24             log.error("关闭es连接失败！",e);
25         }
26     }

es的总结 一 索引模板（用于通过模板匹配匹配到的所有索引） 详细请点击 二 传统数据库与ES之间对比 三 以下的内容来源是 es的官网

二 传统数据库与ES之间对比

三 以下的内容来源是 es的官网

相关推荐

es的总结一索引模板（用于通过模板匹配匹配到的所有索引）详细请点击二传统数据库与ES之间对比三以下的内容来源是 es的官网

二传统数据库与ES之间对比

三以下的内容来源是 es的官网