使用Mybatisplus时-动态构建QueryWrapper：自定义注解+反射

最新推荐文章于 2025-03-01 13:18:54 发布

猪之仆

最新推荐文章于 2025-03-01 13:18:54 发布

阅读量2.4k

点赞数

分类专栏： # mybatis plus 文章标签： java

原文链接：https://blog.youkuaiyun.com/lengjian68/article/details/108312222

版权

mybatis plus 专栏收录该内容

8 篇文章

订阅专栏

如果您在项目使用过mybatisplus，想必有过这样的麻烦，mybatisplus中条件是通过QueryWrapper进行封装，根据不同的业务来确定使用哪种操作符，比如eq,ge,lt等等。比如我们具有相近业务的条件使用同一个条件对象，这样一来就会产生一种非常臃肿的代码结构，并且每增加一个条件，都会牵扯QueryWrapper构造条件的改动，比如下面这样的情形：

只要改动PlFinanceCondition这个条件属性，这个条件的封装就会随之更新，耦合强亦不优雅。为了解决这个问题，我的优化方案为：自定义注解+反射来动态构建QueryWrapper

1、自定义注解

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)

public @interface Wrapper {

/**

* 条件的关键字

*/

String keyword() default "eq";

/**

* 数据表列

*/

String field() default "";

}

说明：注解条件对象，标明其属性使用哪种操作符（默认是eq）和属性对应的数据表的列名

2、Between操作左右边界对象

@Data

public class Between<T> {

private T bLeft;

private T bRight;

public Between(T bLeft, T bRight) {

this.bLeft = bLeft;

this.bRight = bRight;

}

}

3、条件对象中使用该注解

@Data

@Builder

public class PlFinanceCondition {

********省略部分**********

/**

* 分校编码

* */

@Wrapper(field = "area_code")

private String areaCode;

/**

* 支付方式列表

* */

@Wrapper(keyword = "in",field = "pay_type")

private List<Integer> payTypes;

/**

* 支付方式

* */

@Wrapper(field = "pay_type")

private Integer payType;

/**

* 交易开始时间

* */

@Wrapper(keyword = "ge",field = "trade_time")

private Date tradeTimeStart;

/**

* 交易结束时间

* */

@Wrapper(keyword = "lt",field = "trade_time")

private Date tradeTimeEnd;

/**

* 交易时间 between操作

* */

@Wrapper(keyword = "between",field = "trade_time")

private Between<Date> tradeTimeBetween;

/**

* id,trade_time正序

* */

@Wrapper(keyword = "orderByDesc",field = "id,trade_time")

private Boolean orderByIdAndTradeTimeDesc;

}

说明：在每个属性上添加注解，标识属性使用哪种操作和对应数据表列名称

4、通过反射调用不同的操作方法

QueryWrapper的父类AbstractWrapper实现了4个接口，分别为Compare、Nested、Join和Func，其中我们常用的操作方法（比如eq、ge、gt、lt、in等）都在Compare和Func中，所以我这里就处理这两种接口的方法

4.1、通过枚举类抽象一个接口，两种类型Compare、Func

public enum WrapperInterfaceEnum {
Compare(Wrapper.KeywordsEnum.Compare.getKeyword()){
@Override
public <T> void doHandle(QueryWrapper<T> queryWrapper,Wrapper wrapper,Object entityValue) throws Exception {
Class compareClass = WrapperInterfaceEnum.getClass(this.name(),queryWrapper);
if(Wrapper.KeywordsEnum.Compare_Ext.getKeyword().contains(wrapper.keyword())){
//例：default Children between(R column, Object val1, Object val2)
Method m = compareClass.getDeclaredMethod(wrapper.keyword(),Object.class,Object.class,Object.class);
Between between = (Between)entityValue;
m.invoke(queryWrapper,wrapper.field(),between.getBLeft(),between.getBRight());
}else{
//例：default Children eq(R column, Object val)
Method m = compareClass.getDeclaredMethod(wrapper.keyword(),Object.class,Object.class);
m.invoke(queryWrapper,wrapper.field(),entityValue);
}
}
},
Func(Wrapper.KeywordsEnum.Func.getKeyword()){
@Override
public <T> void doHandle(QueryWrapper<T> queryWrapper,Wrapper wrapper,Object entityValue) throws Exception {
****省略*****
}
}
};
private List<String> keyword;

****省略*****

private static <T> Class getClass(String enumName,QueryWrapper<T> queryWrapper) throws ClassNotFoundException {
Class[] classes = queryWrapper.getClass().getSuperclass().getInterfaces();
Class compareClass = null;
for(Class c : classes){
if(enumName.equals(c.getSimpleName())){
compareClass = Class.forName(c.getName());
break;
}
}
return compareClass;
}

/**
* 每个枚举类型不同的实现逻辑
* @param queryWrapper 封装查询条件
* @param wrapper 注解条件对象的注解类
* @param entityValue 条件中对应值
* */
public abstract <T> void doHandle(QueryWrapper<T> queryWrapper,Wrapper wrapper,Object entityValue) throws Exception;
}

说明：该枚举类定义了一个抽象方法doHandle，每个枚举类型通过不同实现来调用不同的AbstractWrapper实现接口的操作方法。该枚举有两种类型，分别对应Compare和Func接口，每个类型都对应有一个操作符列表

Compare(Lists.newArrayList("eq","ge","gt","le","lt","like","notLike","likeLeft","likeRight","between"))

Func(Lists.newArrayList("in","notIn","groupBy","orderByAsc","orderByDesc"))

这里有个关键点，通过当前实例获取其父类实现的接口类型Class[] classes = queryWrapper.getClass().getSuperclass().getInterfaces();

4.2、封装工具类，来使用该枚举类，构造QueryWrapper查询条件

public class QueryWrapperUtil {

public static <T> void buildQueryWrapper(PlFinanceCondition condition,QueryWrapper<T> queryWrapper){

Field[] fields = condition.getClass().getDeclaredFields();

for(Field field : fields){

field.setAccessible(true);

Wrapper wrapper = field.getAnnotation(Wrapper.class);

if(Objects.nonNull(wrapper)){

try {

Object fieldValue = field.get(condition);

if(Objects.nonNull(fieldValue)){

String keyword = wrapper.keyword();

WrapperInterfaceEnum.getByKeyword(keyword).doHandle(queryWrapper,wrapper,fieldValue);

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

}

说明：根据操作符来确定使用枚举类型，调用对应的doHandle

WrapperInterfaceEnum.getByKeyword(keyword).doHandle(queryWrapper,wrapper,fieldValue)

5、使用方式，通过工具类调用对应的方法

@DataSource(DataSourceTypes.SLAVE_PL_FINANCE)

public List<PlFinance> selectByCondition(PlFinanceCondition condition){

QueryWrapper<PlFinance> queryWrapper = new QueryWrapper<>();

QueryWrapperUtil.buildQueryWrapper(condition,queryWrapper);

Page<PlFinance> page = new Page<>(1, DBConstant.MAX_NUMBER_OF_PIECES);

IPage<PlFinance> ppFinanceIPage = plFinanceMapper.selectPage(page,queryWrapper);

return Lists.newArrayList();

}

6、单元测试，验证结果

@Test

public void testWrapper(){

PlFinanceCondition condition = PlFinanceCondition.builder()

.areaCode("1111")//eq

.payTypes(Lists.newArrayList(103))//in

//.tradeTimeStart(new DateTime("2020-01-01").toDate())//ge

.tradeTimeBetween(new Between<>(new DateTime("2020-01-01").toDate(),new DateTime("2020-06-01").toDate()))//between

.orderByIdAndTradeTimeDesc(true)//orderByDesc

.build();

plFinanceService.selectByCondition(condition);

}