java es安装到使用，测试类添加@RunWith(SpringJUnit4ClassRunner.class)-优快云博客

本文链接：https://blog.youkuaiyun.com/csdndd521/article/details/147426552

安装完了后，导入依赖

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

创建索引


import com.tt.tt.pojoRepository.TestPersonRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

@Document(indexName = "test_index_person")
public class TestPerson{

    public TestPerson(String id, String personName, Integer personId, String gmtCreate, String gmtModified) {
        this.id = id;
        this.personName = personName;
        this.personId = personId;
        this.gmtCreate = gmtCreate;
        this.gmtModified = gmtModified;
    }
    public TestPerson() {

    }
    @Override
    public String toString() {
        return "TestPerson{" +
                "id='" + id + '\'' +
                ", personName='" + personName + '\'' +
                ", personId=" + personId +
                ", gmtCreate=" + gmtCreate +
                ", gmtModified=" + gmtModified +
                '}';
    }

    @Id
    private String id;

    @Field(type = FieldType.Text, analyzer = "ik_analyzer",name = "person_name")
    private String personName;
    @Field(type = FieldType.Integer,name = "person_id")
    private Integer personId;

    @Field(type = FieldType.Date,name = "gmt_create")
    private String gmtCreate;

    @Field(type = FieldType.Date,name = "gmt_modified")
    private String gmtModified;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getPersonName() {
        return personName;
    }

    public void setPersonName(String personName) {
        this.personName = personName;
    }

    public Integer getPersonId() {
        return personId;
    }

    public void setPersonId(Integer personId) {
        this.personId = personId;
    }

    public String getGmtCreate() {
        return gmtCreate;
    }

    public void setGmtCreate(String gmtCreate) {
        this.gmtCreate = gmtCreate;
    }

    public String getGmtModified() {
        return gmtModified;
    }

    public void setGmtModified(String gmtModified) {
        this.gmtModified = gmtModified;
    }
}

创建Elasticsearch的查询接口


import com.tt.tt.pojo.TestPerson;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface TestPersonRepository extends ElasticsearchRepository<TestPerson,Long> {
}

yml配置文件中，

spring:
  elasticsearch:
    uris: http://localhost:9200
    connection-timeout: 3s

然后创建测试类
需要添加@RunWith(SpringJUnit4ClassRunner.class) 注解，要不然TestPersonRepository 注入不进来

package com.tt.test;

import com.tt.xxfb.pojo.TestPerson;
import com.tt.xxfb.pojoRepository.TestPersonRepository;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.Avg;
import org.elasticsearch.search.aggregations.metrics.AvgAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.Max;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class Testt {

    @Autowired
    private TestPersonRepository testPersonRepository;

    @Autowired
    private ElasticsearchOperations elasticsearchOperations;

    /***
     * 添加
     */
    @Test
    public void test1(){
        TestPerson testPerson = new TestPerson("b","a",1,"a","a");
        System.out.println(testPerson);

        testPersonRepository.save(testPerson);
    }

    /***
     * 自定义 match 查询
     * 它会对指定字段进行分词处理，并基于分词后的结果匹配文档。
     * 搜索字段 title 包含 "apple phone" 的文档，实际可能匹配到 "apple" 或 "phone" 或两者。
     */
    @Test
    public void test6(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("person_name", "a");
        queryBuilder.withQuery(matchQueryBuilder);
        SearchHits<TestPerson> searchHits = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        searchHits.forEach(item ->{
            System.out.println(item);
        });
    }

    /***
     * 自定义 term 查询
     * select * from person where name = '张无忌';
     */
    @Test
    public void test7(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        TermQueryBuilder personId = QueryBuilders.termQuery("person_id", "1");
        queryBuilder.withQuery(personId);
        SearchHits<TestPerson> searchHits = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        searchHits.forEach(item ->{
            System.out.println(item);
        });
    }

    /***
     * 自定义 match_all 查询
     * SELECT * FROM table
     */
    @Test
    public void test8(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        queryBuilder.withQuery(matchAllQueryBuilder);
        SearchHits<TestPerson> searchHits = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        searchHits.forEach(item ->{
            System.out.println(item);
        });
    }

    /***
     * 自定义 match_phrase 查询
     * 查询文本的分词结果必须按顺序出现在文档中。 搜索 "quick brown fox" 时，文档必须包含连续的 quick → brown → fox，中间不能插入其他词
     * 如搜索固定的书名、地址或产品型号（"iPhone 15 Pro"）。
     */
    @Test
    public void test9(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        MatchPhraseQueryBuilder matchPhraseQueryBuilder = QueryBuilders.matchPhraseQuery("person_name", "小黑子");
        queryBuilder.withQuery(matchPhraseQueryBuilder);
        SearchHits<TestPerson> searchHits = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        searchHits.forEach(item ->{
            System.out.println(item);
        });
    }
    /***
     * 范围查询
     */
    @Test
    public void test10(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("gmt_create");
        rangeQuery.gte("2024-01-31T11:00:00");
        rangeQuery.lt("2024-07-31T11:00:00");
        queryBuilder.withQuery(rangeQuery);
        SearchHits<TestPerson> searchHits = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        searchHits.forEach(item ->{
            System.out.println(item);
        });
    }
    /***
     * 模糊匹配
     */
    @Test
    public void test11(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        FuzzyQueryBuilder fuzzyQueryBuilder = QueryBuilders.fuzzyQuery("person_name", "张三");
        queryBuilder.withQuery(fuzzyQueryBuilder);
        SearchHits<TestPerson> searchHits = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        searchHits.forEach(item ->{
            System.out.println(item);
        });
    }
    /***
     * 布尔查询 必须匹配(must) 过滤(filter) 至少匹配一个(should)
     */
    @Test
    public void test12(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 构建布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

        //布尔查询下添加must
        List<QueryBuilder> must = boolQueryBuilder.must();
        TermQueryBuilder personId = QueryBuilders.termQuery("person_id", "1");
        must.add(personId);

        //布尔查询下添加filter
        List<QueryBuilder> filter = boolQueryBuilder.filter();
        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("gmt_create");
        rangeQuery.gte("2024-07-31T10:00:00");
        filter.add(rangeQuery);

        //布尔查询下添加should
        List<QueryBuilder> should = boolQueryBuilder.should();
        TermQueryBuilder shouldTerm = QueryBuilders.termQuery("person_id", "111");
        should.add(shouldTerm);
        //布尔查询下添加must_not
        List<QueryBuilder> queryBuilders = boolQueryBuilder.mustNot();
        TermQueryBuilder mustNotTerm = QueryBuilders.termQuery("person_name", "哈哈哈");
        queryBuilders.add(mustNotTerm);

        //构建布尔查询语法，准备执行
        queryBuilder.withQuery(boolQueryBuilder);
        SearchHits<TestPerson> searchHits = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        searchHits.forEach(item ->{
            System.out.println(item);
        });
    }
    /***
     * 分页
     */
    @Test
    public void test13(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 查询全部
        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        queryBuilder.withQuery(matchAllQueryBuilder);


        Pageable pageable = PageRequest.of(0, 10, Sort.by("personId").descending());

        queryBuilder.withPageable(pageable);
        SearchHits<TestPerson> searchHits = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        searchHits.forEach(item ->{
            System.out.println(item);
        });
    }
    /***
     * 对查询出来的值进行聚合查询 统计每个唯一值的个数
     */
    @Test
    public void test14(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        //查询数据
        MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("person_name", "张三");
        queryBuilder.withQuery(matchQuery);
        //聚合数据
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("test_aggs").field("gmt_create");
        queryBuilder.addAggregation(termsAggregationBuilder);
        SearchHits<TestPerson> searchHits = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        searchHits.forEach(item ->{
            System.out.println(item);
        });
        Aggregations aggregations = searchHits.getAggregations();
        // 检查 aggregations 是否为 null
        if (aggregations != null) {
            // 第二步：通过聚合名称获取特定的聚合结果
            Terms testAggs = aggregations.get("test_aggs");
            // 检查特定聚合是否存在
            if (testAggs != null) {
                // 第三步：遍历聚合中的桶（buckets）
                for (Terms.Bucket bucket : testAggs.getBuckets()) {
                    // 获取桶的键（在这个例子中是 gmt_create 的值）
                    String keyAsString = bucket.getKeyAsString();
                    // 获取桶中文档的数量
                    long docCount = bucket.getDocCount();
                    // 打印或处理每个桶的结果
                    System.out.println("Key: " + keyAsString + ", DocCount: " + docCount);
                }
            }
        }
    }
    /***
     * 对查询出来的值进行聚合查询 统计每个唯一值的个数  仅仅返回聚合结果
     */
    @Test
    public void test15(){
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        //仅仅返回聚合结果
        queryBuilder.withPageable(PageRequest.of(0,1));
        //查询数据
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("person_name", "张三");
        queryBuilder.withQuery(matchQueryBuilder);
        //聚合
        TermsAggregationBuilder aggregationBuilder = AggregationBuilders.terms("test_aggs").field("gmt_create");
        queryBuilder.addAggregation(aggregationBuilder);
        //获取聚合信息
        SearchHits<TestPerson> search = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        Aggregations aggregations = search.getAggregations();
        if (aggregations != null){
            Terms terms = aggregations.get("test_aggs");
            List<? extends Terms.Bucket> buckets = terms.getBuckets();
            buckets.forEach(item ->{
                System.out.println("key:"+item.getKeyAsString()  +"===="+"doc_count:"+item.getDocCount());
            });
        }

    }
    /***
     * 多个聚合
     */
    @Test
    public void test16(){
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        //仅仅返回聚合结果
        queryBuilder.withPageable(PageRequest.of(0,1));
        TermsAggregationBuilder test_aggs = AggregationBuilders.terms("test_aggs").field("gmt_create");
        queryBuilder.addAggregation(test_aggs);
        AvgAggregationBuilder test_aggs2 = AggregationBuilders.avg("test_aggs2").field("person_id");
        queryBuilder.addAggregation(test_aggs2);
        SearchHits<TestPerson> search = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        Aggregations aggregations = search.getAggregations();
        if (aggregations != null){
            Terms test_aggs1 = aggregations.get("test_aggs");
            if (test_aggs != null){
                test_aggs1.getBuckets().forEach(item ->{
                    System.out.println("key:"+ item.getKeyAsString()+"===="+"doc_count:"+item.getDocCount());
                });
            }
            Avg test2_aggs = aggregations.get("test_aggs2");
            System.out.println( test2_aggs.getValue());
        }
    }
    /***
     * 子聚合 先分组，再计算
     */
    @Test
    public void test17(){
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        queryBuilder.withPageable(PageRequest.of(0,1));
        TermsAggregationBuilder test_aggs = AggregationBuilders.terms("test_aggs").field("gmt_create");
        test_aggs.subAggregation(AggregationBuilders.avg("son_aggs_test").field("person_id"));
        queryBuilder.addAggregation(test_aggs);
        SearchHits<TestPerson> search = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        Aggregations aggregations = search.getAggregations();
        Terms testAgges =  aggregations.get("test_aggs");
        testAgges.getBuckets().forEach(item ->{
            Avg aggregations1 = item.getAggregations().get("son_aggs_test");
            System.out.println("key:"+item.getKeyAsString()+"--doc_count:"+item.getKeyAsString()+"--son_aggs_test"+aggregations1.getValue());
        });
    }
    /**
     * 取聚合最大值
     */
    @Test
    public void test18(){
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        queryBuilder.addAggregation(AggregationBuilders.max("test_agg").field("person_id"));
        SearchHits<TestPerson> search = elasticsearchOperations.search(queryBuilder.build(), TestPerson.class);
        Aggregations aggregations = search.getAggregations();
        Max test_agg = aggregations.get("test_agg");
        System.out.println(test_agg.getValue());
    }
}