springboot2+elasticsearch7.13.3

API 接口参考：http://jvm123.com/2020/08/spring-zhong-shi.html

pom.xml 文件：


    org.elasticsearch.client
    elasticsearch-rest-high-level-client
    7.13.3


yml文件：

# 开发环境数据源配置
spring:
    elasticsearch:
        rest:
            uris: http://192.168.1.198:9200
    datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        druid:
            # 主库数据源
            master:
                url: jdbc:mysql://rm-uf658ly8804f04r25ro.mysql.rds.aliyuncs.com:3306/realize-vue?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
                username: root
                password: 123456
            # 从库数据源
            slave:
                # 从数据源开关/默认关闭
                enabled: false
                url:
                username:
                password:
            # 初始连接数
            initialSize: 5
            # 最小连接池数量
            minIdle: 10
            # 最大连接池数量
            maxActive: 20
            # 配置获取连接等待超时的时间
            maxWait: 60000
            # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
            timeBetweenEvictionRunsMillis: 60000
            # 配置一个连接在池中最小生存的时间，单位是毫秒
            minEvictableIdleTimeMillis: 300000
            # 配置一个连接在池中最大生存的时间，单位是毫秒
            maxEvictableIdleTimeMillis: 900000
            # 配置检测连接是否有效
            validationQuery: SELECt 1 FROM DUAL
            testWhileIdle: true
            testOnBorrow: false
            testOnReturn: false
            webStatFilter:
                enabled: true
            statViewServlet:
                enabled: true
                # 设置白名单，不填则允许所有访问
                allow:
                url-pattern: /druid
@RestController
@Transactional(rollbackFor = Exception.class)
@RequestMapping("/system/SysESLawsAndRegulationsController")
public class SysESLawsAndRegulationsController extends EsbaseController {
    @Autowired
    ISysESLawsAndRegulationsService ISysESLawsAndRegulationsService;

    @Autowired
    ILawsAndRegulationsService iLawsAndRegulationsService;

    @GetMapping("/a")
    public String a() {
        return "a";
    }
    //删除索引
    @GetMapping("/deleteIndex")
    public Boolean deleteIndex() {
        return iLawsAndRegulationsService.deleteIndex();
    }

    //创建索引，存入数据
    @GetMapping("/create")
    public Boolean create() throws IOException {
        return iLawsAndRegulationsService.esTest();
    }




    
    @GetMapping("/getESLawsAndRegulations")
    public TableDataInfo getText(String marketNum,
                                 String incentiveNum,
                                 String enterpriseNum,
                                 String title,
                                 String fullText,
                                 Integer thevalidity,
                                 Integer pageNum,
                                 Integer pageSize
    ) throws IOException {
//        System.out.println("参数"+marketNum +","+ incentiveNum +","+ enterpriseNum +","+title +","+fullText +","+thevalidity);
//        System.out.println("分页："+pageNum+","+pageSize);
        List> esList = ISysESLawsAndRegulationsService.getEsLawsAndRegulations(marketNum, incentiveNum, enterpriseNum, title, fullText, thevalidity,pageNum,pageSize);
        Long esTotal = ISysESLawsAndRegulationsService.getEsTotal(marketNum, incentiveNum, enterpriseNum, title, fullText, thevalidity, pageNum, pageSize);
        return getDataTable(esList,esTotal);

    }


}


-----------------es 分页查询 service----------------

package com.realize.project.system.service.impl;

import com.realize.project.system.service.ISysESLawsAndRegulationsService;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.unit.Timevalue;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;


@Service
public class SysESLawsAndRegulationsServiceImpl implements ISysESLawsAndRegulationsService {

    private static final Logger logger = LoggerFactory.getLogger(SysESLawsAndRegulationsServiceImpl.class);

    //集群名称
    //public static final String CLUSTER_NAME = "my-application";
    @Value("${data.elasticsearch.cluster-name}")
    String cluster_name ;

    @Autowired
    RestHighLevelClient restHighLevelClient;

    
    @Override
    public List> getEsLawsAndRegulations(
            String marketNum,
            String incentiveNum,
            String enterpriseNum,
            String title,
            String fullText,
            Integer thevalidity,
            Integer pageNum,
            Integer pageSize
    ) throws IOException {
        System.out.println(cluster_name);
        //创建索引请求
        SearchRequest searchRequest = new SearchRequest(cluster_name);
        //实例化
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //实例化
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //初始化每个字段的属性
        MatchPhraseQueryBuilder marketNumTQ = null;
        MatchPhraseQueryBuilder incentiveNumTQ = null;
        MatchPhraseQueryBuilder enterpriseNumTQ = null;
        MatchPhraseQueryBuilder titleTQ = null;
        MatchPhraseQueryBuilder fullTextTQ = null;
        MatchPhraseQueryBuilder thevalidityTQ = null;

        if (marketNum != null && incentiveNum != null && enterpriseNum != null && thevalidity != null &&
                marketNum != "" && incentiveNum != "" && enterpriseNum != ""
        ) {
            //如果是全部，则市场板块不成为条件，如果不是全部，则成为条件
            if (!marketNum.equals("AllMarket")) {
                marketNumTQ = QueryBuilders.matchPhraseQuery(marketNum,1);
                boolQueryBuilder.must(marketNumTQ);
            }
            //如果是全部，则市场板块不成为条件，如果不是全部，则成为条件
            if (!incentiveNum.equals("Allincentive")) {
                incentiveNumTQ = QueryBuilders.matchPhraseQuery(incentiveNum,1);
                boolQueryBuilder.must(incentiveNumTQ);
            }
            //如果是全部，则市场板块不成为条件，如果不是全部，则成为条件
            if (!enterpriseNum.equals("Allenterprise")) {
                enterpriseNumTQ = QueryBuilders.matchPhraseQuery(enterpriseNum,1);
                boolQueryBuilder.must(enterpriseNumTQ);
            }
            //有效性为全部，则不用添加有效性条件
            if (thevalidity != 2) {
                //matchPhraseQuery不分词
                thevalidityTQ = QueryBuilders.matchPhraseQuery("thevalidity",thevalidity);
                boolQueryBuilder.must(thevalidityTQ);
            }
            if (title != null && title != "") {
                titleTQ = QueryBuilders.matchPhraseQuery("lawsRegulationsName",title);
                boolQueryBuilder.must(titleTQ);
            }
            if (fullText != null && fullText != "") {
                fullTextTQ = QueryBuilders.matchPhraseQuery("contentInfo",fullText);
                boolQueryBuilder.must(fullTextTQ);
            }
        }

        //全文高亮 标题高亮
        String preTags="";
        String postTags="";
        if ((fullText !=null & fullText !="") || (title !=null && title != "")) {
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.field("contentInfo").field("lawsRegulationsName");
            highlightBuilder.preTags("");
            highlightBuilder.postTags("");
            searchSourceBuilder.highlighter(highlightBuilder);
        }
        //分页
        if(pageNum<=0){
            pageNum = 1;
        }
        if(pageSize<=0){
            pageSize=10;
        }
        //起始记录下标
        int from = (pageNum-1) * pageSize;
        searchSourceBuilder.from(from);
        searchSourceBuilder.size(pageSize);

        //执行查询
        searchSourceBuilder.query(boolQueryBuilder);

        //打印
        System.out.println("检索：   " + searchSourceBuilder.toString());
        //不能超过60秒
        searchSourceBuilder.timeout(new Timevalue(60, TimeUnit.SECONDS));
        searchSourceBuilder.trackTotalHits(true);
        //检索
        searchRequest.source(searchSourceBuilder);
        //数据结果集初始化
        List> list = new ArrayList<>();
        //客户端调用检索语法
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        //获取响应结果
        SearchHits hits = searchResponse.getHits();
        //记录总数
        Long totalHits = hits.getTotalHits().value;
//        System.out.println("命中数：" + totalHits);
        SearchHit[] hitss = searchResponse.getHits().getHits();
//        System.out.println("命中：" + hitss.length);

        //循环存入结果集
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            if ((title != null && title != "") || (fullText != null && fullText != "")) {
                //设置标题高亮
                Map titlehighlightFields = hit.getHighlightFields();
                HighlightField titleHight = titlehighlightFields.get("lawsRegulationsName");
                //设置全文高亮
                Map fullTexthighlightFields = hit.getHighlightFields();
                HighlightField fullTextHight = fullTexthighlightFields.get("contentInfo");

                Map sourceAsMap = hit.getSourceAsMap();
                String contentInfo = (String) sourceAsMap.get("contentInfo");
                //标题-高亮词替换
                if (titleHight != null ){
                    Text[] fragments = titleHight.fragments();
                    StringBuilder newtitle = new StringBuilder();
                    for (Text text:fragments) {
                        newtitle.append(text);
                    }
                    sourceAsMap.replace("lawsRegulationsName", newtitle);
                }
                //全文-高亮词替换
                if (fullTextHight != null ){
                    Text[] fragments = fullTextHight.getFragments();
                    StringBuilder newfullText = new StringBuilder();
                    for (Text text:fragments) {
                        newfullText.append(text);
                    }
                    String strc = contentInfo.replace(fullText,preTags+ fullText +postTags);
                    sourceAsMap.put("contentInfo", strc);
                }
                list.add(sourceAsMap);
            } else {
                list.add(hit.getSourceAsMap());
            }
        }
        System.out.println("结果集长度：" + list.size());

        //返回结果集
        return list;
    }

    
    @Override
    public Long getEsTotal(String marketNum, String incentiveNum, String enterpriseNum, String title, String fullText, Integer thevalidity, Integer pageNum, Integer pageSize) throws IOException {
        //创建索引请求
        SearchRequest searchRequest = new SearchRequest(cluster_name);
        //实例化
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //实例化
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //初始化每个字段的属性
        MatchPhraseQueryBuilder marketNumTQ = null;
        MatchPhraseQueryBuilder incentiveNumTQ = null;
        MatchPhraseQueryBuilder enterpriseNumTQ = null;
        MatchPhraseQueryBuilder titleTQ = null;
        MatchPhraseQueryBuilder fullTextTQ = null;
        MatchPhraseQueryBuilder thevalidityTQ = null;

        if (marketNum != null && incentiveNum != null && enterpriseNum != null && thevalidity != null &&
                marketNum != "" && incentiveNum != "" && enterpriseNum != ""
        ) {
            //如果是全部，则市场板块不成为条件，如果不是全部，则成为条件
            if (!marketNum.equals("AllMarket")) {
                marketNumTQ = QueryBuilders.matchPhraseQuery(marketNum,1);
                boolQueryBuilder.must(marketNumTQ);
            }
            //如果是全部，则市场板块不成为条件，如果不是全部，则成为条件
            if (!incentiveNum.equals("Allincentive")) {
                incentiveNumTQ = QueryBuilders.matchPhraseQuery(incentiveNum,1);
                boolQueryBuilder.must(incentiveNumTQ);
            }
            //如果是全部，则市场板块不成为条件，如果不是全部，则成为条件
            if (!enterpriseNum.equals("Allenterprise")) {
                enterpriseNumTQ = QueryBuilders.matchPhraseQuery(enterpriseNum,1);
                boolQueryBuilder.must(enterpriseNumTQ);
            }
            //有效性为全部，则不用添加有效性条件
            if (thevalidity != 2) {
                //matchPhraseQuery不分词
                thevalidityTQ = QueryBuilders.matchPhraseQuery("thevalidity",thevalidity);
                boolQueryBuilder.must(thevalidityTQ);
            }
            if (title != null && title != "") {
                titleTQ = QueryBuilders.matchPhraseQuery("lawsRegulationsName",title);
                boolQueryBuilder.must(titleTQ);
            }
            if (fullText != null && fullText != "") {
                fullTextTQ = QueryBuilders.matchPhraseQuery("contentInfo",fullText);
                boolQueryBuilder.must(fullTextTQ);
            }
        }
        //分页
        if(pageNum<=0){
            pageNum = 1;
        }
        if(pageSize<=0){
            pageSize=10;
        }
        //起始记录下标
        int from = (pageNum-1) * pageSize;
        searchSourceBuilder.from(from);
        searchSourceBuilder.size(pageSize);

        //执行查询
        searchSourceBuilder.query(boolQueryBuilder);

        //打印
        System.out.println("检索：   " + searchSourceBuilder.toString());
        //不能超过60秒
        searchSourceBuilder.timeout(new Timevalue(60, TimeUnit.SECONDS));
        //检索
        searchRequest.source(searchSourceBuilder);
        //客户端调用检索语法
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        //获取响应结果
        SearchHits hits = searchResponse.getHits();
        Long totalHits = hits.getTotalHits().value;
        //记录总数
//        System.out.println("命中数："+totalHits);
        //返回总记录数
        return totalHits;
    }

}


--------------mysql表数据同步到es  service -----------------------------
package com.realize.project.system.service.impl;

import com.alibaba.fastjson.JSON;
import com.realize.project.system.domain.SyslawsAndRegulations;
import com.realize.project.system.domain.dto.LawsAndRegulationsDto;
import com.realize.project.system.mapper.LawsAndRegulationsMapper;
import com.realize.project.system.service.ILawsAndRegulationsService;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.Timevalue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;


@Service
public class SysLawsAndRegulationsServiceImpl implements ILawsAndRegulationsService {
    @Value("${data.elasticsearch.cluster-name}")
    String cluster_name ;

    @Autowired
    LawsAndRegulationsMapper lawsAndRegulationsMapper;
    @Autowired
    RestHighLevelClient restHighLevelClient;

    
    @Override
    public List select(LawsAndRegulationsDto lawsAndRegulationsDto) {
        List lawsAndRegulationsInfoList = lawsAndRegulationsMapper.select(lawsAndRegulationsDto);
        return lawsAndRegulationsInfoList;
    }

    
    @Override
    public Boolean esTest() throws IOException {
        //查询出所有数据
        List searchList = lawsAndRegulationsMapper.searchText();


        try{
            BulkRequest bulkRequest = new BulkRequest();
            bulkRequest.timeout("2m");
            for (int i = 0; i < searchList.size(); i++) {
                bulkRequest.add(
                        new IndexRequest(cluster_name).source(JSON.toJSonString(searchList.get(i)),XContentType.JSON)
                );
            }
            BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
            return !bulk.hasFailures();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

    
    @Override
    public Boolean deleteIndex(){
        boolean acknowledged = false;
        try {
            DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(cluster_name);
            deleteIndexRequest.indicesOptions(IndicesOptions.LENIENT_EXPAND_OPEN);
            AcknowledgedResponse delete = restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
            acknowledged = delete.isAcknowledged();
            if (acknowledged=true) {
                System.out.println("删除完成");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return acknowledged;
    }

    
    @Override
    public List> getEs(LawsAndRegulationsDto lawsAndRegulationsDto) throws IOException {
        //获取索引请求
        SearchRequest searchRequest = new SearchRequest(cluster_name);
        //搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //TermQueryBuilder termQueryBuilder1 = QueryBuilders.termQuery("lawsRegulationsName", lawsAndRegulationsDto.getTitle());
        QueryBuilder queryBuilder = QueryBuilders.boolQuery()
                .must(QueryBuilders.matchQuery("lawsRegulationsName",lawsAndRegulationsDto.getTitle()).operator(Operator.AND))
                .must(QueryBuilders.matchQuery("contentInfo",lawsAndRegulationsDto.getFullText()).operator(Operator.AND));

        //执行查询
        sourceBuilder.query(queryBuilder);
        sourceBuilder.timeout(new Timevalue(60,TimeUnit.SECONDS));
        searchRequest.source(sourceBuilder);
        List> list = new ArrayList<>();
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        for (SearchHit documentFields : searchResponse.getHits().getHits()) {
            list.add(documentFields.getSourceAsMap());
        }
        return list;
    }

}