ES6.6.2 使用小结 - 封装ES常用的查询方法

最新推荐文章于 2024-08-30 16:23:11 发布
最新推荐文章于 2024-08-30 16:23:11 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： # ElasticSearch 大数据 软件/工具 文章标签： ElasticSearch 搜索引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BAStriver/article/details/88826684
版权

1.首先，接下来的查询demo里面包含了10常用的方法：term查询、terms查询、range查询、exists查询、prefix查询、wildcard查询、regexp查询、fuzzy查询、type查询、ids查询。

2.以下是封装了10个常用方法的QueryUtil：

package com.bas.util;

import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.index.query.QueryBuilder;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class QueryUtil {
    private static SearchHits hits;
    private static TransportClient client = ESUtil.getClient();

    /**
     * 打印常见信息
     */
    public static void print() {
        if (hits == null) {
            return;
        }
        System.out.println("-> totalHits: "+hits.totalHits);
        for (SearchHit hit : hits) {
            System.out.println("-----------");
            System.out.println("source:" + hit.getSourceAsString());
            System.out.println("index:" + hit.getIndex());
            System.out.println("type:" + hit.getType());
            System.out.println("id:" + hit.getId());
            //遍历文档的每个字段
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + "=" + map.get(key));
            }
            System.out.println("HighlightFields:" + hit.getHighlightFields());
            System.out.println("Fields:" + hit.getFields());
            System.out.println("MatchedQueries:" + hit.getMatchedQueries());
            System.out.println("InnerHits:" + hit.getInnerHits());
            System.out.println("-----------");
        }
    }

    /**
     * 执行查询
     *
     * @param query 查询器
     * @return 当前查询对象
     */
    private static List<Map<String, Object>> executeQuery(QueryBuilder query, String indexName, int size) {
        //搜索结果存入SearchResponse
        SearchResponse response = client.prepareSearch(indexName)
                .setQuery(query) //设置查询器
                .setSize(size)      //一次查询文档数
                .get();
        hits = response.getHits();
        if (hits == null) {
            return null;
        }

        List<Map<String, Object>> resultList = new ArrayList<>();
        for (SearchHit hit : hits) {
            resultList.add(hit.getSourceAsMap());
        }
        print();
        return resultList;
    }

    /**
     * Find documents which contain the exact term specified in the field specified.
     * 单个精确词项查询，内容有中文不能匹配
     * @param indexName 索引名
     * @param size 数据量
     * @param field 查询字段
     * @param termValue 单个词项内容
     * @return 结果集
     */
    public synchronized static List<Map<String, Object>> termQuery(String indexName, int size, String field, String termValue) {
        QueryBuilder qb = QueryBuilders.termQuery(field, termValue);
        return executeQuery(qb, indexName, size);
    }

    /**
     * Find documents which contain any of the exact terms specified in the field specified.
     * 多个精确词项查询，内容有中文不能匹配
     * @param indexName 索引名
     * @param size 数据量
     * @param field 查询字段
     * @param termValue 单个词项内容
     * @return 结果集
     */
    public synchronized static List<Map<String, Object>> termsQuery(String indexName, int size, String field, String ...termValue) {
        QueryBuilder qb = QueryBuilders.termsQuery(field, termValue);
        return executeQuery(qb, indexName, size);
    }

    /**
     * Find documents where the field specified
     * contains values (dates, numbers, or strings) in the range specified.
     * @param indexName 索引名
     * @param size 数据量
     * @param field 查询字段
     * @param from 起始时间
     * @param to 截止时间
     * @return 结果集
     */
    public synchronized static List<Map<String, Object>> rangeQuery(String indexName, int size, String field, String from, String to) {
        QueryBuilder qb = QueryBuilders.rangeQuery(field).from(from).to(to);
        return executeQuery(qb, indexName, size);
    }

    /**
     * Find documents where the field specified contains any non-null value.
     * 查找包含任何非空值的文档的指定字段
     * @param indexName 索引名
     * @param size 数据量
     * @param field 查询字段
     * @return 结果集
     */
    public synchronized static List<Map<String, Object>> existsQuery(String indexName, int size, String field) {
        QueryBuilder qb = QueryBuilders.existsQuery(field);
        return executeQuery(qb, indexName, size);
    }

    /**
     * Find documents where the field specified contains terms
     * which being with the exact prefix specified.
     * 匹配包含xx前缀的文档，内容有中文不能匹配
     * @param indexName 索引名
     * @param size 数据量
     * @param field 查询字段
     * @param prefixValue 前缀内容
     * @return 结果集
     */
    public synchronized static List<Map<String, Object>> prefixQuery(String indexName, int size, String field, String prefixValue) {
        QueryBuilder qb = QueryBuilders.prefixQuery(field, prefixValue);
        return executeQuery(qb, indexName, size);
    }

    /**
     * Find documents where the field specified contains terms
     * which match the pattern specified,
     * where the pattern supports single character wildcards (?)
     * and multi-character wildcards (*)
     * 通配符匹配查询，内容有中文不能匹配
     * @param indexName 索引名
     * @param size 数据量
     * @param field 查询字段
     * @param wildcardValue 包含通配符的内容
     * @return 结果集
     */
    public synchronized static List<Map<String, Object>> wildcardQuery(String indexName, int size, String field, String wildcardValue) {
        QueryBuilder qb = QueryBuilders.wildcardQuery(field, wildcardValue);
        return executeQuery(qb, indexName, size);
    }

    /**
     * Find documents where the field specified contains terms
     * which match the regular expression specified.
     * 正则匹配查询，内容有中文不能匹配
     * @param indexName 索引名
     * @param size 数据量
     * @param field 查询字段
     * @param regexpValue 包含正则的内容
     * @return 结果集
     */
    public synchronized static List<Map<String, Object>> regexpQuery(String indexName, int size, String field, String regexpValue) {
        QueryBuilder qb = QueryBuilders.regexpQuery(field, regexpValue);
        return executeQuery(qb, indexName, size);
    }

    /**
     * Find documents where the field specified contains terms
     * which are fuzzily similar to the specified term.
     * Fuzziness is measured as a Levenshtein edit distance of 1 or 2.
     * 模糊查询，内容有中文不能匹配
     * @param indexName 索引名
     * @param size 数据量
     * @param field 查询字段
     * @param fuzzyValue 模糊值
     * @return 结果集
     */
    public synchronized static List<Map<String, Object>> fuzzyQuery(String indexName, int size, String field, String fuzzyValue) {
        QueryBuilder qb = QueryBuilders.fuzzyQuery(field, fuzzyValue);
        return executeQuery(qb, indexName, size);
    }

    /**
     * Find documents of the specified type.
     * 查询指定type名的文档
     * @param indexName 索引名
     * @param size 数据量
     * @param type type名
     * @return 结果集
     */
    public synchronized static List<Map<String, Object>> typeQuery(String indexName, int size, String type) {
        QueryBuilder qb = QueryBuilders.typeQuery(type);
        return executeQuery(qb, indexName, size);
    }

    /**
     * Find documents with the specified type and IDs.
     * 根据指定的type和文档id查询
     * @param indexName 索引名
     * @param size 数据量
     * @param ids 文档的_id
     * @return 结果集
     */
    public synchronized static List<Map<String, Object>> idsQuery(String indexName, int size, String ...ids) {
        QueryBuilder qb = QueryBuilders.idsQuery(ids);
        return executeQuery(qb, indexName, size);
    }


}

其中，ES工具类位于：ES6.6.2 使用小结 - ES工具类使用 

3. 测试每个方法的测试类MatchQueryDemo如下：

package com.bas.demo;

import com.bas.util.ESUtil;
import com.bas.util.QueryUtil;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.junit.jupiter.api.Test;

import java.util.Map;

public class MatchQueryDemo {
    /**
     * 全量查询
     *
     * @param args
     */
    public static void main(String[] args) {
        TransportClient client = ESUtil.getClient();
        //构造查询对象
        QueryBuilder query = QueryBuilders.matchAllQuery();
        //搜索结果存入SearchResponse
        SearchResponse response = client.prepareSearch("app_account")
                .setQuery(query) //设置查询器
                .setSize(3)      //一次查询文档数
                .get();
        SearchHits hits = response.getHits();
        int count = 1;
        for (SearchHit hit : hits) {
            System.out.println("--------------------" + count++);
            System.out.println("source:" + hit.getSourceAsString());
            System.out.println("index:" + hit.getIndex());
            System.out.println("type:" + hit.getType());
            System.out.println("id:" + hit.getId());
            //遍历文档的每个字段
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + "=" + map.get(key));
            }
            System.out.println("--------------------\n");
        }
    }

    /**
     * 单个字段匹配查询
     */
    @Test
    public void matchQuery() {
        SearchHits hits;
        //构造查询对象
        QueryBuilder query = QueryBuilders.matchQuery(
                "title",
                "标题");
        SearchResponse response = ESUtil.getClient().prepareSearch("app_account")
                .setQuery(query) //设置查询器
                .setSize(5)      //一次查询文档数
                .get();
        hits = response.getHits();
        for (SearchHit hit : hits) {
            System.out.println("source:" + hit.getSourceAsString());
            System.out.println("index:" + hit.getIndex());
            System.out.println("type:" + hit.getType());
            System.out.println("id:" + hit.getId());
            //遍历文档的每个字段
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + "=" + map.get(key));
            }
            System.out.println("HighlightFields:" + hit.getHighlightFields());
            System.out.println("Fields:" + hit.getFields());
            System.out.println("MatchedQueries:" + hit.getMatchedQueries().length);
            System.out.println("InnerHits:" + hit.getInnerHits());
        }
    }

    /**
     * 操作符查询
     */
    @Test
    public void operatorQuery() {
        SearchHits hits;
        //构造查询对象
        QueryBuilder query = QueryBuilders.matchQuery(
                "title",
                "标题").operator(Operator.AND);
        SearchResponse response = ESUtil.getClient().prepareSearch("app_account")
                .setQuery(query) //设置查询器
                .setSize(5)      //一次查询文档数
                .get();
        hits = response.getHits();
        for (SearchHit hit : hits) {
            System.out.println("--------");
            System.out.println("source:" + hit.getSourceAsString());
            System.out.println("index:" + hit.getIndex());
            System.out.println("type:" + hit.getType());
            System.out.println("id:" + hit.getId());
            //遍历文档的每个字段
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + "=" + map.get(key));
            }
            System.out.println("HighlightFields:" + hit.getHighlightFields());
            System.out.println("Fields:" + hit.getFields());
            System.out.println("--------");
        }
    }

    /**
     * 多字段同时匹配查询
     * 内容有中文不能匹配
     */
    @Test
    public void multiMatchQuery() {
        SearchHits hits;
        //构造查询对象
        QueryBuilder query = QueryBuilders.multiMatchQuery(
                "bas",
                "title", "url");
        SearchResponse response = ESUtil.getClient().prepareSearch("app_account")
                .setQuery(query) //设置查询器
                .setSize(5)      //一次查询文档数
                .get();
        hits = response.getHits();
        for (SearchHit hit : hits) {
            System.out.println("source:" + hit.getSourceAsString());
            System.out.println("index:" + hit.getIndex());
            System.out.println("type:" + hit.getType());
            System.out.println("id:" + hit.getId());
            //遍历文档的每个字段
            Map<String, Object> map = hit.getSourceAsMap();
            for (String key : map.keySet()) {
                System.out.println(key + "=" + map.get(key));
            }
            System.out.println("HighlightFields:" + hit.getHighlightFields());
            System.out.println("Fields:" + hit.getFields());
        }
    }

    /**
     * 单个词项精确查询，内容有中文不能匹配
     */
    @Test
    public void termQuery() {
        QueryUtil.termQuery("app_account", 5, "url", "bas");
    }

    /**
     * 多个词项精确查询，内容有中文不能匹配
     */
    @Test
    public void termsQuery() {
//        QueryUtil.termsQuery("app_account", 5, "title.keyword", "更新title", "标题"); // 这样就可以匹配中文了，或者修改mapping的字段属性为不分词
        QueryUtil.termsQuery("app_account", 5, "title", "更新title", "标题");
    }

    @Test
    public void rangeQuery() {
        QueryUtil.rangeQuery("app_account", 100, "postdate", "2017-03-24", "2019-03-24");
    }

    @Test
    public void existsQuery() {
        QueryUtil.existsQuery("app_account", 100, "postdate");
    }

    /**
     * 匹配包含xx前缀的文档，内容有中文不能匹配
     */
    @Test
    public void prefixQuery() {
//        QueryUtil.prefixQuery("app_account", 100, "title.keyword","标题"); // 这样就可以匹配中文了
        QueryUtil.prefixQuery("app_account", 100, "title.keyword", "标题");
    }

    /**
     * 通配符匹配查询，内容有中文不能匹配
     */
    @Test
    public void wildcardQuery() {
//        QueryUtil.wildcardQuery("app_account", 100, "title.keyword", "标题*");
        QueryUtil.wildcardQuery("app_account", 100, "title", "标题*");
    }

    /**
     * 正则匹配查询，内容有中文不能匹配
     */
    @Test
    public void regexpQuery() {
//        QueryUtil.regexpQuery("app_account", 100, "title.keyword", "标题.*");
        QueryUtil.regexpQuery("app_account", 100, "title", "标题.*");
    }

    /**
     * 模糊查询，内容有中文不能匹配
     * 字段名加上.keyword也不能匹配中文
     */
    @Test
    public void fuzzyQuery() {
//        QueryUtil.fuzzyQuery("app_account", 100, "title.keyword", "标题");
        QueryUtil.fuzzyQuery("app_account", 100, "title", "asd");
    }

    @Test
    public void typeQuery() {
        QueryUtil.typeQuery("app_account", 5, "blog");
    }

    @Test
    public void idsQuery() {
        QueryUtil.idsQuery("app_account", 5, "asdasdcVcCKaQfGQ3", "52AbtWkBqLTNcYM2gf0z", "62AltWkBqLTNcYM27f2h");
    }

}

 

注：

1.应该会有不少人会发现，ES的查询器的有些方法可能会不能匹配中文，正如测试类的注释说的，在查询字段后加上：.keyword，如图：

2.如果不想每次增加.keyword来匹配中文内容，建立mapping 的时候可以设置"index": "not_analyzed"，这样也可以实现。

 

 

附(两篇和ES常用方法的文章)：

1.https://www.cnblogs.com/fclbky/p/7124469.html

2.https://www.jianshu.com/p/14ac79f93a38

 

BAStriver
关注
专栏目录
使用Map实现树状的查询
qq_40454655的博客
11-27 640
ES中表结构： 角色权限关联关系表： 权限表：权限表中有对应的父子关系 Java实现： 第一步：定义一个JavaBean： public class PrivilegeTreeBean implements Serializable { //节点的ID private Long privilegeId; // 节点的名字 private Strin...
ElasticSearch工具类封装
专注基础架构领域
01-10 2465
最近在项目中有看到一种比较实用的ElasticSearch工具类封装方式，特此记录便于日后查阅。 1、controller层 @RequestMapping(value = "/uri/page", method = RequestMethod.GET) public DataResult page( @RequestParam(name = "pageIndex") Integer pageIndex, @RequestParam(name = "pa...
【ES常用查询操作】
最新发布
weixin_46356409的博客
08-30 2336
"query": {在这个示例中，查询将匹配field1的值大于10的文档。
ElasticSearch读取查询结果（search）
热门推荐
节至
06-17 1万+
在es中所有的查询结果都会保存在SearchResponse中，在从SearchResponse中读取数据的时候，有两种方式：第一种是对Query的结果进行读取，使用的是hit，每一条查询到的doc都是一个hit，可以将每个hit转换为map形式的数据，map的具体形式为的形式，可以得到每一个字段的名称与内容（具体代码如下）； public static List getSC(Searc
解决ES searchHit.getHighlightFields()输出null数据到前端
m0_46378271的博客
07-25 2251
SearchHit类的hit对象是由search.getHits()得到的，而search是一个SearchResponse类。我们进入SearchHit类中查看hit.getHighlightFields()方法的源码，发现由于。最后不加高亮操作，直接转为json，然后转为对象，前端也正常了。发现其getHits()是另一个类中的hit()因此这里的Map自然也就什么都接不到了，此时的hit是一个SearchHit对象。，经过调试排查发现获取为null。，此方法会返回null。分页，遍历搜索的结果。...
ElasticSearch（项目中常用的ES）
pandie的博客
10-02 1047
Elasticsearch是一个搜索服务器，它的作用就是完成数据的查询。
elasticsearch-6.6.2.tar.gz
05-16
Elasticsearch 将 Lucene 的强大功能封装在易于使用的 RESTful API 之下，使得开发者能够轻松地进行索引、搜索、分析和聚合操作。其分布式特性意味着数据可以被自动分片并在多个节点间进行复制，确保高可用性和容错...
Elasticsearch封装RestHighLevelClient的使用工具包
haohaodaren的博客
11-01 1784
pretty-elasticsearch-core pretty-elasticsearch-core是基于elasticsearch 6.5.3版本的RestHighLevelClient使用工具包，可整合到spring 4.0以上的版本中。 最大的优点是快速整合，如果你只用连接单个集群，那么你只需要做三个动作： 1）加入配置文件 2）给索引对应的实体加上两个注解 ...
SpringBoot集成ElasticSearch
欢迎来到我的博客
07-20 578
需要注意的是，这段代码中的 RestHighLevelClient 实例是一个单例对象，只需要在应用程序启动时创建一次即可，因此这个类应该被配置为一个 Spring Bean，以便在需要时注入到其他类中使用。其中 RestHighLevelClient 是 Elasticsearch Java 客户端的高级别别名，是基于 LowLevelClient 之上的封装，提供了一些更加方便的方法和功能。第一步，导入jar包，注意这里的jar包版本可能和你导入的不一致，所以需要修改。第四步，编写util类。
Elasticsearch入门 - 简单上手
BrightMoons的博客
10-28 737
1.1ES简介 ES是使用java 语言并且基于lucence编写的搜索引擎框架，他提供了分布式的全文搜索功能，提供了一个统一的基于restful风格的web 接口。 lucence:一个搜索引擎底层 分布式：突出ES的横向扩展能力 全文检索：将一段词语进行分词，并将分出的词语统一的放在一个分词库中，再搜索时，根据关键字取分词库中检索，找到匹配的内容（倒排索引）。 restful风格的web 接口：只要发送一个http请求，并且根据请求方式的不同，携带参数的不同，执行相应的功能。 应用广泛：WIKI, gi
Elasticsearch
weixin_55261016的博客
06-15 751
ELK是包含但不限于Elasticsearch（简称es）、Logstash、Kibana 三个开源软件的组成的一个整体。这三个软件合成ELK。是用于数据抽取（Logstash）、搜索分析（Elasticsearch）、数据展现（Kibana）的一整套解决方案，所以也称作ELK stack。 本课程从分别对三个组件经行详细介绍，尤其是Elasticsearch，因为它是elk的核心。本课程从es底层对文档、索引、搜索、聚合、集群经行介绍，从搜索和聚合分析实例来展现es的魅力。Logstash从内部如何采集
ES6详细介绍及使用
小仙儿
02-22 8174
ES6中的export和import介绍 一、ES6概念及发展史 1、ES6概念 WSC中：ECMAScript 6.0（以下简称ES6）是 JavaScript 语言的下一代标准，已经在 2015 年 6 月正式发布了（所以也被叫作ES2015）。它的目标，是使得 JavaScript 语言可以用来编写复杂的大型应用程序，成为企业级开发语言。 2、ES6发展史 版本 时间 描述 ECMA-262/ ...
es6中的Map类型
......
10-15 323
var obj1 = { name:'zs' } var obj2 = { name:'ls' } var obj3 = { [obj1]:'ww', [obj2]:'ll' } console.log(obj3) // {[object Object]:'ll'} // es5 中，形如 obj3中的键key，会调用toString()，隐式转换为字符串，[obj1]和[obj2]调用toString()转换为 [object Object] ，俩个相同的key,第.
request对象、response对象
deskDopa的博客
11-08 442
请求方式的通用获取方法： 1. 获取请求参数通用方式：不论get还是post请求方式都可以使用下列方法来获取请求参数 1. String getParameter(String name):根据参数名称获取参数值 username=zs&amp;password=123 2. String[] getParameterValues(String name):根据参数名称获取参...
ElasticSearch进阶（一）ElasticSearch的Java客户端
jwang的博客
10-22 1328
前言 本章讲解ElasticSearch的Java客户端的使用 方法 1.概念 在ES中，提供了多种语言客户端的操控！那么Java我们推荐使用Java REST Client 后期与spring或者springboot整合的时候我们将会使用更加牛x的API哦！ 而Java REST Client又分为两种，我们重点讲解Java High Level REST Clien...
使用java对elasticSearch进行复合查询
梦忆故城的博客
01-29 803
一、实现需求 指定目录下，根据搜索词对有效的es文档的标题进行检索，并对检索词高亮，实现分页查询，若没有填搜索词，则显示指定目录的全部文档信息，查询内容按照更新时间倒序排序。 二、代码实现 1.检索结果文档实体 @Data public class ModelSearchDocsVO { private String classifyName; private String classifyCode; private List<ModelSearchDocsV..
[Java]-Elastic中查询与聚合操作
农家小舍
07-24 2357
文章目录search基础分词器request请求SearchSourceBuilder查询QueryBuildersQueryStringQuery排序游标Scroll聚合AggregationBuildersnested嵌套聚合排序查询聚合collapse去重 在《Elastic中index与document基本操作》中介绍了Elastic的基本知识，及索引与文档操作；本节将介绍Elasticsearch中常用的查询与聚合操作。 search基础 Elasticsearch会对文档内容进行分词，并根据分词
全文搜索引擎 Elasticsearch详解
liuerchong的博客
03-28 3265
文章目录什么是ElasticSearchElasticsearch 的用途是什么？Elasticsearch 的工作原理是什么？Elasticsearch 索引是什么？为何使用 Elasticsearch？ 什么是ElasticSearch Elasticsearch 是一个分布式的免费开源搜索和分析引擎，适用于包括文本、数字、地理空间、结构化和非结构化数据等在内的所有类型的数据。Elasticsearch 在 Apache Lucene 的基础上开发而成，由 Elasticsearch N.V.（即现在的
Java操作ElasticSearch相关内容
weixin_45892531的博客
08-11 892
Java连接ES 创建Maven工程 导入依赖 <dependencies> <!-- 1. elasticsearch--> <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <version&gt...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值