ES的索引管理

Bertha 。 2022-12-04 02:24 126阅读 0赞

转载自 [ES的索引管理][ES]

### 6索引管理 ###

6.1 搭建工程

6.1.1 ES客户端

ES提供多种不同的客户端：

1、TransportClient  
ES提供的传统客户端，官方计划8.0版本删除此客户端。

2、RestClient  
RestClient是官方推荐使用的，它包括两种：Java Low Level REST Client和 Java High Level REST Client。  
ES在6.0之后提供 Java High Level REST Client， 两种客户端官方更推荐使用 Java High Level REST Client，不过当前它还处于完善中，有些功能还没有。  
我们准备采用 Java High Level REST Client，如果它有不支持的功能，则使用Java Low Level REST Client。  
1、添加依赖：

<dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch‐rest‐high‐level‐client</artifactId>
        <version>6.2.1</version>
    </dependency>
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>6.2.1</version>
    </dependency>

2、配置文件

server:
      port: ${port:40100}
    spring:
      application:
        name: xc-search-service
    xuecheng:
      elasticsearch:
        hostlist: ${eshostlist:127.0.0.1:9200} #多个结点中间用逗号分隔

3、配置类

@Configuration
    public class ElasticsearchConfig {
    
        @Value("${xuecheng.elasticsearch.hostlist}")
        private String hostlist;
    
        @Bean
        public RestHighLevelClient restHighLevelClient(){
            //解析hostlist配置信息
            String[] split = hostlist.split(",");
            //创建HttpHost数组，其中存放es主机和端口的配置信息
            HttpHost[] httpHostArray = new HttpHost[split.length];
            for(int i=0;i<split.length;i++){
                String item = split[i];
                httpHostArray[i] = new HttpHost(item.split(":")[0], Integer.parseInt(item.split(":")[1]), "http");
            }
            //创建RestHighLevelClient客户端
            return new RestHighLevelClient(RestClient.builder(httpHostArray));
        }
    
        //项目主要使用RestHighLevelClient，对于低级的客户端暂时不用
        @Bean
        public RestClient restClient(){
            //解析hostlist配置信息
            String[] split = hostlist.split(",");
            //创建HttpHost数组，其中存放es主机和端口的配置信息
            HttpHost[] httpHostArray = new HttpHost[split.length];
            for(int i=0;i<split.length;i++){
                String item = split[i];
                httpHostArray[i] = new HttpHost(item.split(":")[0], Integer.parseInt(item.split(":")[1]), "http");
            }
            return RestClient.builder(httpHostArray).build();
        }
    
    }

### 6.2创建索引库 ###

@SpringBootTest
    @RunWith(SpringRunner.class)
    public class TestSearch {
    
        @Autowired
        RestHighLevelClient restHighLevelClient;
        @Autowired
        RestClient restClient;
    
        @Test
        public void creatIndex() throws IOException {
            //创建索引请求对象
            CreateIndexRequest createIndexRequest = new CreateIndexRequest("xc_course");
            //设置索引参数
            createIndexRequest.settings(Settings.builder().put("number_of_shards",1).put("number_of_replicas",0));
            //设置映射
            createIndexRequest.mapping("doc","{\n" +
                    "\"properties\": {\n" +
                    "\"name\": {\n" +
                    "\"type\": \"text\",\n" +
                    "\"analyzer\":\"ik_max_word\",\n" +
                    "\"search_analyzer\":\"ik_smart\"\n" +
                    "},\n" +
                    "\"description\": {\n" +
                    "\"type\": \"text\",\n" +
                    "\"analyzer\":\"ik_max_word\",\n" +
                    "\"search_analyzer\":\"ik_smart\"\n" +
                    "},\n" +
                    "\"studymodel\": {\n" +
                    "\"type\": \"keyword\"\n" +
                    "},\n" +
                    "\"price\": {\n" +
                    "\"type\": \"float\"\n" +
                    "},\n" +
                    "\"timestamp\": {\n" +
                    "\"type\": \"date\",\n" +
                    "\"format\": \"yyyy‐MM‐dd HH:mm:ss||yyyy‐MM‐dd||epoch_millis\"\n" +
                    "}\n" +
                    "}\n" +
                    "}\n" ,XContentType.JSON);
            //链接客户端
            IndicesClient client = restHighLevelClient.indices();
            //创建响应对象
            CreateIndexResponse response = client.create(createIndexRequest);
            //响应
            boolean acknowledged = response.isAcknowledged();
            System.out.println(acknowledged);
    
    
        }
    
    
    
    
        @Test
        public void delIndex() throws IOException {
            //创建索引请求对象
            DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("xc_course");
            //链接客户端
            IndicesClient client = restHighLevelClient.indices();
            //删除索引
            DeleteIndexResponse delete = client.delete(deleteIndexRequest);
            //响应
            boolean acknowledged = delete.isAcknowledged();
            System.out.println(acknowledged);
    
    
        }
    
    }

### 6.3 添加文档 ###

@Test
        public void addDoc() throws IOException {
            //准备json数据
            Map<String, Object> jsonMap = new HashMap<>();
            jsonMap.put("name", "spring cloud实战");
            jsonMap.put("description", "本课程主要从四个章节进行讲解： 1.微服务架构入门 2.spring cloud 基础入门 3.实战Spring Boot 4.注册中心eureka。");
            jsonMap.put("studymodel", "201001");
            SimpleDateFormat dateFormat =new SimpleDateFormat("yyyy‐MM‐dd HH:mm:ss");
            jsonMap.put("timestamp", dateFormat.format(new Date()));
            jsonMap.put("price", 5.6f);
            //创建索引请求对象
            IndexRequest indexRequest = new IndexRequest("xc_course","doc");
            //指定索引添加文档
            indexRequest.source(jsonMap);
            //链接客户端
            IndexResponse indexResponse = restHighLevelClient.index(indexRequest);
            //获取响应结果
            DocWriteResponse.Result result = indexResponse.getResult();
            System.out.println(result);
    
        }

### 6.4 查询文档 ###

@Test
        public void queryDoc() throws IOException {
            GetRequest getRequest = new GetRequest("xc_course","doc","5W8t9WgBMHjTRj0U9GkF");
            GetResponse getResponse = restHighLevelClient.get(getRequest);
            boolean exists = getResponse.isExists();
            Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();
            System.out.println(sourceAsMap);
    
        }

### 7搜索管理 ###

7.1 准备环境

创建xc_course索引库。
    创建映射：
    post：http://localhost:9200/xc_course/doc/_mapping
    {
                    "properties": {
                        "description": {
                            "type": "text",
                            "analyzer": "ik_max_word",
                            "search_analyzer": "ik_smart"
                        },
                        "name": {
                            "type": "text",
                            "analyzer": "ik_max_word",
                            "search_analyzer": "ik_smart"
                        },
                        "pic":{
                            "type":"text",
                            "index":false
                        },
                        "price": {
                            "type": "float"
                        },
                        "studymodel": {
                            "type": "keyword"
                        },
                        "timestamp": {
                            "type": "date",
                            "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
                        }
                    }
                }
    
    
    初始化文档：
    
    http://localhost:9200/xc_course/doc/1
    {
    "name": "Bootstrap开发",
    "description": "Bootstrap是由Twitter推出的一个前台页面开发框架，是一个非常流行的开发框架，此框架集成了多种页面效果。此开发框架包含了大量的CSS、JS程序代码，可以帮助开发者（尤其是不擅长页面开发的程序人员）轻松的实现一个不受浏览器限制的精美界面效果。",
    "studymodel": "201002",
    "price":38.6,
    "timestamp":"2018-04-25 19:11:35",
    "pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
    }
    http://localhost:9200/xc_course/doc/2
    {
    "name": "java编程基础",
    "description": "java语言是世界第一编程语言，在软件开发领域使用人数最多。",
    "studymodel": "201001",
    "price":68.6,
    "timestamp":"2018-03-25 19:11:35",
    "pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
    }
    http://localhost:9200/xc_course/doc/3
    {
    "name": "spring开发基础",
    "description": "spring 在java领域非常流行，java程序员都在用。",
    "studymodel": "201001",
    "price":88.6,
    "timestamp":"2018-02-24 19:11:35",
    "pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
    }

7.3 DSL搜索

DSL(Domain Specific Language)是ES提出的基于json的搜索方式，在搜索时传入特定的json格式的数据来完成不同的搜索需求。  
DSL比URI搜索方式功能强大，在项目中建议使用DSL方式来完成搜索。

7.3.1 查询所有文档

@SpringBootTest
    @RunWith(SpringRunner.class)
    public class TestSearch {
    
        @Autowired
        RestHighLevelClient restHighLevelClient;
        @Autowired
        RestClient restClient;
    
    
        @Test
        public void queryAll() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //搜索方式
            //matchAllQuery搜索全部
            searchSourceBuilder.query(QueryBuilders.matchAllQuery());
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
        }
    }

7.3.2 分页查询

ES支持分页查询，传入两个参数：from和size。  
form：表示起始文档的下标，从0开始。  
size：查询的文档数量。

//分页查询
        @Test
        public void testSearchPage() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //设置分页参数
            //页码
            int page = 1;
            //每页记录数
            int size = 1;
            //计算出记录起始下标
            int from  = (page-1)*size;
            searchSourceBuilder.from(from);//起始记录下标，从0开始
            searchSourceBuilder.size(size);//每页显示的记录数
            //搜索方式
            //matchAllQuery搜索全部
            searchSourceBuilder.query(QueryBuilders.matchAllQuery());
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }

7.3.3 Term Query

Term Query为精确查询，在搜索时会整体匹配关键字，不再将关键字分词

//TermQuery
        @Test
        public void testTermQuery() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //设置分页参数
            //页码
            int page = 1;
            //每页记录数
            int size = 1;
            //计算出记录起始下标
            int from  = (page-1)*size;
            searchSourceBuilder.from(from);//起始记录下标，从0开始
            searchSourceBuilder.size(size);//每页显示的记录数
            //搜索方式
            //termQuery
            searchSourceBuilder.query(QueryBuilders.termQuery("name","spring"));
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }

7.3.4 根据id精确匹配

ES提供根据多个id值匹配的方法：

//根据id查询
        @Test
        public void testTermQueryByIds() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //搜索方式
            //根据id查询
            //定义id
            String[] ids = new String[]{"1","2"};
            searchSourceBuilder.query(QueryBuilders.termsQuery("_id",ids));
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }

7.3.9 排序

可以在字段上添加一个或多个排序，支持在keyword、date、float等类型上添加，text类型的字段上不允许添加排序。

//Sort
        @Test
        public void testSort() throws IOException, ParseException {
            //搜索请求对象
            SearchRequest searchRequest = new SearchRequest("xc_course");
            //指定类型
            searchRequest.types("doc");
            //搜索源构建对象
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    
            //boolQuery搜索方式
            //定义一个boolQuery
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            //定义过虑器
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));
    
            searchSourceBuilder.query(boolQueryBuilder);
            //添加排序
            searchSourceBuilder.sort("studymodel", SortOrder.DESC);
            searchSourceBuilder.sort("price", SortOrder.ASC);
            //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
            //向搜索请求对象中设置搜索源
            searchRequest.source(searchSourceBuilder);
            //执行搜索,向ES发起http请求
            SearchResponse searchResponse = client.search(searchRequest);
            //搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //得到匹配度高的文档
            SearchHit[] searchHits = hits.getHits();
            //日期格式化对象
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(SearchHit hit:searchHits){
                //文档的主键
                String id = hit.getId();
                //源文档内容
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                //由于前边设置了源文档字段过虑，这时description是取不到的
                String description = (String) sourceAsMap.get("description");
                //学习模式
                String studymodel = (String) sourceAsMap.get("studymodel");
                //价格
                Double price = (Double) sourceAsMap.get("price");
                //日期
                Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
    
        }

[ES]: https://www.jianshu.com/p/3cb80dcf514f