对文档查询，在实际开发中，对文档的查询也是偏多的，记得之前在mou快递公司，做了一套事实的揽件数据操作，就是通过这个来存储数据的，由于一天的数据最少拥有3500万数据

所以是比较多的，而且还要求查询速度特别快，所以就选择了这个作为数据库

首先向es库中插入数据

首先新建索引：

当然也可以使用api一次操作：

向es中创建映射：

我采用的postman进行的，所以

json：

  1. {
  2.     "properties": {
  3.         "description": {
  4.             "type": "text",
  5.             "analyzer": "ik_max_word",
  6.             "search_analyzer": "ik_smart"
  7.         },
  8.         "name": {
  9.             "type": "text",
  10.             "analyzer": "ik_max_word",
  11.             "search_analyzer": "ik_smart"
  12.         },
  13.         "pic": {
  14.             "type": "text",
  15.             "index": false
  16.         },
  17.         "price": {
  18.             "type": "float"
  19.         },
  20.         "studymodel": {
  21.             "type": "keyword"
  22.         },
  23.         "timestamp": {
  24.             "type": "date",
  25.             "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
  26.         }
  27.     }
  28. }

这个json数据我是从网上找的一个课程相关的内容。

插入数据：

使用postman

  1. http://localhost:9200/chenxuyou/doc/9
  2.  
  3. {
  4. "name": "es开发基础",
  5. "description": "在es领域非常流行，es程序员都在用。",
  6. "studymodel": "",
  7. "price":813.6,
  8. "timestamp":"2019-11-14 19:11:35",
  9. "pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
  10. }

参数后面的那个9，这个是id的意思，如果哦我们不传输，那么es会自动给我生成这个，

使用postman

  1. http://localhost:9200/_search

结果： 返回所有的数据，所有的索引下面的数据：

  1. {
  2.     "took": ,
  3.     "timed_out": false,
  4.     "_shards": {
  5.         "total": ,
  6.         "successful": ,
  7.         "skipped": ,
  8.         "failed":
  9.     },
  10.     "hits": {
  11.         "total": ,
  12.         "max_score": ,
  13.         "hits": [
  14.             {
  15.                 "_index": "chenxuyou",
  16.                 "_type": "doc",
  17.                 "_id": "",
  18.                 "_score": ,
  19.                 "_source": {
  20.                     "name": "Bootstrap开发",
  21.                     "description": "Bootstrap是由Twitter推出的一个前台页面开发框架，是一个非常流行的开发框架，此框架集成了多种页面效果。此开发框架包含了大量的CSS、JS程序代码，可以帮助开发者（尤其是不擅长页面开发的程序人员）轻松的实现一个不受浏览器限制的精美界面效果。",
  22.                     "studymodel": "",
  23.                     "price": 38.6,
  24.                     "timestamp": "2018-04-25 19:11:35",
  25.                     "pic": "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
  26.                 }
  27.             },
  28.             {
  29.                 "_index": "chenxuyou",
  30.                 "_type": "doc",
  31.                 "_id": "",
  32.                 "_score": ,
  33.                 "_source": {
  34.                     "name": "java编程基础",
  35.                     "description": "java语言是世界第一编程语言，在软件开发领域使用人数最多。",
  36.                     "studymodel": "",
  37.                     "price": 68.6,
  38.                     "timestamp": "2018-03-25 19:11:35",
  39.                     "pic": "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
  40.                 }
  41.             },
  42.             {
  43.                 "_index": "chenxuyou",
  44.                 "_type": "doc",
  45.                 "_id": "",
  46.                 "_score": ,
  47.                 "_source": {
  48.                     "name": "spring开发基础",
  49.                     "description": "spring 在java领域非常流行，java程序员都在用。",
  50.                     "studymodel": "",
  51.                     "price": 88.6,
  52.                     "timestamp": "2018-02-24 19:11:35",
  53.                     "pic": "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
  54.                 }
  55.             },
  56.             {
  57.                 "_index": "chenxuyou",
  58.                 "_type": "doc",
  59.                 "_id": "",
  60.                 "_score": ,
  61.                 "_source": {
  62.                     "name": "开发基础",
  63.                     "description": "在java领域非常流行，java程序员都在用。",
  64.                     "studymodel": "",
  65.                     "price": 8.6,
  66.                     "timestamp": "2019-02-24 19:11:35",
  67.                     "pic": "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
  68.                 }
  69.             },
  70.             {
  71.                 "_index": "chenxuyou",
  72.                 "_type": "doc",
  73.                 "_id": "",
  74.                 "_score": ,
  75.                 "_source": {
  76.                     "name": "js开发基础",
  77.                     "description": "在js领域非常流行，js程序员都在用。",
  78.                     "studymodel": "",
  79.                     "price": 83.6,
  80.                     "timestamp": "2019-12-24 19:11:35",
  81.                     "pic": "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
  82.                 }
  83.             },
  84.             {
  85.                 "_index": "chenxuyou",
  86.                 "_type": "doc",
  87.                 "_id": "",
  88.                 "_score": ,
  89.                 "_source": {
  90.                     "name": "go开发基础",
  91.                     "description": "在go领域非常流行，go程序员都在用。",
  92.                     "studymodel": "",
  93.                     "price": 813.6,
  94.                     "timestamp": "2019-12-14 19:11:35",
  95.                     "pic": "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
  96.                 }
  97.             },
  98.             {
  99.                 "_index": "chenxuyou",
  100.                 "_type": "doc",
  101.                 "_id": "",
  102.                 "_score": ,
  103.                 "_source": {
  104.                     "name": "python开发基础",
  105.                     "description": "在python领域非常流行，python程序员都在用。",
  106.                     "studymodel": "",
  107.                     "price": 8134.6,
  108.                     "timestamp": "2019-12-14 19:11:35",
  109.                     "pic": "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
  110.                 }
  111.             },
  112.             {
  113.                 "_index": "chenxuyou",
  114.                 "_type": "doc",
  115.                 "_id": "",
  116.                 "_score": ,
  117.                 "_source": {
  118.                     "name": "php开发基础",
  119.                     "description": "在php领域非常流行，php程序员都在用。",
  120.                     "studymodel": "",
  121.                     "price": 813.6,
  122.                     "timestamp": "2019-12-14 19:11:35",
  123.                     "pic": "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
  124.                 }
  125.             },
  126.             {
  127.                 "_index": "chenxuyou",
  128.                 "_type": "doc",
  129.                 "_id": "",
  130.                 "_score": ,
  131.                 "_source": {
  132.                     "name": "es开发基础",
  133.                     "description": "在es领域非常流行，es程序员都在用。",
  134.                     "studymodel": "",
  135.                     "price": 813.6,
  136.                     "timestamp": "2019-11-14 19:11:35",
  137.                     "pic": "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
  138.                 }
  139.             },
  140.             {
  141.                 "_index": "chenxuyou3",
  142.                 "_type": "doc",
  143.                 "_id": "fECECG8BAmmLmqjt7xyH",
  144.                 "_score": ,
  145.                 "_source": {
  146.                     "price": 5.6,
  147.                     "studymodel": "",
  148.                     "name": "spring cloud实战",
  149.                     "description": "本课程主要从四个章节进行讲解： 1.微服务架构入门 2.spring cloud 基础入门 3.实战Spring Boot 4.注册中心eureka。",
  150.                     "timestamp": "2019-12-15 15:45:27"
  151.                 }
  152.             }
  153.         ]
  154.     }
  155. }

结果说明：
took：本次操作花费的时间，单位为毫秒。
timed_out：请求是否超时
_shards：说明本次操作共搜索了哪些分片
hits：搜索命中的记录
hits.total ： 符合条件的文档总数 hits.hits ：匹配度较高的前N个文档
hits.max_score：文档匹配得分，这里为最高分
_score：每个文档都有一个匹配度得分，按照降序排列。
_source：显示了文档的原始内容。

当然也可以对指定索引库进行查询

  1. http://localhost:9200/chenxuyou3/doc/_search
  2.  
  3. post
  4.  
  5. {
  6.     "took": ,
  7.     "timed_out": false,
  8.     "_shards": {
  9.         "total": ,
  10.         "successful": ,
  11.         "skipped": ,
  12.         "failed":
  13.     },
  14.     "hits": {
  15.         "total": ,
  16.         "max_score": ,
  17.         "hits": [
  18.             {
  19.                 "_index": "chenxuyou3",
  20.                 "_type": "doc",
  21.                 "_id": "fECECG8BAmmLmqjt7xyH",
  22.                 "_score": ,
  23.                 "_source": {
  24.                     "price": 5.6,
  25.                     "studymodel": "",
  26.                     "name": "spring cloud实战",
  27.                     "description": "本课程主要从四个章节进行讲解： 1.微服务架构入门 2.spring cloud 基础入门 3.实战Spring Boot 4.注册中心eureka。",
  28.                     "timestamp": "2019-12-15 15:45:27"
  29.                 }
  30.             },
  31.             {
  32.                 "_index": "chenxuyou3",
  33.                 "_type": "doc",
  34.                 "_id": "fUCECG8BAmmLmqjt8xw3",
  35.                 "_score": ,
  36.                 "_source": {
  37.                     "price": 5.6,
  38.                     "studymodel": "",
  39.                     "name": "spring cloud实战",
  40.                     "description": "本课程主要从四个章节进行讲解： 1.微服务架构入门 2.spring cloud 基础入门 3.实战Spring Boot 4.注册中心eureka。",
  41.                     "timestamp": "2019-12-15 15:45:28"
  42.                 }
  43.             },
  44.             {
  45.                 "_index": "chenxuyou3",
  46.                 "_type": "doc",
  47.                 "_id": "fkCECG8BAmmLmqjt-Bwr",
  48.                 "_score": ,
  49.                 "_source": {
  50.                     "price": 5.6,
  51.                     "studymodel": "",
  52.                     "name": "spring cloud实战",
  53.                     "description": "本课程主要从四个章节进行讲解： 1.微服务架构入门 2.spring cloud 基础入门 3.实战Spring Boot 4.注册中心eureka。",
  54.                     "timestamp": "2019-12-15 15:45:29"
  55.                 }
  56.             },
  57.             {
  58.                 "_index": "chenxuyou3",
  59.                 "_type": "doc",
  60.                 "_id": "f0CECG8BAmmLmqjt-xxw",
  61.                 "_score": ,
  62.                 "_source": {
  63.                     "price": 5.6,
  64.                     "studymodel": "",
  65.                     "name": "spring cloud实战",
  66.                     "description": "本课程主要从四个章节进行讲解： 1.微服务架构入门 2.spring cloud 基础入门 3.实战Spring Boot 4.注册中心eureka。",
  67.                     "timestamp": "2019-12-15 15:45:30"
  68.                 }
  69.             },
  70.             {
  71.                 "_index": "chenxuyou3",
  72.                 "_type": "doc",
  73.                 "_id": "ekBpCG8BAmmLmqjtgRwU",
  74.                 "_score": ,
  75.                 "_source": {
  76.                     "price": 5.6,
  77.                     "studymodel": "",
  78.                     "name": "Ealsticseach学习实战",
  79.                     "description": "本课程主要从四个章节进行讲解： 1.微服务架构入门 2.spring cloud 基础入门 3.实战Spring Boot 4.注册中心eureka。",
  80.                     "timestamp": "2019-12-15 15:15:29"
  81.                 }
  82.             }
  83.         ]
  84.     }
  85. }

现在采用客户端的aip进行操作，所以只需要在原来的基础上增阿加一个controller就好

查询全部和分页查询：

  1.  @RequestMapping(value = "/searchAlldoc", method = RequestMethod.GET)
  2.     public String searchAlldoc() {
  3.         //搜索请求对象
  4.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  5.         //指定类型
  6.         searchRequest.types("doc");
  7.         //搜索源构建对象
  8.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  9.         //设置搜索方式
  10.         searchSourceBuilder.query(QueryBuilders.matchAllQuery());
  11.         //设置包含哪些字段，不包括哪些字段，第一个参数，是包含的，第二个是不包含的
  12.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"},new String[]{});
  13.  
  14.         //设置搜索源
  15.         searchRequest.source(searchSourceBuilder);
  16.         SearchResponse search =null;
  17.         try {
  18.             search = client.search(searchRequest, RequestOptions.DEFAULT);
  19.  
  20.         } catch (IOException e) {
  21.             e.printStackTrace();
  22.         }
  23.         SearchHits hits = search.getHits();
  24.         long totalHits = hits.totalHits;
  25.         System.out.println(totalHits);
  26.         SearchHit[] hits1 = hits.getHits();
  27.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  28.         for (SearchHit searchHit:hits1){
  29.             String id = searchHit.getId();
  30.             Map<String, Object> sourceAsMap = searchHit.getSourceAsMap();
  31.             String name = (String) sourceAsMap.get("name");
  32.             //由于前边设置了源文档字段过虑，这时description是取不到的
  33.             String description = (String) sourceAsMap.get("description");
  34.             //学习模式
  35.             String studymodel = (String) sourceAsMap.get("studymodel");
  36.             //价格
  37.             Double price = (Double) sourceAsMap.get("price");
  38.             //日期
  39.            String s = (String) sourceAsMap.get("timestamp");
  40.             Date timestamp =null;
  41.             try {
  42.                 timestamp = dateFormat.parse(s);
  43.  
  44.             } catch (ParseException e) {
  45.                 e.printStackTrace();
  46.             }
  47.             System.out.println(s);
  48.             System.out.println(price);
  49.             System.out.println(name);
  50.             System.out.println(studymodel);
  51.             System.out.println(description);
  52.  
  53.         }
  54.  
  55.         return "ok";
  56.     }
  57.  
  58.     @RequestMapping(value = "/searchAlldocPage", method = RequestMethod.GET)
  59.     public String searchAlldocPage() {
  60.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  61.         //指定类型
  62.         searchRequest.types("doc");
  63.         //搜索源构建对象
  64.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  65.         //设置分页参数
  66.         //页码
  67.         int page = ;
  68.         //每页记录数
  69.         int size = ;
  70.         //计算出记录起始下标
  71.         int from = (page - ) * size;
  72.         searchSourceBuilder.from(from);//起始记录下标，从0开始
  73.         searchSourceBuilder.size(size);//每页显示的记录数
  74.         //搜索方式
  75.         //matchAllQuery搜索全部
  76.         searchSourceBuilder.query(QueryBuilders.matchAllQuery());
  77.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  78.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  79.         //向搜索请求对象中设置搜索源
  80.         searchRequest.source(searchSourceBuilder);
  81.         //执行搜索,向ES发起http请求
  82.         SearchResponse searchResponse = null;
  83.         try {
  84.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  85.         } catch (IOException e) {
  86.             e.printStackTrace();
  87.         }
  88.         //搜索结果
  89.         SearchHits hits = searchResponse.getHits();
  90.         //匹配到的总记录数
  91.         long totalHits = hits.getTotalHits();
  92.         //得到匹配度高的文档
  93.         SearchHit[] searchHits = hits.getHits();
  94.         //日期格式化对象
  95.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  96.         for (SearchHit hit : searchHits) {
  97.             //文档的主键
  98.             String id = hit.getId();
  99.             //源文档内容
  100.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  101.             String name = (String) sourceAsMap.get("name");
  102.             //由于前边设置了源文档字段过虑，这时description是取不到的
  103.             String description = (String) sourceAsMap.get("description");
  104.             //学习模式
  105.             String studymodel = (String) sourceAsMap.get("studymodel");
  106.             //价格
  107.             Double price = (Double) sourceAsMap.get("price");
  108.             //日期
  109.             try {
  110.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  111.                 System.out.println(timestamp);
  112.             } catch (ParseException e) {
  113.                 e.printStackTrace();
  114.             }
  115.             System.out.println(price);
  116.             System.out.println(name);
  117.             System.out.println(studymodel);
  118.             System.out.println(description);
  119.         }
  120.         return "ok";
  121.     }

精确查询

Term Query为精确查询，在搜索时会整体匹配关键字，不再将关键字分词，本来es是进行分词插叙，这个词主要用作精确的，不进行分词的，

  1.  @RequestMapping(value = "/termquerydocPage", method = RequestMethod.GET)
  2.     public String termquerydocPage() {
  3.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  4.         //指定类型
  5.         searchRequest.types("doc");
  6.         //搜索源构建对象
  7.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  8.         //设置分页参数
  9.         //页码
  10.         int page = ;
  11.         //每页记录数
  12.         int size = ;
  13.         //计算出记录起始下标
  14.         int from = (page - ) * size;
  15.         searchSourceBuilder.from(from);//起始记录下标，从0开始
  16.         searchSourceBuilder.size(size);//每页显示的记录数
  17.         //搜索方式
  18.  
  19.         //matchAllQuery搜索全部
  20.         searchSourceBuilder.query(QueryBuilders.termQuery("name","spring"));
  21.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  22.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  23.         //向搜索请求对象中设置搜索源
  24.         searchRequest.source(searchSourceBuilder);
  25.         //执行搜索,向ES发起http请求
  26.         SearchResponse searchResponse = null;
  27.         try {
  28.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  29.         } catch (IOException e) {
  30.             e.printStackTrace();
  31.         }
  32.         //搜索结果
  33.         SearchHits hits = searchResponse.getHits();
  34.         //匹配到的总记录数
  35.         long totalHits = hits.getTotalHits();
  36.         //得到匹配度高的文档
  37.         SearchHit[] searchHits = hits.getHits();
  38.         //日期格式化对象
  39.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  40.         for (SearchHit hit : searchHits) {
  41.             //文档的主键
  42.             String id = hit.getId();
  43.             //源文档内容
  44.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  45.             String name = (String) sourceAsMap.get("name");
  46.             //由于前边设置了源文档字段过虑，这时description是取不到的
  47.             String description = (String) sourceAsMap.get("description");
  48.             //学习模式
  49.             String studymodel = (String) sourceAsMap.get("studymodel");
  50.             //价格
  51.             Double price = (Double) sourceAsMap.get("price");
  52.             //日期
  53.             try {
  54.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  55.                 System.out.println(timestamp);
  56.             } catch (ParseException e) {
  57.                 e.printStackTrace();
  58.             }
  59.             System.out.println(price);
  60.             System.out.println(name);
  61.             System.out.println(studymodel);
  62.             System.out.println(description);
  63.         }
  64.         return "ok";
  65.     }
  66.     @RequestMapping(value = "/termqueryId", method = RequestMethod.GET)
  67.     public String termqueryId() {
  68.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  69.         //指定类型
  70.         searchRequest.types("doc");
  71.         //搜索源构建对象
  72.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  73.         //搜索方式
  74.         //根据id查询
  75.         //定义id
  76.         String[] ids = new String[]{"",""};
  77.         searchSourceBuilder.query(QueryBuilders.termsQuery("_id",ids));
  78.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  79.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  80.         //向搜索请求对象中设置搜索源
  81.         searchRequest.source(searchSourceBuilder);
  82.         //执行搜索,向ES发起http请求
  83.         SearchResponse searchResponse = null;
  84.         try {
  85.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  86.         } catch (IOException e) {
  87.             e.printStackTrace();
  88.         }
  89.         //搜索结果
  90.         SearchHits hits = searchResponse.getHits();
  91.         //匹配到的总记录数
  92.         long totalHits = hits.getTotalHits();
  93.         //得到匹配度高的文档
  94.         SearchHit[] searchHits = hits.getHits();
  95.         //日期格式化对象
  96.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  97.         for (SearchHit hit : searchHits) {
  98.             //文档的主键
  99.             String id = hit.getId();
  100.             //源文档内容
  101.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  102.             String name = (String) sourceAsMap.get("name");
  103.             //由于前边设置了源文档字段过虑，这时description是取不到的
  104.             String description = (String) sourceAsMap.get("description");
  105.             //学习模式
  106.             String studymodel = (String) sourceAsMap.get("studymodel");
  107.             //价格
  108.             Double price = (Double) sourceAsMap.get("price");
  109.             //日期
  110.             try {
  111.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  112.                 System.out.println(timestamp);
  113.             } catch (ParseException e) {
  114.                 e.printStackTrace();
  115.             }
  116.             System.out.println(price);
  117.             System.out.println(name);
  118.             System.out.println(studymodel);
  119.             System.out.println(description);
  120.         }
  121.         return "ok";
  122.     }

控制台打印结果：

  1. 38.6
  2. Bootstrap开发
  3.  
  4. null
  5. Sun Mar  :: CST
  6. 68.6
  7. java编程基础
  8.  
  9. null

matchquery

　　

match Query即全文检索，它的搜索方式是先将搜索字符串分词，再使用各各词条从索引中搜索。

match query与Term query区别是match query在搜索前先将搜索关键字分词，再拿各各词语去索引中搜索。

postman 测试：

  1. http://localhost:9200/chenxuyou/doc/_search
  2.  
  3. post
  4. 第一种
  5. {
  6. "query": {    
  7.     "match" : {
  8.         "description" : {
  9.             "query" : "spring开发",
  10.             "operator" : "or"
  11.         }
  12.     }
  13.   }
  14. }

query：搜索的关键字，对于英文关键字如果有多个单词则中间要用半角逗号分隔，而对于中文关键字中间可以用 逗号分隔也可以不用。

operator：or 表示 只要有一个词在文档中出现则就符合条件，and表示每个词都在文档中出现则才符合条件。 上边的搜索的执行过程是：

1 、将“spring开发”分词，分为spring、开发两个词
2、再使用spring和开发两个词去匹配索引中搜索。
3、由于设置了operator为or，只要有一个词匹配成功则就返回该文档。

  1. 第二中

{
"query": {    
    "match" : {
        "description" : {
            "query" : "spring开发框架",
             "minimum_should_match": "80%"
        }
    }
  }
}

上边使用的operator = or表示只要有一个词匹配上就得分，如果实现三个词至少有两个词匹配如何实现？
使用minimum_should_match可以指定文档匹配词的占比：
比如搜索语句如下：

“spring开发框架”会被分为三个词：spring、开发、框架
设置"minimum_should_match": "80%"表示，三个词在文档的匹配占比为80%，即3*0.8=2.4，向上取整得2，表
示至少有两个词在文档中要匹配成功。

  1.  @RequestMapping(value = "/matchquery", method = RequestMethod.GET)
  2.     public String matchquery() {
  3.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  4.         //指定类型
  5.         searchRequest.types("doc");
  6.         //搜索源构建对象
  7.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  8.         //搜索方式
  9.         //根据id查询
  10.         //定义id
  11.         searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开发框架")
  12.                 .minimumShouldMatch("80%"));
  13.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  14.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  15.         //向搜索请求对象中设置搜索源
  16.         searchRequest.source(searchSourceBuilder);
  17.         //执行搜索,向ES发起http请求
  18.         SearchResponse searchResponse = null;
  19.         try {
  20.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  21.         } catch (IOException e) {
  22.             e.printStackTrace();
  23.         }
  24.         //搜索结果
  25.         SearchHits hits = searchResponse.getHits();
  26.         //匹配到的总记录数
  27.         long totalHits = hits.getTotalHits();
  28.         //得到匹配度高的文档
  29.         SearchHit[] searchHits = hits.getHits();
  30.         //日期格式化对象
  31.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  32.         for (SearchHit hit : searchHits) {
  33.             //文档的主键
  34.             String id = hit.getId();
  35.             //源文档内容
  36.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  37.             String name = (String) sourceAsMap.get("name");
  38.             //由于前边设置了源文档字段过虑，这时description是取不到的
  39.             String description = (String) sourceAsMap.get("description");
  40.             //学习模式
  41.             String studymodel = (String) sourceAsMap.get("studymodel");
  42.             //价格
  43.             Double price = (Double) sourceAsMap.get("price");
  44.             //日期
  45.             try {
  46.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  47.                 System.out.println(timestamp);
  48.             } catch (ParseException e) {
  49.                 e.printStackTrace();
  50.             }
  51.             System.out.println(price);
  52.             System.out.println(name);
  53.             System.out.println(studymodel);
  54.             System.out.println(description);
  55.         }
  56.         return "ok";
  57.     }
  58.  
  59.     @RequestMapping(value = "/matchqueryOr", method = RequestMethod.GET)
  60.     public String matchqueryOr() {
  61.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  62.         //指定类型
  63.         searchRequest.types("doc");
  64.         //搜索源构建对象
  65.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  66.         //搜索方式
  67.         //根据id查询
  68.  
  69. //匹配关键字
  70. searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  71.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  72.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  73.         //向搜索请求对象中设置搜索源
  74.         searchRequest.source(searchSourceBuilder);
  75.         //执行搜索,向ES发起http请求
  76.         SearchResponse searchResponse = null;
  77.         try {
  78.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  79.         } catch (IOException e) {
  80.             e.printStackTrace();
  81.         }
  82.         //搜索结果
  83.         SearchHits hits = searchResponse.getHits();
  84.         //匹配到的总记录数
  85.         long totalHits = hits.getTotalHits();
  86.         //得到匹配度高的文档
  87.         SearchHit[] searchHits = hits.getHits();
  88.         //日期格式化对象
  89.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  90.         for (SearchHit hit : searchHits) {
  91.             //文档的主键
  92.             String id = hit.getId();
  93.             //源文档内容
  94.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  95.             String name = (String) sourceAsMap.get("name");
  96.             //由于前边设置了源文档字段过虑，这时description是取不到的
  97.             String description = (String) sourceAsMap.get("description");
  98.             //学习模式
  99.             String studymodel = (String) sourceAsMap.get("studymodel");
  100.             //价格
  101.             Double price = (Double) sourceAsMap.get("price");
  102.             //日期
  103.             try {
  104.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  105.                 System.out.println(timestamp);
  106.             } catch (ParseException e) {
  107.                 e.printStackTrace();
  108.             }
  109.             System.out.println(price);
  110.             System.out.println(name);
  111.             System.out.println(studymodel);
  112.             System.out.println(description);
  113.         }
  114.         return "ok";
  115.     }

multi Query

　　

　　上边的termQuery和matchQuery一次只能匹配一个Field，本节学习multiQuery，一次可以匹配多个字段。 1、基本使用 单项匹配是在一个field中去匹配，多项匹配是拿关键字去多个Field中匹配。

  1. http://localhost:9200/chenxuyou/doc/_search
  2.  
  3. {
  4.     "query": {
  5.         "multi_match": {
  6.             "query": "spring 开发框架",
  7.             "minimum_should_match": "50%",
  8.             "fields": [
  9.                 "name",
  10.                 "description"
  11.             ]
  12.         }
  13.     }
  14. }
  15. 结果：
  16.  
  17. 提高name的权重得分
  18. {
  19.     "query": {
  20.         "multi_match": {
  21.             "query": "spring 开发框架",
  22.             "minimum_should_match": "50%",
  23.             "fields": [
  24.                 "name^10",
  25.                 "description"
  26.             ]
  27.         }
  28.     }
  29. }

这样会导致两次得分不一样，就会造成结果顺序不一样

  1. @RequestMapping(value = "/multiMatchQuery", method = RequestMethod.GET)
  2.     public String multiMatchQuery() {
  3.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  4.         //指定类型
  5.         searchRequest.types("doc");
  6.         //搜索源构建对象
  7.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  8.         //搜索方式
  9.         //根据id查询
  10.  
  11. //匹配关键字
  12.         //搜索方式
  13.         //MultiMatchQuery
  14.         searchSourceBuilder.query(QueryBuilders.multiMatchQuery("spring css","name","description")
  15.                 .minimumShouldMatch("50%")
  16.                 .field("name",));
  17.        // searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  18.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  19.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  20.         //向搜索请求对象中设置搜索源
  21.         searchRequest.source(searchSourceBuilder);
  22.         //执行搜索,向ES发起http请求
  23.         SearchResponse searchResponse = null;
  24.         try {
  25.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  26.         } catch (IOException e) {
  27.             e.printStackTrace();
  28.         }
  29.         //搜索结果
  30.         SearchHits hits = searchResponse.getHits();
  31.         //匹配到的总记录数
  32.         long totalHits = hits.getTotalHits();
  33.         //得到匹配度高的文档
  34.         SearchHit[] searchHits = hits.getHits();
  35.         //日期格式化对象
  36.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  37.         for (SearchHit hit : searchHits) {
  38.             //文档的主键
  39.             String id = hit.getId();
  40.             //源文档内容
  41.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  42.             String name = (String) sourceAsMap.get("name");
  43.             //由于前边设置了源文档字段过虑，这时description是取不到的
  44.             String description = (String) sourceAsMap.get("description");
  45.             //学习模式
  46.             String studymodel = (String) sourceAsMap.get("studymodel");
  47.             //价格
  48.             Double price = (Double) sourceAsMap.get("price");
  49.             //日期
  50.             try {
  51.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  52.                 System.out.println(timestamp);
  53.             } catch (ParseException e) {
  54.                 e.printStackTrace();
  55.             }
  56.             System.out.println(price);
  57.             System.out.println(name);
  58.             System.out.println(studymodel);
  59.             System.out.println(description);
  60.         }
  61.         return "ok";
  62.     }

布尔查询：

　　　

　　布尔查询对应于Lucene的BooleanQuery查询，实现将多个查询组合起来。 三个参数： must：文档必须匹配must所包括的查询条件，相当于 “AND” should：文档应该匹配should所包括的查询条件其 中的一个或多个，相当于 "OR" must_not：文档不能匹配must_not所包括的该查询条件，相当于“NOT”

　　

  1. @RequestMapping(value = "/boolQuery", method = RequestMethod.GET)
  2.     public String boolQuery() {
  3.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  4.         //指定类型
  5.         searchRequest.types("doc");
  6.         //搜索源构建对象
  7.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  8.         //搜索方式
  9.         //根据id查询
  10.  
  11. //匹配关键字
  12.         //搜索方式
  13.         //MultiMatchQuery
  14.         //boolQuery搜索方式
  15.         //先定义一个MultiMatchQuery
  16.         MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring css", "name", "description")
  17.                 .minimumShouldMatch("50%")
  18.                 .field("name", );
  19.         //再定义一个termQuery
  20.         TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("studymodel", "");
  21.  
  22.         //定义一个boolQuery
  23.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  24.         boolQueryBuilder.must(multiMatchQueryBuilder);
  25.         boolQueryBuilder.must(termQueryBuilder);
  26.  
  27.         searchSourceBuilder.query(boolQueryBuilder);
  28.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  29.         searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
  30.         //向搜索请求对象中设置搜索源
  31.         searchRequest.source(searchSourceBuilder);
  32.         // searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  33.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  34.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  35.         //向搜索请求对象中设置搜索源
  36.         searchRequest.source(searchSourceBuilder);
  37.         //执行搜索,向ES发起http请求
  38.         SearchResponse searchResponse = null;
  39.         try {
  40.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  41.         } catch (IOException e) {
  42.             e.printStackTrace();
  43.         }
  44.         //搜索结果
  45.         SearchHits hits = searchResponse.getHits();
  46.         //匹配到的总记录数
  47.         long totalHits = hits.getTotalHits();
  48.         //得到匹配度高的文档
  49.         SearchHit[] searchHits = hits.getHits();
  50.         //日期格式化对象
  51.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  52.         for (SearchHit hit : searchHits) {
  53.             //文档的主键
  54.             String id = hit.getId();
  55.             //源文档内容
  56.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  57.             String name = (String) sourceAsMap.get("name");
  58.             //由于前边设置了源文档字段过虑，这时description是取不到的
  59.             String description = (String) sourceAsMap.get("description");
  60.             //学习模式
  61.             String studymodel = (String) sourceAsMap.get("studymodel");
  62.             //价格
  63.             Double price = (Double) sourceAsMap.get("price");
  64.             //日期
  65.             try {
  66.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  67.                 System.out.println(timestamp);
  68.             } catch (ParseException e) {
  69.                 e.printStackTrace();
  70.             }
  71.             System.out.println(price);
  72.             System.out.println(name);
  73.             System.out.println(studymodel);
  74.             System.out.println(description);
  75.         }
  76.         return "ok";
  77.     }

过滤器：

　　

过虑是针对搜索的结果进行过虑，过虑器主要判断的是文档是否匹配，不去计算和判断文档的匹配度得分，所以过 虑器性能比查询要高，且方便缓存，推荐尽量使用过虑器去实现查询或者过虑器和查询共同使用。

range：范围过虑，保留大于等于60 并且小于等于100的记录。　

term ：项匹配过虑，保留studymodel等于"201001"的记录。
注意：range和term一次只能对一个Field设置范围过虑。

使用：

  1. @RequestMapping(value = "/filterQuery", method = RequestMethod.GET)
  2.     public String filterQuery() {
  3.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  4.         //指定类型
  5.         searchRequest.types("doc");
  6.         //搜索源构建对象
  7.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  8.         //搜索方式
  9.         //根据id查询
  10. //boolQuery搜索方式
  11.         //先定义一个MultiMatchQuery
  12.         MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring css", "name", "description")
  13.                 .minimumShouldMatch("50%")
  14.                 .field("name", );
  15.  
  16.         //定义一个boolQuery
  17.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  18.         boolQueryBuilder.must(multiMatchQueryBuilder);
  19.         //定义过虑器
  20.         boolQueryBuilder.filter(QueryBuilders.termQuery("studymodel",""));
  21.         boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte().lte());
  22.  
  23.         searchSourceBuilder.query(boolQueryBuilder);
  24. //匹配关键字
  25.         //搜索方式
  26.         //MultiMatchQuery
  27.         //boolQuery搜索方式
  28.         //先定义一个MultiMatchQuery
  29.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  30.         searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
  31.         //向搜索请求对象中设置搜索源
  32.         searchRequest.source(searchSourceBuilder);
  33.         // searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  34.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  35.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  36.         //向搜索请求对象中设置搜索源
  37.         searchRequest.source(searchSourceBuilder);
  38.         //执行搜索,向ES发起http请求
  39.         SearchResponse searchResponse = null;
  40.         try {
  41.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  42.         } catch (IOException e) {
  43.             e.printStackTrace();
  44.         }
  45.         //搜索结果
  46.         SearchHits hits = searchResponse.getHits();
  47.         //匹配到的总记录数
  48.         long totalHits = hits.getTotalHits();
  49.         //得到匹配度高的文档
  50.         SearchHit[] searchHits = hits.getHits();
  51.         //日期格式化对象
  52.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  53.         for (SearchHit hit : searchHits) {
  54.             //文档的主键
  55.             String id = hit.getId();
  56.             //源文档内容
  57.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  58.             String name = (String) sourceAsMap.get("name");
  59.             //由于前边设置了源文档字段过虑，这时description是取不到的
  60.             String description = (String) sourceAsMap.get("description");
  61.             //学习模式
  62.             String studymodel = (String) sourceAsMap.get("studymodel");
  63.             //价格
  64.             Double price = (Double) sourceAsMap.get("price");
  65.             //日期
  66.             try {
  67.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  68.                 System.out.println(timestamp);
  69.             } catch (ParseException e) {
  70.                 e.printStackTrace();
  71.             }
  72.             System.out.println(price);
  73.             System.out.println(name);
  74.             System.out.println(studymodel);
  75.             System.out.println(description);
  76.         }
  77.         return "ok";
  78.     }

排序：　

　　可以在字段上添加一个或多个排序，支持在keyword、date、float等类型上添加，text类型的字段上不允许添加排
序

  1. @RequestMapping(value = "/sortQuery", method = RequestMethod.GET)
  2.     public String sortQuery() {
  3.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  4.         //指定类型
  5.         searchRequest.types("doc");
  6.         //搜索源构建对象
  7.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  8.         //搜索方式
  9.         //根据id查询
  10.         //boolQuery搜索方式
  11.         //定义一个boolQuery
  12.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  13.         //定义过虑器
  14.         boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte().lte());
  15.  
  16.         searchSourceBuilder.query(boolQueryBuilder);
  17.         //添加排序
  18.         searchSourceBuilder.sort("studymodel", SortOrder.DESC);
  19.         searchSourceBuilder.sort("price", SortOrder.ASC);
  20. //匹配关键字
  21.         //搜索方式
  22.         //MultiMatchQuery
  23.         //boolQuery搜索方式
  24.         //先定义一个MultiMatchQuery
  25.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  26.         searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
  27.         //向搜索请求对象中设置搜索源
  28.         searchRequest.source(searchSourceBuilder);
  29.         // searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  30.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  31.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  32.         //向搜索请求对象中设置搜索源
  33.         searchRequest.source(searchSourceBuilder);
  34.         //执行搜索,向ES发起http请求
  35.         SearchResponse searchResponse = null;
  36.         try {
  37.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  38.         } catch (IOException e) {
  39.             e.printStackTrace();
  40.         }
  41.         //搜索结果
  42.         SearchHits hits = searchResponse.getHits();
  43.         //匹配到的总记录数
  44.         long totalHits = hits.getTotalHits();
  45.         //得到匹配度高的文档
  46.         SearchHit[] searchHits = hits.getHits();
  47.         //日期格式化对象
  48.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  49.         for (SearchHit hit : searchHits) {
  50.             //文档的主键
  51.             String id = hit.getId();
  52.             //源文档内容
  53.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  54.             String name = (String) sourceAsMap.get("name");
  55.             //由于前边设置了源文档字段过虑，这时description是取不到的
  56.             String description = (String) sourceAsMap.get("description");
  57.             //学习模式
  58.             String studymodel = (String) sourceAsMap.get("studymodel");
  59.             //价格
  60.             Double price = (Double) sourceAsMap.get("price");
  61.             //日期
  62.             try {
  63.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  64.                 System.out.println(timestamp);
  65.             } catch (ParseException e) {
  66.                 e.printStackTrace();
  67.             }
  68.             System.out.println(price);
  69.             System.out.println(name);
  70.             System.out.println(studymodel);
  71.             System.out.println(description);
  72.         }
  73.         return "ok";
  74.     }

高亮：

　　高亮显示可以将搜索结果一个或多个字突出显示，以便向用户展示匹配关键字的位置

  1. @RequestMapping(value = "/highlightQuery", method = RequestMethod.GET)
  2.     public String highlightQuery() {
  3.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  4.         //指定类型
  5.         searchRequest.types("doc");
  6.         //搜索源构建对象
  7.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  8.         //搜索方式
  9.         //根据id查询
  10.         //boolQuery搜索方式
  11.         //定义一个boolQuery
  12.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  13.         //定义过虑器
  14.         boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte().lte());
  15.  
  16.         searchSourceBuilder.query(boolQueryBuilder);
  17.         //设置高亮
  18.         HighlightBuilder highlightBuilder = new HighlightBuilder();
  19.         highlightBuilder.preTags("<tag>");
  20.         highlightBuilder.postTags("</tag>");
  21.         highlightBuilder.fields().add(new HighlightBuilder.Field("name"));
  22. //        highlightBuilder.fields().add(new HighlightBuilder.Field("description"));
  23.         searchSourceBuilder.highlighter(highlightBuilder);
  24. //匹配关键字
  25.         //搜索方式
  26.         //MultiMatchQuery
  27.         //boolQuery搜索方式
  28.         //先定义一个MultiMatchQuery
  29.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  30.         searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
  31.         //向搜索请求对象中设置搜索源
  32.         searchRequest.source(searchSourceBuilder);
  33.         // searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  34.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  35.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  36.         //向搜索请求对象中设置搜索源
  37.         searchRequest.source(searchSourceBuilder);
  38.         //执行搜索,向ES发起http请求
  39.         SearchResponse searchResponse = null;
  40.         try {
  41.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  42.         } catch (IOException e) {
  43.             e.printStackTrace();
  44.         }
  45.         //搜索结果
  46.         SearchHits hits = searchResponse.getHits();
  47.         //匹配到的总记录数
  48.         long totalHits = hits.getTotalHits();
  49.         //得到匹配度高的文档
  50.         SearchHit[] searchHits = hits.getHits();
  51.         //日期格式化对象
  52.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  53.         for (SearchHit hit : searchHits) {
  54.             //文档的主键
  55.             String id = hit.getId();
  56.             //源文档内容
  57.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  58.             String name = (String) sourceAsMap.get("name");
  59.             //由于前边设置了源文档字段过虑，这时description是取不到的
  60.             String description = (String) sourceAsMap.get("description");
  61.             //学习模式
  62.             String studymodel = (String) sourceAsMap.get("studymodel");
  63.             //价格
  64.             Double price = (Double) sourceAsMap.get("price");
  65.             //日期
  66.             try {
  67.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  68.                 System.out.println(timestamp);
  69.             } catch (ParseException e) {
  70.                 e.printStackTrace();
  71.             }
  72.             System.out.println(price);
  73.             System.out.println(name);
  74.             System.out.println(studymodel);
  75.             System.out.println(description);
  76.         }
  77.         return "ok";
  78.     }

最后讲整个controller进行拿出来：

  1. package com.cxy.elasticsearch.controller;
  2.  
  3. import org.elasticsearch.action.search.SearchRequest;
  4. import org.elasticsearch.action.search.SearchResponse;
  5. import org.elasticsearch.action.update.UpdateRequest;
  6. import org.elasticsearch.action.update.UpdateResponse;
  7. import org.elasticsearch.client.RequestOptions;
  8. import org.elasticsearch.client.RestClient;
  9. import org.elasticsearch.client.RestHighLevelClient;
  10. import org.elasticsearch.index.query.*;
  11. import org.elasticsearch.rest.RestStatus;
  12. import org.elasticsearch.search.SearchHit;
  13. import org.elasticsearch.search.SearchHits;
  14. import org.elasticsearch.search.builder.SearchSourceBuilder;
  15. import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
  16. import org.elasticsearch.search.sort.SortOrder;
  17. import org.springframework.beans.factory.annotation.Autowired;
  18. import org.springframework.web.bind.annotation.RequestMapping;
  19. import org.springframework.web.bind.annotation.RequestMethod;
  20. import org.springframework.web.bind.annotation.RestController;
  21.  
  22. import java.io.IOException;
  23. import java.text.ParseException;
  24. import java.text.SimpleDateFormat;
  25. import java.util.Date;
  26. import java.util.HashMap;
  27. import java.util.Map;
  28.  
  29. @RestController
  30. public class EsdocController {
  31.     @Autowired
  32.     RestHighLevelClient client;
  33.  
  34.     @Autowired
  35.     RestClient restClient;
  36.  
  37.     @RequestMapping(value = "/searchAlldoc", method = RequestMethod.GET)
  38.     public String searchAlldoc() {
  39.         //搜索请求对象
  40.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  41.         //指定类型
  42.         searchRequest.types("doc");
  43.         //搜索源构建对象
  44.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  45.         //设置搜索方式
  46.         searchSourceBuilder.query(QueryBuilders.matchAllQuery());
  47.         //设置包含哪些字段，不包括哪些字段，第一个参数，是包含的，第二个是不包含的
  48.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"},new String[]{});
  49.  
  50.         //设置搜索源
  51.         searchRequest.source(searchSourceBuilder);
  52.         SearchResponse search =null;
  53.         try {
  54.             search = client.search(searchRequest, RequestOptions.DEFAULT);
  55.  
  56.         } catch (IOException e) {
  57.             e.printStackTrace();
  58.         }
  59.         SearchHits hits = search.getHits();
  60.         long totalHits = hits.totalHits;
  61.         System.out.println(totalHits);
  62.         SearchHit[] hits1 = hits.getHits();
  63.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  64.         for (SearchHit searchHit:hits1){
  65.             String id = searchHit.getId();
  66.             Map<String, Object> sourceAsMap = searchHit.getSourceAsMap();
  67.             String name = (String) sourceAsMap.get("name");
  68.             //由于前边设置了源文档字段过虑，这时description是取不到的
  69.             String description = (String) sourceAsMap.get("description");
  70.             //学习模式
  71.             String studymodel = (String) sourceAsMap.get("studymodel");
  72.             //价格
  73.             Double price = (Double) sourceAsMap.get("price");
  74.             //日期
  75.            String s = (String) sourceAsMap.get("timestamp");
  76.             Date timestamp =null;
  77.             try {
  78.                 timestamp = dateFormat.parse(s);
  79.  
  80.             } catch (ParseException e) {
  81.                 e.printStackTrace();
  82.             }
  83.             System.out.println(s);
  84.             System.out.println(price);
  85.             System.out.println(name);
  86.             System.out.println(studymodel);
  87.             System.out.println(description);
  88.  
  89.         }
  90.  
  91.         return "ok";
  92.     }
  93.  
  94.     @RequestMapping(value = "/searchAlldocPage", method = RequestMethod.GET)
  95.     public String searchAlldocPage() {
  96.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  97.         //指定类型
  98.         searchRequest.types("doc");
  99.         //搜索源构建对象
  100.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  101.         //设置分页参数
  102.         //页码
  103.         int page = ;
  104.         //每页记录数
  105.         int size = ;
  106.         //计算出记录起始下标
  107.         int from = (page - ) * size;
  108.         searchSourceBuilder.from(from);//起始记录下标，从0开始
  109.         searchSourceBuilder.size(size);//每页显示的记录数
  110.         //搜索方式
  111.         //matchAllQuery搜索全部
  112.         searchSourceBuilder.query(QueryBuilders.matchAllQuery());
  113.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  114.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  115.         //向搜索请求对象中设置搜索源
  116.         searchRequest.source(searchSourceBuilder);
  117.         //执行搜索,向ES发起http请求
  118.         SearchResponse searchResponse = null;
  119.         try {
  120.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  121.         } catch (IOException e) {
  122.             e.printStackTrace();
  123.         }
  124.         //搜索结果
  125.         SearchHits hits = searchResponse.getHits();
  126.         //匹配到的总记录数
  127.         long totalHits = hits.getTotalHits();
  128.         //得到匹配度高的文档
  129.         SearchHit[] searchHits = hits.getHits();
  130.         //日期格式化对象
  131.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  132.         for (SearchHit hit : searchHits) {
  133.             //文档的主键
  134.             String id = hit.getId();
  135.             //源文档内容
  136.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  137.             String name = (String) sourceAsMap.get("name");
  138.             //由于前边设置了源文档字段过虑，这时description是取不到的
  139.             String description = (String) sourceAsMap.get("description");
  140.             //学习模式
  141.             String studymodel = (String) sourceAsMap.get("studymodel");
  142.             //价格
  143.             Double price = (Double) sourceAsMap.get("price");
  144.             //日期
  145.             try {
  146.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  147.                 System.out.println(timestamp);
  148.             } catch (ParseException e) {
  149.                 e.printStackTrace();
  150.             }
  151.             System.out.println(price);
  152.             System.out.println(name);
  153.             System.out.println(studymodel);
  154.             System.out.println(description);
  155.         }
  156.         return "ok";
  157.     }
  158.  
  159.     @RequestMapping(value = "/termquerydocPage", method = RequestMethod.GET)
  160.     public String termquerydocPage() {
  161.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  162.         //指定类型
  163.         searchRequest.types("doc");
  164.         //搜索源构建对象
  165.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  166.         //设置分页参数
  167.         //页码
  168.         int page = ;
  169.         //每页记录数
  170.         int size = ;
  171.         //计算出记录起始下标
  172.         int from = (page - ) * size;
  173.         searchSourceBuilder.from(from);//起始记录下标，从0开始
  174.         searchSourceBuilder.size(size);//每页显示的记录数
  175.         //搜索方式
  176.  
  177.         //matchAllQuery搜索全部
  178.         searchSourceBuilder.query(QueryBuilders.termQuery("name","spring"));
  179.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  180.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  181.         //向搜索请求对象中设置搜索源
  182.         searchRequest.source(searchSourceBuilder);
  183.         //执行搜索,向ES发起http请求
  184.         SearchResponse searchResponse = null;
  185.         try {
  186.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  187.         } catch (IOException e) {
  188.             e.printStackTrace();
  189.         }
  190.         //搜索结果
  191.         SearchHits hits = searchResponse.getHits();
  192.         //匹配到的总记录数
  193.         long totalHits = hits.getTotalHits();
  194.         //得到匹配度高的文档
  195.         SearchHit[] searchHits = hits.getHits();
  196.         //日期格式化对象
  197.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  198.         for (SearchHit hit : searchHits) {
  199.             //文档的主键
  200.             String id = hit.getId();
  201.             //源文档内容
  202.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  203.             String name = (String) sourceAsMap.get("name");
  204.             //由于前边设置了源文档字段过虑，这时description是取不到的
  205.             String description = (String) sourceAsMap.get("description");
  206.             //学习模式
  207.             String studymodel = (String) sourceAsMap.get("studymodel");
  208.             //价格
  209.             Double price = (Double) sourceAsMap.get("price");
  210.             //日期
  211.             try {
  212.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  213.                 System.out.println(timestamp);
  214.             } catch (ParseException e) {
  215.                 e.printStackTrace();
  216.             }
  217.             System.out.println(price);
  218.             System.out.println(name);
  219.             System.out.println(studymodel);
  220.             System.out.println(description);
  221.         }
  222.         return "ok";
  223.     }
  224.     @RequestMapping(value = "/termqueryId", method = RequestMethod.GET)
  225.     public String termqueryId() {
  226.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  227.         //指定类型
  228.         searchRequest.types("doc");
  229.         //搜索源构建对象
  230.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  231.         //搜索方式
  232.         //根据id查询
  233.         //定义id
  234.         String[] ids = new String[]{"",""};
  235.         searchSourceBuilder.query(QueryBuilders.termsQuery("_id",ids));
  236.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  237.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  238.         //向搜索请求对象中设置搜索源
  239.         searchRequest.source(searchSourceBuilder);
  240.         //执行搜索,向ES发起http请求
  241.         SearchResponse searchResponse = null;
  242.         try {
  243.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  244.         } catch (IOException e) {
  245.             e.printStackTrace();
  246.         }
  247.         //搜索结果
  248.         SearchHits hits = searchResponse.getHits();
  249.         //匹配到的总记录数
  250.         long totalHits = hits.getTotalHits();
  251.         //得到匹配度高的文档
  252.         SearchHit[] searchHits = hits.getHits();
  253.         //日期格式化对象
  254.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  255.         for (SearchHit hit : searchHits) {
  256.             //文档的主键
  257.             String id = hit.getId();
  258.             //源文档内容
  259.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  260.             String name = (String) sourceAsMap.get("name");
  261.             //由于前边设置了源文档字段过虑，这时description是取不到的
  262.             String description = (String) sourceAsMap.get("description");
  263.             //学习模式
  264.             String studymodel = (String) sourceAsMap.get("studymodel");
  265.             //价格
  266.             Double price = (Double) sourceAsMap.get("price");
  267.             //日期
  268.             try {
  269.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  270.                 System.out.println(timestamp);
  271.             } catch (ParseException e) {
  272.                 e.printStackTrace();
  273.             }
  274.             System.out.println(price);
  275.             System.out.println(name);
  276.             System.out.println(studymodel);
  277.             System.out.println(description);
  278.         }
  279.         return "ok";
  280.     }
  281.     @RequestMapping(value = "/matchquery", method = RequestMethod.GET)
  282.     public String matchquery() {
  283.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  284.         //指定类型
  285.         searchRequest.types("doc");
  286.         //搜索源构建对象
  287.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  288.         //搜索方式
  289.         //根据id查询
  290.         //定义id
  291.         searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开发框架")
  292.                 .minimumShouldMatch("80%"));
  293.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  294.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  295.         //向搜索请求对象中设置搜索源
  296.         searchRequest.source(searchSourceBuilder);
  297.         //执行搜索,向ES发起http请求
  298.         SearchResponse searchResponse = null;
  299.         try {
  300.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  301.         } catch (IOException e) {
  302.             e.printStackTrace();
  303.         }
  304.         //搜索结果
  305.         SearchHits hits = searchResponse.getHits();
  306.         //匹配到的总记录数
  307.         long totalHits = hits.getTotalHits();
  308.         //得到匹配度高的文档
  309.         SearchHit[] searchHits = hits.getHits();
  310.         //日期格式化对象
  311.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  312.         for (SearchHit hit : searchHits) {
  313.             //文档的主键
  314.             String id = hit.getId();
  315.             //源文档内容
  316.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  317.             String name = (String) sourceAsMap.get("name");
  318.             //由于前边设置了源文档字段过虑，这时description是取不到的
  319.             String description = (String) sourceAsMap.get("description");
  320.             //学习模式
  321.             String studymodel = (String) sourceAsMap.get("studymodel");
  322.             //价格
  323.             Double price = (Double) sourceAsMap.get("price");
  324.             //日期
  325.             try {
  326.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  327.                 System.out.println(timestamp);
  328.             } catch (ParseException e) {
  329.                 e.printStackTrace();
  330.             }
  331.             System.out.println(price);
  332.             System.out.println(name);
  333.             System.out.println(studymodel);
  334.             System.out.println(description);
  335.         }
  336.         return "ok";
  337.     }
  338.  
  339.     @RequestMapping(value = "/matchqueryOr", method = RequestMethod.GET)
  340.     public String matchqueryOr() {
  341.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  342.         //指定类型
  343.         searchRequest.types("doc");
  344.         //搜索源构建对象
  345.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  346.         //搜索方式
  347.         //根据id查询
  348.  
  349. //匹配关键字
  350. searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  351.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  352.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  353.         //向搜索请求对象中设置搜索源
  354.         searchRequest.source(searchSourceBuilder);
  355.         //执行搜索,向ES发起http请求
  356.         SearchResponse searchResponse = null;
  357.         try {
  358.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  359.         } catch (IOException e) {
  360.             e.printStackTrace();
  361.         }
  362.         //搜索结果
  363.         SearchHits hits = searchResponse.getHits();
  364.         //匹配到的总记录数
  365.         long totalHits = hits.getTotalHits();
  366.         //得到匹配度高的文档
  367.         SearchHit[] searchHits = hits.getHits();
  368.         //日期格式化对象
  369.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  370.         for (SearchHit hit : searchHits) {
  371.             //文档的主键
  372.             String id = hit.getId();
  373.             //源文档内容
  374.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  375.             String name = (String) sourceAsMap.get("name");
  376.             //由于前边设置了源文档字段过虑，这时description是取不到的
  377.             String description = (String) sourceAsMap.get("description");
  378.             //学习模式
  379.             String studymodel = (String) sourceAsMap.get("studymodel");
  380.             //价格
  381.             Double price = (Double) sourceAsMap.get("price");
  382.             //日期
  383.             try {
  384.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  385.                 System.out.println(timestamp);
  386.             } catch (ParseException e) {
  387.                 e.printStackTrace();
  388.             }
  389.             System.out.println(price);
  390.             System.out.println(name);
  391.             System.out.println(studymodel);
  392.             System.out.println(description);
  393.         }
  394.         return "ok";
  395.     }
  396.     @RequestMapping(value = "/multiMatchQuery", method = RequestMethod.GET)
  397.     public String multiMatchQuery() {
  398.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  399.         //指定类型
  400.         searchRequest.types("doc");
  401.         //搜索源构建对象
  402.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  403.         //搜索方式
  404.         //根据id查询
  405.  
  406. //匹配关键字
  407.         //搜索方式
  408.         //MultiMatchQuery
  409.         searchSourceBuilder.query(QueryBuilders.multiMatchQuery("spring css","name","description")
  410.                 .minimumShouldMatch("50%")
  411.                 .field("name",));
  412.         // searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  413.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  414.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  415.         //向搜索请求对象中设置搜索源
  416.         searchRequest.source(searchSourceBuilder);
  417.         //执行搜索,向ES发起http请求
  418.         SearchResponse searchResponse = null;
  419.         try {
  420.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  421.         } catch (IOException e) {
  422.             e.printStackTrace();
  423.         }
  424.         //搜索结果
  425.         SearchHits hits = searchResponse.getHits();
  426.         //匹配到的总记录数
  427.         long totalHits = hits.getTotalHits();
  428.         //得到匹配度高的文档
  429.         SearchHit[] searchHits = hits.getHits();
  430.         //日期格式化对象
  431.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  432.         for (SearchHit hit : searchHits) {
  433.             //文档的主键
  434.             String id = hit.getId();
  435.             //源文档内容
  436.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  437.             String name = (String) sourceAsMap.get("name");
  438.             //由于前边设置了源文档字段过虑，这时description是取不到的
  439.             String description = (String) sourceAsMap.get("description");
  440.             //学习模式
  441.             String studymodel = (String) sourceAsMap.get("studymodel");
  442.             //价格
  443.             Double price = (Double) sourceAsMap.get("price");
  444.             //日期
  445.             try {
  446.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  447.                 System.out.println(timestamp);
  448.             } catch (ParseException e) {
  449.                 e.printStackTrace();
  450.             }
  451.             System.out.println(price);
  452.             System.out.println(name);
  453.             System.out.println(studymodel);
  454.             System.out.println(description);
  455.         }
  456.         return "ok";
  457.     }
  458.  
  459.     @RequestMapping(value = "/boolQuery", method = RequestMethod.GET)
  460.     public String boolQuery() {
  461.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  462.         //指定类型
  463.         searchRequest.types("doc");
  464.         //搜索源构建对象
  465.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  466.         //搜索方式
  467.         //根据id查询
  468.  
  469. //匹配关键字
  470.         //搜索方式
  471.         //MultiMatchQuery
  472.         //boolQuery搜索方式
  473.         //先定义一个MultiMatchQuery
  474.         MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring css", "name", "description")
  475.                 .minimumShouldMatch("50%")
  476.                 .field("name", );
  477.         //再定义一个termQuery
  478.         TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("studymodel", "");
  479.  
  480.         //定义一个boolQuery
  481.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  482.         boolQueryBuilder.must(multiMatchQueryBuilder);
  483.         boolQueryBuilder.must(termQueryBuilder);
  484.  
  485.         searchSourceBuilder.query(boolQueryBuilder);
  486.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  487.         searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
  488.         //向搜索请求对象中设置搜索源
  489.         searchRequest.source(searchSourceBuilder);
  490.         // searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  491.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  492.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  493.         //向搜索请求对象中设置搜索源
  494.         searchRequest.source(searchSourceBuilder);
  495.         //执行搜索,向ES发起http请求
  496.         SearchResponse searchResponse = null;
  497.         try {
  498.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  499.         } catch (IOException e) {
  500.             e.printStackTrace();
  501.         }
  502.         //搜索结果
  503.         SearchHits hits = searchResponse.getHits();
  504.         //匹配到的总记录数
  505.         long totalHits = hits.getTotalHits();
  506.         //得到匹配度高的文档
  507.         SearchHit[] searchHits = hits.getHits();
  508.         //日期格式化对象
  509.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  510.         for (SearchHit hit : searchHits) {
  511.             //文档的主键
  512.             String id = hit.getId();
  513.             //源文档内容
  514.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  515.             String name = (String) sourceAsMap.get("name");
  516.             //由于前边设置了源文档字段过虑，这时description是取不到的
  517.             String description = (String) sourceAsMap.get("description");
  518.             //学习模式
  519.             String studymodel = (String) sourceAsMap.get("studymodel");
  520.             //价格
  521.             Double price = (Double) sourceAsMap.get("price");
  522.             //日期
  523.             try {
  524.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  525.                 System.out.println(timestamp);
  526.             } catch (ParseException e) {
  527.                 e.printStackTrace();
  528.             }
  529.             System.out.println(price);
  530.             System.out.println(name);
  531.             System.out.println(studymodel);
  532.             System.out.println(description);
  533.         }
  534.         return "ok";
  535.     }
  536.  
  537.     @RequestMapping(value = "/filterQuery", method = RequestMethod.GET)
  538.     public String filterQuery() {
  539.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  540.         //指定类型
  541.         searchRequest.types("doc");
  542.         //搜索源构建对象
  543.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  544.         //搜索方式
  545.         //根据id查询
  546. //boolQuery搜索方式
  547.         //先定义一个MultiMatchQuery
  548.         MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring css", "name", "description")
  549.                 .minimumShouldMatch("50%")
  550.                 .field("name", );
  551.  
  552.         //定义一个boolQuery
  553.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  554.         boolQueryBuilder.must(multiMatchQueryBuilder);
  555.         //定义过虑器
  556.         boolQueryBuilder.filter(QueryBuilders.termQuery("studymodel",""));
  557.         boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte().lte());
  558.  
  559.         searchSourceBuilder.query(boolQueryBuilder);
  560. //匹配关键字
  561.         //搜索方式
  562.         //MultiMatchQuery
  563.         //boolQuery搜索方式
  564.         //先定义一个MultiMatchQuery
  565.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  566.         searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
  567.         //向搜索请求对象中设置搜索源
  568.         searchRequest.source(searchSourceBuilder);
  569.         // searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  570.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  571.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  572.         //向搜索请求对象中设置搜索源
  573.         searchRequest.source(searchSourceBuilder);
  574.         //执行搜索,向ES发起http请求
  575.         SearchResponse searchResponse = null;
  576.         try {
  577.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  578.         } catch (IOException e) {
  579.             e.printStackTrace();
  580.         }
  581.         //搜索结果
  582.         SearchHits hits = searchResponse.getHits();
  583.         //匹配到的总记录数
  584.         long totalHits = hits.getTotalHits();
  585.         //得到匹配度高的文档
  586.         SearchHit[] searchHits = hits.getHits();
  587.         //日期格式化对象
  588.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  589.         for (SearchHit hit : searchHits) {
  590.             //文档的主键
  591.             String id = hit.getId();
  592.             //源文档内容
  593.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  594.             String name = (String) sourceAsMap.get("name");
  595.             //由于前边设置了源文档字段过虑，这时description是取不到的
  596.             String description = (String) sourceAsMap.get("description");
  597.             //学习模式
  598.             String studymodel = (String) sourceAsMap.get("studymodel");
  599.             //价格
  600.             Double price = (Double) sourceAsMap.get("price");
  601.             //日期
  602.             try {
  603.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  604.                 System.out.println(timestamp);
  605.             } catch (ParseException e) {
  606.                 e.printStackTrace();
  607.             }
  608.             System.out.println(price);
  609.             System.out.println(name);
  610.             System.out.println(studymodel);
  611.             System.out.println(description);
  612.         }
  613.         return "ok";
  614.     }
  615.  
  616.     @RequestMapping(value = "/sortQuery", method = RequestMethod.GET)
  617.     public String sortQuery() {
  618.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  619.         //指定类型
  620.         searchRequest.types("doc");
  621.         //搜索源构建对象
  622.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  623.         //搜索方式
  624.         //根据id查询
  625.         //boolQuery搜索方式
  626.         //定义一个boolQuery
  627.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  628.         //定义过虑器
  629.         boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte().lte());
  630.  
  631.         searchSourceBuilder.query(boolQueryBuilder);
  632.         //添加排序
  633.         searchSourceBuilder.sort("studymodel", SortOrder.DESC);
  634.         searchSourceBuilder.sort("price", SortOrder.ASC);
  635. //匹配关键字
  636.         //搜索方式
  637.         //MultiMatchQuery
  638.         //boolQuery搜索方式
  639.         //先定义一个MultiMatchQuery
  640.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  641.         searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
  642.         //向搜索请求对象中设置搜索源
  643.         searchRequest.source(searchSourceBuilder);
  644.         // searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  645.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  646.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  647.         //向搜索请求对象中设置搜索源
  648.         searchRequest.source(searchSourceBuilder);
  649.         //执行搜索,向ES发起http请求
  650.         SearchResponse searchResponse = null;
  651.         try {
  652.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  653.         } catch (IOException e) {
  654.             e.printStackTrace();
  655.         }
  656.         //搜索结果
  657.         SearchHits hits = searchResponse.getHits();
  658.         //匹配到的总记录数
  659.         long totalHits = hits.getTotalHits();
  660.         //得到匹配度高的文档
  661.         SearchHit[] searchHits = hits.getHits();
  662.         //日期格式化对象
  663.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  664.         for (SearchHit hit : searchHits) {
  665.             //文档的主键
  666.             String id = hit.getId();
  667.             //源文档内容
  668.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  669.             String name = (String) sourceAsMap.get("name");
  670.             //由于前边设置了源文档字段过虑，这时description是取不到的
  671.             String description = (String) sourceAsMap.get("description");
  672.             //学习模式
  673.             String studymodel = (String) sourceAsMap.get("studymodel");
  674.             //价格
  675.             Double price = (Double) sourceAsMap.get("price");
  676.             //日期
  677.             try {
  678.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  679.                 System.out.println(timestamp);
  680.             } catch (ParseException e) {
  681.                 e.printStackTrace();
  682.             }
  683.             System.out.println(price);
  684.             System.out.println(name);
  685.             System.out.println(studymodel);
  686.             System.out.println(description);
  687.         }
  688.         return "ok";
  689.     }
  690.     @RequestMapping(value = "/highlightQuery", method = RequestMethod.GET)
  691.     public String highlightQuery() {
  692.         SearchRequest searchRequest = new SearchRequest("chenxuyou");
  693.         //指定类型
  694.         searchRequest.types("doc");
  695.         //搜索源构建对象
  696.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  697.         //搜索方式
  698.         //根据id查询
  699.         //boolQuery搜索方式
  700.         //定义一个boolQuery
  701.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  702.         //定义过虑器
  703.         boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte().lte());
  704.  
  705.         searchSourceBuilder.query(boolQueryBuilder);
  706.         //设置高亮
  707.         HighlightBuilder highlightBuilder = new HighlightBuilder();
  708.         highlightBuilder.preTags("<tag>");
  709.         highlightBuilder.postTags("</tag>");
  710.         highlightBuilder.fields().add(new HighlightBuilder.Field("name"));
  711. //        highlightBuilder.fields().add(new HighlightBuilder.Field("description"));
  712.         searchSourceBuilder.highlighter(highlightBuilder);
  713. //匹配关键字
  714.         //搜索方式
  715.         //MultiMatchQuery
  716.         //boolQuery搜索方式
  717.         //先定义一个MultiMatchQuery
  718.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  719.         searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","timestamp"},new String[]{});
  720.         //向搜索请求对象中设置搜索源
  721.         searchRequest.source(searchSourceBuilder);
  722.         // searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开 发").operator(Operator.OR));
  723.         //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
  724.         searchSourceBuilder.fetchSource(new String[]{"name", "studymodel", "price", "timestamp"}, new String[]{});
  725.         //向搜索请求对象中设置搜索源
  726.         searchRequest.source(searchSourceBuilder);
  727.         //执行搜索,向ES发起http请求
  728.         SearchResponse searchResponse = null;
  729.         try {
  730.             searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
  731.         } catch (IOException e) {
  732.             e.printStackTrace();
  733.         }
  734.         //搜索结果
  735.         SearchHits hits = searchResponse.getHits();
  736.         //匹配到的总记录数
  737.         long totalHits = hits.getTotalHits();
  738.         //得到匹配度高的文档
  739.         SearchHit[] searchHits = hits.getHits();
  740.         //日期格式化对象
  741.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  742.         for (SearchHit hit : searchHits) {
  743.             //文档的主键
  744.             String id = hit.getId();
  745.             //源文档内容
  746.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  747.             String name = (String) sourceAsMap.get("name");
  748.             //由于前边设置了源文档字段过虑，这时description是取不到的
  749.             String description = (String) sourceAsMap.get("description");
  750.             //学习模式
  751.             String studymodel = (String) sourceAsMap.get("studymodel");
  752.             //价格
  753.             Double price = (Double) sourceAsMap.get("price");
  754.             //日期
  755.             try {
  756.                 Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
  757.                 System.out.println(timestamp);
  758.             } catch (ParseException e) {
  759.                 e.printStackTrace();
  760.             }
  761.             System.out.println(price);
  762.             System.out.println(name);
  763.             System.out.println(studymodel);
  764.             System.out.println(description);
  765.         }
  766.         return "ok";
  767.     }
  768. }

　　

springboot整合es客户端操作elasticsearch（四）的更多相关文章

  1. springboot整合es客户端操作elasticsearch（五）

    springboot整合es客户端操作elasticsearch的总结: 客户端可以进行可以对所有文档进行查询,就是不加任何条件: SearchRequest searchRequest = new ...

  2. springboot整合es客户端操作elasticsearch（二）

    在上章节中整合elasticsearch客户端出现版本问题进行了处理,这章来进行springboot整合得操作 环境:elaticsearch6.2.1,springboot 2.1.8 客户端版本采 ...

  3. springboot整合es客户端操作elasticsearch（三）

    继续上个随笔: 那么我们只需要修改controller中文件就可以完成相关操作 本次主要是对文档得操作: 更新文档: package com.cxy.elasticsearch.controller; ...

  4. SpringBoot整合ES+Kibana

    前言:最近在写一个HTTP代理服务器,记录日志使用的是ES,所以涉及到SpringBoot和ES的整合,整合完毕后又涉及到数据可视化分析,所以使用了Kibana进行管理,有些坑,需要记录一下 Spri ...

  5. 使用Java客户端操作elasticsearch（二）

    承接上文,使用Java客户端操作elasticsearch,本文主要介绍 常见的配置 和Sniffer(集群探测) 的使用. 常见的配置 前面已介绍过,RestClientBuilder支持同时提供一 ...

  6. 使用Java客户端操作elasticsearch

    Java REST客户端有两种风格: Java低级别REST客户端(Java Low Level REST Client,以后都简称低级客户端算了,难得码字):Elasticsearch的官方low- ...

  7. ElasticSearch（三）springboot整合ES

    最基础的整合: 一.maven依赖 <parent> <groupId>org.springframework.boot</groupId> <artifac ...

  8. SpringBoot 整合es(elasticsearch)使用elasticsearch-rest-high-level-client实现增删改

    引入依赖 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok< ...

  9. springboot整合rabbitmq客户端连接报超时异常问题解决:An unexpected connection driver error occured java.net.SocketException: Socket Closed,java.util.concurrent.TimeoutException

    我用的是springboot2.0.6版本,对应的ampq也是2.0.6版本,然后启动一直报: 还有java.util.concurrent.TimeoutException, 用户授权什么的都对,很 ...

随机推荐

  1. C# ado.net DataSet使用(五)

    一.填充dataset class Program { private static string constr = "server=.;database=northwnd;integrat ...

  2. BZOJ 4802: 欧拉函数 (Pollard-Rho)

    开始一直T,原来是没有srand- CODE #include<bits/stdc++.h> using namespace std; typedef long long LL; vect ...

  3. 基于steam的游戏销量预测 — PART 1 — 爬取steam游戏相关数据的爬虫

    语言:python 环境:ubuntu 爬取内容:steam游戏标签,评论,以及在 steamspy 爬取对应游戏的销量 使用相关:urllib,lxml,selenium,chrome 解释: 流程 ...

  4. 【Android-PopupMenu控件】 自定义标题栏+PopupMenu菜单

    效果图 1.布局文件 layout_main.xml 中间标题栏,左右各一个按钮. <LinearLayout xmlns:android="http://schemas.androi ...

  5. 02 CSS和DIV对界面优化

    01 网站首页的优化 <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> &l ...

  6. Spring AMQP 发送消息到 RabbitMQ 收到 x-queue-type 错误

    在使用 Spring AMQP 发送消息到 RabbitMQ 的时候收到错误信息: inequivalent arg 'x-queue-type' for queue 'com.ossez.real. ...

  7. 洛谷——P2058 海港

    题目传送 由于于题目保证输入的ti是递增的,所以发现当我们统计完一艘船的答案后,这个答案多少会对下一艘船的答案有贡献.同时还发现如果对每个艘船都记录他的乘客在整个数据出现的所有国籍中相应出现的次数,在 ...

  8. Go http包执行流程

    Go 语言实现的 Web 服务工作方式与其他形式下的 Web 工作方式并没有什么不同,具体流程如下: -- http包执行流程 Request:来自用户的请求信息,包括 post.get.Cookie ...

  9. eclipse异常：Exception in thread ""http-bio-8080"-exec-5" java.lang.OutOfMemoryError: PermGen space

    用eclipse运行项目,最烦的就是非代码错误.现在这个异常信息,表示的是tomcat启动内存溢出.试过的最简单的办法就是eclipse->project->clean->clean ...

  10. InnoDB缓存---InnoDB Buffer Pool

    InnoDB Buffer Pool 定义 对于InnoDB存储引擎,不管用户数据还是系统数据都是以页的形式存储在表空间进行管理的,其实都是存储在磁盘上的. 当InnoDB处理客户端请求,需要读取某页 ...