mybatis-plus 使用实体类传参 构造wrapper

1.问题：现在mybatis-plus已经很多人用了，我们查询条件通常会很多，如果使用wrapper去一个个判空，再eq()。是不是很繁琐。比如：

是不是很low啊，现在让我们通过注解一行搞定所有查询条件

2.解决办法

  实现思路：

      1.在实体类中直接使用注解，表明需要什么查询

     2.写个工具类反射获取注解值和属性值，再进行包装wrapper

3.实现过程

1.工具类

/**
 * 牛逼的wrapper构造
 * 描述：实体类使用注解 WhereType
 * 默认 为等于，其他的使用枚举；参考InStorePageVo
 * @author: 张鹏
 * @Date: 2018/11/26
 */
@Data
public class WhereEntityTool {
    private static Map<WhereTypeEnum, WhereFun> typeFunc;

    static {
        if (typeFunc == null) {
            typeFunc = new HashMap<>();
            typeFunc.put(WhereTypeEnum.EQ, (w, k, v) -> {
                w.eq(k, v);
            });
            typeFunc.put(WhereTypeEnum.NEQ, (w, k, v) -> {
                w.ne(k, v);
            });
            typeFunc.put(WhereTypeEnum.IN, (w, k, v) -> {
                if (v instanceof Collection) {
                    w.in(k, (Collection<?>) v);
                } else if (v instanceof Object[]) {
                    w.in(k, (Object[]) v);
                } else {
                    w.in(k, v.toString());
                }
            });
            typeFunc.put(WhereTypeEnum.LIKE, (w, k, v) -> {
                w.like(k, v.toString());
            });
            typeFunc.put(WhereTypeEnum.LE, (w, k, v) -> {
                w.le(k, v);
            });
            typeFunc.put(WhereTypeEnum.LT, (w, k, v) -> {
                w.lt(k, v);
            });
            typeFunc.put(WhereTypeEnum.GE, (w, k, v) -> {
                w.ge(k, v);
            });
            typeFunc.put(WhereTypeEnum.GT, (w, k, v) -> {
                w.gt(k, v);
            });
        }

    }
    /**
     * 封装成需要的wrapper
     *
     * @param t 实体对象
     * @return
     */
    public static Wrapper invoke(Object t) {
        Wrapper<T> wrapper = new EntityWrapper();
        excute(t, wrapper);
        // 获取
        return wrapper;
    }

    public static void invoke(Object t, Wrapper wrapper) {
        excute(t, wrapper);
    }
    /**
     * 执行
     *
     * @param t       obj
     * @param wrapper
     */
    public static void excute(Object t, Wrapper wrapper) {
        //反射获取属性
        Field[] fields = t.getClass().getDeclaredFields();
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                Object val = field.get(t);
                String colum = "";
                if (val != null && !"".equals(val.toString())) {
                    WhereType whereType = field.getAnnotation(WhereType.class);
                    //没有注解，取默认为下划线拼接
                    if (whereType == null) {
                        colum = camelToUnderline(field.getName());
                        // 执行方法
                        typeFunc.get(WhereTypeEnum.EQ).whereFunc(wrapper, colum, val);
                    } else {
                        if (whereType.ignore()) {
                            continue;
                        } else {
                            //没有定义查询属性，取默认
                            if (!StringUtils.isBlank(whereType.filed())) {
                                colum = whereType.filed();
                            } else {
                                colum = camelToUnderline(field.getName());
                            }
                            // 是否另取一个where
                            if (whereType.andNew()) {
                                wrapper.andNew();
                            }
                            // 执行方法
                            typeFunc.get(whereType.type()).whereFunc(wrapper, colum, val);
                        }
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 驼峰转下划线
     * @param param
     * @return
     * @Author 张鹏
     * @Date 2018/11/27 11:52
     */
    public static String camelToUnderline(String param) {
        if (param == null || "".equals(param.trim())) {
            return "";
        }
        int len = param.length();
        StringBuilder sb = new StringBuilder(len);
        for (int i = 0; i < len; i++) {
            char c = param.charAt(i);
            if (Character.isUpperCase(c)) {
                sb.append("_");
                sb.append(Character.toLowerCase(c));
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        InStorePageVo inStorePageVo = new InStorePageVo();
        inStorePageVo.setBusinessCompany("测试了");
        inStorePageVo.setBusinessNo("1112312");
        inStorePageVo.setBusinessType("adaaa");
        inStorePageVo.setCustomerName("zpzp");

        Wrapper<InstoreView> wrapper = WhereEntityTool.invoke(inStorePageVo);
        System.out.println(wrapper.toString());
    }
}

2.注解、枚举类和接口

public enum WhereTypeEnum {
    EQ,NEQ,IN,LIKE,LT,GT,LE,GE;
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface WhereType {

    /**
     * <p>
     * 查询类型
     * </p>
     */
    WhereTypeEnum type() default WhereTypeEnum.EQ;

    /**
     * 判定字段名
     * @return
     */
    String filed() default "";
    /**
     * 是否忽略
     */
    boolean ignore() default false;

    boolean andNew() default  false;

}

/**
 * 说明：
 * @author 张鹏
 * @create
 */
public interface WhereFun {
    void whereFunc(Wrapper wrapper,String field, Object vaule);
}

3.使用效果

    @ApiModelProperty(value="分公司")
    @WhereType(filed = "businessCompany",type=WhereTypeEnum.LIKE)
    private String businessCompany;

    @ApiModelProperty(value="仓库")
    private String wareHouseNo;
    @ApiModelProperty(value="业务状态")
    private String intoStatus;
    @ApiModelProperty(value="入库日期")
    @WhereType(filed = "into_time",type=WhereTypeEnum.GE)
    private String intoTimeStart;
    @WhereType(filed = "into_time",type=WhereTypeEnum.GT)
    private String intoTimeEnd;


/// 调用
        WhereEntityTool.invoke(inStorePageVo,wrapper);

感谢大家的支持！谢谢