SpringBoot与Elasticsearch集成开发实战指南

SpringBootElasticsearch全文检索

于 2026-07-03 09:42:09 修改

·本内容遵循CC 4.0 BY-SA版权协议

1. 从零搭建SpringBoot与Elasticsearch集成环境

在开始实际开发前，我们需要先搭建好基础环境。这里我推荐使用Docker来部署Elasticsearch，这种方式简单快捷，且能保持环境的一致性。

1.1 Docker环境下的Elasticsearch部署

首先确保你的系统已经安装了Docker和Docker Compose。如果没有安装，可以参考Docker官方文档进行安装。下面是我在实际项目中使用的docker-compose.yml配置：

YAML

version: '3'

services:

elasticsearch:

image: elasticsearch:7.12.1

container_name: elasticsearch

environment:

- discovery.type=single-node

- ES_JAVA_OPTS=-Xms512m -Xmx512m

volumes:

- es_data:/usr/share/elasticsearch/data

- es_plugins:/usr/share/elasticsearch/plugins

ports:

- 9200:9200

- 9300:9300

networks:

- es_network

kibana:

image: kibana:7.12.1

container_name: kibana

depends_on:

- elasticsearch

environment:

- ELASTICSEARCH_HOSTS=http://elasticsearch:9200

ports:

- 5601:5601

networks:

- es_network

volumes:

es_data:

es_plugins:

networks:

es_network:

driver: bridge

这个配置做了以下几件事：

创建了一个单节点的Elasticsearch服务
分配了512MB的堆内存（生产环境需要根据实际情况调整）
挂载了数据卷，确保数据持久化
同时部署了Kibana作为可视化工具
创建了专用的网络让两个服务可以互相通信

启动服务只需要执行：

BASH

docker-compose up -d

1.2 验证安装与IK分词器配置

服务启动后，可以通过以下方式验证是否安装成功：

Elasticsearch: 访问 http://localhost:9200，应该能看到Elasticsearch的版本信息
Kibana: 访问 http://localhost:5601，应该能看到Kibana的界面

中文搜索需要安装IK分词器，执行以下命令：

BASH

docker exec -it elasticsearch ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip

安装完成后需要重启Elasticsearch容器：

BASH

docker restart elasticsearch

1.3 SpringBoot项目初始化

创建一个新的SpringBoot项目，添加以下依赖到pom.xml：

XML

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

<groupId>org.elasticsearch.client</groupId>

<artifactId>elasticsearch-rest-high-level-client</artifactId>

</dependency>

<groupId>org.projectlombok</groupId>

<artifactId>lombok</artifactId>

</dependency>

</dependencies>

2. SpringBoot集成Elasticsearch核心配置

2.1 配置Elasticsearch客户端

我们需要创建一个配置类来初始化Elasticsearch的高级客户端：

JAVA

@Configuration

public class ElasticsearchConfig {

@Value("${elasticsearch.host}")

private String host;

@Value("${elasticsearch.port}")

private int port;

@Bean(destroyMethod = "close")

public RestHighLevelClient restHighLevelClient() {

return new RestHighLevelClient(

RestClient.builder(

new HttpHost(host, port, "http")

)

);

}

对应的application.yml配置：

YAML

elasticsearch:

host: localhost

port: 9200

2.2 索引与映射管理

在实际项目中，我们通常需要先定义索引的映射结构。以下是一个用户索引的映射示例：

JAVA

public class UserIndexMapping {

public static final String MAPPING_JSON = "{\n" +

" \"properties\": {\n" +

" \"id\": {\"type\": \"keyword\"},\n" +

" \"username\": {\"type\": \"text\", \"analyzer\": \"ik_max_word\"},\n" +

" \"email\": {\"type\": \"keyword\"},\n" +

" \"age\": {\"type\": \"integer\"},\n" +

" \"createTime\": {\"type\": \"date\", \"format\": \"yyyy-MM-dd HH:mm:ss||epoch_millis\"},\n" +

" \"address\": {\n" +

" \"type\": \"object\",\n" +

" \"properties\": {\n" +

" \"city\": {\"type\": \"keyword\"},\n" +

" \"street\": {\"type\": \"text\", \"analyzer\": \"ik_smart\"}\n" +

" }\n" +

"}";

}

创建索引的代码：

JAVA

@Autowired

private RestHighLevelClient client;

public void createUserIndex() throws IOException {

CreateIndexRequest request = new CreateIndexRequest("user");

request.mapping(UserIndexMapping.MAPPING_JSON, XContentType.JSON);

AcknowledgedResponse response = client.indices().create(request, RequestOptions.DEFAULT);

if (!response.isAcknowledged()) {

throw new RuntimeException("创建索引失败");

}

3. Elasticsearch基础操作实战

3.1 文档CRUD操作

添加文档

JAVA

public void addUser(User user) throws IOException {

IndexRequest request = new IndexRequest("user")

.id(user.getId().toString())

.source(convertUserToMap(user), XContentType.JSON);

IndexResponse response = client.index(request, RequestOptions.DEFAULT);

if (response.status() != RestStatus.CREATED) {

throw new RuntimeException("添加文档失败");

}

private Map<String, Object> convertUserToMap(User user) {

Map<String, Object> map = new HashMap<>();

map.put("id", user.getId());

map.put("username", user.getUsername());

map.put("email", user.getEmail());

map.put("age", user.getAge());

map.put("createTime", user.getCreateTime());

if (user.getAddress() != null) {

Map<String, Object> addressMap = new HashMap<>();

addressMap.put("city", user.getAddress().getCity());

addressMap.put("street", user.getAddress().getStreet());

map.put("address", addressMap);

}

return map;

}

查询文档

JAVA

public User getUserById(Long id) throws IOException {

GetRequest request = new GetRequest("user", id.toString());

GetResponse response = client.get(request, RequestOptions.DEFAULT);

if (!response.isExists()) {

return null;

}

return convertMapToUser(response.getSourceAsMap());

}

private User convertMapToUser(Map<String, Object> map) {

User user = new User();

user.setId(Long.parseLong(map.get("id").toString()));

user.setUsername((String) map.get("username"));

user.setEmail((String) map.get("email"));

user.setAge((Integer) map.get("age"));

user.setCreateTime(new Date(((Long) map.get("createTime"))));

if (map.containsKey("address")) {

@SuppressWarnings("unchecked")

Map<String, Object> addressMap = (Map<String, Object>) map.get("address");

Address address = new Address();

address.setCity((String) addressMap.get("city"));

address.setStreet((String) addressMap.get("street"));

user.setAddress(address);

}

return user;

}

更新文档

JAVA

public void updateUser(User user) throws IOException {

UpdateRequest request = new UpdateRequest("user", user.getId().toString())

.doc(convertUserToMap(user), XContentType.JSON);

UpdateResponse response = client.update(request, RequestOptions.DEFAULT);

if (response.status() != RestStatus.OK) {

throw new RuntimeException("更新文档失败");

}

删除文档

JAVA

public void deleteUser(Long id) throws IOException {

DeleteRequest request = new DeleteRequest("user", id.toString());

DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);

if (response.status() != RestStatus.OK) {

throw new RuntimeException("删除文档失败");

}

3.2 批量操作

批量操作可以显著提高性能，特别是在初始化数据或批量更新时：

JAVA

public void bulkAddUsers(List<User> users) throws IOException {

BulkRequest request = new BulkRequest();

for (User user : users) {

request.add(new IndexRequest("user")

.id(user.getId().toString())

.source(convertUserToMap(user), XContentType.JSON));

}

BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);

if (responses.hasFailures()) {

throw new RuntimeException("批量操作失败: " + responses.buildFailureMessage());

}

4. 高级搜索功能实现

4.1 基本搜索

JAVA

public List<User> searchUsers(String keyword) throws IOException {

SearchRequest request = new SearchRequest("user");

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

sourceBuilder.query(QueryBuilders.multiMatchQuery(keyword, "username", "address.street"));

sourceBuilder.from(0);

sourceBuilder.size(10);

request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

return parseSearchResponse(response);

}

private List<User> parseSearchResponse(SearchResponse response) {

List<User> users = new ArrayList<>();

SearchHits hits = response.getHits();

for (SearchHit hit : hits.getHits()) {

users.add(convertMapToUser(hit.getSourceAsMap()));

}

return users;

}

4.2 复合查询

JAVA

public List<User> advancedSearch(UserSearchCriteria criteria) throws IOException {

SearchRequest request = new SearchRequest("user");

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

if (StringUtils.isNotBlank(criteria.getKeyword())) {

boolQuery.must(QueryBuilders.multiMatchQuery(

criteria.getKeyword(),

"username", "address.street"

));

}

if (criteria.getMinAge() != null || criteria.getMaxAge() != null) {

RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("age");

if (criteria.getMinAge() != null) {

rangeQuery.gte(criteria.getMinAge());

}

if (criteria.getMaxAge() != null) {

rangeQuery.lte(criteria.getMaxAge());

}

boolQuery.filter(rangeQuery);

}

if (criteria.getStartTime() != null || criteria.getEndTime() != null) {

RangeQueryBuilder dateRangeQuery = QueryBuilders.rangeQuery("createTime");

if (criteria.getStartTime() != null) {

dateRangeQuery.gte(criteria.getStartTime().getTime());

}

if (criteria.getEndTime() != null) {

dateRangeQuery.lte(criteria.getEndTime().getTime());

}

boolQuery.filter(dateRangeQuery);

}

sourceBuilder.query(boolQuery);

// 分页

sourceBuilder.from((criteria.getPage() - 1) * criteria.getSize());

sourceBuilder.size(criteria.getSize());

// 排序

if (StringUtils.isNotBlank(criteria.getSortField())) {

sourceBuilder.sort(

criteria.getSortField(),

criteria.isAsc() ? SortOrder.ASC : SortOrder.DESC

);

}

request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

return parseSearchResponse(response);

}

4.3 高亮显示

JAVA

public List<User> searchWithHighlight(String keyword) throws IOException {

SearchRequest request = new SearchRequest("user");

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

// 查询条件

sourceBuilder.query(QueryBuilders.multiMatchQuery(keyword, "username", "address.street"));

// 高亮设置

HighlightBuilder highlightBuilder = new HighlightBuilder();

highlightBuilder.field("username");

highlightBuilder.field("address.street");

highlightBuilder.preTags("");

highlightBuilder.postTags("");

sourceBuilder.highlighter(highlightBuilder);

request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

List<User> users = new ArrayList<>();

for (SearchHit hit : response.getHits().getHits()) {

User user = convertMapToUser(hit.getSourceAsMap());

// 处理高亮结果

Map<String, HighlightField> highlightFields = hit.getHighlightFields();

if (highlightFields.containsKey("username")) {

user.setHighlightUsername(

highlightFields.get("username").fragments()[0].string()

);

}

if (highlightFields.containsKey("address.street")) {

user.getAddress().setHighlightStreet(

highlightFields.get("address.street").fragments()[0].string()

);

}

users.add(user);

}

return users;

}

5. 聚合分析与统计

5.1 基本聚合

JAVA

public Map<String, Long> aggregateByAgeGroup() throws IOException {

SearchRequest request = new SearchRequest("user");

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

// 不返回文档，只返回聚合结果

sourceBuilder.size(0);

// 按年龄区间分组

TermsAggregationBuilder aggregation = AggregationBuilders.terms("age_groups")

.field("age")

.subAggregation(AggregationBuilders.avg("avg_age").field("age"));

sourceBuilder.aggregation(aggregation);

request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

Terms ageGroups = response.getAggregations().get("age_groups");

Map<String, Long> result = new LinkedHashMap<>();

for (Terms.Bucket bucket : ageGroups.getBuckets()) {

result.put(bucket.getKeyAsString(), bucket.getDocCount());

}

return result;

}

5.2 多级聚合

JAVA

public Map<String, Map<String, Long>> multiLevelAggregation() throws IOException {

SearchRequest request = new SearchRequest("user");

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

sourceBuilder.size(0);

// 先按城市分组，再按年龄区间分组

TermsAggregationBuilder cityAgg = AggregationBuilders.terms("by_city")

.field("address.city.keyword");

TermsAggregationBuilder ageAgg = AggregationBuilders.terms("by_age")

.field("age")

.size(5);

cityAgg.subAggregation(ageAgg);

sourceBuilder.aggregation(cityAgg);

request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

Terms byCity = response.getAggregations().get("by_city");

Map<String, Map<String, Long>> result = new LinkedHashMap<>();

for (Terms.Bucket cityBucket : byCity.getBuckets()) {

String city = cityBucket.getKeyAsString();

Terms byAge = cityBucket.getAggregations().get("by_age");

Map<String, Long> ageMap = new LinkedHashMap<>();

for (Terms.Bucket ageBucket : byAge.getBuckets()) {

ageMap.put(ageBucket.getKeyAsString(), ageBucket.getDocCount());

}

result.put(city, ageMap);

}

return result;

}

6. 性能优化与最佳实践

6.1 索引设计优化

合理设置分片数：分片数一旦设置就不能修改，建议根据数据量预估，每个分片大小控制在20-40GB
使用别名：为索引使用别名，方便后续重建索引
禁用不需要的特性：如不需要评分，可以设置 "norms": false
合理使用keyword和text类型：精确匹配用keyword，全文搜索用text

6.2 查询性能优化

使用过滤器(filter)代替查询(query)：过滤器结果会被缓存
避免深度分页：使用search_after代替from/size进行深度分页
合理使用_source过滤：只返回需要的字段
使用批量操作：减少网络往返次数

6.3 实战中的坑与解决方案

字段类型不一致导致查询失败：确保相同字段在不同索引中的类型一致
分词器问题：测试时确保分词器按预期工作
版本兼容性问题：客户端版本与服务器版本尽量保持一致
内存不足：监控JVM内存使用情况，合理设置堆大小

7. 与Spring Data Elasticsearch集成

虽然直接使用RestHighLevelClient提供了最大的灵活性，但Spring Data Elasticsearch提供了更简洁的Repository接口。以下是集成方式：

7.1 添加依赖

XML

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-elasticsearch</artifactId>

</dependency>

7.2 定义实体类

JAVA

@Document(indexName = "user")

public class User {

@Id

private Long id;

@Field(type = FieldType.Text, analyzer = "ik_max_word")

private String username;

@Field(type = FieldType.Keyword)

private String email;

@Field(type = FieldType.Integer)

private Integer age;

@Field(type = FieldType.Date, format = DateFormat.custom, pattern = "yyyy-MM-dd HH:mm:ss||epoch_millis")

private Date createTime;

// getters and setters

}

7.3 定义Repository接口

JAVA

public interface UserRepository extends ElasticsearchRepository<User, Long> {

List<User> findByUsername(String username);

@Query("{\"bool\": {\"must\": [{\"match\": {\"username\": \"?0\"}}]}}")

Page<User> findByUsernameCustomQuery(String username, Pageable pageable);

}

7.4 使用Repository

JAVA

@Service

public class UserService {

@Autowired

private UserRepository userRepository;

public List<User> searchUsers(String keyword) {

return userRepository.findByUsername(keyword);

}

public Page<User> searchUsersPage(String keyword, int page, int size) {

return userRepository.findByUsernameCustomQuery(

keyword,

PageRequest.of(page, size, Sort.by("createTime").descending())

);

}

8. 实际项目中的综合应用

8.1 数据同步方案

在实际项目中，通常需要将数据库中的数据同步到Elasticsearch。常见的同步方案有：

应用层同步：在业务代码中同时更新数据库和Elasticsearch
消息队列异步同步：通过消息队列解耦
日志监听同步：如使用Canal监听数据库binlog
定时任务同步：定期全量或增量同步

以下是基于消息队列的异步同步实现：

JAVA

@Service

@RequiredArgsConstructor

public class UserSyncService {

private final UserRepository userRepository;

private final ElasticsearchOperations elasticsearchOperations;

private final RabbitTemplate rabbitTemplate;

@Transactional

public void saveUser(User user) {

// 保存到数据库

userRepository.save(user);

// 发送同步消息

rabbitTemplate.convertAndSend(

"user.sync.exchange",

"user.sync.routingKey",

user.getId()

);

}

@RabbitListener(bindings = @QueueBinding(

value = @Queue(name = "user.sync.queue"),

exchange = @Exchange(name = "user.sync.exchange"),

key = "user.sync.routingKey"

))

public void syncUserToEs(Long userId) {

User user = userRepository.findById(userId).orElse(null);

if (user != null) {

elasticsearchOperations.save(user);

}

8.2 搜索服务实现

一个完整的搜索服务通常包含以下功能：

搜索建议：自动补全功能
搜索结果高亮
搜索结果过滤
搜索结果排序
搜索结果聚合分析

以下是综合搜索服务的实现：

JAVA

@Service

@RequiredArgsConstructor

public class UserSearchService {

private final UserRepository userRepository;

private final ElasticsearchOperations elasticsearchOperations;

public SearchResult<User> search(SearchRequest request) {

NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();

// 基本查询

if (StringUtils.isNotBlank(request.getKeyword())) {

queryBuilder.withQuery(QueryBuilders.multiMatchQuery(

request.getKeyword(),

"username", "email", "address.street"

));

} else {

queryBuilder.withQuery(QueryBuilders.matchAllQuery());

}

// 过滤条件

if (request.getMinAge() != null || request.getMaxAge() != null) {

RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("age");

if (request.getMinAge() != null) {

rangeQuery.gte(request.getMinAge());

}

if (request.getMaxAge() != null) {

rangeQuery.lte(request.getMaxAge());

}

queryBuilder.withFilter(rangeQuery);

}

// 分页

queryBuilder.withPageable(PageRequest.of(

request.getPage() - 1,

request.getSize()

));

// 排序

if (StringUtils.isNotBlank(request.getSortBy())) {

queryBuilder.withSort(SortBuilders.fieldSort(request.getSortBy())

.order(request.isAsc() ? SortOrder.ASC : SortOrder.DESC));

}

// 高亮

if (StringUtils.isNotBlank(request.getKeyword())) {

queryBuilder.withHighlightFields(

new HighlightBuilder.Field("username")

.preTags("")

.postTags(""),

new HighlightBuilder.Field("address.street")

.preTags("")

.postTags("")

);

}

// 聚合

if (request.isNeedAggregation()) {

queryBuilder.addAggregation(AggregationBuilders.terms("city_agg")

.field("address.city.keyword")

.size(10));

queryBuilder.addAggregation(AggregationBuilders.terms("age_agg")

.field("age")

.size(5));

}

SearchHits<User> searchHits = elasticsearchOperations.search(

queryBuilder.build(),

User.class

);

// 处理结果

SearchResult<User> result = new SearchResult<>();

result.setTotal(searchHits.getTotalHits());

result.setPage(request.getPage());

result.setSize(request.getSize());

List<User> users = new ArrayList<>();

for (SearchHit<User> hit : searchHits) {

User user = hit.getContent();

// 处理高亮

if (hit.getHighlightFields().containsKey("username")) {

user.setHighlightUsername(

hit.getHighlightFields().get("username").get(0)

);

}

if (hit.getHighlightFields().containsKey("address.street")) {

user.getAddress().setHighlightStreet(

hit.getHighlightFields().get("address.street").get(0)

);

}

users.add(user);

}

result.setData(users);

// 处理聚合结果

if (request.isNeedAggregation() && searchHits.hasAggregations()) {

Map<String, Aggregation> aggregations = searchHits.getAggregations().asMap();

if (aggregations.containsKey("city_agg")) {

result.setCityAggregation(

((ParsedStringTerms) aggregations.get("city_agg"))

.getBuckets().stream()

.collect(Collectors.toMap(

b -> b.getKeyAsString(),

b -> b.getDocCount()

))

);

}

if (aggregations.containsKey("age_agg")) {

result.setAgeAggregation(

((ParsedLongTerms) aggregations.get("age_agg"))

.getBuckets().stream()

.collect(Collectors.toMap(

b -> b.getKeyAsString(),

b -> b.getDocCount()

))

);

}

return result;

}

9. 监控与维护

9.1 健康检查

JAVA

@Scheduled(fixedRate = 60000)

public void checkElasticsearchHealth() {

try {

ClusterHealthResponse health = client.cluster()

.health(new ClusterHealthRequest(), RequestOptions.DEFAULT);

if (health.getStatus() == ClusterHealthStatus.RED) {

log.error("Elasticsearch集群状态异常: {}", health);

// 发送告警通知

}

} catch (IOException e) {

log.error("Elasticsearch健康检查失败", e);

// 发送告警通知

}

9.2 性能监控

JAVA

public void monitorPerformance() throws IOException {

NodesStatsRequest request = new NodesStatsRequest();

request.indices(true);

request.os(true);

request.jvm(true);

NodesStatsResponse response = client.nodes().stats(request, RequestOptions.DEFAULT);

for (NodeStats nodeStats : response.getNodes()) {

log.info("节点 {} 状态:", nodeStats.getNode().getName());

log.info(" - JVM内存使用: {}/{}",

nodeStats.getJvm().getMem().getHeapUsed(),

nodeStats.getJvm().getMem().getHeapMax());

log.info(" - CPU使用率: {}", nodeStats.getOs().getCpu().getPercent());

log.info(" - 索引性能: index={}/s, search={}/s",

nodeStats.getIndices().getIndexing().getTotal().getIndexCount(),

nodeStats.getIndices().getSearch().getTotal().getQueryCount());

}

9.3 索引维护

定期优化索引：

JAVA

@Scheduled(cron = "0 0 3 * * ?") // 每天凌晨3点执行

public void optimizeIndices() throws IOException {

ForceMergeRequest request = new ForceMergeRequest("user");

request.maxNumSegments(1); // 合并为1个段

request.flush(true); // 合并后刷新

ForceMergeResponse response = client.indices()

.forcemerge(request, RequestOptions.DEFAULT);

log.info("索引优化完成: {}", response);

}

10. 安全配置

10.1 基本认证

如果Elasticsearch启用了安全认证，可以在客户端配置中添加认证信息：

JAVA

@Configuration

public class ElasticsearchConfig {

@Value("${elasticsearch.host}")

private String host;

@Value("${elasticsearch.port}")

private int port;

@Value("${elasticsearch.username}")

private String username;

@Value("${elasticsearch.password}")

private String password;

@Bean(destroyMethod = "close")

public RestHighLevelClient restHighLevelClient() {

final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();

credentialsProvider.setCredentials(

AuthScope.ANY,

new UsernamePasswordCredentials(username, password)

);

return new RestHighLevelClient(

RestClient.builder(new HttpHost(host, port, "http"))

.setHttpClientConfigCallback(httpClientBuilder ->

httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider)

)

);

}

10.2 SSL/TLS配置

对于生产环境，建议启用SSL/TLS：

JAVA

@Bean(destroyMethod = "close")

public RestHighLevelClient restHighLevelClient() throws Exception {

SSLContext sslContext = SSLContextBuilder

.create()

.loadTrustMaterial(new TrustSelfSignedStrategy())

.build();

return new RestHighLevelClient(

RestClient.builder(new HttpHost(host, port, "https"))

.setHttpClientConfigCallback(httpClientBuilder ->

httpClientBuilder.setSSLContext(sslContext)

)

);

}

11. 测试策略

11.1 单元测试

使用Elasticsearch的测试容器进行单元测试：

JAVA

@SpringBootTest

@Testcontainers

class UserSearchServiceTest {

@Container

private static final ElasticsearchContainer elasticsearch =

new ElasticsearchContainer("docker.elastic.co/elasticsearch/elasticsearch:7.12.1")

.withExposedPorts(9200);

@DynamicPropertySource

static void elasticsearchProperties(DynamicPropertyRegistry registry) {

registry.add("elasticsearch.host", elasticsearch::getHost);

registry.add("elasticsearch.port", () -> elasticsearch.getMappedPort(9200));

}

@Autowired

private UserSearchService userSearchService;

@BeforeEach

void setup() throws IOException {

// 初始化测试数据

}

@Test

void shouldSearchUsers() {

// 测试搜索功能

}

11.2 性能测试

使用JMeter或自定义代码进行性能测试：

JAVA

public class ElasticsearchPerformanceTest {

private static final int THREAD_COUNT = 10;

private static final int REQUEST_COUNT = 1000;

public static void main(String[] args) throws Exception {

ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);

RestHighLevelClient client = createClient();

long startTime = System.currentTimeMillis();

for (int i = 0; i < REQUEST_COUNT; i++) {

executor.submit(() -> {

try {

SearchRequest request = new SearchRequest("user");

request.source(new SearchSourceBuilder()

.query(QueryBuilders.matchAllQuery())

.size(10));

client.search(request, RequestOptions.DEFAULT);

} catch (IOException e) {

e.printStackTrace();

}

});

}

executor.shutdown();

executor.awaitTermination(1, TimeUnit.HOURS);

long duration = System.currentTimeMillis() - startTime;

System.out.printf("完成 %d 次查询，耗时 %d ms，QPS=%.2f%n",

REQUEST_COUNT, duration,

REQUEST_COUNT / (duration / 1000.0));

client.close();

}

private static RestHighLevelClient createClient() {

return new RestHighLevelClient(

RestClient.builder(new HttpHost("localhost", 9200, "http"))

);

}

12. 常见问题解决方案

12.1 连接问题

问题：无法连接到Elasticsearch集群
解决方案：

检查Elasticsearch服务是否正常运行
检查网络连接和防火墙设置
验证客户端配置的主机和端口是否正确
检查集群健康状态：GET /_cluster/health

12.2 性能问题

问题：查询响应慢
优化建议：

使用过滤器(filter)代替查询(query)利用缓存
减少返回字段数量，使用_source过滤
避免使用脚本查询
优化分片大小和数量
增加硬件资源，特别是内存

12.3 映射问题

问题：字段类型不匹配
解决方案：

检查现有索引的映射：GET /index/_mapping
如果需要修改字段类型，必须重建索引
使用别名实现零停机重建索引

12.4 内存问题

问题：Elasticsearch内存占用高
解决方案：

增加JVM堆大小，但不超过物理内存的50%
减少字段数据缓存大小
限制聚合查询的内存使用
监控并优化查询，避免内存密集型操作

13. 版本升级与迁移

13.1 版本升级策略

滚动升级：适用于小版本升级(如7.12.1到7.13.0)
全集群重启升级：适用于大版本升级(如6.x到7.x)
使用Reindex API：当需要重建索引时

13.2 数据迁移

使用Elasticsearch的Reindex API进行数据迁移：

JAVA

public void reindex(String sourceIndex, String destIndex) throws IOException {

ReindexRequest request = new ReindexRequest();

request.setSourceIndices(sourceIndex);

request.setDestIndex(destIndex);

// 可选：设置版本冲突处理

request.setConflicts("proceed");

// 可选：设置批量大小

request.setSourceBatchSize(1000);

BulkByScrollResponse response = client.reindex(request, RequestOptions.DEFAULT);

log.info("迁移完成: 耗时={}, 处理文档数={}",

response.getTook(), response.getTotal());

}

14. 扩展与进阶

14.1 自定义分析器

JAVA

public void createIndexWithCustomAnalyzer() throws IOException {

String analyzerJson = "{\n" +

" \"settings\": {\n" +

" \"analysis\": {\n" +

" \"analyzer\": {\n" +

" \"my_custom_analyzer\": {\n" +

" \"type\": \"custom\",\n" +

" \"tokenizer\": \"standard\",\n" +

" \"filter\": [\"lowercase\", \"my_stop\"]\n" +

" }\n" +

" },\n" +

" \"filter\": {\n" +

" \"my_stop\": {\n" +

" \"type\": \"stop\",\n" +

" \"stopwords\": [\"a\", \"an\", \"the\"]\n" +

" }\n" +

" },\n" +

" \"mappings\": {\n" +

" \"properties\": {\n" +

" \"content\": {\n" +

" \"type\": \"text\",\n" +

" \"analyzer\": \"my_custom_analyzer\"\n" +

" }\n" +

"}";

CreateIndexRequest request = new CreateIndexRequest("custom_index")

.source(analyzerJson, XContentType.JSON);

client.indices().create(request, RequestOptions.DEFAULT);

}

14.2 插件开发

Elasticsearch支持自定义插件开发，常见的插件类型包括：

自定义分析器插件
自定义评分插件
自定义REST端点插件

14.3 机器学习功能

Elasticsearch提供了内置的机器学习功能，可用于异常检测、预测等场景：

JAVA

public void setupAnomalyDetection(String