基于RestHighLevelClient的Elasticsearch的基本使用

旧城等待， 2021-11-23 10:54 833阅读 0赞

这是RestHighLevelClient的一些使用方式和笔记；

**一、版本选择**  
版本的选择一定要慎！Es的版本，ik的版本，以及高级客户端的包的版本一定要统一，不得不说兼容上还是做得很差的。版本的API差异还是很大。会导致一些问题例如NoSuchMethodInvoce的异常等等。  
附上maven

<dependency>
                <groupId>org.elasticsearch</groupId>
                <artifactId>elasticsearch</artifactId>
                <version>7.2.0</version>
            </dependency>
            <dependency>
                <groupId>org.elasticsearch.client</groupId>
                <artifactId>elasticsearch-rest-high-level-client</artifactId>
                <version>7.2.0</version>
            </dependency>

**二、创建客户端**  
官方文档一定是最有用的东西,附上地址 https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-create-index.html。 （注：以下方式都是采用官方文档的方式，版本可根据自己使用来选择）

properties配置

#elasticsearch配置
    elastic-search.clusterName=
    elastic-search.hostName=宿主机地址
    elastic-search.port=宿主机端口
    elastic-search.indices=
    elastic-search.types=

ElasticSearchConfig 代码

@Data
    @ConfigurationProperties(prefix = "elastic-search")
    @Configuration
    public class ElasticSearchConfig {
    
        //ES集群名,默认值
        private String clusterName;
    
        //ES集群中节点的域名或IP
        private String hostName;
    
        //ES连接端口号
        private Integer port;
    
        //ES查询的索引名称
        private String indices;
    
        //ES查询的Types
        private String types;
    }

注入客户端

@Configuration
    public class ElasticsearchBean {
    
        private final ElasticSearchConfig esConfig;
    
        @Autowired
        public ElasticsearchBean(ElasticSearchConfig esConfig) {
            this.esConfig = esConfig;
        }
    
        /**
         * @return 封装 RestClient
         */
        @Bean(destroyMethod = "close")
        public RestHighLevelClient restHighLevelClient(){
            return new RestHighLevelClient(RestClient.builder(new HttpHost(esConfig.getHostName(), esConfig.getPort(), "http")));
        }
    }

**@Bean(destroyMethod = “close”) 及时关闭资源非常重要，曾经遇到过不关闭资源导致整个服务器崩溃的问题**

**三、创建索引**  
有三种创建索引的方法：

这是ES使用HTTP的方式创建的列子

curl -XPOST http://localhost:9200/index/_mapping -H 'Content-Type:application/json' -d'
    {
            "properties": {
                "content": {
                    "type": "text",
                    "analyzer": "ik_max_word",
                    "search_analyzer": "ik_smart"
                }
            }
    
    }'

首先第一种以Map创建的方式

//CreateIndexRequest 实例， 需要注意包的版本 我这里用的7.2的版本 org.elasticsearch.client.indices;
            CreateIndexRequest request = new CreateIndexRequest(indexName);
            //封装属性 类似于json格式
            Map<String, Object> jsonMap = new HashMap<>();
            Map<String, Object> properties = new HashMap<>();
            Map<String, Object> content = new HashMap<>();
            content.put("type", "integer");
            Map<String, Object>account = new HashMap<>();
            content .put("type", "text");
            content .put("analyzer", "ik_max_word");
            properties.put("id", content);
            properties.put("account", account);
            jsonMap.put("properties", properties);
            //设置分片
       		request.settings(Settings.builder()
                    .put("index.number_of_shards", 3)
                    .put("index.number_of_replicas", 2)
            );
             request.mapping(jsonMap);
             //我使用的同步的方式 异步请参考官方文档
            CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
            if (!createIndexResponse.isAcknowledged()){
                throw new BusinessException("创建索引失败");
            }

第二种使用Builder的方式

XContentBuilder builder = XContentFactory.jsonBuilder();
            builder.startObject()
                        .startObject("mappings")
                            .startObject("properties")
                                .startObject("id")
                                    .field("type", "integer")
                                .endObject()
                                .startObject("account")
                                     .field("type", "text")
                                     .field("analyzer","ik_max_word")
                                     .field("search_analyzer","ik_smart")
                                 .endObject()
                            .endObject()
                        .endObject()
                        .startObject("settings")
                            .field("number_of_shards",3)
                             .field("number_of_replicas",1)
                         .endObject()
                    .endObject();
            request.mapping(builder); //版本不一样注意这个方法不一样，有些版本是source方法
            CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
            if (!createIndexResponse.isAcknowledged()){
                throw new BusinessException("创建索引失败");
            }

第三种以json的方式

request.mapping(
            "{\n" +
            "  \"properties\": {\n" +
            "    \"message\": {\n" +
            "      \"type\": \"text\"\n" +
            "    }\n" +
            "  }\n" +
            "}", 
            XContentType.JSON);
    CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
            if (!createIndexResponse.isAcknowledged()){
                throw new BusinessException("创建索引失败");
            }

**五、数据操作**  
需要注意的是，从Elasticsearch5.x开始就提出了弱化索引类型-type的使用，起初，我们说"索引"和关系数据库的“库”是相似的，“类型”和“表”是对等的。这是一个不正确的对比，导致了不正确的假设。在关系型数据库里,"表"是相互独立的,一个“表”里的列和另外一个“表”的同名列没有关系，互不影响。但在类型里字段不是这样的。  
举个例子，两个不同type下的两个user\_name，在ES同一个索引下其实被认为是同一个filed，你必须在两个不同的type中定义相同的filed映射。否则，不同type中的相同字段名称就会在处理中出现冲突的情况，导致Lucene处理效率下降。  
所以在Elasticsearch7.x就完全去除了type。每个索引的type默认且只有为\_doc。

**首先是新增**

public void save(User user) throws Exception{
            IndexRequest request = new IndexRequest(INDEX_NAME);
            request.id(user.getId());	//ID也可使用内部自动生成的 不过希望和数据库统一唯一业务ID
            request.source(JSON.toJSONString(user), XContentType.JSON);
         	restHighLevelClient.index(request, RequestOptions.DEFAULT);
        }

**获取**

public Object get(String id) {
            GetRequest getRequest = new GetRequest(INDEX_NAME, id);
            GetResponse getResponse = restHighLevelClient.get(getRequest,RequestOptions.DEFAULT);
                if (getResponse.isExists()) {
                    String sourceAsString = getResponse.getSourceAsString();
                    return sourceAsString;
                }
            return null;
        }

**删除**

public void delete(String id) {
           DeleteRequest request = new DeleteRequest(INDEX_NAME, String.valueOf(id));
           DeleteResponse deleteResponse = restHighLevelClient.delete(request,RequestOptions.DEFAULT);
                if (deleteResponse.status() == RestStatus.OK) {
                    logger.info("删除成功！id: {}", id);
                }
        }

增删改都非常的简单

**基本分页查询**

public Page<User> listPage(Pageable pageable, String coutent) throws Exception{
       	    //创建检索请求
        	SearchRequest searchRequest = new SearchRequest(INDEX_NAME);
       	    //创建搜索构建者
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            //设置构建搜索属性
            sourceBuilder.from(pageable.getPageNumber() * pageable.getPageSize()); // 需要注意这里是从多少条开始
            sourceBuilder.size(pageable.getPageSize()); //共返回多少条数据
            sourceBuilder.sort(new FieldSortBuilder("id").order(SortOrder.ASC)); //根据自己的需求排序
    
            if (!StringUtils.isEmpty(coutent)){
            //自定义组合查询
                BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
                TermQueryBuilder termQuery = QueryBuilders.termQuery(STATUS, STATUS);
                MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("coutent",coutent)
                        .fuzziness(Fuzziness.AUTO); //模糊匹配
                boolQueryBuilder.must(termQuery).must(queryBuilder);
                sourceBuilder.query(boolQueryBuilder);
            }
        	//传入构建进行搜索
            searchRequest.source(sourceBuilder);
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    		//处理结果
            RestStatus restStatus = searchResponse.status();
            if (restStatus != RestStatus.OK){
                throw new BusinessException("搜索错误");
            }
            List<User> list = new ArrayList<>();
            SearchHits hits = searchResponse.getHits();
            hits.forEach(item -> list.add(JSON.parseObject(item.getSourceAsString(), User.class)));
            return new PageImpl<>(list, pageable, hits.getTotalHits().value);
        }

**使用QueryBuilder的一些含义**

QueryBuilders.termQuery("key", obj) 完全匹配
    QueryBuilders.termsQuery("key", obj1, obj2..)   一次匹配多个值
    QueryBuilders.matchQuery("key", Obj) 单个匹配, field不支持通配符, 前缀具高级特性
    QueryBuilders.multiMatchQuery("text", "field1", "field2"..);  匹配多个字段, field有通配符忒行
    QueryBuilders.matchAllQuery();         匹配所有文件

Bool Query 用于组合多个叶子或复合查询子句的默认查询  
must 相当于 与 & =  
must not 相当于 非 ~ ！=  
should 相当于 或 | or  
filter 过滤

QueryBuilders.boolQuery()
            .must(termQuery("content", "test1"))
            .must(termQuery("content", "test4"))
            .mustNot(termQuery("content", "test2"))
            .should(termQuery("content", "test3"))
            .filter(termQuery("content", "test5"));

**高亮查询**

/**
         * 搜索入口 搜索结果处理
         */
        public Page<User> searchContent(Pageable pageable, String content) throws IOException{
            SearchResponse searchResponse = searchHighlight(pageable.getPageSize() * pageable.getPageNumber(), pageable.getPageSize(), content, "account", "name");
            List<User> list = Arrays.stream(searchResponse.getHits().getHits()).map(this::toHighLightUser).collect(Collectors.toList());
            return new PageImpl<>(list, pageable, searchResponse.getHits().getTotalHits().value);
        }
    
        /**
         * SearchHit 转换为高亮字段对象
         */
        private User toHighLightUser(SearchHit searchHit){
            User user = JSON.parseObject(searchHit.getSourceAsString(), User.class);
            Map<String, HighlightField> highlightFields = searchHit.getHighlightFields();
            if (!highlightFields.isEmpty()){
                HighlightField account = highlightFields.get("account");
                if (!StringUtils.isEmpty(account)){
                    user.setAccount(Arrays.stream(account.getFragments()).map(Text::string).collect(Collectors.joining("\n")));
                }
                HighlightField name = highlightFields.get("name");
                if (!StringUtils.isEmpty(name)){
                    user.setName(Arrays.stream(name.getFragments()).map(Text::string).collect(Collectors.joining("\n")));
                }
            }
            return user;
        }
    
        /**
         * 构建高亮字段 进行 多字段模糊查询
         */
        private SearchResponse searchHighlight(int from, int size, String content, String ... fields) throws IOException{
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            for (String field : fields){
                highlightBuilder.field(makeHighlightContent(field));
            }
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            //自定义条件
            boolQueryBuilder.should(QueryBuilders.multiMatchQuery(content, fields).fuzziness(Fuzziness.AUTO));
            boolQueryBuilder.should(QueryBuilders.wildcardQuery("account", "*" + content + "*"));
            boolQueryBuilder.should(QueryBuilders.wildcardQuery("name", "*" + content + "*"));
            return searchDocument(highlightBuilder, boolQueryBuilder , from , size);
        }
    
        /**
         * 构建SearchRequest, SearchSourceBuilder , 执行search方法
         */
        private SearchResponse searchDocument(HighlightBuilder highlightBuilder, QueryBuilder queryBuilder, int from, int size) throws IOException{
            SearchRequest searchRequest = new SearchRequest();
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            if (!ObjectUtils.isEmpty(highlightBuilder)){
                searchSourceBuilder.highlighter(highlightBuilder);
            }
            searchSourceBuilder.query(queryBuilder);
            searchSourceBuilder.from(from);
            searchSourceBuilder.size(size);
            searchRequest.source(searchSourceBuilder);
            return restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        }
    
        /**
         * 封装高亮查询字段
         */
        private HighlightBuilder.Field makeHighlightContent(String fieldName){
            HighlightBuilder.Field highlightContent = new HighlightBuilder.Field(fieldName);
            highlightContent.preTags("<span style=\"color:red\">");
            highlightContent.postTags("</span>");
            return highlightContent;
        }

（后续慢慢更新。。。。。）