QueryHelp

Condition

/**
 * @author xinkai.ye
 * @date 2019-6-4 13:52:30
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Condition {

    // 基本对象的属性名
    String propName() default "";

    // 查询方式
    Type type() default Type.EQ;

    /**
     * 多字段模糊搜索，仅支持String类型字段，多个用逗号隔开, 如@Condition(blurry = "email,username")
     */
    String blurry() default "";

    enum Type {
        // 相等
        EQ
        // 大于等于
        , GE
        // 小于等于
        , LE
        // 中模糊查询
        , INNER_LIKE
        // 左模糊查询
        , LEFT_LIKE
        // 右模糊查询
        , RIGHT_LIKE
        // 大于
        , GT
        // 小于
        , LT
        // 包含
        , IN
        // 不等于
        , NE
        // between
        , BETWEEN
        // 不为空
        , NOT_NULL
        // 为空
        , IS_NULL
    }

    // 排序方式
    Order order() default Order.NONE;

    enum Order {
        // 升序
        ASC
        // 降序
        , DESC
        // 降序
        , NONE
    }
}

QueryHelp

package me.yexinkai.utils;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import me.yexinkai.annotation.Condition;

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

/**
 * @author xinkai.ye
 * @date 2019-6-4 14:59:48
 */
@SuppressWarnings({"unchecked", "all"})
public class QueryHelp {

    public static <Q> Query getQuery(Q qc) throws Exception {
        return getQuery(qc, null);
    }

    public static <Q> Query getQuery(Q qc, PageData pageData) throws Exception {
        Query query = new Query();
        // 自动忽略value为空的条件
        query.autoIgnoreEmptyValue();
        query.notRecRecords();
        if (qc == null) {
            return query;
        }

        if (!BeanUtil.isEmpty(pageData)) {
            query.startPage(pageData);
        }
        List<Field> fields = getAllFields(qc.getClass(), new ArrayList<Field>());
        for (Field field : fields) {
            boolean accessible = field.isAccessible();
            // 设置对象的访问权限，保证对private的属性的访
            field.setAccessible(true);
            Condition q = field.getAnnotation(Condition.class);
            if (q != null) {
                String propName = q.propName();
                String blurry = q.blurry();
                String attributeName = StrUtil.isBlank(propName) ? field.getName() : propName;
                // 优先调用get方法,可以使用get方法进行数据处理
                Method method = QueryHelp.convertGetter(qc.getClass(), field);
                Object val;
                if (method != null) {
                    val = method.invoke(qc);
                } else {
                    val = field.get(qc);
                }
                // 排序一定要在判空前面,否则会被跳过
                Condition.Order order = q.order();
                if (null != order && !"NONE".equals(order)) {
                    switch (order) {
                        case ASC:
                            query.addAscOrderByClause(attributeName);
                            break;
                        case DESC:
                            query.addDescOrderByClause(attributeName);
                            break;
                        default:
                            break;
                    }
                }
                // 是否为NULL一定要在判空前面,否则会被跳过
                switch (q.type()) {
                    case NOT_NULL:
                        query.notNull(attributeName);
                        break;
                    case IS_NULL:
                        query.isNull(attributeName);
                        break;
                    default:
                        break;
                }
                // 跳过空值
                if (ObjectUtil.isNull(val) || "".equals(val)) {
                    continue;
                }
                // 模糊多字段
                if (ObjectUtil.isNotEmpty(blurry)) {
                    String[] blurrys = blurry.split(",");
                    Query likeQuery = new Query();
                    for (String s : blurrys) {
                        likeQuery.like(s, "%" + val.toString() + "%");
                    }
                    query.add(likeQuery);
                    continue;
                }
                switch (q.type()) {
                    case EQ:
                        query.eq(attributeName, val);
                        break;
                    case GE:
                        query.gtOrEq(attributeName, val);
                        break;
                    case LE:
                        query.ltOrEq(attributeName, val);
                        break;
                    case GT:
                        query.gt(attributeName, val);
                        break;
                    case LT:
                        query.lt(attributeName, val);
                        break;
                    case INNER_LIKE:
                        query.like(attributeName, "%" + val.toString() + "%");
                        break;
                    case LEFT_LIKE:
                        query.like(attributeName, "%" + val.toString());
                        break;
                    case RIGHT_LIKE:
                        query.like(attributeName, val.toString() + "%");
                        break;
                    case IN:
                        if (CollUtil.isNotEmpty((List<Object>)val)) {
                            query.in(attributeName, (List<Object>)val);
                        }
                        break;
                    case NE:
                        query.ne(attributeName, val);
                        break;
                    case BETWEEN:
                        List<Object> between = new ArrayList<>((List<Object>)val);
                        if (CollUtil.isNotEmpty(between) && between.size() == 2) {
                            query.between(attributeName, between.get(0), between.get(1));
                        }
                        break;
                    default:
                        break;
                }
            }
            field.setAccessible(accessible);
        }

        return query;
    }

    private static List<Field> getAllFields(Class clazz, List<Field> fields) {
        if (clazz != null) {
            fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
            getAllFields(clazz.getSuperclass(), fields);
        }
        return fields;
    }

    /*
     * 反射机制：通过字段名和参数获取getter方法
     */
    private static Method convertGetter(Class cla, Field field) {
        String name = field.getName();
        String str1 = name.substring(0, 1);
        String str2 = name.substring(1, name.length());
        String method_get = "get" + str1.toUpperCase() + str2;
        Method method = null;
        try {
            method = cla.getMethod(method_get);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return method;
    }
}

查询条件QueryCriteria

@Data
public class AgentProfitConfigQueryCriteria implements Serializable {

    @Condition()
    private String tradeType;

    @Query(type = QueryCondition.Type.INNER_LIKE)
    private String configName;

    @Condition(propName = "createTime", type = QueryCondition.Type.GE)
    private String createTimeStart;

    @Condition(propName = "createTime", type = QueryCondition.Type.LE)
    private String createTimeEnd;

    @QueryCondition(order = QueryCondition.Order.DESC)
    private String createTime;

    public String getCreateTimeStart() {
        return StrUtil.isEmpty(createTimeStart) ? null : createTimeStart + " 00:00:00";
    }

    public String getCreateTimeEnd() {
        return StrUtil.isEmpty(createTimeEnd) ? null : createTimeEnd + " 23:59:59";
    }
}

使用

/**
 * @author:yxkai
 * @email:yxkai@betterda.com
 * @创建日期:2020/11/10 @功能说明：
 */
@RestController
@RequestMapping("/agentScoreDetail")
public class AgentScoreDetailController {

 	@Reference(version = PayCloudConstant.VERSION_101)
    private AgentScoreDetailService agentScoreDetailService;
    /**
     * 分页查询
     */
    @RequestMapping("findByPage")
    @ResponseBody
    public Object findByPage(AgentScoreDetailQueryCriteria queryCriteria, PageData pageData) throws Exception {
        PageInfo<AgentScoreDetail> pageInfo =
            agentScoreDetailService.findPageInfoByQuery(QueryHelp.getQuery(queryCriteria, pageData));
        return new Pagination<>(pageInfo, pageData);
    }

}