pom 引入依赖：
<!-- elasticsearch 7.16 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
package com.realize.framework.config;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @Author hzj
* @Date 2022/1/6 13:33
* @Desc ElasticSearch配置
**/
@Configuration
public class ElasticSearchClientConfig {
@Value("${spring.elasticsearch.ip}")
private String ip;
@Bean
public RestHighLevelClient restHighLevelClient() {
RestHighLevelClient restHighLevelClient = new RestHighLevelClient(RestClient.builder(new HttpHost(ip, 9200, "http")));
return restHighLevelClient;
}
}
yml:
# ES 地址
spring
elasticsearch:
ip: 47.101.207.23
package com.realize.project.system.service.impl;
import com.alibaba.fastjson.JSON;
import com.realize.common.constant.Constants;
import com.realize.common.constant.HttpStatus;
import com.realize.common.utils.StringUtils;
import com.realize.framework.convert.PdfConvertTxtComponent;
import com.realize.framework.redis.RedisCache;
import com.realize.framework.upLoad.AliYunOSSService;
import com.realize.framework.web.page.TableNoticeDataInfo;
import com.realize.project.system.domain.AshareMain;
import com.realize.project.system.domain.AshareOwnership;
import com.realize.project.system.domain.BusiPublicNotice;
import com.realize.project.system.domain.OssMetaGq;
import com.realize.project.system.domain.dto.EnumSecDto;
import com.realize.project.system.domain.vo.BusiPublicNoticeReqVo;
import com.realize.project.system.domain.vo.PublicNoticeClassifyReqVo;
import com.realize.project.system.domain.vo.PublicNoticeMapVo;
import com.realize.project.system.mapper.BusiPublicNoticeMapper;
import com.realize.project.system.service.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
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.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.text.Text;
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.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 股权激励公告Service业务层处理
*
* @author realize
* @date 2022-04-15
*/
@Slf4j
@Service
public class BusiPublicNoticeServiceImpl implements IBusiPublicNoticeService
{
//全局用-公告检索ES索引库
private static final String clusterName="public_notice";
@Autowired
private BusiPublicNoticeMapper busiPublicNoticeMapper;
@Autowired
private RestHighLevelClient restHighLevelClient;
@Autowired
private SqlSessionFactory sqlSessionFactory;
@Autowired
private PdfConvertTxtComponent pdfConvertTxtComponent;
@Autowired
private AliYunOSSService aliyunOSSService;
@Autowired
private IEnumSecService enumSecService;
@Autowired
private IAshareMainService ashareMainService;
@Autowired
private IAshareOwnershipService ashareOwnershipService;
@Autowired
private IOssMetaGqService ossMetaGqService;
@Autowired
private RedisCache redisCache;
/**
* ES 查询共用条件
* @Description ES 公告检索
* @param publicNoticeReqVo
* @return List<Map<String,Object>> 公告检索结果集
* @return
*/
public SearchResponse commonConditions(BusiPublicNoticeReqVo publicNoticeReqVo){
//创建索引请求
SearchRequest searchRequest = new SearchRequest(clusterName);
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
//按照省份分组
AggregationBuilder aggregationBuilder = AggregationBuilders.terms("agg").field("region.keyword");
searchSourceBuilder.aggregation(aggregationBuilder);
//按照父行业/行业分组
AggregationBuilder parentindustryAggregationBuilder = AggregationBuilders.terms("aggParentindustry").field("parentindustry.keyword");
AggregationBuilder industryAggregationBuilder = AggregationBuilders.terms("aggIndustry").field("industry.keyword");
parentindustryAggregationBuilder.subAggregation(industryAggregationBuilder);
searchSourceBuilder.aggregation(parentindustryAggregationBuilder);
//按照市场类型分组
AggregationBuilder marketcodeAggregationBuilder = AggregationBuilders.terms("aggMarketcode").field("markettype.keyword");
searchSourceBuilder.aggregation(marketcodeAggregationBuilder);
//按照公告分类分组
AggregationBuilder noticetypeAggregationBuilder = AggregationBuilders.terms("aggNoticetype").field("noticetype.keyword");
searchSourceBuilder.aggregation(noticetypeAggregationBuilder);
//初始化每个字段的属性
RangeQueryBuilder publishdateQuery = null;
MatchPhraseQueryBuilder theValidityTQ = null;//不分词
TermsQueryBuilder termsQueryTQ=null;//会分词
//1发布时间
if (publicNoticeReqVo.getPublishdates()!=null && publicNoticeReqVo.getPublishdates().size()>0) {
publishdateQuery = QueryBuilders.rangeQuery("publishdate")
.gte(publicNoticeReqVo.getPublishdates().get(0).getTime())
.lte(publicNoticeReqVo.getPublishdates().get(1).getTime());
boolQueryBuilder.must(publishdateQuery);
}
//2证券代码
if (StringUtils.isNotBlank(publicNoticeReqVo.getStockcode())) {
//matchPhraseQuery不分词
theValidityTQ = QueryBuilders.matchPhraseQuery("stockcode",publicNoticeReqVo.getStockcode());
boolQueryBuilder.must(theValidityTQ);
}
//市场类型
if (StringUtils.isNotBlank(publicNoticeReqVo.getMarketcode())) {
//matchPhraseQuery不分词
theValidityTQ = QueryBuilders.matchPhraseQuery("marketcode",publicNoticeReqVo.getMarketcode());
boolQueryBuilder.must(theValidityTQ);
}
//公司性质
if (StringUtils.isNotBlank(publicNoticeReqVo.getOwnership())) {
//matchPhraseQuery不分词
theValidityTQ = QueryBuilders.matchPhraseQuery("ownershipcode",publicNoticeReqVo.getOwnership());
boolQueryBuilder.must(theValidityTQ);
}
//公告类型-查询股权激励tab页数据
if (StringUtils.isNotBlank(publicNoticeReqVo.getNoticecode())) {
//matchPhraseQuery不分词
theValidityTQ = QueryBuilders.matchPhraseQuery("noticecode",publicNoticeReqVo.getNoticecode());
boolQueryBuilder.must(theValidityTQ);
}
//业务类型-查询股权激励tab页数据
if (StringUtils.isNotBlank(publicNoticeReqVo.getCustomcode())) {
//matchPhraseQuery不分词
theValidityTQ = QueryBuilders.matchPhraseQuery("customcode",publicNoticeReqVo.getCustomcode());
boolQueryBuilder.must(theValidityTQ);
}
List<PublicNoticeClassifyReqVo> classifyArr = publicNoticeReqVo.getClassifyArr();
if(CollectionUtils.isNotEmpty(classifyArr)){
List<String> parentIndustry0 = classifyArr.stream().filter(b -> b.getParentIndustryPlus()!=null && b.getParentIndustryPlus() == 0).map(b->b.getParentIndustry()).collect(Collectors.toList());
List<String> parentIndustry1 = classifyArr.stream().filter(b -> b.getParentIndustryPlus()!=null && b.getParentIndustryPlus() == 1).map(b->b.getParentIndustry()).collect(Collectors.toList());
//父行业分类 加减查询；
if(CollectionUtils.isNotEmpty(parentIndustry0)){
termsQueryTQ = QueryBuilders.termsQuery("parentindustry.keyword", parentIndustry0);
boolQueryBuilder.mustNot(termsQueryTQ);
}
if(CollectionUtils.isNotEmpty(parentIndustry1)){
termsQueryTQ = QueryBuilders.termsQuery("parentindustry.keyword", parentIndustry1);
boolQueryBuilder.must(termsQueryTQ);
}
//行业分类 加减查询；
List<String> industry0 = classifyArr.stream().filter(b -> b.getIndustryPlus() != null && b.getIndustryPlus() == 0).map(b->b.getIndustry()).collect(Collectors.toList());
List<String> industry1 = classifyArr.stream().filter(b -> b.getIndustryPlus() != null && b.getIndustryPlus() == 1).map(b->b.getIndustry()).collect(Collectors.toList());
if(CollectionUtils.isNotEmpty(industry0)){
termsQueryTQ = QueryBuilders.termsQuery("industry.keyword", industry0);
boolQueryBuilder.mustNot(termsQueryTQ);
}
if(CollectionUtils.isNotEmpty(industry1)){
termsQueryTQ = QueryBuilders.termsQuery("industry.keyword", industry1);
boolQueryBuilder.must(termsQueryTQ);
}
//区域分布 加减查询；
List<String> region0 = classifyArr.stream().filter(b -> b.getRegionPlus() !=null && b.getRegionPlus() == 0).map(b->b.getRegion()).collect(Collectors.toList());
List<String> region1 = classifyArr.stream().filter(b -> b.getRegionPlus() !=null && b.getRegionPlus() == 1).map(b->b.getRegion()).collect(Collectors.toList());
if(CollectionUtils.isNotEmpty(region0)){
termsQueryTQ = QueryBuilders.termsQuery("region.keyword", region0);
boolQueryBuilder.mustNot(termsQueryTQ);
}
if(CollectionUtils.isNotEmpty(region1)){
termsQueryTQ = QueryBuilders.termsQuery("region.keyword", region1);
boolQueryBuilder.must(termsQueryTQ);
}
//市场类型 加减查询；
List<String> marketType0 = classifyArr.stream().filter(b -> b.getMarketTypePlus()!=null && b.getMarketTypePlus() == 0).map(b->b.getMarketType()).collect(Collectors.toList());
List<String> marketType1 = classifyArr.stream().filter(b -> b.getMarketTypePlus()!=null && b.getMarketTypePlus() == 1).map(b->b.getMarketType()).collect(Collectors.toList());
if(CollectionUtils.isNotEmpty(marketType0)){
termsQueryTQ = QueryBuilders.termsQuery("markettype.keyword", marketType0);
boolQueryBuilder.mustNot(termsQueryTQ);
}
if(CollectionUtils.isNotEmpty(marketType1)){
termsQueryTQ = QueryBuilders.termsQuery("markettype.keyword", marketType1);
boolQueryBuilder.must(termsQueryTQ);
}
//公告类型 加减查询；
List<String> noticeType0 = classifyArr.stream().filter(b -> b.getNoticeTypePlus()!=null && b.getNoticeTypePlus() == 0).map(b->b.getNoticeType()).collect(Collectors.toList());
List<String> noticeType1 = classifyArr.stream().filter(b -> b.getNoticeTypePlus()!=null && b.getNoticeTypePlus() == 1).map(b->b.getNoticeType()).collect(Collectors.toList());
if(CollectionUtils.isNotEmpty(noticeType0)){
termsQueryTQ = QueryBuilders.termsQuery("noticetype.keyword", noticeType0);
boolQueryBuilder.mustNot(termsQueryTQ);
}
if(CollectionUtils.isNotEmpty(noticeType1)){
termsQueryTQ = QueryBuilders.termsQuery("noticetype.keyword", noticeType1);
boolQueryBuilder.must(termsQueryTQ);
}
}
//3-1标题-包含全部关键字 使用should需要再套一个bool must=and 和 should=or
if (StringUtils.isNotBlank(publicNoticeReqVo.getTitle())) {
String[] strings = publicNoticeReqVo.getTitle().split(" ");//输入多个关键字 以空格区分
if(publicNoticeReqVo.getScope()!=null&&publicNoticeReqVo.getScope()==1) {//0同篇；不限制范围
BoolQueryBuilder boolQueryBuilder1 = new BoolQueryBuilder();
for (int i = 0; i < strings.length; i++) {
boolQueryBuilder.must(boolQueryBuilder1.must(QueryBuilders.matchPhraseQuery("title",strings[i])));
}
}else {//跨度查询 同段同句；限制范围
SpanNearQueryBuilder queryBuilderSpanNearQueryInclude = QueryBuilders.spanNearQuery(QueryBuilders.spanTermQuery("title", strings[0]), 10000);
for (int i = 1; i < strings.length; i++) {
queryBuilderSpanNearQueryInclude.addClause(QueryBuilders.spanTermQuery("title", strings[i]));
}
SpanTermQueryBuilder queryBuilderSpanNearQueryExclude=null;
if(publicNoticeReqVo.getScope()!=null&&publicNoticeReqVo.getScope()==2){//同段搜素类似，相邻搜索不能有： 对应分隔符变为 \n,或者 同段搜素类似，对应分隔符变为\n,或者<p>,</p>
queryBuilderSpanNearQueryExclude = QueryBuilders.spanTermQuery("title", "\n/<p>");
}else if(publicNoticeReqVo.getScope()!=null&&publicNoticeReqVo.getScope()==3){//同句搜素类似，相邻搜索不能有: 对应分隔符变为 。 、？、！
queryBuilderSpanNearQueryExclude = QueryBuilders.spanTermQuery("title", "。/?/!");
}else if(publicNoticeReqVo.getScope()!=null&&publicNoticeReqVo.getScope()==4){
queryBuilderSpanNearQueryExclude = QueryBuilders.spanTermQuery("title", "。/?/!/不构成/不包含");
}
//QueryBuilder queryBuilderSpanNotQuery= QueryBuilders.spanNotQuery(queryBuilderSpanNearQueryInclude,queryBuilderSpanNearQueryExclude); //.include().exclude();
}
}
//3-2标题-包含任一全部关键字 使用should需要再套一个bool must=and 和 should=or
if (StringUtils.isNotBlank(publicNoticeReqVo.getContainAnyTitle())) {
BoolQueryBuilder boolQueryBuilder1 = new BoolQueryBuilder();
String[] strings = publicNoticeReqVo.getContainAnyTitle().split(" "); //输入多个关键字 以空格区分
for (int i = 0; i < strings.length; i++) {
boolQueryBuilder.must(boolQueryBuilder1.should(QueryBuilders.matchPhraseQuery("title",strings[i])));
}
}
//3-3标题-不包含任一全部关键字 使用should需要再套一个bool must=and 和 should=or
if (StringUtils.isNotBlank(publicNoticeReqVo.getNoContainAnyTitle())) {
BoolQueryBuilder boolQueryBuilder1 = new BoolQueryBuilder();
String[] strings = publicNoticeReqVo.getNoContainAnyTitle().split(" "); //输入多个关键字 以空格区分
for (int i = 0; i < strings.length; i++) {
boolQueryBuilder.must(boolQueryBuilder1.mustNot(QueryBuilders.matchPhraseQuery("title",strings[i])));
}
}
//4-1章节 包含全部关键字 使用should需要再套一个bool
if (StringUtils.isNotBlank(publicNoticeReqVo.getChapter())) {
BoolQueryBuilder boolQueryBuilder1 = new BoolQueryBuilder();
String[] split = publicNoticeReqVo.getChapter().split(" "); //输入多个关键字 以空格区分
for (int i = 0; i < split.length; i++) {
boolQueryBuilder.must(boolQueryBuilder1.must(QueryBuilders.matchPhraseQuery("parseChapter",split[i])));
}
}
//4-2章节 包含任一全部关键字 使用should需要再套一个bool
if (StringUtils.isNotBlank(publicNoticeReqVo.getContainAnyChapter())) {
BoolQueryBuilder boolQueryBuilder1 = new BoolQueryBuilder();
String[] split = publicNoticeReqVo.getContainAnyChapter().split(" "); //输入多个关键字 以空格区分
//使用should需要再套一个bool
for (int i = 0; i < split.length; i++) {
boolQueryBuilder.must(boolQueryBuilder1.should(QueryBuilders.matchPhraseQuery("parseChapter",split[i])));
}
}
//4-3章节 不包含任一全部关键字 使用should需要再套一个bool
if (StringUtils.isNotBlank(publicNoticeReqVo.getNoContainAnyChapter())) {
BoolQueryBuilder boolQueryBuilder1 = new BoolQueryBuilder();
String[] split = publicNoticeReqVo.getNoContainAnyChapter().split(" "); //输入多个关键字 以空格区分
//使用should需要再套一个bool
for (int i = 0; i < split.length; i++) {
boolQueryBuilder.must(boolQueryBuilder1.mustNot(QueryBuilders.matchPhraseQuery("parseChapter",split[i])));
}
}
//5正文 包含全部关键字 使用should需要再套一个bool
QueryBuilder queryBuilderSpanNotQuery=null;
if (StringUtils.isNotBlank(publicNoticeReqVo.getFullText())) {
String[] split = publicNoticeReqVo.getFullText().split(" "); //输入多个关键字 以空格区分
if(publicNoticeReqVo.getScope()!=null&&publicNoticeReqVo.getScope()==1) {//0同篇；不限制范围
BoolQueryBuilder boolQueryBuilder1 = new BoolQueryBuilder();
for (int i = 0; i < split.length; i++) {
boolQueryBuilder.must(boolQueryBuilder1.must(QueryBuilders.matchPhraseQuery("parseContent",split[i])));
}
}else {//跨度查询 同段同句；限制范围
SpanNearQueryBuilder queryBuilderSpanNearQueryInclude = QueryBuilders.spanNearQuery(QueryBuilders.spanTermQuery("parseContent", split[0]), 10000);
for (int i = 1; i < split.length; i++) {
queryBuilderSpanNearQueryInclude.addClause(QueryBuilders.spanTermQuery("parseContent", split[i]));
}
SpanTermQueryBuilder queryBuilderSpanNearQueryExclude=null;
if(publicNoticeReqVo.getScope()!=null&&publicNoticeReqVo.getScope()==2){//同段搜素类似，相邻搜索不能有:对应分隔符变为 \n,或者 ,
queryBuilderSpanNearQueryExclude = QueryBuilders.spanTermQuery("parseContent", "\n/,/，");
}else if(publicNoticeReqVo.getScope()!=null&&publicNoticeReqVo.getScope()==3){//同句搜素类似，相邻搜索不能有:对应分隔符变为 。 、？、！
queryBuilderSpanNearQueryExclude = QueryBuilders.spanTermQuery("parseContent", "。/?/!");
}else if(publicNoticeReqVo.getScope()!=null&&publicNoticeReqVo.getScope()==4){
queryBuilderSpanNearQueryExclude = QueryBuilders.spanTermQuery("parseContent", "。/?/!/不构成/不包含");
}
queryBuilderSpanNotQuery= QueryBuilders.spanNotQuery(queryBuilderSpanNearQueryInclude,queryBuilderSpanNearQueryExclude); //.include().exclude();
//boolQueryBuilder.must(queryBuilderSpanNotQuery);
}
}
//5正文 包含任一全部关键字 使用should需要再套一个bool
if (StringUtils.isNotBlank(publicNoticeReqVo.getContainAnyFullText())) {
BoolQueryBuilder boolQueryBuilder1 = new BoolQueryBuilder();
String[] split = publicNoticeReqVo.getContainAnyFullText().split(" "); //输入多个关键字 以空格区分
for (int i = 0; i < split.length; i++) {
boolQueryBuilder.must(boolQueryBuilder1.should(QueryBuilders.matchPhraseQuery("parseContent",split[i])));
}
}
//5正文 不包含任一全部关键字 使用should需要再套一个bool
if (StringUtils.isNotBlank(publicNoticeReqVo.getNoContainAnyFullText())) {
BoolQueryBuilder boolQueryBuilder1 = new BoolQueryBuilder();
String[] split = publicNoticeReqVo.getNoContainAnyFullText().split(" "); //输入多个关键字 以空格区分
for (int i = 0; i < split.length; i++) {
boolQueryBuilder.must(boolQueryBuilder1.mustNot(QueryBuilders.matchPhraseQuery("parseContent",split[i])));
}
}
//全文高亮 标题高亮
if (StringUtils.isNotBlank(publicNoticeReqVo.getTitle()) || StringUtils.isNotBlank(publicNoticeReqVo.getContainAnyTitle())||StringUtils.isNotBlank(publicNoticeReqVo.getNoContainAnyTitle())
|| StringUtils.isNotBlank(publicNoticeReqVo.getFullText())) {
//实例化高亮构建器
HighlightBuilder highlightBuilder = new HighlightBuilder();
//需要高亮的字段（可多个）
highlightBuilder.field("title").field("parseContent");
highlightBuilder.requireFieldMatch(true);
//最大高亮分片数，没有这个配置就会导致全文显示不全问题
highlightBuilder.fragmentSize(800000);
//从第一个分片获取高亮片段，没有这个配置就会导致全文显示不全问题
highlightBuilder.numOfFragments(0);
//前缀
highlightBuilder.preTags("<span style='font-weight: bolder;color:red'>");
//后缀
highlightBuilder.postTags("</span>");
//添加查询构建器中,形成查询
searchSourceBuilder.highlighter(highlightBuilder);
}
Integer pageNum = publicNoticeReqVo.getPageNum();
Integer pageSize = publicNoticeReqVo.getPageSize();
//分页
if(pageNum<=0){
pageNum = 1;
}
if(pageSize<=0){
pageSize=10;
}
//起始记录下标
int from = (pageNum-1) * pageSize;
searchSourceBuilder.from(from);
searchSourceBuilder.size(pageSize);
//排序规则：
if(StringUtils.isNotBlank(publicNoticeReqVo.getSortField())){//公司聚合
FieldSortBuilder fieldSortBuilder1 = new FieldSortBuilder("stockticker.keyword").order(SortOrder.ASC);
searchSourceBuilder.sort(fieldSortBuilder1);
FieldSortBuilder fieldSortBuilder2 = new FieldSortBuilder("publishdate").order(SortOrder.DESC);
searchSourceBuilder.sort(fieldSortBuilder2);
}else{//最近，最早；
FieldSortBuilder fieldSortBuilder = new FieldSortBuilder("publishdate").order(publicNoticeReqVo.getSortDirection()!=null && publicNoticeReqVo.getSortDirection()==0?SortOrder.ASC:SortOrder.DESC);
searchSourceBuilder.sort(fieldSortBuilder);
}
//执行查询
if(queryBuilderSpanNotQuery!=null){
searchSourceBuilder.query(queryBuilderSpanNotQuery);
}else{
searchSourceBuilder.query(boolQueryBuilder);
}
//打印
System.out.println("打印方便核查的ES检索条件： " + searchSourceBuilder.toString());
//不能超过60秒
searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
//限制查询最大数
searchSourceBuilder.trackTotalHits(true);
//检索
searchRequest.source(searchSourceBuilder);
//客户端调用检索语法
SearchResponse searchResponse = null;
try {
searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
} catch (IOException e) {
e.printStackTrace();
}
return searchResponse;
}
/**
* @Description ES 公告检索
* @param publicNoticeReqVo
* @return List<Map<String,Object>> 公告检索结果集
**/
@Override
public TableNoticeDataInfo getEsBusiPublicNotice(BusiPublicNoticeReqVo publicNoticeReqVo) {
SearchResponse searchResponse = this.commonConditions(publicNoticeReqVo);
//获取响应结果
SearchHits hits = searchResponse.getHits();
//记录查询后总数
Long totalHits = hits.getTotalHits().value;
// System.out.println("命中数：" + totalHits);
SearchHit[] hitss = searchResponse.getHits().getHits();
// System.out.println("命中：" + hitss.length);
//数据结果集初始化
List<Map<String, Object>> list = new ArrayList<>();
//循环存入结果集
for (SearchHit hit : searchResponse.getHits().getHits()) {
//理因判断不为空才让加前后缀
if (StringUtils.isNotBlank(publicNoticeReqVo.getTitle()) || StringUtils.isNotBlank(publicNoticeReqVo.getContainAnyTitle())||StringUtils.isNotBlank(publicNoticeReqVo.getNoContainAnyTitle())
||StringUtils.isNotBlank(publicNoticeReqVo.getFullText())) {
//设置标题高亮
Map<String, HighlightField> titlehighlightFields = hit.getHighlightFields();
HighlightField titleHight = titlehighlightFields.get("title");
Map<String, Object> sourceAsMap = hit.getSourceAsMap();
String contentInfo = (String) sourceAsMap.get("title");
//标题-高亮词替换
if (titleHight != null ){
Text[] fragments = titleHight.fragments();
StringBuilder newtitle = new StringBuilder();
for (Text text:fragments) {
newtitle.append(text);
}
sourceAsMap.replace("title", newtitle);
}
//设置全文高亮
Map<String, HighlightField> fullTexthighlightFields = hit.getHighlightFields();
HighlightField fullTextHight = fullTexthighlightFields.get("parseContent");
//全文-高亮词替换
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);
sourceAsMap.replace("contentInfo", newfullText);
}
list.add(sourceAsMap);
} else {
//否则直接添加进结果集，不需要高亮
list.add(hit.getSourceAsMap());
}
}
//System.out.println("结果集长度：" + list.size());
//获取聚合结果集
//按照省份分组
List<PublicNoticeMapVo> listRegionsMap=new ArrayList();
Terms terms = searchResponse.getAggregations().get("agg");
for (Terms.Bucket entry : terms.getBuckets()) {
PublicNoticeMapVo publicNoticeMapVo=new PublicNoticeMapVo();
publicNoticeMapVo.setName(entry.getKey().toString());
publicNoticeMapVo.setCount(entry.getDocCount());
listRegionsMap.add(publicNoticeMapVo);
}
//按照父行业分组
List<PublicNoticeMapVo> listIndustryMap=new ArrayList();
Terms terms2 = searchResponse.getAggregations().get("aggParentindustry");
for (Terms.Bucket entry : terms2.getBuckets()) {
PublicNoticeMapVo publicNoticeMapVo=new PublicNoticeMapVo();
publicNoticeMapVo.setName(entry.getKey().toString());
publicNoticeMapVo.setCount(entry.getDocCount());
List<PublicNoticeMapVo> listSonIndustryMap=new ArrayList();
Terms towTerms = (Terms) entry.getAggregations().asMap().get("aggIndustry");
for (Terms.Bucket entryTwo : towTerms.getBuckets()) {
PublicNoticeMapVo publicNoticeMapSonVo=new PublicNoticeMapVo();
publicNoticeMapSonVo.setName(entryTwo.getKey().toString());
publicNoticeMapSonVo.setCount(entryTwo.getDocCount());
listSonIndustryMap.add(publicNoticeMapSonVo);
}
publicNoticeMapVo.setSonArray(listSonIndustryMap);
listIndustryMap.add(publicNoticeMapVo);
}
//按照市场类型分组
List<PublicNoticeMapVo> listMarketcodesMap=new ArrayList();
Terms terms3 = searchResponse.getAggregations().get("aggMarketcode");
for (Terms.Bucket entry : terms3.getBuckets()) {
PublicNoticeMapVo publicNoticeMapVo=new PublicNoticeMapVo();
publicNoticeMapVo.setName(entry.getKey().toString());
publicNoticeMapVo.setCount(entry.getDocCount());
listMarketcodesMap.add(publicNoticeMapVo);
}
//按照公告类型分组
List<PublicNoticeMapVo> listNoticetypeMap=new ArrayList();
Terms terms4 = searchResponse.getAggregations().get("aggNoticetype");
for (Terms.Bucket entry : terms4.getBuckets()) {
PublicNoticeMapVo publicNoticeMapVo=new PublicNoticeMapVo();
publicNoticeMapVo.setName(entry.getKey().toString());
publicNoticeMapVo.setCount(entry.getDocCount());
listNoticetypeMap.add(publicNoticeMapVo);
}
//获取响应结果
//SearchHits hits = searchResponse.getHits();
//Long totalHits = hits.getTotalHits().value;
TableNoticeDataInfo rspData = new TableNoticeDataInfo();
rspData.setCode(HttpStatus.SUCCESS);
rspData.setMsg("查询成功");
rspData.setRows(list);
rspData.setTotal(totalHits);
rspData.setMapRegions(listRegionsMap);
rspData.setMapParentIndustrycodes(listIndustryMap);
rspData.setMapMarketcodes(listMarketcodesMap);
rspData.setMapNoticetypes(listNoticetypeMap);
return rspData;
}
/**
* @Description ES 公告检索
* @param publicNoticeReqVo
* @return List<Map<String,Object>> 公告检索结果集
* @return int 命中条数
**/
@Override
public Long getEsTotal(BusiPublicNoticeReqVo publicNoticeReqVo) {
SearchResponse searchResponse = this.commonConditions(publicNoticeReqVo);
//获取响应结果
SearchHits hits = searchResponse.getHits();
Long totalHits = hits.getTotalHits().value;
//记录总数
// System.out.println("命中数："+totalHits);
//返回总记录数
return totalHits;
}
@Override
public void insertBatchBusiPublicNotice(List<BusiPublicNotice> noticeList) {
busiPublicNoticeMapper.insertBatchBusiPublicNotice(noticeList);
}
@Override
public int updateAnnouncementOSSUrl(BusiPublicNotice busiPublicNoticeDto) {
return busiPublicNoticeMapper.updateAnnouncementOSSUrl(busiPublicNoticeDto);
}
/**
* 前端显示 地域分布 分组
* @param publicNoticeReqVo
* @return
*/
public Map<String, Long> getTermsAggByRegion(BusiPublicNoticeReqVo publicNoticeReqVo){
Map<String, Long> groupMap = new HashMap<>();
//按照省份分组
SearchResponse searchResponse = this.commonConditions(publicNoticeReqVo);
Terms terms = searchResponse.getAggregations().get("agg");
for (Terms.Bucket entry : terms.getBuckets()) {
groupMap.put(entry.getKey().toString(), entry.getDocCount());
}
Map<String, Long> groupMap2 = new HashMap<>();
//按照父行业分组
Terms terms2 = searchResponse.getAggregations().get("aggParentindustry");
for (Terms.Bucket entry : terms2.getBuckets()) {
groupMap2.put(entry.getKey().toString(), entry.getDocCount());
}
Map<String, Long> groupMap3 = new HashMap<>();
//按照市场类型分组
Terms terms3 = searchResponse.getAggregations().get("aggMarketcode");
for (Terms.Bucket entry : terms3.getBuckets()) {
groupMap3.put(entry.getKey().toString(), entry.getDocCount());
}
return groupMap;
}
@Override
public Map<String, Long> getTermsAggByParentIndustrycode(BusiPublicNoticeReqVo publicNoticeReqVo) {
Map<String, Long> groupMap = new HashMap<>();
//按照省份分组
//客户端调用检索语法
SearchResponse searchResponse = this.commonConditions(publicNoticeReqVo);
Terms terms = searchResponse.getAggregations().get("aggParentindustry");
for (Terms.Bucket entry : terms.getBuckets()) {
groupMap.put(entry.getKey().toString(), entry.getDocCount());
}
return groupMap;
}
@Override
public Map<String, Long> getTermsAggByIndustrycode(BusiPublicNoticeReqVo publicNoticeReqVo) {
Map<String, Long> groupMap = new HashMap<>();
//按照省份分组
//客户端调用检索语法
SearchResponse searchResponse = this.commonConditions(publicNoticeReqVo);
Terms terms = searchResponse.getAggregations().get("aggIndustry");
for (Terms.Bucket entry : terms.getBuckets()) {
groupMap.put(entry.getKey().toString(), entry.getDocCount());
}
return groupMap;
}
@Override
public Map<String, Long> getTermsAggByMarketcode(BusiPublicNoticeReqVo publicNoticeReqVo) {
Map<String, Long> groupMap = new HashMap<>();
//按照省份分组
//客户端调用检索语法
SearchResponse searchResponse = this.commonConditions(publicNoticeReqVo);
Terms terms = searchResponse.getAggregations().get("aggMarketcode");
for (Terms.Bucket entry : terms.getBuckets()) {
groupMap.put(entry.getKey().toString(), entry.getDocCount());
}
return groupMap;
}
}