如何在Spring Boot与MongoDB中构建多参数动态查询与过滤功能

import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class CustomerRepository {

    private final MongoTemplate mongoTemplate;

    public CustomerRepository(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    public List<Customer> findCustomersByCriteria(
            String firstName, String lastName, String address, Long birthNumber) {

        // 初始化一个空的Criteria对象
        Criteria criteria = new Criteria();

        // 根据传入的参数动态添加查询条件
        if (firstName != null && !firstName.isEmpty()) {
            // 使用and方法连接多个条件
            criteria = criteria.and("firstName").is(firstName);
        }
        if (lastName != null && !lastName.isEmpty()) {
            criteria = criteria.and("lastName").is(lastName);
        }
        if (address != null && !address.isEmpty()) {
            criteria = criteria.and("address").is(address);
        }
        if (birthNumber != null) {
            criteria = criteria.and("birthNumber").is(birthNumber);
        }

        // 将构建好的Criteria封装到Query对象中
        Query query = new Query(criteria);

        // 执行查询并返回结果
        return mongoTemplate.find(query, Customer.class);
    }
}

import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.regex.Pattern; // 导入Pattern

// ... (其他导入和类定义不变)

public List<Customer> findCustomersByFuzzyCriteria(
        String firstName, String lastName, String address, Long birthNumber) {

    Criteria criteria = new Criteria();

    // 辅助方法，用于生成模糊匹配的正则表达式
    // 匹配长度至少为3个字符，且在任意位置出现
    private String createFuzzyRegex(String text) {
        if (text == null || text.length() < 3) {
            return null; // 或者抛出异常，或根据业务逻辑处理
        }
        // Pattern.CASE_INSENSITIVE 用于忽略大小写
        // Pattern.quote() 用于转义特殊字符，防止用户输入影响正则
        return ".*" + Pattern.quote(text) + ".*";
    }

    if (firstName != null && firstName.length() >= 3) {
        String regex = createFuzzyRegex(firstName);
        if (regex != null) {
            criteria = criteria.and("firstName").regex(regex, "i"); // "i" 表示不区分大小写
        }
    }
    if (lastName != null && lastName.length() >= 3) {
        String regex = createFuzzyRegex(lastName);
        if (regex != null) {
            criteria = criteria.and("lastName").regex(regex, "i");
        }
    }
    // ... 对其他文本字段（如address）也应用类似逻辑

    if (birthNumber != null) {
        criteria = criteria.and("birthNumber").is(birthNumber);
    }

    Query query = new Query(criteria);
    return mongoTemplate.find(query, Customer.class);
}

import org.springframework.data.domain.Sort; // 导入Sort类
// ... (其他导入和类定义不变)

public List<Customer> findCustomersWithDynamicSort(
        String firstName, String lastName, String sortByField, String sortDirection) {

    Criteria criteria = new Criteria();
    // ... (根据firstName, lastName等构建criteria，如前所述)

    Query query = new Query(criteria);

    // 动态添加排序条件
    if (sortByField != null && !sortByField.isEmpty()) {
        Sort.Direction direction = Sort.Direction.ASC; // 默认升序
        if ("desc".equalsIgnoreCase(sortDirection)) {
            direction = Sort.Direction.DESC;
        }
        // 可以添加多个排序字段
        query.with(Sort.by(new Sort.Order(direction, sortByField)));
        // 如果需要多个排序条件，可以这样组合：
        // query.with(Sort.by(
        //     new Sort.Order(direction, sortByField),
        //     new Sort.Order(Sort.Direction.ASC, "defaultSortField")
        // ));
    }

    return mongoTemplate.find(query, Customer.class);
}

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/api/customers")
public class CustomerController {

    private final CustomerRepository customerRepository;

    public CustomerController(CustomerRepository customerRepository) {
        this.customerRepository = customerRepository;
    }

    @GetMapping
    public List<Customer> searchCustomers(
            @RequestParam(required = false) String firstName,
            @RequestParam(required = false) String lastName,
            @RequestParam(required = false) String address,
            @RequestParam(required = false) Long birthNumber,
            @RequestParam(required = false, defaultValue = "firstName") String sortBy, // 默认按firstName排序
            @RequestParam(required = false, defaultValue = "asc") String sortDirection) {

        // 在这里调用CustomerRepository中实现动态查询的方法
        // 假设CustomerRepository中有一个统一处理所有参数的方法
        return customerRepository.findCustomersByFuzzyCriteriaAndSort(
                firstName, lastName, address, birthNumber, sortBy, sortDirection);
    }
}

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
</dependency>