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

依赖

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

---

 配置

spring:
  elasticsearch:
    rest:
      uris: "http://localhost:9200" # Elasticsearch服务器地址
      connection-timeout: 5000 # 连接超时时间

简单测试

使用Spring Data Elasticsearch的Repository接口来访问Elasticsearch。创建一个继承ElasticsearchRepository的接口。传入你的实体类和 ID 类型。

import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

public interface MyEntityRepository extends ElasticsearchRepository<MyEntity, String> {
    // 自定义查询方法可以在这里定义
}

 使用@Document注解来标记Elasticsearch的索引实体类。

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;

@Document(indexName = "myindex")
public class MyEntity {
    @Id
    private String id;
    @Field(type = FieldType.Text)
    private String name;
    // 其他字段...
}

在服务层注入这个 Repository 并使用它来执行 CRUD 操作。 

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyEntityService {

    @Autowired
    private MyEntityRepository repository;

    public MyEntity save(MyEntity entity) {
        return repository.save(entity);
    }

    public Optional<MyEntity> findById(String id) {
        return repository.findById(id);
    }

    public Iterable<MyEntity> findAll() {
        return repository.findAll();
    }

    public void deleteById(String id) {
        repository.deleteById(id);
    }

    // 可以添加自定义查询方法的实现
}

---

ElasticsearchTemplate 和 ReactiveElasticsearchTemplate 和ElasticsearchRepository有什么不同

`ElasticsearchTemplate`、`ReactiveElasticsearchTemplate` 和 `ElasticsearchRepository` 是 Spring Data Elasticsearch 中用于与 Elasticsearch 交互的三种不同的组件，它们各自有不同的用途和特点：

### ElasticsearchTemplate
- **同步客户端**: 提供同步的 Elasticsearch 操作，例如索引文档、搜索、更新和删除。
- **低级访问**: 允许执行更复杂的操作，如执行原生查询、管理索引映射和执行脚本。
- **使用场景**: 当你需要对 Elasticsearch 进行细粒度控制时使用。

### ReactiveElasticsearchTemplate
- **响应式客户端**: 提供非阻塞的 Elasticsearch 操作，支持响应式编程模型。
- **与 WebFlux 集成**: 适合在响应式应用程序中使用，例如 Spring WebFlux。
- **使用场景**: 当你需要构建高性能的响应式应用程序，并且希望利用非阻塞 I/O 操作时使用。

### ElasticsearchRepository
- **数据访问抽象**: 是 Spring Data 的一部分，提供声明式的数据处理能力。
- **简化 CRUD 操作**: 自动实现基本的 CRUD 操作，如保存、删除、查询等。
- **查询方法名称生成**: 支持通过方法名称生成查询，简化了查询的编写。
- **使用场景**: 当你想要快速实现数据访问层，并且希望利用 Spring Data 的便捷性时使用。

### 区别和选择
- **编程模型**: `ElasticsearchTemplate` 是同步的，`ReactiveElasticsearchTemplate` 是响应式的。根据你的应用程序是否需要响应式编程来选择。
- **抽象级别**: `ElasticsearchRepository` 提供了更高级别的抽象，简化了数据访问层的实现。`ElasticsearchTemplate` 和 `ReactiveElasticsearchTemplate` 提供了更接近底层的 Elasticsearch 操作。
- **查询能力**: `ElasticsearchRepository` 支持通过方法名称生成查询，但可能不支持所有复杂的查询。`ElasticsearchTemplate` 和 `ReactiveElasticsearchTemplate` 允许执行更复杂的查询。
- **集成方式**: 如果你的应用程序是基于 Spring WebFlux 或其他响应式库构建的，`ReactiveElasticsearchTemplate` 是更好的选择。对于传统的同步应用程序，`ElasticsearchTemplate` 更加合适。

总结来说，选择哪一个组件取决于你的具体需求、应用程序的编程模型以及你希望在数据访问层实现的复杂性。在某些情况下，你可能需要同时使用这些组件，以充分利用它们各自的优势。

ElasticsearchUtil 工具类 

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Component;

@Component
public class ElasticsearchUtil {

    private final ElasticsearchTemplate elasticsearchTemplate;

    @Autowired
    public ElasticsearchUtil(ElasticsearchTemplate elasticsearchTemplate) {
        this.elasticsearchTemplate = elasticsearchTemplate;
    }

    // 检查索引是否存在
    public boolean indexExists(String indexName) {
        return elasticsearchTemplate.indexExists(indexName);
    }

    // 创建索引
    public void createIndex(String indexName) {
        IndexOperations indexOps = elasticsearchTemplate.indexOps(indexName);
        if (!indexOps.exists()) {
            indexOps.create();
        }
    }

    // 删除索引
    public void deleteIndex(String indexName) {
        if (indexExists(indexName)) {
            elasticsearchTemplate.deleteIndex(indexName);
        }
    }

    // 索引单个文档
    public <T> void indexSingleDocument(T document) {
        elasticsearchTemplate.index(document);
    }

    // 索引多个文档
    public <T> void indexDocuments(Iterable<T> documents) {
        elasticsearchTemplate.bulkIndex(documents);
    }

    // 通过ID查找文档
    public <T> T findById(String id, Class<T> clazz) {
        return elasticsearchTemplate.get(id, clazz);
    }

    // 执行搜索查询
    public <T> Iterable<T> search(NativeSearchQuery searchQuery, Class<T> clazz) {
        return elasticsearchTemplate.queryForList(searchQuery, clazz);
    }

    // 构建并执行搜索查询
    public <T> Iterable<T> search(String queryString, Class<T> clazz) {
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(queryString)
                .build();
        return search(searchQuery, clazz);
    }

    // 删除文档
    public void deleteDocument(String id, Class<?> clazz) {
        elasticsearchTemplate.delete(id, clazz);
    }

    // 更新文档
    public <T> T updateDocument(T document) {
        elasticsearchTemplate.update(document);
        return document;
    }

    // 其他自定义方法...
}