SpringBoot 整合 ES 进行各种高级查询搜索

这篇具有很好参考价值的文章主要介绍了SpringBoot 整合 ES 进行各种高级查询搜索。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

上一章:《ElasticSearch集群的搭建》


8.1 环境准备

如果你还未安装es的相关信息,请先移步至:《ElasticSearch安装》进行安装

如果您的SpringBoot项目还未整合es,请移步至:《SpringBoot整合ElasticSearch实现模糊查询,批量CRUD,排序,分页,高亮》

同时本文的操作中涉及到ElasticSearchRepository和ElasticsearchRestTemplate的使用,如果您还不是很理解他们是怎么使用的,请移步:《ElasticSearchRepository和ElasticsearchRestTemplate的使用》

如果以上内容您都有掌握或了解,那就继续向下学习吧

8.2 数据准备

因为本文都是数据的搜索,所以我们需要在我们的es服务器里先插入一些数据以供我们后面使用
esUserService


public interface EsUserService extends ElasticsearchRepository<User, Integer> {
}

@RestController
public class EsController {
    @Autowired
    private ElasticsearchRestTemplate elasticsearchTemplate;
    @Autowired
    private EsUserService esUserService;
    @Autowired
    private RestHighLevelClient client;

    private String[] names = {"诸葛亮", "曹操", "李白", "韩信", "赵云", "小乔", "狄仁杰", "李四", "诸小明", "王五"};
    private String[] infos = {"我来自中国的一个小乡村,地处湖南省", "我来自中国的一个大城市,名叫上海,人们称作魔都"
            , "我来自杭州,这是一个浪漫的城市"};

    /**
     * 准备数据
     *
     * @return
     */
    @GetMapping("prepareDate")
    public Object saveUser() {
        //添加索引mapping索引会自动创建但mapping自只用默认的这会导致分词器不生效 所以这里我们手动导入mapping
        Random random = new Random();
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            User user = new User();
            user.setId(i);
            user.setName(names[random.nextInt(9)]);
            user.setAge(random.nextInt(40) + i);
            user.setInfo(infos[random.nextInt(2)]);
            users.add(user);
        }
        Iterable<User> users1 = esUserService.saveAll(users);

        return users1;
    }
}

SpringBoot 整合 ES 进行各种高级查询搜索

下面开始我们本文的重点
由于我们需要频繁的使用map转对象,所以给大家一个比较好用的map转对象方法

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.math.BigDecimal;
import java.sql.ResultSet;
import java.util.Map;
import java.util.Objects;

/**
 * 利用反射讲数据转化为Object
 *
 * @param <T>
 */
public class BeanHandler<T> {
    private Class<T> clazz;

    public BeanHandler(Class<T> clazz) {
        this.clazz = clazz;
    }

    /**
     * 讲sql 查询结果 ResultSet转化为对象
     *
     * @param rs
     * @return
     * @throws Exception
     */
    public T handle(ResultSet rs) throws Exception {
        //结果集默认指向为第一个数据的前一个
        if (rs.next()) {
            //根据传入的字节码创建传入的指定对象
            T obj = clazz.newInstance();
            //获取指定字节码信息
            BeanInfo beanInfo = Introspector.getBeanInfo(clazz, Object.class);
            //获取所有属性描述器
            PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor pd : pds) {
                //获取结果集中对应字段名的值
                Object o = rs.getObject(pd.getName());
                //执行当前方法并传入参数
                pd.getWriteMethod().invoke(obj, o);
            }
            return obj;
        }
        return null;
    }

    /**
     * 将map 利用反射转化为对象
     *
     * @param map
     * @return
     * @throws Exception
     */
    public T handle(Map<String, Object> map) throws Exception {
        //结果集默认指向为第一个数据的前一个
        //根据传入的字节码创建传入的指定对象
        T obj = clazz.newInstance();
        BeanInfo beanInfo = Introspector.getBeanInfo(clazz, Object.class);
        PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();

        for (PropertyDescriptor pd : pds) {
            Object o = map.get(pd.getName());
            if (Objects.nonNull(o)) {
                // !!!这里需要对属性类型做强制类型转化,
                o = getPropertyTypeObject(pd, o);
                // 下面的方法相当于属性的 set方法
                pd.getWriteMethod().invoke(obj, o);
            }
        }
        return obj;
    }


    /**
     * 将对应的mapValue 强转为实体类对应的类型
     *
     * @param pd
     * @param o
     * @return
     */
    public Object getPropertyTypeObject(PropertyDescriptor pd, Object o) {
        //当前属性的类型
        String name = pd.getPropertyType().getName();
        name = name.substring(name.lastIndexOf(".") + 1);
        switch (name) {
            case "String":
                o = String.valueOf(o);
                break;
            case "Long":
                o = Long.valueOf(String.valueOf(o));
                break;
            case "Double":
                o = Double.valueOf(String.valueOf(o));
                break;
            case "Integer":
                o = Integer.valueOf(String.valueOf(o));
                break;
            case "BigDecimal":
                o = new BigDecimal(String.valueOf(o));
                break;
        }
        return o;
    }

}

8.3 单条件精确查询

 @PostMapping("singleConditionPreciseQuery")
    public Object singleConditionPreciseQuery(@RequestParam(value = "query") String query) throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.matchQuery("name", query));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        List<User> users = new ArrayList<>();
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

8.4 范围查询

  /**
     * 范围查询
     * 包括from、to
     *
     * @return
     */
    @PostMapping("rangeSearch1")
    public Object rangeSearch1(@RequestParam(value = "from") int from, @RequestParam(value = "to") int to) throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.rangeQuery("age").from(from).to(to));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查询结果
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

    /**
     * 范围查询
     * 不包括from、to
     *
     * @return
     */
    @PostMapping("rangeSearch2")
    public Object rangeSearch2(@RequestParam(value = "from") int from, @RequestParam(value = "to") int to) throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.rangeQuery("age").from(from, false).to(to, false));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查询结果
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

    /**
     * 范围查询
     * lt:小于,gt:大于
     *
     * @return
     */
    @PostMapping("rangeSearch3")
    public Object rangeSearch3(@RequestParam(value = "from") int from, @RequestParam(value = "to") int to) throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.rangeQuery("age").lt(to).gt(from));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查询结果
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

SpringBoot 整合 ES 进行各种高级查询搜索

8.5 模糊查询,支持通配符

    /**
     * 模糊查询,支持通配符
     *
     * @return
     */
    @PostMapping("vagueSearch")
    public Object vagueSearch(@RequestParam(value = "query") String query) throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.wildcardQuery("name", query));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

    /**
     * 不使用通配符的模糊查询,左右匹配
     *
     * @return
     */
    @PostMapping("vagueSearch1")
    public Object vagueSearch1(@RequestParam(value = "query") String query) throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.queryStringQuery(query).field("name"));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }
    /**
     * 多字段模糊查询
     *
     * @return
     */
    @PostMapping("vagueSearch2")
    public Object vagueSearch2(@RequestParam(value = "query") String query) throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.multiMatchQuery(query, "name", "info"));

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

8.6 排序

 /**
     * 排序
     *
     * @return
     */
    @PostMapping("sortSearch")
    public Object sortSearch(@RequestParam(value = "query") String query) throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.multiMatchQuery(query, "name", "info"))
                .sort("age", SortOrder.ASC);//按照年龄正序

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

8.7 精确统计筛选文档数

   /**
     * 精确统计筛选文档数,查询性能有所降低
     *
     * @return
     */
    @PostMapping("countSearch")
    public Object countSearch() throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .trackTotalHits(true);
        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查询结果
        return response;
    }

8.8 设置源字段过滤返回

    /**
     * 设置源字段过虑,第一个参数结果集包括哪些字段,第二个参数表示结果集不包括哪些字段
     *
     * @return
     */
    @PostMapping("filterSearch")
    public Object filterSearch() throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .fetchSource(new String[]{"name", "age"}, new String[]{"id", "info"});
        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

SpringBoot 整合 ES 进行各种高级查询搜索

通过上图的结果我们也可以看出:

  • 第一个参数结果集包括哪些字段
  • 第二个参数表示结果集不包括哪些字段

SpringBoot 整合 ES 进行各种高级查询搜索

8.9 根据 id 精确匹配

   /**
     * 根据Id精准查询
     *
     * @return
     */
    @PostMapping("searchByIds")
    public Object searchByIds(@RequestBody Map<String, Object> params) throws Exception {
        List<Integer> ids = (List<Integer>) params.get("ids");
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.termsQuery("_id", ids));
        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

8.10 matchAllQuery 搜索全部

   /**
     * matchAllQuery 搜索全部
     *
     * @return
     */
    @PostMapping("martchAllQuery")
    public Object martchAllQuery() throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.matchAllQuery());
        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

8.11 match 搜索匹配

   /**
     * match 搜索匹配
     *
     * @return
     */
    @PostMapping("martch")
    public Object martch(@RequestBody Map<String, Object> params) throws Exception {
        List<String> querys = (List<String>) params.get("querys");
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.matchQuery("name", querys));
        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

8.12 bool组合查询

    /**
     * bool组合查询
     *
     * @return
     */
    @PostMapping("boolSearch")
    public Object boolSearch(@RequestBody Map<String, Object> params) throws Exception {
        List<String> queryNames = (List<String>) params.get("names");
        int maxAge = (int) params.get("maxAge");
        int minAge = (int) params.get("minAge");

        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
        boolQueryBuilder.must(QueryBuilders.termsQuery("name", queryNames));
        boolQueryBuilder.must(QueryBuilders.rangeQuery("age").lte(maxAge).gte(minAge));
        builder.query(boolQueryBuilder);
        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

SpringBoot 整合 ES 进行各种高级查询搜索

8.13 nested类型嵌套查询

有时候,我们需要查询一个对象内部类的值,发现通过平时的查询查询不到数据,这时DSL(Domain Specific language,即特定领域专用语言)出场了!

elasticsearch中的内部对象无法按预期工作,这里的问题是elasticsearch(lucene)使用的库没有内部对象的概念,因此内部对象被扁平化为一个简单的字段名称和值列表。

    /**
     * nested类型嵌套查询
     *
     * @return
     */
    @PostMapping("nestedSearch")
    public Object nestedSearch() throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //条件查询
        BoolQueryBuilder mainBool=new BoolQueryBuilder();
        mainBool.must(QueryBuilders.matchQuery("name", "赵六"));
        //nested类型嵌套查询
        BoolQueryBuilder boolQueryBuilder=new BoolQueryBuilder();
        boolQueryBuilder.must(QueryBuilders.matchQuery("user.name", "A"));
        boolQueryBuilder.must(QueryBuilders.matchQuery("user.info", "浦东"));
        NestedQueryBuilder nested = QueryBuilders.nestedQuery("user",boolQueryBuilder, ScoreMode.None);
        mainBool.must(nested);
        builder.query(mainBool);
        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

8.14 多条件查询 + 排序 + 分页

    /**
     * 多条件查询 + 排序 + 分页
     *
     * @return
     */
    @PostMapping("multiConditionSearch")
    public Object multiConditionSearch() throws Exception {
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //条件搜索
        BoolQueryBuilder boolQueryBuilder=new BoolQueryBuilder();
        boolQueryBuilder.must(QueryBuilders.matchQuery
        ("name", "张").operator(Operator.AND);//需要 满足所有字段);
        boolQueryBuilder.must(QueryBuilders.rangeQuery("age").lte(30).gte(20));
        builder.query(boolQueryBuilder);
        //结果集合分页
        builder.from(0).size(2);

        //排序
        builder.sort("age",SortOrder.ASC);
        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 执行请求
        List<User> users = new ArrayList<>();
        for (SearchHit searchHit : response.getHits().getHits()) {
            Map<String, Object> map = searchHit.getSourceAsMap();
            BeanHandler<User> beanHandler = new BeanHandler<>(User.class);
            User user = beanHandler.handle(map);
            users.add(user);
        }
        // 解析查询结果
        return users;
    }

8.15 聚合查询

   /**
     * 求和
     *
     * @return
     */
    @PostMapping("sumSearch")
    public Object sumSearch() throws Exception {
        Map<String, Object> result = new HashMap<>();
        // 创建请求
        SearchSourceBuilder builder = new SearchSourceBuilder()
                .query(QueryBuilders.termsQuery("_id", new int[]{1, 2, 3}));
        //条件搜索
        //结果集合分页
        builder.from(0).size(2);
        builder.query(QueryBuilders.matchAllQuery());
        //聚合查询
        AggregationBuilder aggregation = AggregationBuilders.sum("sum_age").field("age");
        builder.aggregation(aggregation);

        //搜索
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");
        searchRequest.types("_doc");
        searchRequest.source(builder);
        // 执行请求
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析查询结果
        return response;
    }

SpringBoot 整合 ES 进行各种高级查询搜索

SpringBoot 整合 ES 进行各种高级查询搜索

值得我们注意的是在进行聚合操作的fild上,如果我们该字段设置成key或者text,则会出现以下错误
SpringBoot 整合 ES 进行各种高级查询搜索

原因是:

文本字段未针对需要每个文档字段数据(如聚合和排序)的操作进行优化,因此默认情况下禁用这些操作。

我们需要改用关键字字段。或者,在设置了text或者key的字段上设置fielddata=true,以便通过取消反转索引来加载字段数据。

请注意,这可能会占用大量内存


git地址:https://gitee.com/ninesuntec/es-better.git

PS:本章git上的代码如果有被注释掉的,只是为了防止和后面的章节不冲突,并无错误,大家自行解注查看即可文章来源地址https://www.toymoban.com/news/detail-413899.html

到了这里,关于SpringBoot 整合 ES 进行各种高级查询搜索的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • ElasticSearch系列 - SpringBoot整合ES之全文搜索匹配查询 match

    官方文档地址:https://www.elastic.co/guide/en/elasticsearch/reference/index.html 权威指南:https://www.elastic.co/guide/cn/elasticsearch/guide/current/structured-search.html 1. 数据准备 官方测试数据下载地址:https://download.elastic.co/demos/kibana/gettingstarted/accounts.zip ,数据量很大,我们自己构造数据吧。 2. m

    2023年04月08日
    浏览(52)
  • ES基础、高级特性及整合SpringBoot

            之前给服务器安好了ES和Kibana一直没来得及动手试试,这篇就系统性地介绍一下ES的基本使用和特性,以及如何将其与SpringBoot整合。         本文基于 ElasticSearch 7.5.0 + Kibana 7.5.0,版本一定要一致! 目录 1 什么是ElasticSearch? 2 ElasticSearch基本概念 2.1 ElasticSearch/Ki

    2024年02月05日
    浏览(41)
  • 【Elasticsearch】SpringBoot整合ES实现搜索功能 | 高亮显示

    先看代码: controller: serviceImpl: 小结 : 1、添加ES场景启动器 2、yaml配置ES 3、准备需要用到的变量 注:还有一个注入的RestHighLevelClient 结构如下: 具体调用的方法以及设置页码等参看代码。 加断点查看对应searchResponse数据结构: HighlightFields的数据结构: 对照kinaba结果: 3、根

    2024年02月11日
    浏览(45)
  • ElasticSearch系列 - SpringBoot整合ES:组合多个查询条件 bool 查询

    01. ElasticSearch 布尔查询是什么? 在实际应用中,我们很有可能会查询多个值或字段。 一个 bool 查询由三部分组成: must:所有的语句都必须(must) 匹配,与 AND 等价。 must_not:所有的语句都不能(must not)匹配,与 NOT 等价。 should:至少有一个语句要匹配,与 OR 等价。 02.

    2023年04月08日
    浏览(74)
  • ElasticSearch序列 - SpringBoot整合ES:范围查询 range

    01. ElasticSearch range查询是什么? Elasticsearch 中的 range 查询可以用于查询某个字段在一定范围内的文档。 range 查询可同时提供包含和不包含这两种范围表达式,可供组合的选项如下: gt : 大于(greater than) lt : 小于(less than) gte : = 大于或等于(greater than or equal to) lte : = 小于

    2024年02月09日
    浏览(43)
  • ElasticSearch系列 - SpringBoot整合ES:实现搜索结果排序 sort

    00. 数据准备 01. Elasticsearch 默认的排序方式是什么? ElasticSearch 默认的排序方式是相关性排序。相关性排序是根据查询条件与文档的匹配程度来计算每个文档的相关性得分,然后按照得分从高到低进行排序。相关性排序是 ElasticSearch 中最常用的排序方式,因为它可以根据查询

    2024年02月02日
    浏览(54)
  • 搜索引擎ElasticSearch分布式搜索和分析引擎学习,SpringBoot整合ES个人心得

    Elasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎,基于RESTful web接口。Elasticsearch是用Java语言开发的,并作为Apache许可条款下的开放源码发布,是一种流行的企业级搜索引擎。Elasticsearch用于云计算中,能够达到实时搜索,稳定,可靠,

    2024年02月04日
    浏览(72)
  • ElasticSearch序列 - SpringBoot整合ES:根据指定的 ids 查询

    1. ElasticSearch 根据 ids 查询文档 ① 索引文档,构造数据 ② 查询文档 id 为 1 或者 2 的文档: 我们索引文档时,文档的id为整型,为什么查询出来的文档 id为字符串类型呢?如果我们使用字符串类型的文档id查询呢? 可以看到仍然可以查询到匹配的文档。 在Elasticsearch中,文档

    2024年02月11日
    浏览(57)
  • ElasticSearch系列 - SpringBoot整合ES:多个精确值查询 terms

    ElasticSearch - SpringBoot整合ES:多个精确值查询 terms 01. ElasticSearch terms 查询支持的数据类型 在Elasticsearch中,terms查询支持多种数据类型,包括: 字符串类型:可以将多个字符串值作为数组传递给terms查询,以匹配包含任何一个指定字符串值的文档。 数值类型:可以将多个数值作

    2024年02月16日
    浏览(71)
  • 【ElasticSearch-基础篇】ES高级查询Query DSL术语级别查询并结合springboot使用

    Elasticsearch 提供了基于 JSON 的完整 Query DSL(Domain Specific Language)来定义查询。 因Query DSL是利用Rest API传递JSON格式的请求体(RequestBody)数据与ES进行交互,所以我们在使用springboot的时候也可以很方便的进行集成,本文主要讲述的就是使用springboot实现各类DSL的语法查询。 Elastics

    2024年02月01日
    浏览(52)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包