elasticsearch8的基本使用

第一步，导入依赖
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>8.17.3</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

第二步，连接
    @Configuration
    public class ElasticSearchClientConfig {
        //注入IOC容器
        @Bean
        public ElasticsearchClient elasticsearchClient(){
            RestClient client = RestClient.builder(new HttpHost("localhost", 9200,"http")).build();
            ElasticsearchTransport transport = new RestClientTransport(client,new JacksonJsonpMapper());
            return new ElasticsearchClient(transport);
        }
    }
增加index
  @Autowired
  private ElasticsearchClient client;
  
  @Test
    public void createTest() throws IOException {
        
        //写法比RestHighLevelClient更加简洁
        CreateIndexResponse indexResponse = client.indices().create(c -> c.index("user"));
    }
查询Index
    @Test
    public void queryTest() throws IOException {
        GetIndexResponse getIndexResponse = client.indices().get(i -> i.index("user"));
    }
判断index是否存在
    @Test
    public void existsTest() throws IOException {
        BooleanResponse booleanResponse = client.indices().exists(e -> e.index("user"));
        System.out.println(booleanResponse.value());
    }
删除index
@Test
    public void deleteTest() throws IOException {
        DeleteIndexResponse deleteIndexResponse = client.indices().delete(d -> d.index("user"));
        System.out.println(deleteIndexResponse.acknowledged());
    }
插入document
    @Test
    public void addDocumentTest() throws IOException {
 
        User user = new User("user1", 10);
        IndexResponse indexResponse = client.index(i -> i
                .index("user")
 
                //设置id
                .id("1")
 
                //传入user对象
                .document(user));
 
    }
更新Document
    @Test
    public void updateDocumentTest() throws IOException {
        UpdateResponse<User> updateResponse = client.update(u -> u
                        .index("user")
                        .id("1")
                        .doc(new User("user2", 13))
                , User.class);
    }
判断Document是否存在
    @Test
    public void existDocumentTest() throws IOException {
        BooleanResponse indexResponse = client.exists(e -> e.index("user").id("1"));
        System.out.println(indexResponse.value());
    }
查询Document
    @Test
    public void getDocumentTest() throws IOException {
        GetResponse<User> getResponse = client.get(g -> g
                        .index("user")
                        .id("1")
                , User.class
        );
        System.out.println(getResponse.source());
    }
删除Document
    @Test
    public void deleteDocumentTest() throws IOException {
        DeleteResponse deleteResponse = client.delete(d -> d
                .index("user")
                .id("1")
        );
        System.out.println(deleteResponse.id());
    }
批量插入Document
    @Test
    public void bulkTest() throws IOException {
        List<User> userList = new ArrayList<>();
        userList.add(new User("user1", 11));
        userList.add(new User("user2", 12));
        userList.add(new User("user3", 13));
        userList.add(new User("user4", 14));
        userList.add(new User("user5", 15));
        List<BulkOperation> bulkOperationArrayList = new ArrayList<>();
        //遍历添加到bulk中
        for(User user : userList){
            bulkOperationArrayList.add(BulkOperation.of(o->o.index(i->i.document(user))));
        }
     
        BulkResponse bulkResponse = client.bulk(b -> b.index("user")
                .operations(bulkOperationArrayList));
 
    }
搜索查询
String searchText = "自行车";

SearchResponse<Product> response = client.search(s -> s
    .index("products") 
    .query(q -> q      
        .match(t -> t   
            .field("name")  
            .query(searchText)
        )
    ),
    Product.class      
);

TotalHits total = response.hits().total();//total可以获取结果的总数
boolean isExactResult = total.relation() == TotalHitsRelation.Eq;

if (isExactResult) {
    logger.info("找到 " + total.value() + " 个结果");
} else {
    logger.info("找到超过 " + total.value() + " 个结果");
}

List<Hit<Product>> hits = response.hits().hits();
for (Hit<Product> hit: hits) {
    Product product = hit.source();
    logger.info("找到产品 " + product.getSku() + "，得分 " + hit.score());
}

分页查询
    @Test
    public void grepTextBook() throws IOException {
        SearchResponse<TextBook> matchSearch = client.search(s -> s
                        .index(index)
                        .query(q -> q
                                .match(t -> t
                                        .field("bookName")
                                        .query("老坛")
                                )
                        )
                        .from(1)
                        .size(100)
                        .sort(so -> so // 排序操作项
                                .field(f -> f // 排序字段规则
                                        .field("num")
                                        .order(SortOrder.Desc)
                                )
                        ),
                TextBook.class);
        for (Hit<TextBook> hit: matchSearch.hits().hits()) {
            TextBook pd = hit.source();
            System.out.println(pd);
        }
    }
match在匹配时会对所查找的关键词进行分词，然后按分词匹配查找。
        // 执行查询
        SearchResponse<Map> searchResponse = elasticsearchClient.search(srBuilder -> srBuilder
                .index("db_idx4")
                // match 查询：对输入内容先分词再查询。
                .query(queryBuilder -> queryBuilder
                        .match(matchQueryBuilder -> matchQueryBuilder
                            .field("address").query("王者打野")))
                , Map.class);

        //解析查询结果
        System.out.println(searchResponse);
精确查询Term
        // 执行查询
        SearchResponse<Map> searchResponse = elasticsearchClient.search(srBuilder -> srBuilder
                        .index("db_idx4")
                        // terms查询：对输入内容不做分词处理。
                        .query(queryBuilder -> queryBuilder
                                .term(termQueryBuilder -> termQueryBuilder
                                .field("address.keyword")
                                .value("三国演义小乔"))
                        )
                , Map.class);

        //解析查询结果
        System.out.println(searchResponse);
范围查询range
        // 执行查询
        SearchResponse<Map> searchResponse = elasticsearchClient.search(srBuilder -> srBuilder
                        .index("db_idx4")
                        // 范围查询Range
                        .query(queryBuilder -> queryBuilder
                                .range(rangeQueryBuilder -> rangeQueryBuilder
                                .field("age")
                                .gte(JsonData.of(18))
                                .lt(JsonData.of(23)))
                        )
                , Map.class);

        //解析查询结果
        System.out.println(searchResponse);