如何消除Criteria SQL构建中的重复if判断？求实现示例

Hey Pavel, I get it—those endless if checks in your Criteria API code are definitely a pain to maintain. Let's fix that by using a strategy pattern approach, which eliminates repetitive conditionals and makes your code way cleaner. Here's a tailored example for your PhoneSpecification scenario:

First, create a functional interface to encapsulate the logic for each filter condition. It will handle checking if the filter is applicable and generating the corresponding Predicate:

import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import java.util.Optional;

@FunctionalInterface
interface FilterPredicateProcessor {
    Optional<Predicate> process(Root<Phone> root, CriteriaBuilder cb, PhoneFilter filter);
}

Create separate processors for each field in your PhoneFilter. Each processor handles exactly one filter condition, so no more messy overlapping if blocks:

// Processor for brand filter
FilterPredicateProcessor brandProcessor = (root, cb, filter) -> {
    if (filter.getBrand() != null && !filter.getBrand().isEmpty()) {
        return Optional.of(cb.equal(root.get("brand"), filter.getBrand()));
    }
    return Optional.empty();
};

// Processor for minimum price filter
FilterPredicateProcessor minPriceProcessor = (root, cb, filter) -> {
    if (filter.getMinPrice() != null) {
        return Optional.of(cb.ge(root.get("price"), filter.getMinPrice()));
    }
    return Optional.empty();
};

// Processor for maximum price filter
FilterPredicateProcessor maxPriceProcessor = (root, cb, filter) -> {
    if (filter.getMaxPrice() != null) {
        return Optional.of(cb.le(root.get("price"), filter.getMaxPrice()));
    }
    return Optional.empty();
};

// Add more processors for other fields (e.g., model, releaseYear) as needed

Now, update your specification to use these processors. We'll collect all valid predicates and combine them with AND logic (adjust to OR if your use case requires it):

import lombok.AllArgsConstructor;
import lombok.NonNull;
import org.springframework.data.jpa.domain.Specification;
import jakarta.persistence.criteria.*;
import java.util.List;
import java.util.stream.Collectors;

@AllArgsConstructor
class PhoneSpecification implements Specification<Phone> {
    private final @NonNull PhoneFilter filter;

    // List all your processors here
    private final List<FilterPredicateProcessor> processors = List.of(
        brandProcessor,
        minPriceProcessor,
        maxPriceProcessor
        // Add new processors here when you add filter fields
    );

    @Override
    public Predicate toPredicate(Root<Phone> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
        // Collect all non-empty predicates from processors
        List<Predicate> validPredicates = processors.stream()
            .map(processor -> processor.process(root, cb, filter))
            .filter(Optional::isPresent)
            .map(Optional::get)
            .collect(Collectors.toList());

        // Combine all predicates with AND logic
        return cb.and(validPredicates.toArray(new Predicate[0]));
    }
}

If you have many processors, move them to a factory class to keep your specification lean:

class PhoneFilterProcessorFactory {
    public static List<FilterPredicateProcessor> createProcessors() {
        return List.of(
            createBrandProcessor(),
            createMinPriceProcessor(),
            createMaxPriceProcessor()
        );
    }

    private static FilterPredicateProcessor createBrandProcessor() {
        return (root, cb, filter) -> {
            if (filter.getBrand() != null && !filter.getBrand().isEmpty()) {
                return Optional.of(cb.equal(root.get("brand"), filter.getBrand()));
            }
            return Optional.empty();
        };
    }

    private static FilterPredicateProcessor createMinPriceProcessor() {
        return (root, cb, filter) -> {
            if (filter.getMinPrice() != null) {
                return Optional.of(cb.ge(root.get("price"), filter.getMinPrice()));
            }
            return Optional.empty();
        };
    }

    // Add other processor creation methods here
}

Then update your specification to use the factory:

private final List<FilterPredicateProcessor> processors = PhoneFilterProcessorFactory.createProcessors();

Why This Works: #

• No more repetitive if checks—each filter logic is isolated in its own processor
• Adding a new filter field only requires creating a new processor (follows the Open/Closed Principle)
• Code is far more readable and maintainable, with clear separation of concerns

If you still want to experiment with reflection, you could map filter field names to entity attributes and dynamically generate predicates, but this strategy pattern approach is safer and more intuitive for most cases.

内容的提问来源于stack exchange，提问作者Pavel