mybait-plus实现动态自定义查询条件

mybait-plus实现动态自定义查询条件

实现一个list接口满足大部分的前端查询要求

1、创建一个枚举

/**
 * 自定义查询的枚举
 */
public enum WhereEnum {

    EQ(1),// =
    NE(2),//<>
    LIKE(3),// likt %%
    NOT_LIKE(4), //not like %%
    GT(5), // >
    GE(6),// >=
    LT(7),// <
    LE(8),// <=
    LIKE_LEFT(9), // like %x
    LIKE_RIGHT(10),// like x%
    IS_NULL(11),// xx is null
    IS_NOT_NULL(12),// xx is not null
    IN(13),// in ()
    NOT_IN(14),// not in ()
    ORDER_BY_ASE(15),// order by asc
    ORDER_BY_DESC(16),// order by desc
    SELECT(17), // select xx ,xx 只查询某些字段
    ;

    private final int value;

    WhereEnum(int value) {
        this.value = value;
    }

    public int value() {
        return this.value;
    }


}

2、创建注解

import org.springframework.stereotype.Indexed;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Where {

    /**
     * 字段名
     * @return
     */
    String field() default "";

    /**
     *  字段查询的类型
     * @return
     */
    WhereEnum whereEnum() default WhereEnum.EQ ;


}

3、创建vo类

@Data
public class SupervisionWhere {

    @Where(field = "id")
    private String id;

	/**
	* 如果是自定义查询语句，连表查询，可以直接加前缀
	*/
    @Where(field = "a.TITLE",whereEnum = WhereEnum.LIKE)
    private String title;

    @Where(field = "END_DATE",whereEnum = WhereEnum.GE)
    private Date startDate;

    @Where(field = "END_DATE",whereEnum = WhereEnum.LE)
    private Date endDate;
    
    @Where(whereEnum = WhereEnum.ORDER_BY_ASE)
    private String orderByAsc;

    @Where(whereEnum = WhereEnum.ORDER_BY_DESC)
    private String orderByDesc;

    private Integer pageNo;

    /**
     * 默认每页20条
     */
    private Integer pageSize = 20;

}

4、创建工具类

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Lists;
import org.apache.commons.lang3.StringUtils;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.util.ObjectUtils;
import java.lang.reflect.Field;
import java.util.List;

/**
 * 动态自定义查询条件工具类
 */
public class WhereUtil {


    /**
     * 拼接查询条件
     *
     * @param queryWrapper 条件对象
     * @param obj          数据实体
     * @return void 返回参数说明
     * @exception/throws
     */
    public static void convertQuery(QueryWrapper queryWrapper, Object obj) throws IllegalAccessException {
        Class clazz = obj.getClass();
        // 反射遍历属性
        for (Field field : clazz.getDeclaredFields()) {
            // 抑制Java对修饰符的检查
            field.setAccessible(true);
            // 获取属性值
            Object fieldValue =  field.get(obj);
            // 如果是null的跳过
            if (ObjectUtils.isEmpty(fieldValue)) {
                continue;
            }
            // 判断是不是空字符串
            if (fieldValue instanceof String) {
                if (StringUtils.isEmpty(fieldValue.toString().trim())) {
                    continue;
                }
            }

            // 查询注解
            Where whereAnnotation = AnnotationUtils.getAnnotation(field, Where.class);
            if(ObjectUtils.isEmpty(whereAnnotation)){
                continue;
            }
            // 获取字段名
            String fieldName = whereAnnotation.field();
            // 获取枚举
            WhereEnum whereEnum = whereAnnotation.whereEnum();
            // 拼接查询条件
            switch (whereEnum) {
                case EQ:
                    queryWrapper.eq(fieldName, fieldValue);
                    break;
                case NE:
                    queryWrapper.ne(fieldName, fieldValue);
                    break;
                case LIKE:
                    queryWrapper.like(fieldName, fieldValue);
                    break;
                case NOT_LIKE:
                    queryWrapper.notLike(fieldName, fieldValue);
                    break;
                case GT:
                    queryWrapper.gt(fieldName, fieldValue);
                    break;
                case GE:
                    queryWrapper.ge(fieldName, fieldValue);
                    break;
                case LT:
                    queryWrapper.lt(fieldName, fieldValue);
                    break;
                case LE:
                    queryWrapper.le(fieldName, fieldValue);
                    break;
                case LIKE_LEFT:
                    queryWrapper.likeLeft(fieldName, fieldValue);
                    break;
                case LIKE_RIGHT:
                    queryWrapper.likeRight(fieldName, fieldValue);
                    break;
                case IS_NULL:
                    queryWrapper.isNull(fieldValue);
                    break;
                case IS_NOT_NULL:
                    queryWrapper.isNotNull(fieldValue);
                    break;
                case IN:
                    queryWrapper.in(fieldName, (List)fieldValue);
                    break;
                case NOT_IN:
                    queryWrapper.notIn(fieldName, (List)fieldValue);
                    break;
                case ORDER_BY_ASE:
                    queryWrapper.orderByAsc(fieldValue);
                    break;
                case ORDER_BY_DESC:
                    queryWrapper.orderByDesc(fieldValue);
                    break;
                case SELECT:
                    if (fieldValue instanceof String) {
                        queryWrapper.select(((String) fieldValue).split(","));
                    }
                    break;
                default:
                    break;
            }
        }
    }
}

5、接口调用

@GetMapping(value = "/supervision")
    public Result<?> list(SupervisionWhere supervision) throws IllegalAccessException {

        QueryWrapper<Supervision> queryWrapper = new QueryWrapper<>();
        // 拼接查询条件
        WhereUtil.convertQuery(queryWrapper,supervision);
        // 如果有页码，则进行分页查询，默认每页 20 条，可传参修改
        if (supervision.getPageNo() != null ){
            Page<Supervision> page = new Page(supervision.getPageNo(), supervision.getPageSize());
            return Result.OK(service.page(page, queryWrapper));
        }
        // 没有侧进行普通查询
        return Result.OK(service.list(queryWrapper));
    }

这样就可以了