MybatisPlus这样用简直就是不要太香，你还不快来试试!

在平时的开发中大多数都是重复的增删改查业务，特别是查询这个频率最高。查询又有按id查询，按组合条件查询，最烦琐的就是按条件查询。明明是多个业务之间重复的工作，只是表名字不一样，却要重复的去做查询组装。例如有一个产品表，需要按照各种查询条件进行查询，一般我们使用mybatis的话会在xml中这样配置：

	<select id="selectList" parameterType="Prodct" resultMap="ProductResult">
	    <include refid="selectProductVo"/>
		<where>
			<if test="code != null and code != ''">
				AND code like concat('%', #{code}, '%')
			</if>
		<if test="name != null and name != ''">
				AND name like concat('%', #{name}, '%')
			</if>
			<if test="cateId != null ">
				AND cateId = #{cateId},
			</if>
    <!-- 后面省略其他更多的条件组装 -->
		</where>
	</select>

如果还有一个用户表，订单表 都需要按业务字段查询，咱们也必须重复上面的配置，虽然是可以复制粘贴过来，但是这种方式还是太过于繁琐。那试试用 MybatisPlus又会怎样呢？MybatisPlus提供了查询器，可以使用代码按条件进行包装查询，具体用法如下：

  LambdaQueryWrapper<ProductEntity> wrapper = new LambdaQueryWrapper<ProductEntity>();
        if (StringUtils.isNotBlank(queryDto.getCode())) {
            wrapper.eq(ProductEntity::getCode, queryDto.getCode());
        }
        if (StringUtils.isNotBlank(queryDto.getName())) {
            wrapper.like(ProductEntity::getName, queryDto.getName());
        }
        if (StringUtils.isNotBlank(queryDto.getKeywork())) {
            wrapper.like(ProductEntity::getKeywork, queryDto.getKeywork());
        }
        if (queryDto.getIsDel() != null) {
            wrapper.eq(ProductEntity::getIsDel, queryDto.getIsDel());
        }
        if (queryDto.getIsShow() != null) {
            wrapper.eq(ProductEntity::getIsShow, queryDto.getIsShow());
        }
        if (queryDto.getIsHot() != null) {
            wrapper.eq(ProductEntity::getIsHot, queryDto.getIsHot());
        }
        if (queryDto.getIsRecom() != null) {
            wrapper.eq(ProductEntity::getIsRecom, queryDto.getIsRecom());
        }

可以看到，用MybatisPlus一样也少不了你得手动去组装这些查询条件，只不过是由xml切换到了代码去组装。有人就说了 MybatisPlus不是提供了Lambda链式查询吗？是的Lambda链式查询确实不错，但是如果使用Lambda链式查询代码看起来还不如上面的舒服。如下面的代码：

  new LambdaQueryWrapper<ProductEntity>()
                .eq(StringUtils.isNotBlank(queryDto.getCode()),ProductEntity::getCode,queryDto.getCode())
                .like(StringUtils.isNotBlank(queryDto.getName()),ProductEntity::getName,queryDto.getName());

这还只是组装两个查询条件，要是8个10个或者更多的查询条件，这个链式看起来头都大，而且你调试的是否非常不方便，所以不要太迷恋链式调用这种形式。上面两种常规方式都不能让这种不同的业务单表查询变得更简单或者减少重复工作。

鉴于以上这种代码的弊端，我提出一个优化需求：

1. 能不能传入一个java对象就可以自动的返回查询包装器
2. 返回的查询组装能支持等于，小于，大于，模糊匹配等这些类型
3. 这个方法能支持所有的业务表
4. 查询类型可以通过字段定义而不是代码写死

以上四点需求满后，最理想的效果如下：

// 商品查询
ProductQuery productQuery=new ProductQuery();
// 用户查询
UserQuery  userQuery =UserQuery();
// 动态查询方法，入参是 商品查询对象
QueryWrapper<ProductEntity> wrapper = getDynamicaWrapper(productQuery);
// 动态查询方法，入参是 用户查询对象
QueryWrapper<UserEntity> wrapper = getDynamicaWrapper(userQuery);

今天和大家分享一个简单的方法，让这种没有技术含量的条件组装变得简单，让你使用MybatisPlus一下子爽起来，毕竟减少重复工作一种都是编程领域的终极目标。下面把所以的实现过程贴出来，方便大家需要的时候可以复制粘贴。

首先，先定义一个枚举类，这个枚举类基本包含了SQL查询的类型：

public enum QueryFiledEnum {
    EQ,
    LIKE,
    NOT_LIKE,
    NE,
    GE,
    GT,
    LE,
    IN,
    NOT_IN,
    LEFT_LIKE,
    RIGHT_LIKE,
    BETWEEN,
    NOT_BETWEEN,
}

然后，咱们还得定义一个注解，用于配置字段

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface QueryFiled {
   // 查询的类型（比如等于，大于，小于 ,模糊查询等),对应上面的枚举类
    public QueryFiledEnum type() default QueryFiledEnum.EQ;
    // 是否排除这个字段的组装，默认是不排除
    public boolean exclude() default false;
}

接着，你需要定义一个通用的服务类，把这种重复的条件组装封装起来，做成一个通用的方法调用

public class BaseService<M extends BaseMapper<T>, T> extends ServiceImpl<M, T> {
  /***
   这个就是动态的条件组装方法，看到入参是Object类型，所以这个方法可以接受任何的查询对象
   方法返回一个QueryWrapper ，拿到这个QueryWrapper后你可以继续做其他的查询组装
  **/
  protected QueryWrapper<T> getDynamicaWrapper(Object baseQuery) {
        QueryWrapper<T> wrapper = new QueryWrapper<>();
        if (baseQuery == null) {
            return wrapper;
        }
       // 采用反射
        Field[] fields = baseQuery.getClass().getDeclaredFields();
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                Object fieldValue = field.get(baseQuery);
                if (isNotEmpty(fieldValue)) {
                   // 获取字段注解
                    QueryFiled annotation = field.getAnnotation(QueryFiled.class);
                    // 把字段名称转换为数据库字段
                    String fieldName = fieldToColumn(field.getName());
                    // 没有注解，默认使用等于查询
                    if (annotation == null) {
                        wrapper.eq(fieldName, fieldValue);
                    } else {
                        QueryFiledEnum type = annotation.type();
                        if (!annotation.exclude()) {
                            // 根据查询类型 动态拼接查询器
                            setQueryWrapper(type, fieldName, fieldValue, wrapper);
                        }
                    }
                }
            } catch (Exception e) {
                if (log.isDebugEnabled()) {
                    log.debug(e.getMessage());
                }
            }
        }
        return wrapper;
    }

   /***
    这个是具体的查询组装的逻辑，后期需要扩展查询类型，就需要改这个地方代码即可
   **/
    private final void setQueryWrapper(QueryFiledEnum type, String fieldName, Object fieldValue, QueryWrapper<T> wrapper) {
        String tn = type.name();
        switch (type) {
            case EQ:
                wrapper.eq(fieldName, fieldValue);
                break;
            case NE:
                wrapper.ne(fieldName, fieldValue);
                break;
            case GE:
                wrapper.ge(fieldName, fieldValue);
                break;
            case LE:
                wrapper.le(fieldName, fieldValue);
                break;
            case GT:
                wrapper.gt(fieldName, fieldValue);
                break;
            case LIKE:
                wrapper.like(fieldName, fieldValue);
                break;
            case LEFT_LIKE:
                wrapper.likeLeft(fieldName, fieldValue);
                break;
            case RIGHT_LIKE:
                wrapper.likeRight(fieldName, fieldValue);
                break;
            case NOT_LIKE:
                wrapper.notLike(fieldName, fieldValue);
                break;
            case IN:
                if (fieldValue instanceof Collection || fieldValue instanceof Object[]) {
                    wrapper.in(fieldName, fieldValue);
                }
                break;
            case NOT_IN:
                if (fieldValue instanceof Collection || fieldValue instanceof Object[]) {
                    wrapper.notIn(fieldName, fieldValue);
                }
                break;
            case BETWEEN:
                if (fieldValue instanceof Object[]) {
                    Object[] fv = (Object[]) fieldValue;
                    wrapper.between(fieldName, fv[0], fv[1]);
                }
                break;
            case NOT_BETWEEN:
                if (fieldValue instanceof Object[]) {
                    Object[] fv = (Object[]) fieldValue;
                    wrapper.notBetween(fieldName, fv[0], fv[1]);
                }
                break;
            default:
                break;
        }
    }
  
    // 将java 字段转换成数据库字段
    private String fieldToColumn(String field) {
        StringBuilder sb = new StringBuilder(10);
        for (int i = 0; i < field.length(); i++) {
            if ('A' <= field.charAt(i) && field.charAt(i) <= 'Z') {
                sb.append("_").append(Character.toLowerCase(field.charAt(i)));
            } else {
                sb.append(field.charAt(i));
            }
        }
        return sb.toString();
    }
}

代码比较简单，逻辑也不复杂，只是通过反射把动态组装查询这个地方做了封装，让查询基于一个可配置的对象即可自动完成，看注释就可以明白。下面咱看看具体怎么使用这个超级方法。

按照不同业务，首先得定义一个查询对象，比如我的商品查询对象：

@Data
public class ProductQuery{
    // 这个字段没有注解，说明是默认使用 等于 查询
    private String code;
    // 排除掉这个字段的动态组装，也就是动态查询方法里面不组装这个条件
    @QueryFiled(exclude = true)
    private Long cateId;
    // 这个注解指定了查询的类型
    @QueryFiled(type = QueryFiledEnum.LIKE)
    private String name;
    @QueryFiled(type = QueryFiledEnum.LIKE)
    private String keywork;
    private Integer isHot;
    private Integer isNew;
    private Integer isShow;
    private Integer isRecom;
    private Integer isDel;
}

可以看到，所有查询的条件都在这个类上面完成了，包括查询的字段，查询的类型，查询的参数都通过这个类去完成。注意的是 这个字段的命名要和你的实体 ProductEntity一样。其实我们也可以完全把这些配置写在ProductEntity上就不需要重复而且要求必须这些字段一样了。但是为了更规范，一般我们实体类和业务类不混淆一起使用，比如ProductEntity一般有很多的字段，咱不能为了查询就在这个实体类上添加那么多于数据库无关的配置吧，所以单独创建一个查询类是比较标准的做法。

然后就是开头上面的代码那样使用了

ProductQuery productQuery=new ProductQuery();
// 动态查询方法，入参是 商品查询对象
QueryWrapper<ProductEntity> wrapper = getDynamicaWrapper(productQuery);

如果你的业务中还有用户，订单等后续就可以只需要创建*Query这样的查询类简单的配置就可以不用写那些一大堆重复的if else或者xml了。这样简单一个封装，让你的工作量瞬间减少，作为程序员最怕的就是重复的工作。那这个动态查询方法有什么优点吗？

1. 封装各业务表重复的查询条件
2. 基于查询描述类进行动态查询拼接，不需要手动去组装
3. 支持注解配置查询参数
4. 对原有查询无侵入性，返回QueryWrapper后可以继续QueryWrapper的所有功能
5. 不依赖具体查询配置类，只依赖其中的属性命名

如果你觉得这种方式好用，可以在你的代码中试一试，你会瞬间摆脱那种重复烦人无技术含量的查询条件拼装，要是觉得好用记得点赞关注，鼓励支持下。