内容参考自 图灵学院 ElasticSearch专栏

项目地址:

直接参考码云地址: https://gitee.com/zjj19941/ZJJ_ElasticSearch.git

直接看 com.baiqi.elasticsearch.service.JobFullTextServiceTest 测试类

pom依赖

  1. <dependency>
  2.   <groupId>org.elasticsearch</groupId>
  3.   <artifactId>elasticsearch</artifactId>
  4.   <version>7.6.1</version>
  5. </dependency>
  7. <!-- ES的高阶的客户端API -->
  8. <dependency>
  9.   <groupId>org.elasticsearch.client</groupId>
  10.   <artifactId>elasticsearch-rest-high-level-client</artifactId>
  11.   <version>7.6.1</version>
  12. </dependency>

连接ElasticSearch索引库

  1.     private RestHighLevelClient restHighLevelClient;
  2.     // 索引库的名字
  3.     private static final String JOB_IDX = "job_index";
  5.     /**
  6.      * 连接ElasticSearch索引库
  7.      */
  8.     public JobFullTextServiceImpl() {
  9.         // 建立与ES的连接
  10.         // 1. 使用RestHighLevelClient构建客户端连接。
  11.         // 2. 基于RestClient.builder方法来构建RestClientBuilder
  12.         // 3. 用HttpHost来添加ES的节点
  13.         RestClientBuilder restClientBuilder = RestClient.builder(
  14.                 new HttpHost("zjj101", 9200, "http")
  15.                 , new HttpHost("zjj102", 9200, "http")
  16.                 , new HttpHost("zjj103", 9200, "http"));
  17.        /* RestClientBuilder restClientBuilder = RestClient.builder(
  18.                 new HttpHost("192.168.21.130", 9200, "http"));*/
  19.         restHighLevelClient = new RestHighLevelClient(restClientBuilder);
  20.     }

添加数据

  1.   /**添加数据
  2.      *
  3.      * @param jobDetail
  4.      * @throws IOException
  5.      */
  6.     @Override
  7.     public void add(JobDetail jobDetail) throws IOException {
  8.         //1.    构建IndexRequest对象，用来描述ES发起请求的数据。
  9.         IndexRequest indexRequest = new IndexRequest(JOB_IDX);
  11.         //2.    设置文档ID。
  12.         indexRequest.id(jobDetail.getId() + "");
  14.         //3.    使用FastJSON将实体类对象转换为JSON。
  15.         String json = JSONObject.toJSONString(jobDetail);
  17.         //4.    使用IndexRequest.source方法设置文档数据，并设置请求的数据为JSON格式。
  18.         indexRequest.source(json, XContentType.JSON);
  20.         //5.    使用ES High level client调用index方法发起请求，将一个文档添加到索引中。
  21.         restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
  22.     }

根据id查找

  1.     /**
  2.      * 根据id查找
  3.      * @param id
  4.      * @return
  5.      * @throws IOException
  6.      */
  7.     @Override
  8.     public JobDetail findById(long id) throws IOException {
  9.         // 1.    构建GetRequest请求。
  10.         GetRequest getRequest = new GetRequest(JOB_IDX, id + "");
  12.         // 2.    使用RestHighLevelClient.get发送GetRequest请求，并获取到ES服务器的响应。
  13.         GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
  15.         // 3.    将ES响应的数据转换为JSON字符串 (这个字符串是_source代码块儿里面的数据)
  16.         String json = getResponse.getSourceAsString();
  18.         // 4.    并使用FastJSON将JSON字符串转换为JobDetail类对象
  19.         JobDetail jobDetail = JSONObject.parseObject(json, JobDetail.class);
  21.         // 5.    记得：单独设置ID,因为_source里面是没有id这个属性的,如果你需要id这个属性你就得单独设置进去
  22.         jobDetail.setId(id);
  24.         return jobDetail;
  25.     }

更新数据

  1.     /**
  2.      * 更新数据
  3.      * @param jobDetail
  4.      * @throws IOException
  5.      */
  6.     @Override
  7.     public void update(JobDetail jobDetail) throws IOException {
  8.         // 1.    判断对应ID的文档是否存在
  9.         // a)    构建GetRequest
  10.         GetRequest getRequest = new GetRequest(JOB_IDX, jobDetail.getId() + "");
  12.         // b)    执行client的exists方法，发起请求，判断是否存在
  13.         // 为什么要先判断是否存在呢?因为你不判断的话,你直接操作的话,万一这条数据不存在,就会抛异常出来
  14.         boolean exists = restHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);
  16.         if(exists) {
  17.             // 2.    构建UpdateRequest请求
  18.             UpdateRequest updateRequest = new UpdateRequest(JOB_IDX, jobDetail.getId() + "");
  20.             // 3.    设置UpdateRequest的文档，并配置为JSON格式
  21.             updateRequest.doc(JSONObject.toJSONString(jobDetail), XContentType.JSON);
  23.             // 4.    执行client发起update请求
  24.             restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
  25.         }
  26.     }

根据id删除

  2.     /**
  3.      * 根据id删除
  4.      * @param id
  5.      * @throws IOException
  6.      */
  7.     @Override
  8.     public void deleteById(long id) throws IOException {
  9.         // 1.    构建delete请求
  10.         DeleteRequest deleteRequest = new DeleteRequest(JOB_IDX, id + "");
  12.         // 2.    使用RestHighLevelClient执行delete请求
  13.         restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
  15.     }

根据关键字搜索

  1.     /**
  2.      * 根据关键字搜索
  3.      * @param keywords
  4.      * @return
  5.      * @throws IOException
  6.      */
  7.     @Override
  8.     public List<JobDetail> searchByKeywords(String keywords) throws IOException {
  9.         // 1.构建SearchRequest检索请求
  10.         // 专门用来进行全文检索、关键字检索的API
  11.         SearchRequest searchRequest = new SearchRequest(JOB_IDX);
  13.         // 2.创建一个SearchSourceBuilder专门用于构建查询条件
  14.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  16.         // 3.使用QueryBuilders.multiMatchQuery构建一个查询条件（搜索title、jd），并配置到SearchSourceBuilder
  17.         MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery(keywords, "title", "jd");
  19.         // 将查询条件设置到查询请求构建器中
  20.         searchSourceBuilder.query(multiMatchQueryBuilder);
  22.         // 4.调用SearchRequest.source将查询条件设置到检索请求
  23.         searchRequest.source(searchSourceBuilder);
  25.         // 5.执行RestHighLevelClient.search发起请求
  26.         SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
  27.         SearchHit[] hitArray = searchResponse.getHits().getHits();
  29.         // 6.遍历结果
  30.         ArrayList<JobDetail> jobDetailArrayList = new ArrayList<>();
  32.         for (SearchHit documentFields : hitArray) {
  33.             // 1)获取命中的结果
  34.             String json = documentFields.getSourceAsString();
  36.             // 2)将JSON字符串转换为对象
  37.             JobDetail jobDetail = JSONObject.parseObject(json, JobDetail.class);
  39.             // 3)使用SearchHit.getId设置文档ID
  40.             jobDetail.setId(Long.parseLong(documentFields.getId()));
  42.             jobDetailArrayList.add(jobDetail);
  43.         }
  45.         return jobDetailArrayList;
  46.     }

基于form size分页查询

  1.   @Override
  2.     public Map<String, Object> searchByPage(String keywords, int pageNum, int pageSize) throws IOException {
  3.         // 1.构建SearchRequest检索请求
  4.         // 专门用来进行全文检索、关键字检索的API
  5.         SearchRequest searchRequest = new SearchRequest(JOB_IDX);
  7.         // 2.创建一个SearchSourceBuilder专门用于构建查询条件
  8.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  10.         // 3.使用QueryBuilders.multiMatchQuery构建一个查询条件（搜索title、jd），并配置到SearchSourceBuilder
  11.         MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery(keywords, "title", "jd");
  13.         // 将查询条件设置到查询请求构建器中
  14.         searchSourceBuilder.query(multiMatchQueryBuilder);
  16.         // 每页显示多少条
  17.         searchSourceBuilder.size(pageSize);
  18.         // 设置从第几条开始查询
  19.         searchSourceBuilder.from((pageNum - 1) * pageSize);
  21.         // 4.调用SearchRequest.source将查询条件设置到检索请求
  22.         searchRequest.source(searchSourceBuilder);
  24.         // 5.执行RestHighLevelClient.search发起请求
  25.         SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
  26.         SearchHit[] hitArray = searchResponse.getHits().getHits();
  28.         // 6.遍历结果
  29.         ArrayList<JobDetail> jobDetailArrayList = new ArrayList<>();
  31.         for (SearchHit documentFields : hitArray) {
  32.             // 1)获取命中的结果
  33.             String json = documentFields.getSourceAsString();
  35.             // 2)将JSON字符串转换为对象
  36.             JobDetail jobDetail = JSONObject.parseObject(json, JobDetail.class);
  38.             // 3)使用SearchHit.getId设置文档ID
  39.             jobDetail.setId(Long.parseLong(documentFields.getId()));
  41.             jobDetailArrayList.add(jobDetail);
  42.         }
  44.         // 8.    将结果封装到Map结构中（带有分页信息）
  45.         // a)    total -> 使用SearchHits.getTotalHits().value获取到所有的记录数
  46.         // b)    content -> 当前分页中的数据
  47.         long totalNum = searchResponse.getHits().getTotalHits().value;
  48.         HashMap hashMap = new HashMap();
  49.         hashMap.put("total", totalNum);
  50.         hashMap.put("content", jobDetailArrayList);
  53.         return hashMap;
  54.     }

基于 scroll分页和查询结果带关键字就高亮处理

  1.    // scroll分页解决深分页问题
  2.     @Override
  3.     public Map<String, Object> searchByScrollPage(String keywords, String scrollId, int pageSize) throws IOException {
  4.         SearchResponse searchResponse = null;
  6.         if(scrollId == null) {
  7.             // 1.构建SearchRequest检索请求
  8.             // 专门用来进行全文检索、关键字检索的API
  9.             SearchRequest searchRequest = new SearchRequest(JOB_IDX);
  11.             // 2.创建一个SearchSourceBuilder专门用于构建查询条件
  12.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  14.             // 3.使用QueryBuilders.multiMatchQuery构建一个查询条件（搜索title、jd），并配置到SearchSourceBuilder
  15.             MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery(keywords, "title", "jd");
  17.             // 将查询条件设置到查询请求构建器中
  18.             searchSourceBuilder.query(multiMatchQueryBuilder);
  20.             // 设置高亮
  21.             HighlightBuilder highlightBuilder = new HighlightBuilder();
  22.             highlightBuilder.field("title");
  23.             highlightBuilder.field("jd");
  24.             highlightBuilder.preTags("<font color='red'>");
  25.             highlightBuilder.postTags("</font>");
  27.             // 给请求设置高亮
  28.             searchSourceBuilder.highlighter(highlightBuilder);
  30.             // 每页显示多少条
  31.             searchSourceBuilder.size(pageSize);
  33.             // 4.调用SearchRequest.source将查询条件设置到检索请求
  34.             searchRequest.source(searchSourceBuilder);
  36.             //--------------------------
  37.             // 设置scroll查询
  38.             //--------------------------
  39.             searchRequest.scroll(TimeValue.timeValueMinutes(5));
  41.             // 5.执行RestHighLevelClient.search发起请求
  42.             searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
  44.         }
  45.         // 第二次查询的时候，直接通过scroll id查询数据
  46.         else {
  47.             SearchScrollRequest searchScrollRequest = new SearchScrollRequest(scrollId);
  48.             searchScrollRequest.scroll(TimeValue.timeValueMinutes(5));
  50.             // 使用RestHighLevelClient发送scroll请求
  51.             searchResponse = restHighLevelClient.scroll(searchScrollRequest, RequestOptions.DEFAULT);
  52.         }
  54.         //--------------------------
  55.         // 迭代ES响应的数据
  56.         //--------------------------
  58.         SearchHit[] hitArray = searchResponse.getHits().getHits();
  60.         // 6.遍历结果
  61.         ArrayList<JobDetail> jobDetailArrayList = new ArrayList<>();
  63.         for (SearchHit documentFields : hitArray) {
  64.             // 1)获取命中的结果
  65.             String json = documentFields.getSourceAsString();
  67.             // 2)将JSON字符串转换为对象
  68.             JobDetail jobDetail = JSONObject.parseObject(json, JobDetail.class);
  70.             // 3)使用SearchHit.getId设置文档ID
  71.             jobDetail.setId(Long.parseLong(documentFields.getId()));
  73.             jobDetailArrayList.add(jobDetail);
  75.             // 设置高亮的一些文本到实体类中
  76.             // 封装了高亮
  77.             Map<String, HighlightField> highlightFieldMap = documentFields.getHighlightFields();
  78.             HighlightField titleHL = highlightFieldMap.get("title");
  79.             HighlightField jdHL = highlightFieldMap.get("jd");
  81.             if(titleHL != null) {
  82.                 // 获取指定字段的高亮片段
  83.                 Text[] fragments = titleHL.getFragments();
  84.                 // 将这些高亮片段拼接成一个完整的高亮字段
  85.                 StringBuilder builder = new StringBuilder();
  86.                 for(Text text : fragments) {
  87.                     builder.append(text);
  88.                 }
  89.                 // 设置到实体类中
  90.                 jobDetail.setTitle(builder.toString());
  91.             }
  93.             if(jdHL != null) {
  94.                 // 获取指定字段的高亮片段
  95.                 Text[] fragments = jdHL.getFragments();
  96.                 // 将这些高亮片段拼接成一个完整的高亮字段
  97.                 StringBuilder builder = new StringBuilder();
  98.                 for(Text text : fragments) {
  99.                     builder.append(text);
  100.                 }
  101.                 // 设置到实体类中
  102.                 jobDetail.setJd(builder.toString());
  103.             }
  104.         }
  106.         // 8.    将结果封装到Map结构中（带有分页信息）
  107.         // a)    total -> 使用SearchHits.getTotalHits().value获取到所有的记录数
  108.         // b)    content -> 当前分页中的数据
  109.         long totalNum = searchResponse.getHits().getTotalHits().value;
  110.         HashMap hashMap = new HashMap();
  111.         hashMap.put("scroll_id", searchResponse.getScrollId());
  112.         hashMap.put("content", jobDetailArrayList);
  114.         return hashMap;
  115.     }