将“Elasticsearch“ 和 “SpringBoot“ 做整合，对 “ElasticsearchRestTemplate“ 的一些API做简单的测试。

本文链接：https://blog.csdn.net/momoxiaobaixh/article/details/122591875

以下的代码是基本所有的

QueryBuilders. 的方法做解释，并实现了简单测试差缺几个地理位置的查询因为不常用所以没有测试，有问题的可以评论，我会在周末做处理！测试数据直接链接：百度网盘https://pan.baidu.com/s/1xF_pKjRNgv4pWc1OEbRIbA?pwd=wjn0
提取码：wjn0

自己写一个全部数据导入用 PUT /bank/_doc/_bulk

package com.xh.spring_es.service.impl;

import com.xh.spring_es.bean.Bank;
import com.xh.spring_es.bean.Home;
import com.xh.spring_es.dao.BankDao;
import com.xh.spring_es.service.BankService;
import org.apache.lucene.search.join.ScoreMode;
import org.elasticsearch.common.lucene.search.function.FunctionScoreQuery;
import org.elasticsearch.index.query.*;
import org.elasticsearch.indices.TermsLookup;
import org.elasticsearch.script.Script;
import org.elasticsearch.script.ScriptType;
import org.elasticsearch.search.sort.SortBuilders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.geo.GeoPoint;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @Author hxh
 * @Description
 * @Date 2022/1/18
 */
@Service
public class BankServiceImpl implements BankService {


    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;

    /**
     * QueryBuilders.queryStringQuery("1") 数据库中存在某个值的全部查出来
     * 可以使用.field() 来限制字段
     */
    @Override
    public void searchTest01() {
        System.out.println("11111");
        //name: 为ES中保存的字段
        //QueryBuilders.queryStringQuery 数据库中存在某个值的全部查出来
        //
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.queryStringQuery("1"))
                .build();
        System.out.println(searchQuery.toString());
        //一般情况下，我们不是直接是new NativeSearchQuery，而是使用NativeSearchQueryBuilder。
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        System.out.println(search);
        for (SearchHit<Bank> bankSearchHit : search) {
            //SearchHit{id='1', score=1.0, sortValues=[], content=Bank(accountNumber=1, address=880 Holmes Lane, age=32, balance=39225, city=Brogan, email=amberduke@pyrami.com, employer=Pyrami, firstName=Amber, gender=M, lastName=Duke, state=IL), highlightFields={}}
            System.out.println(bankSearchHit);
        }
    }

    /**
     * 根据给定的字段的值的分词查询分词中在指定范围内的文档
     * 待查询的字段类型为text会分词
     * 待查询的值不会分词
     * QueryBuilders.rangeQuery("account_number") 查询某个范围的数据
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *     "range": {
     *       "待查询的字段": {
     *         "gte": "下限",
     *         "lte": "上限"
     *       }
     *     }
     *   }
     * }
     */
    public void searchTest02() {
        //QueryBuilders.rangeQuery("account_number") 查询某个范围的数据
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.rangeQuery("account_number")
                        .gte(10).lte(100))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        for (SearchHit<Bank> bankSearchHit : search) {
            System.out.println(bankSearchHit);
        }
    }

    /**
     * QueryBuilders.matchAllQuery() 查询所有的数据
     *
     * @return
     */
    public SearchHits<Bank> searchTest03() {
        //QueryBuilders.matchAllQuery() 查询所有的数据
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchAllQuery())
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * QueryBuilders.idsQuery().addIds("1","10","100","13") 根据ID集合查询对应数据
     *
     * @return
     */
    public SearchHits<Bank> searchTest04() {
        //QueryBuilders.idsQuery().addIds("1","10","100","13") 根据ID集合查询对应数据
        //Set<String> ids = QueryBuilders.idsQuery().ids();
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.idsQuery().addIds("1", "10", "100", "13"))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * QueryBuilders.matchBoolPrefixQuery("address","Lane") 匹配包含 Lane 的数据
     * 注意 "School Lane"和上面查出的结果一样 所以：
     * match_bool_prefix 查询内部将输入文本通过指定analyzer分词器处理为多个term，然后基于这些个term进行bool query，
     * 除了最后一个term使用前缀查询 其它都是term query。
     * 参数	                        说明
     * analyzer	                    指定terms文本分词器，默认是用mapping阶段指定的分词器
     * minimum_should_match	        指定匹配度，可以是[0,1]的小数，也可以是百分比
     * operator	                    指定多个term之间的匹配方式，and或者or
     * 查询语句：
     *
     * @return
     */
    public SearchHits<Bank> searchTest05() {
        //
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchBoolPrefixQuery("address", "Lane").analyzer("ik_max_word").minimumShouldMatch("20%").operator(Operator.OR).analyzer("").minimumShouldMatch("100%"))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * match_phrase_prefix query重要的不同点是，match_phrase_prefix query前缀匹配是以短语为最小粒度进行的，
     * 而 match_bool_prefix 如果不对相关度进行限制的话，它会匹配更多的内容。
     *
     * @return
     */
    public SearchHits<Bank> searchTest06() {
        //
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchPhrasePrefixQuery("address", "Sch"))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * QueryBuilders.matchPhraseQuery("address","School") 查询是匹配的整个字段
     * 和上面的区别在于 它是字段精确查询
     *
     * @return
     */
    public SearchHits<Bank> searchTest07() {
        //
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchPhraseQuery("address", "School"))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * QueryBuilders.matchQuery("firstname", "Amber") 整个字段精确查询
     * 这里注意 你的数据里面有空格的话  就自求多福  这里我测试不出来 所以换了没空格的字段测试
     *
     * @return
     */
    public SearchHits<Bank> searchTest08() {
        //
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchQuery("firstname", "Amber").operator(Operator.OR))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 测试不成功
     *
     * @return
     */
    public SearchHits<Bank> searchTest09() {
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                //.withQuery(QueryBuilders.moreLikeThisQuery(new String[]{"${account_number}"},new String[]{"${1}"},null))
                .withQuery(QueryBuilders.moreLikeThisQuery(new String[]{"lastname"}, new String[]{"Duke"}, null))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * QueryBuilders.multiMatchQuery("Duke", "firstname","lastname")  第一个参数是查询条件，之后的是字段  也就是说查询 Duke 在 "firstname","lastname" 字段中 有的数据
     * 创建一个匹配查询的布尔型提供字段名称和文本。
     *
     * @return
     */
    public SearchHits<Bank> searchTest10() {
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.multiMatchQuery("Duke", "firstname", "lastname"))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * QueryBuilders.nestedQuery("userList",nestedBoolQueryBuilder, ScoreMode.None) 嵌套查询 由于我的数据没有嵌套的所以 没有做测试
     * 有人测试成功可以评论
     * {
     *   "blackList":[],
     *   "id":"1",
     *   "name":"xx"
     * }
     *
     * @return
     */
    public SearchHits<Bank> searchTest11() {

        BoolQueryBuilder nestedBoolQueryBuilder = QueryBuilders.boolQuery();
        nestedBoolQueryBuilder.must(QueryBuilders.matchQuery("blackList.relationValue", ""));
        nestedBoolQueryBuilder.must(QueryBuilders.matchQuery("blackList.relationKey", ""));

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.nestedQuery("blackList", nestedBoolQueryBuilder, ScoreMode.None))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * withQuery(QueryBuilders.prefixQuery("firstname", "Duke")) 我在使用这个查时 有数据却查询不出来 大家可以多测试点字段
     * 包含与查询相匹配的文档指定的前缀。
     *
     * @return
     */
    public SearchHits<Bank> searchTest12() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.prefixQuery("email", "hattiebo"))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * QueryBuilders.regexpQuery("email","h.*l") 正则表达式查询  可以直接去 https://doc.codingdict.com/elasticsearch/265/ 学习
     * 注意 我的问题还是  使用 firstname 查询失效
     *
     * @return
     */
    public SearchHits<Bank> searchTest13() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.regexpQuery("email", "h.*l"))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 不会  看不懂  以后再学习 补全
     *
     * @return
     */
    public SearchHits<Bank> searchTest14() {
        Map<String, Object> params = new HashMap<>();
        params.put("param1", 2);
        Script script = new Script(ScriptType.INLINE, Script.DEFAULT_SCRIPT_LANG,
                "doc['自定字段'].value > params.param1", params);
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.scriptQuery(script))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 根据给定的字段的值的分词查询分词中符合查询字符串的文档
     * 待查询的字段类型为text会分词
     * 查询字符串会分词
     *
     * @return
     */
    public SearchHits<Bank> searchTest15() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.simpleQueryStringQuery("M"))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 查找符合big query条件的文档，之后筛选出包含little query的文档
     * 注意：所有span query的待查询的字段必须为同一个，不然会报异常
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *     "span_containing": {
     *       "little": {
     *         "待查询的字段": {
     *           "message": {
     *             "value": "待查询的值"
     *           }
     *         }
     *       },
     *       "big": {
     *         "span_near": {
     *           "clauses": [
     *             {
     *               "待查询的字段": {
     *                 "message": {
     *                   "value": "待查询的值"
     *                 }
     *               }
     *             },
     *             {
     *               "待查询的字段": {
     *                 "message": {
     *                   "value": "待查询的值"
     *                 }
     *               }
     *             }
     *           ],
     *           "slop": 1,
     *           "in_order": false
     *         }
     *       }
     *     }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest16() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.spanContainingQuery(
                        QueryBuilders.spanNearQuery(
                                QueryBuilders.spanTermQuery("email", "amberd"),
                                12).addClause(QueryBuilders.spanTermQuery("email", "hattie")),
                        QueryBuilders.spanTermQuery("email", "dalea")))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 查询出待查询的值在待查询的字段的值的分词中前end个位置的文档
     * 注意 不知道是分词库 还是 我的数据全是英文的缘故 导致 我原先的查询不成功 故 我新建了一个带中文数据的 查询结果正确
     * GET /student/_search
     * {
     *   "query": {
     *     "span_first": {
     *       "match": {
     *         "span_term": {
     *           "descr": "一"
     *         }
     *       },
     *       "end": 10
     *     }
     *   }
     * }
     *
     * @return 结果如下
     *"hits" : [
     *       {
     *         "_index" : "student",
     *         "_type" : "_doc",
     *         "_id" : "1",
     *         "_score" : 0.7870574,
     *         "_source" : {
     *           "name" : "红楼梦",
     *           "author" : "曹雪芹",
     *           "count" : 10000000,
     *           "on-sale" : "1985-01-01",
     *           "descr" : "一个是阆苑仙葩，一个是美玉无瑕"
     *         }
     *       },
     *       {
     *         "_index" : "student",
     *         "_type" : "_doc",
     *         "_id" : "jJ-7YX4BrQIFjbbFbHLm",
     *         "_score" : 0.7721133,
     *         "_source" : {
     *           "name" : "西游记",
     *           "author" : "吴承恩",
     *           "count" : 10000,
     *           "on-sale" : "2022-01-16",
     *           "descr" : "看俺老孙一棒"
     *         }
     *       }
     *     ]
     */
    public SearchHits<Bank> searchTest17() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.spanFirstQuery(
                        QueryBuilders.spanTermQuery("firstname", "Duke"),
                        4))
                .build();

        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 查找满足条件的文档
     * GET /student/_search
     * {
     *   "query": {
     *     "span_multi": {
     *       "match": {
     *         "wildcard": {
     *           "descr": "爱"
     *         }
     *       }
     *     }
     *   }
     * }
     *
     * @return
     */
    public SearchHits<Bank> searchTest18() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.spanMultiTermQueryBuilder(QueryBuilders.wildcardQuery("email", "amberduke@pyrami.com")))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 几个span query匹配的值的跨度必须在0-slop范围内，匹配的值的顺序必须和span query顺序一样
     * 注意：所有span query的待查询的字段必须为同一个，不然会报错
     * 我对最大跨度的理解是： 两个查询之间的单词数量不能超过slop个 比如 ： slop = 2 ; 我的内容是： "我和你一起去吃饭" ; 你的查询值是 "我" ,"饭" 之间的跨度就是 6 个了
     * GET /student/_search
     * {
     *   "query": {
     *     "span_near": {
     *       "clauses": [
     *         {
     *           "span_term": {
     *             "descr": {
     *               "value": "爱"
     *             }
     *           }
     *         },{
     *           "span_term": {
     *             "descr": {
     *               "value": "仇"
     *             }
     *           }
     *         }
     *       ],
     *       "slop": 2,
     *       "in_order": false
     *     }
     *   }
     * }
     *
     * @return
     */
    public SearchHits<Bank> searchTest19() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.spanNearQuery(QueryBuilders.spanTermQuery("email", "amberduke"),
                        12).addClause(QueryBuilders.spanTermQuery("email", "sss")))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 把include query查询结果中符合exclude query的文档排除后返回结果
     * 注意：include query和exclude query的待查询的字段必须为同一个，不然会报异常
     * 注意：include query和exclude query的span query都为span_term好像不会被拦截
     * 有趣的是  你把 两个的value 写成相同的  他就生效了  😄
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *     "span_not": {
     *       "include": {
     *         "span_term": {
     *           "descr": {
     *             "value": "一"
     *           }
     *         }
     *       },
     *       "exclude": {
     *         "span_term": {
     *           "descr": {
     *             "value": "棒"
     *           }
     *         }
     *       }
     *     }
     *   }
     * }
     *
     * @return
     */
    public SearchHits<Bank> searchTest20() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.spanNotQuery(QueryBuilders.spanTermQuery("email", "amberduke"),
                        QueryBuilders.spanTermQuery("email", "ss")))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 返回与任何span query匹配的文档
     * 注意：所有span query的待查询的字段必须为同一个，不然会报异常
     * es:
     * GET /student/_search
     * {
     *    "query": {
     *      "span_or": {
     *      "clauses": [
     *          span query array
     *         ]
     *      }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest21() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.spanOrQuery(QueryBuilders.spanTermQuery("email", "amberduke"))
                        .addClause(QueryBuilders.spanTermQuery("email", "ss")))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 等同于 term query ，但与其他Span查询一起使用
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *     "span_term": {
     *        "待查询的字段": {
     *           "value": "待查询的值"
     *         }
     *     }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest22() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.spanTermQuery("email", "amberduke"))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }


    /**
     * 查找符合big query条件且包含little query的文档
     * 注意：所有span query的待查询的字段必须为同一个，不然会报异常
     * es:
     GET /student/_search
     * {
     *   "query": {
     *     "span_within": {
     *       "little": {
     *         "span_term": {
     *           "待查询的字段": {
     *             "value": "待查询的值"
     *           }
     *         }
     *       },
     *       "big": {
     *         "span_near": {
     *           "clauses": [
     *             {
     *               "span_term": {
     *                 "待查询的字段": {
     *                   "value": "待查询的值"
     *                 }
     *               }
     *             },
     *             {
     *               "span_term": {
     *                 "待查询的字段": {
     *                   "value": "待查询的值"
     *                 }
     *               }
     *             }
     *           ],
     *           "slop": 1,
     *           "in_order": false
     *         }
     *       }
     *     }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest23() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.spanWithinQuery(QueryBuilders.spanNearQuery(
                        QueryBuilders.spanTermQuery("待查询的字段", "待查询的值"),
                        12).addClause(QueryBuilders.spanTermQuery("待查询的字段", "待查询的值")),
                        QueryBuilders.spanTermQuery("待查询的字段", "待查询的值")))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 根据给定的字段的值的分词查询分词中包含给定的值的文档
     * 待查询的字段类型为text会分词
     * 待查询的值不会分词
     * QueryBuilders.termQuery  查询字段匹配的数据
     *
     * @return
     */
    public SearchHits<Bank> searchTest24() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.termQuery("待查询的字段", "待查询的值"))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 根据给定的字段的值的分词查询分词中包含指定索引下指定id的文档的指定字段的值
     * 待查询的字段类型为text会分词
     * 待查询的值不会分词
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *     "terms": {
     *       "待查询的字段": {
     *         "index": "作为查询条件的索引",
     *         "id": "作为查询条件的文档的id",
     *         "path": "作为查询条件的字段"
     *       }
     *     }
     *   }
     * }
     *
     * @return
     */
    public SearchHits<Bank> searchTest25() {

        TermsLookup termsLookup = new TermsLookup("作为查询条件的索引", "作为查询条件的文档的id", "作为查询条件的字段");
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.termsLookupQuery("待查询的字段", termsLookup))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 根据给定的字段的值的分词查询分词中包含待查询的值（包含通配符，*：任意字符；?：任意一个字符）的文档
     * 注意：尽量别用*或?开头
     * 待查询的字段类型为text会分词
     * 待查询的值不会分词
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *     "wildcard": {
     *       "待查询的字段": {
     *         "value": "待查询的值（包含通配符，*：任意字符；?：任意一个字符）"
     *       }
     *     }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest26() {
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.wildcardQuery("待查询的字段", "待查询的值"))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }


    /**
     * 根据查询语句的base编码格式进行查询，例如：
     * eyJ0ZXJtIiA6IHsgIuW+heafpeivoueahOWtl+autSI6ICLlvoXmn6Xor6LnmoTlgLwiIH19 对应 {"term" : { "待查询的字段": "待查询的值" }}
     * 可以自己点到源码里面看看  它最后的方法是  this.source = source.getBytes(StandardCharsets.UTF_8);
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *      "wrapper": {
     *          "query": "base64编码格式的查询语句"
     *      }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest27() {
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.wrapperQuery("eyJ0ZXJtIiA6IHsgIuW+heafpeivoueahOWtl+autSI6ICLlvoXmn6Xor6LnmoTlgLwiIH19"))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 返回positive query的查询结果，如果positive query的查询结果也满足negative query，则改变其_source的值
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *    "boosting": {
     *      "positive": {
     *        指定用于查询的 query，最后返回结果必须满足 positive 对应的条件
     *      },
     *      "negative": {
     *        指定影响相关性算分的 query，
     *        如果positive query查询出来的文档同时满足 negative query，
     *        那么最终得分 = positive query 得分 * negative_boost
     *      },
     *      "negative_boost": 范围是 0 到 1.0
     *    }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest28() {
        QueryBuilder positiveQuery = QueryBuilders.wildcardQuery("待查询的字段", "待查询的值");
        QueryBuilder negativeQuery = QueryBuilders.wildcardQuery("待查询的字段", "待查询的值");
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.boostingQuery(positiveQuery, negativeQuery))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }


    /**
     * 查询满足条件的文档并返回指定的_source
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *     "constant_score": {
     *       "filter": {
     *         query
     *       },
     *       "boost": 1.2
     *     }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest29() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.constantScoreQuery(QueryBuilders.termQuery("待查询的字段", "待查询的值")).boost(1.2f))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }


    /**
     * 对子查询的结果做去重合并，score沿用子查询score的最大值
     * 待查询的字段类型为text会分词
     * 待查询的值会分词
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *    "dis_max": {
     *      "queries": [
     *          查询条件array
     *      ]
     *    }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest30() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.disMaxQuery()
                        .add(QueryBuilders.matchPhrasePrefixQuery("待查询的字段", "待查询的值"))
                        .add(QueryBuilders.matchPhraseQuery("待查询的字段", "待查询的值")))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     *{
     *   "query": {
     *     "bool": {
     *       "should": [
     *         {
     *           "multi_match": {
     *             "query": "mountain",
     *             "fields": [
     *               "description$string"
     *             ]
     *           }
     *         },
     *         {
     *           "bool": {
     *             "should": [
     *               {
     *                 "distance_feature": {
     *                   "field": "location$location",
     *                   "pivot": "1km",
     *                   "origin": [
     *                     -35.58,20.4
     *                   ],
     *                   "boost": 1
     *                 }
     *               },
     *               {
     *                 "distance_feature": {
     *                   "field": "date_established$date",
     *                   "pivot": "10d",
     *                   "origin": "now",
     *                   "boost": 10
     *                 }
     *               }
     *             ]
     *           }
     *         }
     *       ]
     *     }
     *   },
     *   "_source": {
     *     "includes": [
     *       "title$string",
     *       "location$location",
     *       "date_established$date"
     *     ]
     *   }
     * }
     * @return
     */
    public SearchHits<Bank> searchTest31() {
        //对于地理点
        GeoPoint geo = new GeoPoint(-35.58, 20.4);
        DistanceFeatureQueryBuilder.Origin origin = new DistanceFeatureQueryBuilder.Origin(String.valueOf(geo));
        DistanceFeatureQueryBuilder dfqb = new DistanceFeatureQueryBuilder("location$location", origin, "1km");
        //对于日期
        DistanceFeatureQueryBuilder.Origin origin1 = new DistanceFeatureQueryBuilder.Origin("now");
        DistanceFeatureQueryBuilder dfqb1 = new DistanceFeatureQueryBuilder("date_established$date", origin1, "10d");

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.distanceFeatureQuery("字段", origin, "1km"))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 查询文档中包含待查询字段的数据
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *     "exists": {
     *       "field": "待查询字段"
     *     }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest32() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.existsQuery("name"))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }


    /**
     * 具体不清楚是干嘛的，好像只能用于span query下，猜测是从已查询到的文档中过滤出符合该query的文档
     * 注意：所有span query的待查询的字段必须为同一个，不然会报异常
     * es:
     * GET index/_search
     * {
     *   "query": {
     *     "span_near": {
     *       "clauses": [
     *         {
     *           "span_term": {
     *             "待查询的字段": {
     *               "value": "待查询的值"
     *             }
     *           }
     *         },
     *         {
     *           "field_masking_span": {
     *             "query": {
     *               "span_term": {
     *                 "待查询的字段": {
     *                   "value": "待查询的值"
     *                 }
     *               }
     *             },
     *             "field": "待查询的字段"
     *           }
     *         }
     *       ],
     *       "slop": 12,
     *       "in_order": false
     *     }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest33() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.fieldMaskingSpanQuery(
                        QueryBuilders.spanTermQuery("待查询的字段", "待查询的值"),
                        "待查询的字段"))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 查询满足条件的文档但不对_source进行计算
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *    "function_score": {
     *      "query": {
     *        query
     *      }
     *    }
     *   }
     * }
     */
    public SearchHits<Bank> searchTest34() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.functionScoreQuery(
                        QueryBuilders.termQuery("待查询的字段", "待查询的值")))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 根据给定的字段的值的分词查询分词中包含给定的值在纠正指定次数（默认是2）后的文档
     * 待查询的字段不会分词
     * 待查询的值不会分词
     * es:
     * GET /student/_search
     * {
     *   "query": {
     *    "fuzzy": {
     *      "待查询的字段": {
     *        "value": "待查询的值，会被纠正",
     *        "fuzziness": 纠正次数
     *
     *      }
     *    }
     *   }
     * }
     * @return
     */
    public SearchHits<Bank> searchTest35() {

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.fuzzyQuery("待查询的字段", "待查询的值"))
                .build();
        SearchHits<Bank> search = elasticsearchRestTemplate.search(searchQuery, Bank.class);
        return search;
    }

    /**
     * 搜索矩形范围内的文档
     * 地理位置的就不做 测试了 一般使用不到
     *
     * @param top    最上边的纬度
     * @param left   最左边的经度
     * @param bottom 最下边的纬度
     * @param right  右边的经度
     */
    public SearchHits<Home> searchTest36() {
        double top = 37.779637;
        double left = 112.510492;
        double bottom = 37.72303;
        double right = 112.688716;
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.geoBoundingBoxQuery("location").setCorners(top, left, bottom, right))
                .build();
        SearchHits<Home> search = elasticsearchRestTemplate.search(searchQuery, Home.class);
        return search;
    }

}

实体类

package com.xh.spring_es.bean;

import lombok.Data;
import lombok.ToString;
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;

/**
 * @Author hxh
 * @Description
 * @Date 2022/1/18
 */
@Data
@ToString
@Document(indexName = "bank")
public class Bank {
    @Id
    @Field(type = FieldType.Text,name = "account_number")
    private Integer accountNumber;
    @Field(type = FieldType.Keyword,name = "address")
    private String address;
    private Integer age;
    private Integer balance;
    @Field(analyzer = "ik_max_word",type = FieldType.Text,name = "city")
    private String city;
    @Field(analyzer = "ik_max_word",type = FieldType.Text,name = "email")
    private String email;
    @Field(type = FieldType.Text,name = "employer")
    private String employer;
    @Field(analyzer = "ik_max_word",type = FieldType.Text,name = "firstname")
    private String firstName;
    @Field(type = FieldType.Text,name = "gender")
    private String gender;
    @Field(type = FieldType.Text,name = "lastname")
    private String lastName;
    @Field(type = FieldType.Text,name = "state")
    private String state;
}

yml文件可以选择使用ES配置类来获取连接

spring:
  elasticsearch:
    rest:
      uris: http://192.168.95.128:9200
      username: test
      password: test
  application:
    name: ES7
server:
  port: 8002

依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

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

package com.xh.spring_es.config;

import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.client.ClientConfiguration;
import org.springframework.data.elasticsearch.client.RestClients;
import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;

/**
 * @Author hxh
 * @Description     可以使用配置文件  也可以在yml文件配置
 * @Date 2022/1/17
 */
//@Configuration
//public class EsConfig extends AbstractElasticsearchConfiguration {
//    @Override
//    @Bean
//    public RestHighLevelClient elasticsearchClient() {
//        final ClientConfiguration clientConfiguration = ClientConfiguration.builder()
//                .connectedTo("192.168.8.101:9200")
//                .build();
//        return RestClients.create(clientConfiguration).rest();
//    }
//}