Elasticsearch 技术文档

// Product.java
package com.example.elasticsearch.entity;

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.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;

@Document(indexName = "products")
public class Product {

    @Id
    private String id;

    @Field(type = FieldType.Text, analyzer = "ik_max_word")
    private String name;

    @Field(type = FieldType.Text, analyzer = "ik_max_word")
    private String description;

    @Field(type = FieldType.Keyword)
    private String category;

    @Field(type = FieldType.Double)
    private BigDecimal price;

    @Field(type = FieldType.Keyword)
    private List<String> tags;

    @Field(type = FieldType.Date)
    private LocalDateTime createTime;

    @Field(type = FieldType.Boolean)
    private Boolean active;

    // 构造函数
    public Product() {}

    public Product(String name, String description, String category,
                   BigDecimal price, List<String> tags) {
        this.name = name;
        this.description = description;
        this.category = category;
        this.price = price;
        this.tags = tags;
        this.createTime = LocalDateTime.now();
        this.active = true;
    }

    // Getter 和 Setter 方法
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getDescription() { return description; }
    public void setDescription(String description) { this.description = description; }

    public String getCategory() { return category; }
    public void setCategory(String category) { this.category = category; }

    public BigDecimal getPrice() { return price; }
    public void setPrice(BigDecimal price) { this.price = price; }

    public List<String> getTags() { return tags; }
    public void setTags(List<String> tags) { this.tags = tags; }

    public LocalDateTime getCreateTime() { return createTime; }
    public void setCreateTime(LocalDateTime createTime) { this.createTime = createTime; }

    public Boolean getActive() { return active; }
    public void setActive(Boolean active) { this.active = active; }

    @Override
    public String toString() {
        return "Product{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", category='" + category + '\'' +
                ", price=" + price +
                ", tags=" + tags +
                '}';
    }
}

// ProductRepository.java
package com.example.elasticsearch.repository;

import com.example.elasticsearch.entity.Product;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.data.elasticsearch.annotations.Query;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;

import java.math.BigDecimal;
import java.util.List;

public interface ProductRepository extends ElasticsearchRepository<Product, String> {

    // 基本查询方法
    List<Product> findByName(String name);
    List<Product> findByCategory(String category);
    List<Product> findByPriceBetween(BigDecimal minPrice, BigDecimal maxPrice);
    List<Product> findByActiveTrue();

    // 复杂查询
    List<Product> findByNameContainingOrDescriptionContaining(String name, String description);
    List<Product> findByTagsIn(List<String> tags);

    // 分页查询
    Page<Product> findByCategory(String category, Pageable pageable);

    // 自定义查询
    @Query("{\"bool\": {\"must\": [{\"match\": {\"name\": \"?0\"}}, {\"range\": {\"price\": {\"gte\": \"?1\", \"lte\": \"?2\"}}}]}}")
    List<Product> findByNameAndPriceRange(String name, BigDecimal minPrice, BigDecimal maxPrice);

    @Query("{\"bool\": {\"should\": [{\"match\": {\"name\": \"?0\"}}, {\"match\": {\"description\": \"?0\"}}], \"filter\": [{\"term\": {\"active\": true}}]}}")
    List<Product> searchActiveProducts(String keyword);
}

// ProductService.java
package com.example.elasticsearch.service;

import com.example.elasticsearch.entity.Product;
import com.example.elasticsearch.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

import static org.elasticsearch.index.query.QueryBuilders.*;

@Service
public class ProductService {

    @Autowired
    private ProductRepository productRepository;

    @Autowired
    private ElasticsearchOperations elasticsearchOperations;

    // 保存产品
    public Product saveProduct(Product product) {
        return productRepository.save(product);
    }

    // 批量保存
    public Iterable<Product> saveAllProducts(List<Product> products) {
        return productRepository.saveAll(products);
    }

    // 根据ID查找
    public Optional<Product> findById(String id) {
        return productRepository.findById(id);
    }

    // 查找所有产品
    public Iterable<Product> findAllProducts() {
        return productRepository.findAll();
    }

    // 根据名称查找
    public List<Product> findByName(String name) {
        return productRepository.findByName(name);
    }

    // 根据分类查找
    public List<Product> findByCategory(String category) {
        return productRepository.findByCategory(category);
    }

    // 价格范围查询
    public List<Product> findByPriceRange(BigDecimal minPrice, BigDecimal maxPrice) {
        return productRepository.findByPriceBetween(minPrice, maxPrice);
    }

    // 分页查询
    public Page<Product> findByCategoryWithPagination(String category, int page, int size) {
        Pageable pageable = PageRequest.of(page, size);
        return productRepository.findByCategory(category, pageable);
    }

    // 全文搜索
    public List<Product> searchProducts(String keyword) {
        return productRepository.searchActiveProducts(keyword);
    }

    // 高级搜索
    public SearchHits<Product> advancedSearch(String keyword, String category,
                                            BigDecimal minPrice, BigDecimal maxPrice) {
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();

        // 构建查询条件
        if (keyword != null && !keyword.isEmpty()) {
            queryBuilder.withQuery(boolQuery()
                .should(matchQuery("name", keyword))
                .should(matchQuery("description", keyword))
                .minimumShouldMatch(1));
        }

        // 添加过滤条件
        if (category != null && !category.isEmpty()) {
            queryBuilder.withFilter(termQuery("category", category));
        }

        if (minPrice != null || maxPrice != null) {
            queryBuilder.withFilter(rangeQuery("price")
                .gte(minPrice != null ? minPrice : 0)
                .lte(maxPrice != null ? maxPrice : Double.MAX_VALUE));
        }

        // 只查询活跃产品
        queryBuilder.withFilter(termQuery("active", true));

        NativeSearchQuery searchQuery = queryBuilder.build();
        return elasticsearchOperations.search(searchQuery, Product.class);
    }

    // 聚合查询
    public List<String> getCategories() {
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        queryBuilder.withAggregations(AggregationBuilders.terms("categories")
            .field("category"));

        NativeSearchQuery searchQuery = queryBuilder.build();
        SearchHits<Product> searchHits = elasticsearchOperations.search(searchQuery, Product.class);

        // 处理聚合结果
        // 这里简化处理，实际应用中需要解析聚合结果
        return List.of("电子产品", "服装", "食品", "图书");
    }

    // 删除产品
    public void deleteProduct(String id) {
        productRepository.deleteById(id);
    }

    // 更新产品
    public Product updateProduct(String id, Product product) {
        if (productRepository.existsById(id)) {
            product.setId(id);
            return productRepository.save(product);
        }
        throw new RuntimeException("Product not found with id: " + id);
    }
}

// ProductController.java
package com.example.elasticsearch.controller;

import com.example.elasticsearch.entity.Product;
import com.example.elasticsearch.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/products")
@CrossOrigin(origins = "*")
public class ProductController {

    @Autowired
    private ProductService productService;

    // 创建产品
    @PostMapping
    public ResponseEntity<Product> createProduct(@RequestBody Product product) {
        Product savedProduct = productService.saveProduct(product);
        return ResponseEntity.ok(savedProduct);
    }

    // 批量创建产品
    @PostMapping("/batch")
    public ResponseEntity<Iterable<Product>> createProducts(@RequestBody List<Product> products) {
        Iterable<Product> savedProducts = productService.saveAllProducts(products);
        return ResponseEntity.ok(savedProducts);
    }

    // 根据ID获取产品
    @GetMapping("/{id}")
    public ResponseEntity<Product> getProduct(@PathVariable String id) {
        Optional<Product> product = productService.findById(id);
        return product.map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }

    // 获取所有产品
    @GetMapping
    public ResponseEntity<Iterable<Product>> getAllProducts() {
        Iterable<Product> products = productService.findAllProducts();
        return ResponseEntity.ok(products);
    }

    // 根据名称搜索
    @GetMapping("/search/name")
    public ResponseEntity<List<Product>> searchByName(@RequestParam String name) {
        List<Product> products = productService.findByName(name);
        return ResponseEntity.ok(products);
    }

    // 根据分类搜索
    @GetMapping("/search/category")
    public ResponseEntity<List<Product>> searchByCategory(@RequestParam String category) {
        List<Product> products = productService.findByCategory(category);
        return ResponseEntity.ok(products);
    }

    // 价格范围搜索
    @GetMapping("/search/price")
    public ResponseEntity<List<Product>> searchByPriceRange(
            @RequestParam BigDecimal minPrice,
            @RequestParam BigDecimal maxPrice) {
        List<Product> products = productService.findByPriceRange(minPrice, maxPrice);
        return ResponseEntity.ok(products);
    }

    // 分页查询
    @GetMapping("/search/category/paged")
    public ResponseEntity<Page<Product>> searchByCategoryPaged(
            @RequestParam String category,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size) {
        Page<Product> products = productService.findByCategoryWithPagination(category, page, size);
        return ResponseEntity.ok(products);
    }

    // 全文搜索
    @GetMapping("/search")
    public ResponseEntity<List<Product>> searchProducts(@RequestParam String keyword) {
        List<Product> products = productService.searchProducts(keyword);
        return ResponseEntity.ok(products);
    }

    // 高级搜索
    @GetMapping("/search/advanced")
    public ResponseEntity<SearchHits<Product>> advancedSearch(
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String category,
            @RequestParam(required = false) BigDecimal minPrice,
            @RequestParam(required = false) BigDecimal maxPrice) {
        SearchHits<Product> searchHits = productService.advancedSearch(keyword, category, minPrice, maxPrice);
        return ResponseEntity.ok(searchHits);
    }

    // 获取所有分类
    @GetMapping("/categories")
    public ResponseEntity<List<String>> getCategories() {
        List<String> categories = productService.getCategories();
        return ResponseEntity.ok(categories);
    }

    // 更新产品
    @PutMapping("/{id}")
    public ResponseEntity<Product> updateProduct(@PathVariable String id, @RequestBody Product product) {
        try {
            Product updatedProduct = productService.updateProduct(id, product);
            return ResponseEntity.ok(updatedProduct);
        } catch (RuntimeException e) {
            return ResponseEntity.notFound().build();
        }
    }

    // 删除产品
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteProduct(@PathVariable String id) {
        productService.deleteProduct(id);
        return ResponseEntity.ok().build();
    }
}

// ElasticsearchConfig.java
package com.example.elasticsearch.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.client.ClientConfiguration;
import org.springframework.data.elasticsearch.client.elc.ElasticsearchConfiguration;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;

@Configuration
@EnableElasticsearchRepositories(basePackages = "com.example.elasticsearch.repository")
public class ElasticsearchConfig extends ElasticsearchConfiguration {

    @Override
    public ClientConfiguration clientConfiguration() {
        return ClientConfiguration.builder()
                .connectedTo("localhost:9200")
                .withConnectTimeout(1000)
                .withSocketTimeout(30000)
                .build();
    }
}

// DataInitializer.java
package com.example.elasticsearch.init;

import com.example.elasticsearch.entity.Product;
import com.example.elasticsearch.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;

@Component
public class DataInitializer implements CommandLineRunner {

    @Autowired
    private ProductRepository productRepository;

    @Override
    public void run(String... args) throws Exception {
        // 清空现有数据
        productRepository.deleteAll();

        // 创建示例产品
        List<Product> products = Arrays.asList(
            new Product("iPhone 15", "苹果最新智能手机", "电子产品",
                       new BigDecimal("6999"), Arrays.asList("手机", "苹果", "5G")),
            new Product("MacBook Pro", "专业级笔记本电脑", "电子产品",
                       new BigDecimal("12999"), Arrays.asList("笔记本", "苹果", "专业")),
            new Product("Nike运动鞋", "舒适透气的运动鞋", "服装",
                       new BigDecimal("599"), Arrays.asList("运动鞋", "Nike", "舒适")),
            new Product("Java编程思想", "经典Java编程书籍", "图书",
                       new BigDecimal("89"), Arrays.asList("Java", "编程", "经典")),
            new Product("星巴克咖啡", "香浓醇厚的咖啡", "食品",
                       new BigDecimal("35"), Arrays.asList("咖啡", "星巴克", "香浓"))
        );

        // 保存产品
        productRepository.saveAll(products);

        System.out.println("数据初始化完成，共创建 " + products.size() + " 个产品");
    }
}

// ProductServiceTest.java
package com.example.elasticsearch.service;

import com.example.elasticsearch.entity.Product;
import com.example.elasticsearch.repository.ProductRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
public class ProductServiceTest {

    @Autowired
    private ProductService productService;

    @Autowired
    private ProductRepository productRepository;

    @Test
    public void testSaveAndFindProduct() {
        // 创建产品
        Product product = new Product("测试产品", "这是一个测试产品", "测试分类",
                                   new BigDecimal("100"), List.of("测试", "产品"));

        // 保存产品
        Product savedProduct = productService.saveProduct(product);
        assertNotNull(savedProduct.getId());

        // 查找产品
        Optional<Product> foundProduct = productService.findById(savedProduct.getId());
        assertTrue(foundProduct.isPresent());
        assertEquals("测试产品", foundProduct.get().getName());
    }

    @Test
    public void testSearchByName() {
        List<Product> products = productService.findByName("iPhone");
        assertFalse(products.isEmpty());
        assertTrue(products.stream().anyMatch(p -> p.getName().contains("iPhone")));
    }

    @Test
    public void testSearchByCategory() {
        List<Product> products = productService.findByCategory("电子产品");
        assertFalse(products.isEmpty());
        products.forEach(p -> assertEquals("电子产品", p.getCategory()));
    }

    @Test
    public void testPriceRangeSearch() {
        List<Product> products = productService.findByPriceRange(
            new BigDecimal("1000"), new BigDecimal("8000"));
        assertFalse(products.isEmpty());
        products.forEach(p -> {
            assertTrue(p.getPrice().compareTo(new BigDecimal("1000")) >= 0);
            assertTrue(p.getPrice().compareTo(new BigDecimal("8000")) <= 0);
        });
    }

    @Test
    public void testFullTextSearch() {
        List<Product> products = productService.searchProducts("苹果");
        assertFalse(products.isEmpty());
        // 验证搜索结果包含苹果相关产品
        assertTrue(products.stream().anyMatch(p ->
            p.getName().contains("iPhone") || p.getName().contains("MacBook")));
    }
}

// ElasticsearchHealthIndicator.java
package com.example.elasticsearch.health;

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.stereotype.Component;

@Component
public class ElasticsearchHealthIndicator implements HealthIndicator {

    private final ElasticsearchOperations elasticsearchOperations;

    public ElasticsearchHealthIndicator(ElasticsearchOperations elasticsearchOperations) {
        this.elasticsearchOperations = elasticsearchOperations;
    }

    @Override
    public Health health() {
        try {
            // 执行简单查询检查连接
            elasticsearchOperations.indexOps("products").exists();
            return Health.up()
                    .withDetail("message", "Elasticsearch is running")
                    .build();
        } catch (Exception e) {
            return Health.down()
                    .withDetail("error", e.getMessage())
                    .build();
        }
    }
}

// ElasticsearchMetrics.java
package com.example.elasticsearch.metrics;

import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.stereotype.Component;

@Component
public class ElasticsearchMetrics {

    @Autowired
    private MeterRegistry meterRegistry;

    @Autowired
    private ElasticsearchOperations elasticsearchOperations;

    public void recordSearchTime(long startTime) {
        long duration = System.currentTimeMillis() - startTime;
        meterRegistry.timer("elasticsearch.search.duration").record(
            java.time.Duration.ofMillis(duration));
    }

    public void incrementSearchCount() {
        meterRegistry.counter("elasticsearch.search.count").increment();
    }

    public void recordIndexingTime(long startTime) {
        long duration = System.currentTimeMillis() - startTime;
        meterRegistry.timer("elasticsearch.indexing.duration").record(
            java.time.Duration.ofMillis(duration));
    }
}