前言

这是根据项目代码做的调整，其它项目需要根据自己的项目调整，参考的是mybatis-plus工具的代码

package com.yss.fomp.capital.order.util;

import cn.hutool.core.util.ClassUtil;
import cn.hutool.core.util.ReflectUtil;
import com.baomidou.mybatisplus.core.toolkit.LambdaUtils;
import com.baomidou.mybatisplus.core.toolkit.support.LambdaMeta;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.google.common.collect.Lists;
import org.apache.ibatis.reflection.property.PropertyNamer;
import org.springframework.data.domain.Sort;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

/**
 * JPA 条件构建
 *
 * @author pengzhikang
 * @date 2026/3/12 14:16
 * @since 1.0.0
 */
public class JpaQueryLambdaWrapper<T extends BaseEntity> {

    /** 条件 */
    private final List<JpaCondition<Object>> conditions;

    /** 排序 */
    private final List<Sort.Order> orders;

    public JpaQueryLambdaWrapper() {
        this(null);
    }

    public JpaQueryLambdaWrapper(T entity) {
        this.conditions = new ArrayList<>();
        this.orders = new ArrayList<>();
        build(entity);
    }

    public List<JpaCondition<Object>> getConditions() {
        return conditions;
    }

    public Sort getSort() {
        return orders.isEmpty() ? Sort.unsorted() : Sort.by(orders);
    }

    /**
     * 构建
     *
     * @param entity 实体类
     * @author pengzhikang
     * @date 2026/03/12 14:31
     */
    private void build(T entity) {
        if (entity == null) {
            return;
        }
        Field[] declaredFields = ClassUtil.getDeclaredFields(entity.getClass());
        for (Field field : declaredFields) {
            Object value = ReflectUtil.getFieldValue(entity, field);
            if (value != null) {
                conditions.add(JpaCondition.get(field.getName(), JpaConditionOperator.EQ, value));
            }
        }
    }

    /**
     * 从字段表达式到列表
     *
     * @param column 列
     * @return {@link String }
     * @author pengzhikang
     * @date 2026/03/13 10:52
     */
    protected String columnToString(SFunction<T, ?> column) {
        LambdaMeta meta = LambdaUtils.extract(column);
        return PropertyNamer.methodToProperty(meta.getImplMethodName());
    }

    /**
     * 添加条件
     *
     * @param condition 条件
     * @param column    列
     * @param operator  操作员
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:23
     */
    protected JpaQueryLambdaWrapper<T> addCondition(boolean condition, SFunction<T, ?> column, JpaConditionOperator operator, Object val) {
        if (condition) {
            conditions.add(JpaCondition.get(columnToString(column), operator, val));
        }
        return this;
    }

    /**
     * 添加条件
     *
     * @param condition 条件
     * @param column    列
     * @param operator  操作员
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:23
     */
    protected JpaQueryLambdaWrapper<T> addCondition(boolean condition, SFunction<T, ?> column, JpaConditionOperator operator, Collection<?> val) {
        if (condition) {
            conditions.add(JpaCondition.get(columnToString(column), operator, val));
        }
        return this;
    }

    /**
     * 添加条件
     *
     * @param condition 条件
     * @param column    列
     * @param operator  操作员
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:23
     */
    protected JpaQueryLambdaWrapper<T> addCondition(boolean condition, SFunction<T, ?> column, JpaConditionOperator operator) {
        if (condition) {
            conditions.add(JpaCondition.get(columnToString(column), operator));
        }
        return this;
    }

    /**
     * 等于 =
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:23
     */
    public JpaQueryLambdaWrapper<T> eq(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.EQ, val);
    }

    /**
     * 不等于 <>
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:23
     */
    public JpaQueryLambdaWrapper<T> ne(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.NOTEQ, val);
    }

    /**
     * 大于 >
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:23
     */
    public JpaQueryLambdaWrapper<T> gt(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.GT, val);
    }

    /**
     * 大于等于 >=
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:24
     */
    public JpaQueryLambdaWrapper<T> ge(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.GTEQ, val);
    }

    /**
     * 小于 <
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:24
     */
    public JpaQueryLambdaWrapper<T> lt(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.LT, val);
    }

    /**
     * 小于等于 <=
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:24
     */
    public JpaQueryLambdaWrapper<T> le(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.LTEQ, val);
    }

    /**
     * LIKE '%值%'
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:25
     */
    public JpaQueryLambdaWrapper<T> like(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.LIKE, val);
    }

    /**
     * NOT LIKE '%值%'
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:27
     */
    public JpaQueryLambdaWrapper<T> notLike(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.NOTLIKE, val);
    }

    /**
     * LIKE '%值'
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:27
     */
    public JpaQueryLambdaWrapper<T> likeLeft(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.LEFTLIKE, val);
    }

    /**
     * LIKE '值%'
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:28
     */
    public JpaQueryLambdaWrapper<T> likeRight(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.RIGHTLIKE, val);
    }

    /**
     * NOT LIKE '%值'
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:28
     */
    public JpaQueryLambdaWrapper<T> notLikeLeft(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.NOTLEFTLIKE, val);
    }

    /**
     * NOT LIKE '值%
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:28
     */
    public JpaQueryLambdaWrapper<T> notRightLeft(boolean condition, SFunction<T, ?> column, Object val) {
        return addCondition(condition, column, JpaConditionOperator.NOTRIGHTLIKE, val);
    }

    /**
     * 是否为空 is null
     *
     * @param condition 条件
     * @param column    列
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:28
     */
    public JpaQueryLambdaWrapper<T> isNull(boolean condition, SFunction<T, ?> column) {
        return addCondition(condition, column, JpaConditionOperator.NULL);
    }

    /**
     * 是否不为空 is not null
     *
     * @param condition 条件
     * @param column    列
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:29
     */
    public JpaQueryLambdaWrapper<T> isNotNull(boolean condition, SFunction<T, ?> column) {
        return addCondition(condition, column, JpaConditionOperator.NOTNULL);
    }

    /**
     * 包含 in (xx, xx, xx)
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:29
     */
    public JpaQueryLambdaWrapper<T> in(boolean condition, SFunction<T, ?> column, Object... val) {
        return addCondition(condition, column, JpaConditionOperator.IN, Lists.newArrayList(val));
    }

    /**
     * 包含 in (xx, xx, xx)
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:29
     */
    public JpaQueryLambdaWrapper<T> in(boolean condition, SFunction<T, ?> column, Collection<?> val) {
        return addCondition(condition, column, JpaConditionOperator.IN, val);
    }

    /**
     * 不包含 not in (xx, xx, xx)
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:30
     */
    public JpaQueryLambdaWrapper<T> notIn(boolean condition, SFunction<T, ?> column, Object... val) {
        return addCondition(condition, column, JpaConditionOperator.NOTIN, Lists.newArrayList(val));
    }

    /**
     * 不包含 not in (xx, xx, xx)
     *
     * @param condition 条件
     * @param column    列
     * @param val       值
     * @return {@link JpaQueryLambdaWrapper }<{@link T }>
     * @author pengzhikang
     * @date 2026/03/13 11:30
     */
    public JpaQueryLambdaWrapper<T> notIn(boolean condition, SFunction<T, ?> column, Collection<?> val) {
        return addCondition(condition, column, JpaConditionOperator.NOTIN, val);
    }

    /**
     * 排序依据
     *
     * @param direction 方向
     * @param column    列
     * @author pengzhikang
     * @date 2026/03/13 11:57
     */
    public void orderBy(Sort.Direction direction, SFunction<T, ?>... column) {
        Arrays.stream(column)
                .map(it -> new Sort.Order(direction, columnToString(it)))
                .forEach(orders::add);
    }

    /**
     * 升序排
     *
     * @param column 列
     * @author pengzhikang
     * @date 2026/03/13 11:57
     */
    public void asc(SFunction<T, ?>... column) {
        Arrays.stream(column)
                .map(it -> new Sort.Order(Sort.Direction.ASC, columnToString(it)))
                .forEach(orders::add);
    }

    /**
     * 降序排
     *
     * @param column 列
     * @author pengzhikang
     * @date 2026/03/13 11:57
     */
    public void desc(SFunction<T, ?> ... column) {
        Arrays.stream(column)
                .map(it -> new Sort.Order(Sort.Direction.DESC, columnToString(it)))
                .forEach(orders::add);
    }

    /**
     * 排序依据
     *
     * @param direction 方向
     * @param column    列
     * @author pengzhikang
     * @date 2026/03/13 11:57
     */
    public JpaQueryLambdaWrapper<T> by(Sort.Direction direction, SFunction<T, ?> column) {
        orders.add(new Sort.Order(direction, columnToString(column)));
        return this;
    }

    /**
     * 升序
     *
     * @param column    列
     * @author pengzhikang
     * @date 2026/03/13 11:57
     */
    public JpaQueryLambdaWrapper<T> asc(SFunction<T, ?> column) {
        orders.add(new Sort.Order(Sort.Direction.ASC, columnToString(column)));
        return this;
    }

    /**
     *  降序
     *
     * @param column    列
     * @author pengzhikang
     * @date 2026/03/13 11:57
     */
    public JpaQueryLambdaWrapper<T> desc(SFunction<T, ?> column) {
        orders.add(new Sort.Order(Sort.Direction.DESC, columnToString(column)));
        return this;
    }
}