当前位置：首页 > news >正文

Springboot整合spring-boot-starter-data-elasticsearch

news 2024/10/28 23:33:27

前言

spring-boot-starter-data-elasticsearch 是 Spring Boot 提供的一个起始依赖，旨在简化与 Elasticsearch 交互的开发过程。它集成了 Spring Data Elasticsearch，提供了一套完整的 API，用于与 Elasticsearch 进行 CRUD 操作、查询、索引等

相对于es原生依赖的话，进行了一下封装，在使用过程中相对便捷

项目源码

项目源码：https://gitee.com/shen-chuhao/walker_open_java.git

elasticsearch和springboot版本要求

在使用 spring-boot-starter-data-elasticsearch 时，Spring Boot 版本和 Elasticsearch 版本不一致可能导致以下问题：

兼容性问题：
- Spring Data Elasticsearch 依赖于特定版本的 Elasticsearch 客户端库。如果版本不兼容，可能会导致运行时异常或方法未找到的错误。
功能缺失或错误：
- 一些新功能可能在不兼容的版本中不可用，或者可能会存在实现上的差异，导致某些功能无法正常工作。
配置问题：
- 某些配置选项可能会因版本不一致而有所不同。例如，某些配置参数在新版本中可能被弃用，或者在旧版本中可能不可用。
序列化和反序列化问题：
- 数据模型的变化可能导致在 Elasticsearch 中存储的数据格式与预期不符，从而引发解析错误。
性能问题：
- 不兼容的版本可能导致性能下降或不稳定，尤其是在高并发环境下。

整合步骤

依赖添加

 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-elasticsearch</artifactId></dependency>

yaml配置添加

spring:elasticsearch:rest:uris: localhost:19200# 账号密码配置，如果没有则不需要password: elasticusername: elastic

实体类添加

package com.walker.es.entity;import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Transient;
import org.springframework.data.annotation.TypeAlias;
import org.springframework.data.elasticsearch.annotations.DateFormat;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.format.annotation.DateTimeFormat;import java.util.Date;@Data//索引
// boolean createIndex() default true;  默认会创建索引
@Document(indexName = "alarm_record", shards = 2, replicas = 2,createIndex = true)
public class AlarmRecordEntity {//    配置使用的id@Idprivate Long id;//    事件
//  配置属性，分词器@Field(type = FieldType.Text, analyzer = "ik_max_word")private String title;//    设备@Field(type = FieldType.Keyword)private String deviceCode;//    时间  需要使用keyword，否则无法实现范围查询 @Field(type = FieldType.Keyword)private String time;//    在es中进行忽略的@Transientprivate String msg;}

@Document注解：可以设置索引的名称，分片、副本，是否自动创建索引等
@Id：指定文档的id
@Field(type = FieldType.Text, analyzer = “ik_max_word”) 属性配置，可以用于配置字段的类型，分词器等等，具体的可以查看后面的相关注解

Repository类

package com.walker.es.repository;import com.walker.es.entity.AlarmRecordEntity;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Repository;// 添加注解
@Repository
// 继承类 ElasticsearchRepository
public interface AlarmRecordRepository extends ElasticsearchRepository<AlarmRecordEntity, Long> {// 你可以在这里添加自定义查询方法
}

继承ElasticsearchRepository类，可以使用ElasticsearchRepository封装好的增删改查等方法

测试类

先注入repository

    @Autowiredprivate AlarmRecordRepository alarmRecordRepository;

新增数据

    // 创建新警报记录@PostMappingpublic ResponseEntity<AlarmRecordEntity> createAlarmRecord(@RequestBody AlarmRecordEntity alarmRecord) {
//      自动生成雪花idalarmRecord.setId(IdUtil.getSnowflakeNextId());AlarmRecordEntity savedRecord = alarmRecordRepository.save(alarmRecord);return ResponseEntity.ok(savedRecord);}

请求参数：

{"title": "打架告警","deviceCode": "A001","time": "2024-11-10 10:10:00","msg": "消息描述"
}

执行后，如果第一次插入数据，则会自动生成索引。

副本、分片

字段映射情况

查询插入的数据

修改数据

@Autowiredprivate DocumentOperations documentOperations;@Autowiredprivate ElasticsearchConverter elasticsearchConverter;// 更新警报记录@PutMapping("/{id}")public ResponseEntity<AlarmRecordEntity> updateAlarmRecord(@PathVariable Long id, @RequestBody AlarmRecordEntity alarmRecord) {//使用ElasticsearchConverter 将对象转成Document对象Document document = elasticsearchConverter.mapObject(alarmRecord);// 修改方法UpdateQuery updateQuery = UpdateQuery.builder(String.valueOf(id)).withDocument(document).build();UpdateResponse updateResponse = documentOperations.update(updateQuery, IndexCoordinates.of("alarm_record"));log.info("修改数据结果：{}", JSONUtil.toJsonStr(updateResponse));return ResponseEntity.ok(alarmRecord);}

Repository中是没有修改数据的方法的
所有得使用操作类DocumentOperations、或者ElasticsearchOperations

实践结果：

修改结果如下：

删除

    // 删除警报记录@DeleteMapping("/{id}")public ResponseEntity<Void> deleteAlarmRecord(@PathVariable Long id) {if (!alarmRecordRepository.existsById(id)) {return ResponseEntity.notFound().build();}alarmRecordRepository.deleteById(id);return ResponseEntity.noContent().build();}

使用repository的deleteById
批量删除

使用repository进行基础查询

    // 获取所有警报记录@GetMapping("/findByDeviceCode")public List<AlarmRecordEntity> findByDeviceCode(String deviceCode) {return  alarmRecordRepository.findAlarmRecordEntitiesByDeviceCodeEquals(deviceCode);}

继承ElasticsearchRepository类后，可以使用findXXByXX，进行查询，类似于jpa
例如下面的方法

package com.walker.es.repository;import com.walker.es.entity.AlarmRecordEntity;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Repository;import java.util.List;@Repository
public interface AlarmRecordRepository extends ElasticsearchRepository<AlarmRecordEntity, Long> {// 根据deviceCode=xx进行查询，不需要去重写方法等，相对简便List<AlarmRecordEntity> findAlarmRecordEntitiesByDeviceCodeEquals(String deviceCode);}

具体的关键词使用，可以查看附录1repository关键词

分页查询、条件搜索

这个是实际业务场景中用的比较多的了

但是_ElasticsearchRepository 无法实现复杂的查询，所以还是得使用ElasticsearchTemplate 或者_ElasticsearchOperations 进行处理

spring-data-elasticsearch的操作类主要有以下几种：

IndexOperations 定义了在索引级别执行的操作，比如创建或删除索引。

DocumentOperations 定义了基于实体 ID 存储、更新和检索实体的操作。

SearchOperations 定义了使用查询搜索多个实体的操作。

ElasticsearchOperations 结合了 DocumentOperations 和 SearchOperations 接口的功能。

请求体

@Data
public class AlarmSearchDTO {
//    注意，页码需要从0开始，否则会跳过private Integer pageIndex=0;private Integer pageSize=10;private String title;private String deviceCode;private String startTime;private String endTime;
}

controllerfangfa

 @PostMapping("/page")public PageVo<AlarmRecordEntity> getAlarmRecords(@RequestBody AlarmSearchDTO dto) {// 分页类  将页码和页数参数填入Pageable pageable = PageRequest.of(dto.getPageIndex(),dto.getPageSize());// 构建查询 在spring-data-elastic中有三种查询方式，具体可以查看后面的查询方式NativeSearchQueryBuilder  query = new NativeSearchQueryBuilder().withPageable(pageable);//        如果设备编码非空if(StrUtil.isNotEmpty(dto.getDeviceCode())){
//            精确查询 termQueryquery.withQuery(QueryBuilders.termQuery("deviceCode",dto.getDeviceCode() ));}if(StrUtil.isNotEmpty(dto.getTitle())){
//            模糊查询 fuzzyQuery   如果是要根据分词拆分查询的话，得使用matchQueryquery.withQuery(QueryBuilders.fuzzyQuery("title",dto.getTitle() ));}//        范围查询if (StrUtil.isNotEmpty(dto.getStartTime())) {
//            range范围查询需要keyword才能生效，如果使用text则会不生效query.withQuery(QueryBuilders.rangeQuery("time").gte(dto.getStartTime()).lte(dto.getEndTime()));}NativeSearchQuery searchQuery = query.build();//        排序：根据id倒叙searchQuery.addSort(Sort.sort(AlarmRecordEntity.class).by(AlarmRecordEntity::getId).descending());// 执行查询SearchHits<AlarmRecordEntity> search = elasticsearchTemplate.search(searchQuery, AlarmRecordEntity.class);PageVo<AlarmRecordEntity> pageVo = new PageVo<>();if(search!=null){//设置总数pageVo.setTotal(search.getTotalHits());// 返回的行数List<SearchHit<AlarmRecordEntity>> searchHits = search.getSearchHits();if(CollUtil.isNotEmpty(searchHits)){ArrayList<AlarmRecordEntity> rows = new ArrayList<>();for (SearchHit<AlarmRecordEntity> searchHit : searchHits) {AlarmRecordEntity content = searchHit.getContent();rows.add(content);}pageVo.setList(rows);}}return pageVo;}

Query查询方式主要有以下几种

1. CriteriaQuery

定义：CriteriaQuery 是一个用于构建类型安全查询的方式。它允许通过构建查询条件来进行灵活的查询。

使用案例：

 CodeCriteriaQuery criteriaQuery = new CriteriaQuery();
criteriaQuery.addCriteria(Criteria.where("fieldName").is("value"));List<MyEntity> results = elasticsearchOperations.queryForList(criteriaQuery, MyEntity.class);

2. StringQuery

定义：StringQuery 是一种基于字符串的查询方式，允许直接使用 Elasticsearch 的查询 DSL（Domain Specific Language）。

使用案例：

CodeStringQuery stringQuery = new StringQuery("{\"match\":{\"fieldName\":\"value\"}}");List<MyEntity> results = elasticsearchOperations.queryForList(stringQuery, MyEntity.class);

3. NativeQuery

定义：NativeQuery 允许执行原生的 Elasticsearch 查询，通常用于需要更复杂或特定的查询场景。

使用案例：

CodeNativeSearchQueryBuilder searchQueryBuilder = new NativeSearchQueryBuilder();
searchQueryBuilder.withQuery(QueryBuilders.matchQuery("fieldName", "value"));NativeSearchQuery searchQuery = searchQueryBuilder.build();
List<MyEntity> results = elasticsearchOperations.queryForList(searchQuery, MyEntity.class);

总结

CriteriaQuery 适用于类型安全且灵活的查询构建。
StringQuery 提供直接使用查询 DSL 的能力。
NativeQuery 适合复杂的查询需求，允许使用原生的 Elasticsearch 查询。

可以发现，在查询条件中，还是需要手动写出属性的名称，使用起来相对会麻烦一些。

具体的查询方式，可以自己去查找一下，例如范围查询，模糊查询，分词查询等等。

总结

spring-data-elasticsearch的查询，相当于原生的es依赖而言，多了一些注解封装、repository类等，但是对于复杂查询还是没有办法很简便，因此便有了第三方的依赖Easy-es的诞生，类似于Mybatis-plus的方式，对于新手对es的使用比较友好，后面会进行讲解

最后：我是Walker，一个热爱分享的程序员，希望我的输出能够帮助到你

附录

repository关键词

Keyword	Sample	Elasticsearch Query String
`And`	`findByNameAndPrice`	`{ "query" : { "bool" : { "must" : [ { "query_string" : { "query" : "?", "fields" : [ "name" ] } }, { "query_string" : { "query" : "?", "fields" : [ "price" ] } } ] } }}`
`Or`	`findByNameOrPrice`	`{ "query" : { "bool" : { "should" : [ { "query_string" : { "query" : "?", "fields" : [ "name" ] } }, { "query_string" : { "query" : "?", "fields" : [ "price" ] } } ] } }}`
`Is`	`findByName`	`{ "query" : { "bool" : { "must" : [ { "query_string" : { "query" : "?", "fields" : [ "name" ] } } ] } }}`
`Not`	`findByNameNot`	`{ "query" : { "bool" : { "must_not" : [ { "query_string" : { "query" : "?", "fields" : [ "name" ] } } ] } }}`
`Between`	`findByPriceBetween`	`{ "query" : { "bool" : { "must" : [ {"range" : {"price" : {"from" : ?, "to" : ?, "include_lower" : true, "include_upper" : true } } } ] } }}`
`LessThan`	`findByPriceLessThan`	`{ "query" : { "bool" : { "must" : [ {"range" : {"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : false } } } ] } }}`
`LessThanEqual`	`findByPriceLessThanEqual`	`{ "query" : { "bool" : { "must" : [ {"range" : {"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : true } } } ] } }}`
`GreaterThan`	`findByPriceGreaterThan`	`{ "query" : { "bool" : { "must" : [ {"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : false, "include_upper" : true } } } ] } }}`
`GreaterThanEqual`	`findByPriceGreaterThanEqual`	`{ "query" : { "bool" : { "must" : [ {"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : true, "include_upper" : true } } } ] } }}`
`Before`	`findByPriceBefore`	`{ "query" : { "bool" : { "must" : [ {"range" : {"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : true } } } ] } }}`
`After`	`findByPriceAfter`	`{ "query" : { "bool" : { "must" : [ {"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : true, "include_upper" : true } } } ] } }}`
`Like`	`findByNameLike`	`{ "query" : { "bool" : { "must" : [ { "query_string" : { "query" : "?*", "fields" : [ "name" ] }, "analyze_wildcard": true } ] } }}`
`StartingWith`	`findByNameStartingWith`	`{ "query" : { "bool" : { "must" : [ { "query_string" : { "query" : "?*", "fields" : [ "name" ] }, "analyze_wildcard": true } ] } }}`
`EndingWith`	`findByNameEndingWith`	`{ "query" : { "bool" : { "must" : [ { "query_string" : { "query" : "*?", "fields" : [ "name" ] }, "analyze_wildcard": true } ] } }}`
`Contains/Containing`	`findByNameContaining`	`{ "query" : { "bool" : { "must" : [ { "query_string" : { "query" : "?", "fields" : [ "name" ] }, "analyze_wildcard": true } ] } }}`
`In` (when annotated as FieldType.Keyword)	`findByNameIn(Collection<String>names)`	`{ "query" : { "bool" : { "must" : [ {"bool" : {"must" : [ {"terms" : {"name" : ["?","?"]}} ] } } ] } }}`
`In`	`findByNameIn(Collection<String>names)`	`{ "query": {"bool": {"must": [{"query_string":{"query": "\"?\" \"?\"", "fields": ["name"]}}]}}}`
`NotIn` (when annotated as FieldType.Keyword)	`findByNameNotIn(Collection<String>names)`	`{ "query" : { "bool" : { "must" : [ {"bool" : {"must_not" : [ {"terms" : {"name" : ["?","?"]}} ] } } ] } }}`
`NotIn`	`findByNameNotIn(Collection<String>names)`	`{"query": {"bool": {"must": [{"query_string": {"query": "NOT(\"?\" \"?\")", "fields": ["name"]}}]}}}`
`True`	`findByAvailableTrue`	`{ "query" : { "bool" : { "must" : [ { "query_string" : { "query" : "true", "fields" : [ "available" ] } } ] } }}`
`False`	`findByAvailableFalse`	`{ "query" : { "bool" : { "must" : [ { "query_string" : { "query" : "false", "fields" : [ "available" ] } } ] } }}`
`OrderBy`	`findByAvailableTrueOrderByNameDesc`	`{ "query" : { "bool" : { "must" : [ { "query_string" : { "query" : "true", "fields" : [ "available" ] } } ] } }, "sort":[{"name":{"order":"desc"}}] }`
`Exists`	`findByNameExists`	`{"query":{"bool":{"must":[{"exists":{"field":"name"}}]}}}`
`IsNull`	`findByNameIsNull`	`{"query":{"bool":{"must_not":[{"exists":{"field":"name"}}]}}}`
`IsNotNull`	`findByNameIsNotNull`	`{"query":{"bool":{"must":[{"exists":{"field":"name"}}]}}}`
`IsEmpty`	`findByNameIsEmpty`	`{"query":{"bool":{"must":[{"bool":{"must":[{"exists":{"field":"name"}}],"must_not":[{"wildcard":{"name":{"wildcard":"*"}}}]}}]}}}`
`IsNotEmpty`	`findByNameIsNotEmpty`	`{"query":{"bool":{"must":[{"wildcard":{"name":{"wildcard":"*"}}}]}}}`