深入理解 QueryDSL 的 BooleanBuilder：构建复杂逻辑表达式

BooleanBuilder builder = new BooleanBuilder();

Predicate initialPredicate = QEntity.entity.field.eq("value");
BooleanBuilder builder = new BooleanBuilder(initialPredicate);

Predicate predicate1 = QEntity.entity.field1.eq("value1");
Predicate predicate2 = QEntity.entity.field2.eq("value2");
BooleanBuilder builder = new BooleanBuilder(predicate1);
builder.and(predicate2);
// 结果为：field1 = "value1" AND field2 = "value2"

Predicate predicate3 = QEntity.entity.field3.eq("value3");
Predicate predicate4 = QEntity.entity.field4.eq("value4");
builder.andAnyOf(predicate3, predicate4);
// 结果为：field1 = "value1" AND field2 = "value2" AND (field3 = "value3" OR field4 = "value4")

Predicate predicate5 = QEntity.entity.field5.eq("value5");
builder.andNot(predicate5);
// 结果为：field1 = "value1" AND field2 = "value2" AND NOT field5 = "value5"

Predicate predicate6 = QEntity.entity.field6.eq("value6");
builder.or(predicate6);
// 结果为：(field1 = "value1" AND field2 = "value2") OR field6 = "value6"

Predicate predicate7 = QEntity.entity.field7.eq("value7");
Predicate predicate8 = QEntity.entity.field8.eq("value8");
builder.orAllOf(predicate7, predicate8);
// 结果为：(field1 = "value1" AND field2 = "value2") OR (field7 = "value7" AND field8 = "value8")

Predicate predicate9 = QEntity.entity.field9.eq("value9");
builder.orNot(predicate9);
// 结果为：(field1 = "value1" AND field2 = "value2") OR NOT field9 = "value9"

builder.not();
// 结果为：NOT (field1 = "value1" AND field2 = "value2")

Visitor<String, Void> visitor = new MyVisitor();
String result = builder.accept(visitor, null);

BooleanBuilder clonedBuilder = builder.clone();

Predicate currentPredicate = builder.getValue();

boolean hasValue = builder.hasValue();

Class<? extends Boolean> type = builder.getType();

String predicateString = builder.toString();

import com.querydsl.core.BooleanBuilder;
import com.querydsl.sql.SQLQueryFactory;
import java.util.List;

public class UserFilter {

    private final SQLQueryFactory queryFactory;

    public UserFilter(SQLQueryFactory queryFactory) {
        this.queryFactory = queryFactory;
    }

    /**
     * 根据用户名、年龄范围和激活状态筛选用户
     * 
     * @param username 用户名
     * @param minAge 最小年龄
     * @param maxAge 最大年龄
     * @param isActive 是否激活
     * @return 满足条件的用户列表
     */
    public List<User> filterUsers(String username, Integer minAge, Integer maxAge, Boolean isActive) {
        QUser qUser = QUser.user;

        // 初始化 BooleanBuilder
        BooleanBuilder builder = new BooleanBuilder();

        // 根据用户名构建条件
        if (username != null) {
            builder.and(qUser.username.eq(username));
        }

        // 根据最小年龄构建条件
        if (minAge != null) {
            builder.and(qUser.age.goe(minAge));
        }

        // 根据最大年龄构建条件
        if (maxAge != null) {
            builder.and(qUser.age.loe(maxAge));
        }

        // 根据激活状态构建条件
        if (isActive != null) {
            builder.and(qUser.isActive.eq(isActive));
        }

        // 执行查询并返回结果
        return queryFactory.selectFrom(qUser)
                           .where(builder)
                           .fetch();
    }
}

import com.querydsl.core.BooleanBuilder;
import com.querydsl.sql.SQLQueryFactory;
import java.util.List;

public class ProductSearch {

    private final SQLQueryFactory queryFactory;

    public ProductSearch(SQLQueryFactory queryFactory) {
        this.queryFactory = queryFactory;
    }

    /**
     * 根据名称、价格区间和类别搜索产品
     * 
     * @param name 产品名称
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @param category 产品类别
     * @return 满足条件的产品列表
     */
    public List<Product> searchProducts(String name, Double minPrice, Double maxPrice, String category) {
        QProduct qProduct = QProduct.product;

        // 初始化 BooleanBuilder
        BooleanBuilder builder = new BooleanBuilder();

        // 根据名称构建条件
        if (name != null) {
            builder.and(qProduct.name.containsIgnoreCase(name));
        }

        // 根据最低价格构建条件
        if (minPrice != null) {
            builder.and(qProduct.price.goe(minPrice));
        }

        // 根据最高价格构建条件
        if (maxPrice != null) {
            builder.and(qProduct.price.loe(maxPrice));
        }

        // 根据类别构建条件
        if (category != null) {
            builder.and(qProduct.category.eq(category));
        }

        // 执行查询并返回结果
        return queryFactory.selectFrom(qProduct)
                           .where(builder)
                           .fetch();
    }
}

import com.querydsl.core.BooleanBuilder;
import com.querydsl.sql.SQLQueryFactory;
import java.time.LocalDate;
import java.util.List;

public class OrderQuery {

    private final SQLQueryFactory queryFactory;

    public OrderQuery(SQLQueryFactory queryFactory) {
        this.queryFactory = queryFactory;
    }

    /**
     * 根据客户ID、订单状态和日期范围查询订单
     * 
     * @param customerId 客户ID
     * @param status 订单状态
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return 满足条件的订单列表
     */
    public List<Order> queryOrders(Long customerId, String status, LocalDate startDate, LocalDate endDate) {
        QOrder qOrder = QOrder.order;

        // 初始化 BooleanBuilder
        BooleanBuilder builder = new BooleanBuilder();

        // 根据客户ID构建条件
        if (customerId != null) {
            builder.and(qOrder.customerId.eq(customerId));
        }

        // 根据订单状态构建条件
        if (status != null) {
            builder.and(qOrder.status.eq(status));
        }

        // 根据开始日期构建条件
        if (startDate != null) {
            builder.and(qOrder.orderDate.goe(startDate));
        }

        // 根据结束日期构建条件
        if (endDate != null) {
            builder.and(qOrder.orderDate.loe(endDate));
        }

        // 执行查询并返回结果
        return queryFactory.selectFrom(qOrder)
                           .where(builder)
                           .fetch();
    }
}