@Autowired
    private RestHighLevelClient restHighLevelClient;

/**
     * 创建索引
     * @throws IOException
     */
    @Test
    void creatIndex() throws IOException {
        //1.创建一个索引客户端
        IndicesClient indicesClient = restHighLevelClient.indices();
        //2.创建一个creat索引请求
        CreateIndexRequest request=new CreateIndexRequest("api_index");
        //3.传递request和默认选项进行调用，并得到response响应
        CreateIndexResponse createIndexResponse = indicesClient.create(request, RequestOptions.DEFAULT);
        //4.判断是否创建成功createIndexResponse.isAcknowledged()被确认
        System.out.println(createIndexResponse.isAcknowledged());
    }

/**
     * 获取索引，判断是否存在
     */
    @Test
    void getIndex() throws IOException {
        //1.创建一个索引客户端
        IndicesClient indicesClient = restHighLevelClient.indices();
        //2.创建一个get索引请求
        GetIndexRequest getIndexRequest=new GetIndexRequest("api_index");
        //3.判断索引是否存在
        System.out.println(indicesClient.exists(getIndexRequest, RequestOptions.DEFAULT));
    }

/**
     * 删除索引
     */
    @Test
    void deleteIndex() throws IOException {
        //1.创建索引客户端
        IndicesClient indicesClient = restHighLevelClient.indices();
        //2.创建一个delete索引请求
        DeleteIndexRequest deleteIndexRequest=new DeleteIndexRequest("api_index");
        //3.执行删除请求，得到AcknowledgedResponse响应
        AcknowledgedResponse response = indicesClient.delete(deleteIndexRequest, RequestOptions.DEFAULT);
        //4.判断是否删除成功response.isAcknowledged()被确认
        System.out.println(response.isAcknowledged());
    }

/**
     * 添加文档
     * 将实体类转json传入request
     * @throws IOException
     */
    @Test
    void addDocument() throws IOException {
        //1.创建实体类对象
        User user=new User("if",18);
        //2.获取index请求(连接数据库)
        IndexRequest indexRequest=new IndexRequest("api_index");
        //3.规则：PUT /api_index/_doc/1
        //设置id为1
        indexRequest.id("1")
        //过期时间默认是1s
        .timeout("1s")
        //用fastjson将实体类转json
        .source(JSON.toJSONString(user), XContentType.JSON);
        //4.直接使用restHighLevelClient.index传入request调用
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        //5.返回结果（有"total":2,"successful":1,"failed":0之类的信息）
        System.out.println(indexResponse.toString());
        //6.此时响应状态为CREATED（如果是更新就是UPDATE）
        System.out.println(indexResponse.status());
    }

/**
     * 根据id判断文档是否存在
     * @throws IOException
     */
    @Test
    void isExistDocument() throws IOException {
        //1.指定索引和id
        GetRequest getRequest=new GetRequest("api_index","1");
        //2.查询是否存在此id的文档
        System.out.println(restHighLevelClient.exists(getRequest,RequestOptions.DEFAULT));
    }

/**
     * 根据id获取文档信息
     * @throws IOException
     */
    @Test
    void getDocument() throws IOException {
        //1.指定索引和id
        GetRequest getRequest=new GetRequest("api_index","1");
        //2.传入getRequest获得响应
        GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
        //3.查看文档全部信息
        System.out.println(getResponse.toString());
        //4.得到具体信息
        //索引库
        System.out.println("getResponse.getIndex() = "+getResponse.getIndex());
        //文档id
        System.out.println("getResponse.getId() = "+getResponse.getId());
        //json格式的String形式实体类信息
        System.out.println("getResponse.getSourceAsString() = "+getResponse.getSourceAsString());
        //Map形式实体类信息
        Map<String, Object> source = getResponse.getSource();
        for (String s : source.keySet()) {
            System.out.println(s+" : "+source.get(s));
        }
    }

/**
     * 根据id更新文档
     * 使用updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
     */
    @Test
    void updateDocument() throws IOException {
        //1.获取updateRequest
        UpdateRequest updateRequest=new UpdateRequest("api_index","1");
        //2.创建实体类
        User user=new User("修改后的if",16);
        //3.封装updateRequest
        updateRequest.timeout("1s")
                //因为put更新时需要用到doc参数
                .doc(JSON.toJSONString(user),XContentType.JSON);
        //4.放入客户端执行
        UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        //5.查看结果OK
        System.out.println(updateResponse.status());
    }

/**
    * 根据id删除文档
    * @throws IOException
    */
   @Test
   void deleteDocument() throws IOException {
       //1.获取deleteRequest
       DeleteRequest deleteRequest=new DeleteRequest("api_index","1");
       //2.传入restHighLevelClient客户端
       DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
       //3.查看响应结果
       System.out.println(deleteResponse.status());
   }

/**
     * 批量处理数据（本质上还是循环）
     */
    @Test
    void batchInsertDocument() throws IOException {
        //1.创建BulkRequest
        BulkRequest bulkRequest=new BulkRequest();
        bulkRequest.timeout("10s");
        //2.创建大量数据List
        List<User> userList=new ArrayList<>();
        for(int i=0;i<5;i++){
            userList.add(new User(""+i,i*10));
        }
        //3.循环add进入bulkRequest
        for(int i=0;i<5;i++){
            bulkRequest.add(
                new IndexRequest("api_index")
                    .id(""+i)
                    .source(JSON.toJSONString(userList.get(i)),XContentType.JSON));
        }
        //4.提交一次（可能就不需要循环提交了，效率就高一点点了）
        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        //5.查看状态和是否失败
        System.out.println(bulkResponse.status()+"-"+bulkResponse.hasFailures());
    }

/**
     * 条件查询
     * TermQueryBuilder参数封装到SearchSourceBuilder
     * 再传入SearchRequest，提交到客户端restHighLevelClient
     * 返回SearchResponse
     * searchResponse.getHits().getHits()是具体数据，以Map<String, Object>形式返回
     * @throws IOException
     */
    @Test
    void search() throws IOException {
        SearchRequest searchRequest=new SearchRequest("api_index");
        //1.构建搜索条件类
        SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
        //2.查询条件类，使用QueryBuilders
        //3.QueryBuilders.termQuery()精确查询
        //term不兼容中文！但是将查询字段后加上.keyword即可，例如name.keyword
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name.keyword", "小杨同学");
        //4.QueryBuilders.matchAllQuery()匹配所有
//        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        //5.提交查询条件进行构建
        searchSourceBuilder.query(termQueryBuilder)
                //6.设置60秒超时
                .timeout(new TimeValue(60, TimeUnit.SECONDS));
        //7.将builder提交到request
        searchRequest.source(searchSourceBuilder);
        //8.将请求提交到client获得结果
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        //9.获得结果转为json
        SearchHits searchHits = searchResponse.getHits();
        System.out.println(JSON.toJSONString(searchHits));
        //10.得到具体数据
        for (SearchHit hitsHit : searchHits.getHits()) {
            Map<String, Object> map = hitsHit.getSourceAsMap();
            System.out.println(map);
        }
    }

package com.ifyyf.es_study.utils;

import com.ifyyf.es_study.pojo.Content;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author if
 * @Description: What is it
 * @Date 2021-10-14 下午 08:00
 */
public class HtmlParseUtil {

    public static List<Content> searchJd(String keys) throws IOException {
        //获取请求地址    https://search.jd.com/Search?enc=utf-8&keyword=java
        String url="https://search.jd.com/Search?enc=utf-8&keyword="+keys;
        //解析网页，document返回的就是js的dom对象
        //所有js中能使用的dom对象的方法，这个对象都能使用
        Document document = Jsoup.parse(new URL(url), 30000);
        Element jGoodsList = document.getElementById("J_goodsList");
//        System.out.println(jGoodsList);
        //获取到所有的li标签元素
        Elements li = jGoodsList.getElementsByTag("li");
        List<Content> list=new ArrayList<>();
        for (Element element : li) {
            //图片特别的多的网站为了响应速度，图片一般是懒加载的
            String imgSrc = element.getElementsByTag("img").eq(0).attr("data-lazy-img");
            String price = element.getElementsByClass("p-price").eq(0).text();
            String title = element.getElementsByClass("p-name p-name-type-2").eq(0).text();
            Content content=new Content(title,imgSrc,price);
            list.add(content);
        }
        return list;
    }
}

package com.ifyyf.es_study.service;

/**
 * @Author if
 * @Description: What is it
 * @Date 2021-10-14 下午 08:20
 */
public interface ContentService {
    boolean batchInsertFromJd(String key);
}

package com.ifyyf.es_study.service.impl;

import com.alibaba.fastjson.JSON;
import com.ifyyf.es_study.pojo.Content;
import com.ifyyf.es_study.service.ContentService;
import com.ifyyf.es_study.utils.HtmlParseUtil;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Author if
 * @Description: What is it
 * @Date 2021-10-14 下午 08:28
 */
@Service
public class ContentServiceImpl implements ContentService {
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    @Override
    public boolean batchInsertFromJd(String key) {
        BulkRequest bulkRequest=new BulkRequest();
        bulkRequest.timeout("3m");
        try{
            List<Content> contents = HtmlParseUtil.searchJd("java");
            for(int i=0;i<contents.size();i++){
                bulkRequest.add(new IndexRequest("jd_search")
                        .source(JSON.toJSONString(contents.get(i)), XContentType.JSON));
            }
            BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
            return !bulkResponse.hasFailures();
        }catch(Exception e){
            e.printStackTrace();
        }
        return false;
    }
}

@Override
    public List<Map<String, Object>> searchByKeyWord(String key,int from,int size) throws IOException {
        List<Map<String, Object>> result=new ArrayList<>();
        SearchRequest searchRequest=new SearchRequest("jd_search");
        SearchSourceBuilder searchSourceBuilder =new SearchSourceBuilder();
        //因为中文在精确搜索时有问题，所以用的模糊matchQuery
        MatchQueryBuilder termQueryBuilder = QueryBuilders.matchQuery("title",key);
        searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS))
                .query(termQueryBuilder)
                .from((from-1)*size)
                .size(size);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            result.add(hit.getSourceAsMap());
        }
        return result;
    }

@Test
    void searchByKeyWord() throws IOException {
        List<Map<String, Object>> list = contentService.searchByKeyWord("编程思想",1,3);
        for (Map<String, Object> map : list) {
            System.out.println(map);
        }
    }

package com.ifyyf.es_study.controller;

import com.ifyyf.es_study.service.ContentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * @Author if
 * @Description: What is it
 * @Date 2021-10-14 下午 08:19
 */
@RestController
public class ContentController {

    @Autowired
    private ContentService contentService;

    @GetMapping("/searchByKeyWord/{key}/{page}/{size}")
    public List<Map<String,Object>> searchByKeyWord(@PathVariable String key,
                                                    @PathVariable int page,
                                                    @PathVariable int size) throws IOException {
        return contentService.searchByKeyWord(key,page,size);
    }
}

@Override
    public List<Map<String, Object>> searchHighLight(String key,int from,int size) throws IOException {
        List<Map<String, Object>> result=new ArrayList<>();
        SearchRequest searchRequest=new SearchRequest("jd_search");
        SearchSourceBuilder searchSourceBuilder =new SearchSourceBuilder();
        //因为中文在精确搜索时有问题，所以用的模糊matchQuery
        MatchQueryBuilder termQueryBuilder = QueryBuilders.matchQuery("title",key);
        //高亮构造器
        HighlightBuilder highlightBuilder=new HighlightBuilder();
        //是否需要多个参数高亮
        highlightBuilder.requireFieldMatch(false);
        //设置高亮字段
        highlightBuilder.field("title");
        //前标签
        highlightBuilder.preTags("<strong class='high-light' style='color:red'>");
        //后标签闭合
        highlightBuilder.postTags("</strong>");
        searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS))
                .query(termQueryBuilder)
                .from((from-1)*size)
                .size(size)
                .highlighter(highlightBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            //得到所有结果
            Map<String, Object> source = hit.getSourceAsMap();
            //获取高亮的字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            HighlightField highlightField = highlightFields.get("title");
            //解析高亮字段
            if(highlightField!=null){
                source.put(highlightField.getName(),highlightField.getFragments()[0].toString());
            }
            result.add(source);
        }
        return result;
    }