文章目录
- 🌞 Sun Frame：SpringBoot 的轻量级开发框架（个人开源项目推荐）
- 🌟 亮点功能
- 📦 spring cloud模块概览
- 🔗 更多信息
- 1.spring-data-es操作ES
- 2.自定义封装ES
🌞 Sun Frame：SpringBoot 的轻量级开发框架（个人开源项目推荐）
轻松高效的现代化开发体验
Sun Frame 是我个人开源的一款基于 SpringBoot 的轻量级框架，专为中小型企业设计。它提供了一种快速、简单且易于扩展的开发方式。
我们的开发文档记录了整个项目从0到1的任何细节，实属不易，请给我们一个Star！🌟
您的支持是我们持续改进的动力。
您的支持是我们持续改进的动力。
🌟 亮点功能
- 组件化开发：灵活选择，简化流程。
- 高性能：通过异步日志和 Redis 缓存提升性能。
- 易扩展：支持多种数据库和消息队列。
📦 spring cloud模块概览
- Nacos 服务：高效的服务注册与发现。
- Feign 远程调用：简化服务间通信。
- 强大网关：路由与限流。
常用工具
- 日志管理：异步处理与链路追踪。
- Redis 集成：支持分布式锁与缓存。
- Swagger 文档：便捷的 API 入口。
- 测试支持：SpringBoot-Test 集成。
- EasyCode：自定义EasyCode模板引擎，一键生成CRUD。
🔗 更多信息
- 开源地址：Gitee Sun Frame
- 详细文档：语雀文档
1.spring-data-es操作ES
1.引入依赖
<!-- ES -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
<version>2.4.2</version>
</dependency>
2.application.yml配置uris
3.SubjectInfoEs.java 创建ES实体类（指定映射和索引）
package com.sunxiansheng.subject.infra.basic.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import java.util.Date;
/**
* Description: 题目ES，相当于db中的表结构
* @Author sun
* @Create 2024/6/17 16:01
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Document(indexName = "subject_index", createIndex = false) // 指定索引名，这里的createIndex=true，默认自动创建索引
public class SubjectInfoEs {
// 使用es必须的
@Field(type = FieldType.Long)
@Id
private Long id;
@Field(type = FieldType.Text, analyzer = "ik_smart")
private String subjectName;
@Field(type = FieldType.Text, analyzer = "ik_smart")
private String subjectAnswer;
@Field(type = FieldType.Text, analyzer = "ik_smart")
private String createUser;
@Field(type = FieldType.Date, index = false)
private Date createTime;
}
4.SubjectEsRepository.java 依赖注入一个接口（对应于实体类）
package com.sunxiansheng.subject.infra.basic.esRepo;
import com.sunxiansheng.subject.infra.basic.entity.SubjectInfoEs;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Component;
/**
* Description:
* @Author sun
* @Create 2024/6/17 16:09
* @Version 1.0
*/
@Component
public interface SubjectEsRepository extends ElasticsearchRepository<SubjectInfoEs, Long> {
}
5.SubjectEsService.java
package com.sunxiansheng.subject.infra.basic.service;
/**
* Description:
* @Author sun
* @Create 2024/6/17 16:11
* @Version 1.0
*/
public interface SubjectEsService {
void createIndex();
void getDocs();
void find();
void search();
}
6.SubjectEsServiceImpl.java
package com.sunxiansheng.subject.infra.basic.service.impl;
import com.sunxiansheng.subject.infra.basic.entity.SubjectInfoEs;
import com.sunxiansheng.subject.infra.basic.service.SubjectEsService;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* Description:
* @Author sun
* @Create 2024/6/17 16:12
* @Version 1.0
*/
@Service
public class SubjectEsServiceImpl implements SubjectEsService {
@Resource
private ElasticsearchRestTemplate elasticsearchRestTemplate;
/**
* 创建索引
*/
@Override
public void createIndex() {
// 得到ES实体类中的索引信息然后创建
IndexOperations indexOperations = elasticsearchRestTemplate.indexOps(SubjectInfoEs.class);
// 创建索引
indexOperations.create();
// 绑定映射
Document mapping = indexOperations.createMapping(SubjectInfoEs.class);
indexOperations.putMapping(mapping);
}
/**
*
*/
@Override
public void getDocs() {
}
@Override
public void find() {
}
@Override
public void search() {
}
}
7.TestFeignController.java 测试
8.测试
1.请求，注意要加上loginId因为没走网关，不加就会空指针
9.添加文档
1.SubjectEsService.java
void addDocs();
2.SubjectEsServiceImpl.java
/**
* 添加文档，也就相当于添加一条数据
*/
@Override
public void addDocs() {
List<SubjectInfoEs> list = new LinkedList<>();
// 添加两条数据
list.add(new SubjectInfoEs(1L, "Java", "Java", "sun", null));
list.add(new SubjectInfoEs(2L, "Spring", "Spring", "sun", null));
// 批量添加
subjectEsRepository.saveAll(list);
}
3.TestFeignController.java
@RequestMapping("/addDocs")
public void createaddDocsIndex() {
subjectEsService.addDocs();
}
4.测试
10.查找文档
1.SubjectEsService.java
void find();
2.SubjectEsServiceImpl.java
/**
* 查找列对应的元素
*/
@Override
public void find() {
NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder()
.withQuery(QueryBuilders.matchQuery("subjectName", "Java"))
.build();
SearchHits<SubjectInfoEs> search = elasticsearchRestTemplate.search(nativeSearchQuery, SubjectInfoEs.class);
List<SearchHit<SubjectInfoEs>> searchHits = search.getSearchHits();
log.info("searchHits:{}", searchHits);
}
3.TestFeignController.java
@RequestMapping("/find")
public void find() {
subjectEsService.find();
}
4.测试
2.自定义封装ES
1.环境准备
1.删除上面引入的ES依赖
2.删除application.yml中的ES配置
3.删除原来的文件
4.sun-club-infra 引入原生的ES依赖
<!-- 封装自定义ES -->
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>7.5.2</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-client</artifactId>
<version>7.5.2</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>7.5.2</version>
</dependency>
<!-- 集合工具类，配合封装自定义ES -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.4</version>
</dependency>
2.自定义封装集群es连接统一管理
1.目录结构
2.EsClusterConfig.java ES的集群配置的实体类
package com.sunxiansheng.subject.infra.basic.es;
import lombok.Data;
import java.io.Serializable;
/**
* Description: ES的集群配置的实体类
* @Author sun
* @Create 2024/6/17 17:08
* @Version 1.0
*/
@Data
public class EsClusterConfig implements Serializable {
/*
集群名称
*/
private String name;
/*
集群节点
*/
private String nodes;
}
3.EsConfigProperties.java 读取配置文件的es集群配置
package com.sunxiansheng.subject.infra.basic.es;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
* Description: 读取配置文件的集群配置
* @Author sun
* @Create 2024/6/17 17:10
* @Version 1.0
*/
@Component
@ConfigurationProperties(prefix = "es.cluster") // 这个就相当于将esConfigs对应于配置文件的es.cluster.esConfigs
public class EsConfigProperties {
private List<EsClusterConfig> esConfigs = new ArrayList<>();
public List<EsClusterConfig> getEsConfigs() {
return esConfigs;
}
public void setEsConfigs(List<EsClusterConfig> esConfigs) {
this.esConfigs = esConfigs;
}
}
3.编写配置文件
es:
cluster:
es-configs[0]:
name: 98bd89b5ccaf
nodes: ip:9200
4.EsRestClient.java Es工具类，将每个集群节点对应的某个客户端放到Map
package com.sunxiansheng.subject.infra.basic.es;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.http.HttpHost;
import org.apache.http.client.methods.HttpPost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Description: Es工具类
* @Author sun
* @Create 2024/6/17 17:43
* @Version 1.0
*/
@Component
@Slf4j
public class EsRestClient {
/*
表示某个集群节点对应的某个客户端的map
RestHighLevelClient：是由集群的ip端口数组生成的
*/
public static Map<String, RestHighLevelClient> clientMap = new HashMap<>();
/*
获取配置文件中填写的es.cluster.es-configs的集群信息
*/
@Resource
private EsConfigProperties esConfigProperties;
/**
* @PostConstruct：注解用于标记一个方法，该方法会在依赖注入完成后自动调用
* 这里将从配置文件中读取的集群信息封装到map中
*/
@PostConstruct
public void initialize() {
// 获取集群节点的信息
List<EsClusterConfig> esConfigs = esConfigProperties.getEsConfigs();
esConfigs.forEach(esClusterConfig -> {
String name = esClusterConfig.getName();
String nodes = esClusterConfig.getNodes();
log.info("initialize.esClusterConfig.name:{},nodes:{}", name, nodes);
// 将每个集群的ip端口数组转换为RestHighLevelClient
RestHighLevelClient restHighLevelClient = initRestClient(esClusterConfig);
if (restHighLevelClient != null) {
// 如果不为空就放到clientMap中
clientMap.put(name, restHighLevelClient);
} else {
// 如果为空，打印日志
log.error("initialize.esClusterConfig.name:{},nodes:{} is null", name, nodes);
}
});
}
/**
* 通过一个集群节点来初始化该集群节点对应的客户端
* @param esClusterConfig
* @return
*/
private RestHighLevelClient initRestClient(EsClusterConfig esClusterConfig) {
// 得到该集群节点的IP端口数组
String[] ipPortArr = esClusterConfig.getNodes().split(",");
// 初始化一个HttpHost的列表
List<HttpHost> httpHostList = new ArrayList<>(ipPortArr.length);
// 对每一个ip端口进行处理
for (String ipPort : ipPortArr) {
// 分割ip端口
String[] ipPortInfo = ipPort.split(":");
// 校验
if (ipPortInfo.length == 2) {
// 创建一个HttpPost的对象，存放ip和端口
HttpHost httpHost = new HttpHost(ipPortInfo[0], NumberUtils.toInt(ipPortInfo[1]));
// 放到list中
httpHostList.add(httpHost);
}
}
// 创建一个HttpHost的数组，存放HttpHost
HttpHost[] httpHosts = new HttpHost[httpHostList.size()];
// httpHostList的数据放到这个数组里
httpHostList.toArray(httpHosts);
// 得到RestClient
RestClientBuilder builder = RestClient.builder(httpHosts);
// 升级一下
RestHighLevelClient restHighLevelClient = new RestHighLevelClient(builder);
return restHighLevelClient;
}
}
5.启动测试，可以读取到配置信息
3.封装ES常用操作（全）
1.EsClusterConfig.java ES的集群配置的实体类
package com.sunxiansheng.subject.infra.basic.es;
import lombok.Data;
import java.io.Serializable;
/**
* Description: ES的集群配置的实体类
* @Author sun
* @Create 2024/6/17 17:08
* @Version 1.0
*/
@Data
public class EsClusterConfig implements Serializable {
/*
集群名称
*/
private String name;
/*
集群节点
*/
private String nodes;
}
2.EsConfigProperties.java 读取配置文件的集群配置
package com.sunxiansheng.subject.infra.basic.es;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
* Description: 读取配置文件的集群配置
* @Author sun
* @Create 2024/6/17 17:10
* @Version 1.0
*/
@Component
@ConfigurationProperties(prefix = "es.cluster") // 这个就相当于将esConfigs对应于配置文件的es.cluster.esConfigs
public class EsConfigProperties {
private List<EsClusterConfig> esConfigs = new ArrayList<>();
public List<EsClusterConfig> getEsConfigs() {
return esConfigs;
}
public void setEsConfigs(List<EsClusterConfig> esConfigs) {
this.esConfigs = esConfigs;
}
}
3.EsIndexInfo.java Es的索引信息
package com.sunxiansheng.subject.infra.basic.es;
import lombok.Data;
import java.io.Serializable;
/**
* Description: Es的索引信息
* @Author sun
* @Create 2024/6/17 17:17
* @Version 1.0
*/
@Data
public class EsIndexInfo implements Serializable {
/*
集群名称
*/
private String clusterName;
/*
索引名称
*/
private String indexName;
}
4.EsSourceData.java Es源数据
package com.sunxiansheng.subject.infra.basic.es;
import lombok.Data;
import java.io.Serializable;
import java.util.Map;
/**
* Description: Es源数据
* @Author sun
* @Create 2024/6/17 17:41
* @Version 1.0
*/
@Data
public class EsSourceData implements Serializable {
private String docId;
private Map<String, Object> data;
}
5.EsSearchRequest.java Es查询的请求实体类
package com.sunxiansheng.subject.infra.basic.es;
import lombok.Data;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.SortOrder;
/**
* Description: Es查询的请求实体类
* @Author sun
* @Create 2024/6/17 17:20
* @Version 1.0
*/
@Data
public class EsSearchRequest {
/**
* 查询条件
*/
private BoolQueryBuilder bq;
/**
* 查询字段
*/
private String[] fields;
/**
* 页数
*/
private int from;
/**
* 条数
*/
private int size;
/**
* 需要快照
*/
private Boolean needScroll;
/**
* 快照缓存时间
*/
private Long minutes;
/**
* 排序字段
*/
private String sortName;
/**
* 排序类型
*/
private SortOrder sortOrder;
/**
* 高亮builder
*/
private HighlightBuilder highlightBuilder;
}
6.EsRestClient.java
package com.sunxiansheng.subject.infra.basic.es;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.http.HttpHost;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.search.Scroll;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.ScoreSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.*;
/**
* Description: Es工具类
* @Author sun
* @Create 2024/6/17 17:43
* @Version 1.0
*/
@Component
@Slf4j
public class EsRestClient {
/*
表示某个集群节点对应的某个客户端的map
RestHighLevelClient：是由集群的ip端口数组生成的
*/
public static Map<String, RestHighLevelClient> clientMap = new HashMap<>();
/*
获取配置文件中填写的es.cluster.es-configs的集群信息
*/
@Resource
private EsConfigProperties esConfigProperties;
/*
*/
private static final RequestOptions COMMON_OPTIONS;
/**
* 为COMMON_OPTIONS进行静态初始化，在类加载的时候会执行
*/
static {
RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
COMMON_OPTIONS = builder.build();
}
/**
* @PostConstruct：注解用于标记一个方法，该方法会在依赖注入完成后自动调用
* 这里将从配置文件中读取的集群信息封装到map中
*/
@PostConstruct
public void initialize() {
// 获取集群节点的信息
List<EsClusterConfig> esConfigs = esConfigProperties.getEsConfigs();
esConfigs.forEach(esClusterConfig -> {
String name = esClusterConfig.getName();
String nodes = esClusterConfig.getNodes();
log.info("initialize.esClusterConfig.name:{},nodes:{}", name, nodes);
// 将每个集群的ip端口数组转换为RestHighLevelClient
RestHighLevelClient restHighLevelClient = initRestClient(esClusterConfig);
if (restHighLevelClient != null) {
// 如果不为空就放到clientMap中
clientMap.put(name, restHighLevelClient);
} else {
// 如果为空，打印日志
log.error("initialize.esClusterConfig.name:{},nodes:{} is null", name, nodes);
}
});
}
/**
* 通过一个集群节点来初始化该集群节点对应的客户端
* @param esClusterConfig
* @return
*/
private RestHighLevelClient initRestClient(EsClusterConfig esClusterConfig) {
// 得到该集群节点的IP端口数组
String[] ipPortArr = esClusterConfig.getNodes().split(",");
// 初始化一个HttpHost的列表
List<HttpHost> httpHostList = new ArrayList<>(ipPortArr.length);
// 对每一个ip端口进行处理
for (String ipPort : ipPortArr) {
// 分割ip端口
String[] ipPortInfo = ipPort.split(":");
// 校验
if (ipPortInfo.length == 2) {
// 创建一个HttpPost的对象，存放ip和端口
HttpHost httpHost = new HttpHost(ipPortInfo[0], NumberUtils.toInt(ipPortInfo[1]));
// 放到list中
httpHostList.add(httpHost);
}
}
// 创建一个HttpHost的数组，存放HttpHost
HttpHost[] httpHosts = new HttpHost[httpHostList.size()];
// httpHostList的数据放到这个数组里
httpHostList.toArray(httpHosts);
// 得到RestClient
RestClientBuilder builder = RestClient.builder(httpHosts);
// 升级一下
RestHighLevelClient restHighLevelClient = new RestHighLevelClient(builder);
return restHighLevelClient;
}
/**
* 获取集群名对应的RestHighLevelClient
* @param clusterName
* @return
*/
private static RestHighLevelClient getClient(String clusterName) {
return clientMap.get(clusterName);
}
/**
* 新增文档（新增一条记录）
* @param esIndexInfo 包含集群名和索引名
* @param esSourceData 文档id和map类型的data
* @return
*/
public static boolean insertDoc(EsIndexInfo esIndexInfo, EsSourceData esSourceData) {
try {
// ==========构建表的一条数据==========
// 获取es的索引名（表名）对应的请求
IndexRequest indexRequest = new IndexRequest(esIndexInfo.getIndexName());
// 设置源数据
indexRequest.source(esSourceData.getData());
// 设置记录的id
indexRequest.id(esSourceData.getDocId());
// ==========构建表的一条数据==========
// 根据集群名获取client
getClient(esIndexInfo.getClusterName()).index(indexRequest, COMMON_OPTIONS);
// 如果没报错就返回true
return true;
} catch (Exception e) {
// 打日志
log.error("insertDoc.error:{}", e.getMessage(), e);
}
// 如果报错就返回false
return false;
}
/**
* 更新文档（更新记录）
* @param esIndexInfo
* @param esSourceData
* @return
*/
public static boolean updateDoc(EsIndexInfo esIndexInfo, EsSourceData esSourceData) {
try {
// 构建更新请求
UpdateRequest updateRequest = new UpdateRequest();
// 设置索引
updateRequest.index(esIndexInfo.getIndexName());
// 设置文档
updateRequest.id(esSourceData.getDocId());
// 设置源数据
updateRequest.doc(esSourceData.getData());
// 根据集群名获取client，执行更新操作
getClient(esIndexInfo.getClusterName()).update(updateRequest, COMMON_OPTIONS);
// 如果没报错就返回true
return true;
} catch (Exception e) {
// 打日志
log.error("updateDoc.error:{}", e.getMessage(), e);
}
// 如果报错就返回false
return false;
}
/**
* 批量更新文档（更新记录）
* @param esIndexInfo
* @param esSourceDataList
* @return
*/
public static boolean batchUpdateDoc(EsIndexInfo esIndexInfo, List<EsSourceData> esSourceDataList) {
try {
// 标志位
boolean flag = false;
// 创建一个多请求对象
BulkRequest bulkRequest = new BulkRequest();
// 遍历源数据的列表
for (EsSourceData esSourceData : esSourceDataList) {
// 获取文档id
String docId = esSourceData.getDocId();
// 构建一个更新请求放到BulkRequest中
if (StringUtils.isNotBlank(docId)) {
// 构建更新请求
UpdateRequest updateRequest = new UpdateRequest();
// 设置索引
updateRequest.index(esIndexInfo.getIndexName());
// 设置文档
updateRequest.id(esSourceData.getDocId());
// 设置源数据
updateRequest.doc(esSourceData.getData());
// 将更新请求放到BulkRequest
bulkRequest.add(updateRequest);
flag = true;
}
}
// 如果flag为true，就说明更新请求已经存放完毕，可以更新了
if (flag) {
// 根据集群名获取客户端执行批量更新
BulkResponse bulk = getClient(esIndexInfo.getClusterName()).bulk(bulkRequest, COMMON_OPTIONS);
// 如果有失败的，就返回false
if (bulk.hasFailures()) {
return false;
}
}
// 如果没报错就返回true
return true;
} catch (Exception e) {
// 打日志
log.error("batchUpdateDoc.error:{}", e.getMessage(), e);
}
// 如果报错就返回false
return false;
}
/**
* 删除索引下的所有文档
* @param esIndexInfo
* @return
*/
public static boolean delete(EsIndexInfo esIndexInfo) {
try {
// 根据索引构建一个请求
DeleteByQueryRequest deleteByQueryRequest = new DeleteByQueryRequest(esIndexInfo.getIndexName());
// 设置查询
deleteByQueryRequest.setQuery(QueryBuilders.matchAllQuery());
// 指定集群得到客户端进行删除操作
BulkByScrollResponse response = getClient(esIndexInfo.getClusterName()).deleteByQuery(
deleteByQueryRequest, COMMON_OPTIONS
);
// 获取删除的数量
long deleted = response.getDeleted();
log.info("deleted.size:{}", deleted);
return true;
} catch (Exception e) {
// 打日志
log.error("delete.error:{}", e.getMessage(), e);
}
return false;
}
/**
* 根据id删除文档
* @param esIndexInfo
* @return
*/
public static boolean deleteDoc(EsIndexInfo esIndexInfo, String docId) {
try {
// 根据索引获取删除请求
DeleteRequest deleteRequest = new DeleteRequest(esIndexInfo.getIndexName());
// 设置要删除的文档id
deleteRequest.id(docId);
// 根据集群名获取客户端，执行删除操作
DeleteResponse response = getClient(esIndexInfo.getClusterName()).delete(deleteRequest, COMMON_OPTIONS);
// 打日志
log.info("deleted.response:{}", JSON.toJSONString(response));
return true;
} catch (Exception e) {
// 打日志
log.error("deleteDoc.error:{}", e.getMessage(), e);
}
return false;
}
/**
* 根据id判断文档是否存在
* @param esIndexInfo
* @param docId
* @return
*/
public static boolean isExistDocById(EsIndexInfo esIndexInfo, String docId) {
try {
// 根据索引获取请求
GetRequest getRequest = new GetRequest(esIndexInfo.getIndexName());
// 设置文档id
getRequest.id(docId);
// 根据集群名返回客户端，判断文档是否存在
return getClient(esIndexInfo.getClusterName()).exists(getRequest, COMMON_OPTIONS);
} catch (Exception e) {
// 打日志
log.error("isExistDocById.error:{}", e.getMessage(), e);
}
return false;
}
/**
* 根据id查询文档（一条记录）
* @param esIndexInfo
* @param docId
* @return
*/
public static Map<String, Object> getDocById(EsIndexInfo esIndexInfo, String docId) {
try {
// 根据索引获取请求
GetRequest getRequest = new GetRequest(esIndexInfo.getIndexName());
// 设置文档id
getRequest.id(docId);
// 根据集群名返回客户端，根据id查询文档
GetResponse response = getClient(esIndexInfo.getClusterName()).get(getRequest, COMMON_OPTIONS);
// 获取文档信息
Map<String, Object> source = response.getSource();
return source;
} catch (Exception e) {
// 打日志
log.error("getDocById.error:{}", e.getMessage(), e);
}
return null;
}
/**
* 根据id查询指定字段的文档
* @param esIndexInfo
* @param docId
* @param fields
* @return
*/
public static Map<String, Object> getDocById(EsIndexInfo esIndexInfo, String docId, String[] fields) {
try {
// 根据索引获取请求
GetRequest getRequest = new GetRequest(esIndexInfo.getIndexName());
// 设置文档id
getRequest.id(docId);
// 设置要查询文档的指定字段
FetchSourceContext fetchSourceContext = new FetchSourceContext(true, fields, null);
getRequest.fetchSourceContext(fetchSourceContext);
// 根据集群名返回客户端，根据id查询文档
GetResponse response = getClient(esIndexInfo.getClusterName()).get(getRequest, COMMON_OPTIONS);
// 获取文档信息
Map<String, Object> source = response.getSource();
return source;
} catch (Exception e) {
// 打日志
log.error("getDocById.error:{}", e.getMessage(), e);
}
return null;
}
/**
* 条件查询
* @param esIndexInfo
* @param esSearchRequest
* @return
*/
public static SearchResponse searchWithTermQuery(EsIndexInfo esIndexInfo, EsSearchRequest esSearchRequest) {
try {
// 获取BoolQueryBuilder
BoolQueryBuilder bq = esSearchRequest.getBq();
// 获取查询条件
String[] fields = esSearchRequest.getFields();
int from = esSearchRequest.getFrom();
int size = esSearchRequest.getSize();
Boolean needScroll = esSearchRequest.getNeedScroll();
Long minutes = esSearchRequest.getMinutes();
String sortName = esSearchRequest.getSortName();
SortOrder sortOrder = esSearchRequest.getSortOrder();
HighlightBuilder highlightBuilder = esSearchRequest.getHighlightBuilder();
// 构建查询条件
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(bq);
// 查询的字段、分页、大小
searchSourceBuilder.fetchSource(fields, null).from(from).size(size);
// 如果有高亮的就加入条件
if (Objects.nonNull(highlightBuilder)) {
searchSourceBuilder.highlighter(highlightBuilder);
}
// 如果有排序字段就加入条件
if (StringUtils.isNotBlank(sortName)) {
searchSourceBuilder.sort(sortName);
}
// 降序排序
searchSourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
// 构建查询请求
SearchRequest searchRequest = new SearchRequest();
// 设置查询类型
searchRequest.searchType(SearchType.DEFAULT);
// 设置索引名
searchRequest.indices(esIndexInfo.getIndexName());
// 设置查询条件
searchRequest.source(searchSourceBuilder);
// 需要快照的情况
if (needScroll) {
Scroll scroll = new Scroll(TimeValue.timeValueMinutes(minutes));
searchRequest.scroll(scroll);
}
// 通过集群名来获取客户端执行查询请求
SearchResponse searchResponse = getClient(esIndexInfo.getClusterName()).search(searchRequest, COMMON_OPTIONS);
return searchResponse;
} catch (Exception e) {
// 打日志
log.error("searchWithTermQuery.error:{}", e.getMessage(), e);
}
return null;
}
}
620
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
