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

梦里梦外; 2022-02-27 03:44 687阅读 0赞

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

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

  1. package com.bas.util;
  3. import org.elasticsearch.action.search.SearchResponse;
  4. import org.elasticsearch.client.transport.TransportClient;
  5. import org.elasticsearch.index.query.QueryBuilders;
  6. import org.elasticsearch.search.SearchHit;
  7. import org.elasticsearch.search.SearchHits;
  8. import org.elasticsearch.index.query.QueryBuilder;
  10. import java.util.ArrayList;
  11. import java.util.List;
  12. import java.util.Map;
  14. public class QueryUtil {
  15.     private static SearchHits hits;
  16.     private static TransportClient client = ESUtil.getClient();
  18.     /**
  19.      * 打印常见信息
  20.      */
  21.     public static void print() {
  22.         if (hits == null) {
  23.             return;
  24.         }
  25.         System.out.println("-> totalHits: "+hits.totalHits);
  26.         for (SearchHit hit : hits) {
  27.             System.out.println("-----------");
  28.             System.out.println("source:" + hit.getSourceAsString());
  29.             System.out.println("index:" + hit.getIndex());
  30.             System.out.println("type:" + hit.getType());
  31.             System.out.println("id:" + hit.getId());
  32.             //遍历文档的每个字段
  33.             Map<String, Object> map = hit.getSourceAsMap();
  34.             for (String key : map.keySet()) {
  35.                 System.out.println(key + "=" + map.get(key));
  36.             }
  37.             System.out.println("HighlightFields:" + hit.getHighlightFields());
  38.             System.out.println("Fields:" + hit.getFields());
  39.             System.out.println("MatchedQueries:" + hit.getMatchedQueries());
  40.             System.out.println("InnerHits:" + hit.getInnerHits());
  41.             System.out.println("-----------");
  42.         }
  43.     }
  45.     /**
  46.      * 执行查询
  47.      *
  48.      * @param query 查询器
  49.      * @return 当前查询对象
  50.      */
  51.     private static List<Map<String, Object>> executeQuery(QueryBuilder query, String indexName, int size) {
  52.         //搜索结果存入SearchResponse
  53.         SearchResponse response = client.prepareSearch(indexName)
  54.                 .setQuery(query) //设置查询器
  55.                 .setSize(size)      //一次查询文档数
  56.                 .get();
  57.         hits = response.getHits();
  58.         if (hits == null) {
  59.             return null;
  60.         }
  62.         List<Map<String, Object>> resultList = new ArrayList<>();
  63.         for (SearchHit hit : hits) {
  64.             resultList.add(hit.getSourceAsMap());
  65.         }
  66.         print();
  67.         return resultList;
  68.     }
  70.     /**
  71.      * Find documents which contain the exact term specified in the field specified.
  72.      * 单个精确词项查询，内容有中文不能匹配
  73.      * @param indexName 索引名
  74.      * @param size 数据量
  75.      * @param field 查询字段
  76.      * @param termValue 单个词项内容
  77.      * @return 结果集
  78.      */
  79.     public synchronized static List<Map<String, Object>> termQuery(String indexName, int size, String field, String termValue) {
  80.         QueryBuilder qb = QueryBuilders.termQuery(field, termValue);
  81.         return executeQuery(qb, indexName, size);
  82.     }
  84.     /**
  85.      * Find documents which contain any of the exact terms specified in the field specified.
  86.      * 多个精确词项查询，内容有中文不能匹配
  87.      * @param indexName 索引名
  88.      * @param size 数据量
  89.      * @param field 查询字段
  90.      * @param termValue 单个词项内容
  91.      * @return 结果集
  92.      */
  93.     public synchronized static List<Map<String, Object>> termsQuery(String indexName, int size, String field, String ...termValue) {
  94.         QueryBuilder qb = QueryBuilders.termsQuery(field, termValue);
  95.         return executeQuery(qb, indexName, size);
  96.     }
  98.     /**
  99.      * Find documents where the field specified
  100.      * contains values (dates, numbers, or strings) in the range specified.
  101.      * @param indexName 索引名
  102.      * @param size 数据量
  103.      * @param field 查询字段
  104.      * @param from 起始时间
  105.      * @param to 截止时间
  106.      * @return 结果集
  107.      */
  108.     public synchronized static List<Map<String, Object>> rangeQuery(String indexName, int size, String field, String from, String to) {
  109.         QueryBuilder qb = QueryBuilders.rangeQuery(field).from(from).to(to);
  110.         return executeQuery(qb, indexName, size);
  111.     }
  113.     /**
  114.      * Find documents where the field specified contains any non-null value.
  115.      * 查找包含任何非空值的文档的指定字段
  116.      * @param indexName 索引名
  117.      * @param size 数据量
  118.      * @param field 查询字段
  119.      * @return 结果集
  120.      */
  121.     public synchronized static List<Map<String, Object>> existsQuery(String indexName, int size, String field) {
  122.         QueryBuilder qb = QueryBuilders.existsQuery(field);
  123.         return executeQuery(qb, indexName, size);
  124.     }
  126.     /**
  127.      * Find documents where the field specified contains terms
  128.      * which being with the exact prefix specified.
  129.      * 匹配包含xx前缀的文档，内容有中文不能匹配
  130.      * @param indexName 索引名
  131.      * @param size 数据量
  132.      * @param field 查询字段
  133.      * @param prefixValue 前缀内容
  134.      * @return 结果集
  135.      */
  136.     public synchronized static List<Map<String, Object>> prefixQuery(String indexName, int size, String field, String prefixValue) {
  137.         QueryBuilder qb = QueryBuilders.prefixQuery(field, prefixValue);
  138.         return executeQuery(qb, indexName, size);
  139.     }
  141.     /**
  142.      * Find documents where the field specified contains terms
  143.      * which match the pattern specified,
  144.      * where the pattern supports single character wildcards (?)
  145.      * and multi-character wildcards (*)
  146.      * 通配符匹配查询，内容有中文不能匹配
  147.      * @param indexName 索引名
  148.      * @param size 数据量
  149.      * @param field 查询字段
  150.      * @param wildcardValue 包含通配符的内容
  151.      * @return 结果集
  152.      */
  153.     public synchronized static List<Map<String, Object>> wildcardQuery(String indexName, int size, String field, String wildcardValue) {
  154.         QueryBuilder qb = QueryBuilders.wildcardQuery(field, wildcardValue);
  155.         return executeQuery(qb, indexName, size);
  156.     }
  158.     /**
  159.      * Find documents where the field specified contains terms
  160.      * which match the regular expression specified.
  161.      * 正则匹配查询，内容有中文不能匹配
  162.      * @param indexName 索引名
  163.      * @param size 数据量
  164.      * @param field 查询字段
  165.      * @param regexpValue 包含正则的内容
  166.      * @return 结果集
  167.      */
  168.     public synchronized static List<Map<String, Object>> regexpQuery(String indexName, int size, String field, String regexpValue) {
  169.         QueryBuilder qb = QueryBuilders.regexpQuery(field, regexpValue);
  170.         return executeQuery(qb, indexName, size);
  171.     }
  173.     /**
  174.      * Find documents where the field specified contains terms
  175.      * which are fuzzily similar to the specified term.
  176.      * Fuzziness is measured as a Levenshtein edit distance of 1 or 2.
  177.      * 模糊查询，内容有中文不能匹配
  178.      * @param indexName 索引名
  179.      * @param size 数据量
  180.      * @param field 查询字段
  181.      * @param fuzzyValue 模糊值
  182.      * @return 结果集
  183.      */
  184.     public synchronized static List<Map<String, Object>> fuzzyQuery(String indexName, int size, String field, String fuzzyValue) {
  185.         QueryBuilder qb = QueryBuilders.fuzzyQuery(field, fuzzyValue);
  186.         return executeQuery(qb, indexName, size);
  187.     }
  189.     /**
  190.      * Find documents of the specified type.
  191.      * 查询指定type名的文档
  192.      * @param indexName 索引名
  193.      * @param size 数据量
  194.      * @param type type名
  195.      * @return 结果集
  196.      */
  197.     public synchronized static List<Map<String, Object>> typeQuery(String indexName, int size, String type) {
  198.         QueryBuilder qb = QueryBuilders.typeQuery(type);
  199.         return executeQuery(qb, indexName, size);
  200.     }
  202.     /**
  203.      * Find documents with the specified type and IDs.
  204.      * 根据指定的type和文档id查询
  205.      * @param indexName 索引名
  206.      * @param size 数据量
  207.      * @param ids 文档的_id
  208.      * @return 结果集
  209.      */
  210.     public synchronized static List<Map<String, Object>> idsQuery(String indexName, int size, String ...ids) {
  211.         QueryBuilder qb = QueryBuilders.idsQuery(ids);
  212.         return executeQuery(qb, indexName, size);
  213.     }
  216. }

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

  1. 测试每个方法的测试类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 {

    1.  /**
    2.   * 全量查询
    3.   *
    4.   * @param args
    5.   */
    6.  public static void main(String[] args) {
    7.      TransportClient client = ESUtil.getClient();
    8.      //构造查询对象
    9.      QueryBuilder query = QueryBuilders.matchAllQuery();
    10.      //搜索结果存入SearchResponse
    11.      SearchResponse response = client.prepareSearch("app_account")
    12.              .setQuery(query) //设置查询器
    13.              .setSize(3)      //一次查询文档数
    14.              .get();
    15.      SearchHits hits = response.getHits();
    16.      int count = 1;
    17.      for (SearchHit hit : hits) {
    18.          System.out.println("--------------------" + count++);
    19.          System.out.println("source:" + hit.getSourceAsString());
    20.          System.out.println("index:" + hit.getIndex());
    21.          System.out.println("type:" + hit.getType());
    22.          System.out.println("id:" + hit.getId());
    23.          //遍历文档的每个字段
    24.          Map<String, Object> map = hit.getSourceAsMap();
    25.          for (String key : map.keySet()) {
    26.              System.out.println(key + "=" + map.get(key));
    27.          }
    28.          System.out.println("--------------------\n");
    29.      }
    30.  }
    32.  /**
    33.   * 单个字段匹配查询
    34.   */
    35.  @Test
    36.  public void matchQuery() {
    37.      SearchHits hits;
    38.      //构造查询对象
    39.      QueryBuilder query = QueryBuilders.matchQuery(
    40.              "title",
    41.              "标题");
    42.      SearchResponse response = ESUtil.getClient().prepareSearch("app_account")
    43.              .setQuery(query) //设置查询器
    44.              .setSize(5)      //一次查询文档数
    45.              .get();
    46.      hits = response.getHits();
    47.      for (SearchHit hit : hits) {
    48.          System.out.println("source:" + hit.getSourceAsString());
    49.          System.out.println("index:" + hit.getIndex());
    50.          System.out.println("type:" + hit.getType());
    51.          System.out.println("id:" + hit.getId());
    52.          //遍历文档的每个字段
    53.          Map<String, Object> map = hit.getSourceAsMap();
    54.          for (String key : map.keySet()) {
    55.              System.out.println(key + "=" + map.get(key));
    56.          }
    57.          System.out.println("HighlightFields:" + hit.getHighlightFields());
    58.          System.out.println("Fields:" + hit.getFields());
    59.          System.out.println("MatchedQueries:" + hit.getMatchedQueries().length);
    60.          System.out.println("InnerHits:" + hit.getInnerHits());
    61.      }
    62.  }
    64.  /**
    65.   * 操作符查询
    66.   */
    67.  @Test
    68.  public void operatorQuery() {
    69.      SearchHits hits;
    70.      //构造查询对象
    71.      QueryBuilder query = QueryBuilders.matchQuery(
    72.              "title",
    73.              "标题").operator(Operator.AND);
    74.      SearchResponse response = ESUtil.getClient().prepareSearch("app_account")
    75.              .setQuery(query) //设置查询器
    76.              .setSize(5)      //一次查询文档数
    77.              .get();
    78.      hits = response.getHits();
    79.      for (SearchHit hit : hits) {
    80.          System.out.println("--------");
    81.          System.out.println("source:" + hit.getSourceAsString());
    82.          System.out.println("index:" + hit.getIndex());
    83.          System.out.println("type:" + hit.getType());
    84.          System.out.println("id:" + hit.getId());
    85.          //遍历文档的每个字段
    86.          Map<String, Object> map = hit.getSourceAsMap();
    87.          for (String key : map.keySet()) {
    88.              System.out.println(key + "=" + map.get(key));
    89.          }
    90.          System.out.println("HighlightFields:" + hit.getHighlightFields());
    91.          System.out.println("Fields:" + hit.getFields());
    92.          System.out.println("--------");
    93.      }
    94.  }
    96.  /**
    97.   * 多字段同时匹配查询
    98.   * 内容有中文不能匹配
    99.   */
    100.  @Test
    101.  public void multiMatchQuery() {
    102.      SearchHits hits;
    103.      //构造查询对象
    104.      QueryBuilder query = QueryBuilders.multiMatchQuery(
    105.              "bas",
    106.              "title", "url");
    107.      SearchResponse response = ESUtil.getClient().prepareSearch("app_account")
    108.              .setQuery(query) //设置查询器
    109.              .setSize(5)      //一次查询文档数
    110.              .get();
    111.      hits = response.getHits();
    112.      for (SearchHit hit : hits) {
    113.          System.out.println("source:" + hit.getSourceAsString());
    114.          System.out.println("index:" + hit.getIndex());
    115.          System.out.println("type:" + hit.getType());
    116.          System.out.println("id:" + hit.getId());
    117.          //遍历文档的每个字段
    118.          Map<String, Object> map = hit.getSourceAsMap();
    119.          for (String key : map.keySet()) {
    120.              System.out.println(key + "=" + map.get(key));
    121.          }
    122.          System.out.println("HighlightFields:" + hit.getHighlightFields());
    123.          System.out.println("Fields:" + hit.getFields());
    124.      }
    125.  }
    127.  /**
    128.   * 单个词项精确查询，内容有中文不能匹配
    129.   */
    130.  @Test
    131.  public void termQuery() {
    132.      QueryUtil.termQuery("app_account", 5, "url", "bas");
    133.  }
    135.  /**
    136.   * 多个词项精确查询，内容有中文不能匹配
    137.   */
    138.  @Test
    139.  public void termsQuery() {

    // QueryUtil.termsQuery(“app_account”, 5, “title.keyword”, “更新title”, “标题”); // 这样就可以匹配中文了，或者修改mapping的字段属性为不分词

    1.      QueryUtil.termsQuery("app_account", 5, "title", "更新title", "标题");
    2.  }
    4.  @Test
    5.  public void rangeQuery() {
    6.      QueryUtil.rangeQuery("app_account", 100, "postdate", "2017-03-24", "2019-03-24");
    7.  }
    9.  @Test
    10.  public void existsQuery() {
    11.      QueryUtil.existsQuery("app_account", 100, "postdate");
    12.  }
    14.  /**
    15.   * 匹配包含xx前缀的文档，内容有中文不能匹配
    16.   */
    17.  @Test
    18.  public void prefixQuery() {

    // QueryUtil.prefixQuery(“app_account”, 100, “title.keyword”,”标题”); // 这样就可以匹配中文了

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

    // QueryUtil.wildcardQuery(“app_account”, 100, “title.keyword”, “标题*”);

    1.      QueryUtil.wildcardQuery("app_account", 100, "title", "标题*");
    2.  }
    4.  /**
    5.   * 正则匹配查询，内容有中文不能匹配
    6.   */
    7.  @Test
    8.  public void regexpQuery() {

    // QueryUtil.regexpQuery(“app_account”, 100, “title.keyword”, “标题.*”);

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

    // QueryUtil.fuzzyQuery(“app_account”, 100, “title.keyword”, “标题”);

    1.      QueryUtil.fuzzyQuery("app_account", 100, "title", "asd");
    2.  }
    4.  @Test
    5.  public void typeQuery() {
    6.      QueryUtil.typeQuery("app_account", 5, "blog");
    7.  }
    9.  @Test
    10.  public void idsQuery() {
    11.      QueryUtil.idsQuery("app_account", 5, "asdasdcVcCKaQfGQ3", "52AbtWkBqLTNcYM2gf0z", "62AltWkBqLTNcYM27f2h");
    12.  }

    }

注：

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

20190326182255843.png

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

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

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

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

发表评论

表情：
评论列表 （有 0 条评论，687人围观）

还没有评论，来说两句吧...

相关阅读