14、Mybatis-Plus入门 - 条件构造器

前言

mybatis-plus提供了强大的条件构造器，用于构造Where条件。

Wrapper  条件构造抽象类
    -- AbstractWrapper 查询条件封装，用于生成 sql 中的 where 语句。
        -- QueryWrapper Query封装操作类，用于查询。
        -- UpdateWrapper Update条件封装操作类，用于更新。
        -- AbstractLambdaWrapper 使用 Lambda 表达式封装 wrapper
            -- LambdaQueryWrapper 使用 Lambda 语法封装条件，用于查询。
            -- LambdaUpdateWrapper 使用 Lambda 语法封装条件，用于更新。

AbstractWrapper

QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条件。

案例演示

以下案例全部采用Lambda表达式，这样

allEq

全部eq(或个别isNull)。

allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)

参数说明：

params : key为数据库字段名,value为字段值
null2IsNull : 为true则在map的value为null时调用 isNull 方法,为false时则忽略value为null的
condition: 该条件是否加入最后生成的sql中

案例演示：

    @Test
    public void allEqTest() {
   
     
        System.out.println("----- allEq ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        Map<SFunction<OrderTbl, ?>,Object> params = new HashMap<>();
        params.put(OrderTbl::getUserId, 123);
        params.put(OrderTbl::getCount, 0);
        // allEq(Map<R, V> params)
        // queryWrapper.allEq(params);
        // SELECT id,user_id,commodity_code,count,money,dept_id,tenant_id,is_deleted,version,oper_user,gmt_create,gmt_modified FROM order_tbl WHERE is_deleted=0 AND (count = 0 AND user_id = 123)

        params.put(OrderTbl::getCommodityCode, null);
        // allEq(Map<R, V> params, boolean null2IsNull)
        // queryWrapper.allEq(params,true);
        // SELECT id,user_id,commodity_code,count,money,dept_id,tenant_id,is_deleted,version,oper_user,gmt_create,gmt_modified FROM order_tbl WHERE is_deleted=0 AND (count = 0 AND user_id = 123 AND commodity_code IS NULL)

        // allEq(boolean condition, Map<R, V> params, boolean null2IsNull)
        boolean condition=false; // 条件
        queryWrapper.allEq(condition,params,true);
        // SELECT id,user_id,commodity_code,count,money,dept_id,tenant_id,is_deleted,version,oper_user,gmt_create,gmt_modified FROM order_tbl WHERE is_deleted=0
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

使用BiPredicate函数式接口test()方法对params进行过滤，K为键，V为值，可以自定义过滤，返回false时，该KV将被移出params。

    public <V> Children allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull) {
   
     
        if (condition && CollectionUtils.isNotEmpty(params)) {
   
     
            params.forEach((k, v) -> {
   
     
                if (filter.test(k, v)) {
   
     
                    if (StringUtils.checkValNotNull(v)) {
   
     
                        this.eq(k, v);
                    } else if (null2IsNull) {
   
     
                        this.isNull(k);
                    }
                }
            });
        }
        return this.typedThis;
    }

allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull) 

参数说明：

filter : 过滤函数,是否允许字段传入比对条件中
params、null2IsNull、condition : 同上

案例演示：
只演示第一个，其他两个和上面一样，注意不能使用lambdaQuery，否则会导致无法过滤K。

    @Test
    public void allEqTest02() {
   
     
        System.out.println("----- allEq ------");
        QueryWrapper<OrderTbl> queryWrapper = Wrappers.query();
        Map<String, Object> params = new HashMap<>();
        params.put("user_id", "123");
        params.put("count", 0);
        queryWrapper.allEq((k, v) -> {
   
     
            // 此处表示params中键为user_id 并且值为"123"的参数才添加到条件中
            return "user_id".equals(k) && "123".equals(v);
        }, params);
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

eq

等于=

eq(R column, Object val)
eq(boolean condition, R column, Object val)

参数说明：

column: 字段
val：字段值
condition : 该条件是否加入最后生成的sql中

案例演示：

    @Test
    public void eqTest02() {
   
     
        System.out.println("----- eq ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        //queryWrapper.eq(OrderTbl::getUserId,123); // AND (user_id = 123)
        queryWrapper.eq(true,OrderTbl::getUserId,123);
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

ne

不等于<>，参数同上。

ne(R column, Object val)
ne(boolean condition, R column, Object val)

案例演示：

    @Test
    public void neTest02() {
   
     
        System.out.println("----- ne ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        //queryWrapper.ne(OrderTbl::getUserId,123); // AND (user_id <> 123)
        queryWrapper.ne(true,OrderTbl::getUserId,123);
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

gt

大于>，参数同上
案例演示：

    @Test
    public void gtTest02() {
   
     
        System.out.println("----- gt ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        //queryWrapper.gt(OrderTbl::getId,999999); // AND (id > 999999)
        queryWrapper.gt(true,OrderTbl::getId,999999);
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

ge

大于等于 >=，参数同上

ge(R column, Object val)
ge(boolean condition, R column, Object val)

案例演示：

    @Test
    public void geTest02() {
   
     
        System.out.println("----- ge ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.ge(OrderTbl::getGmtCreate,new Date()); //   AND (gmt_create >= '2021-04-20T23:22:30.325+0800')
        //queryWrapper.ge(true,OrderTbl::getGmtCreate,new Date());
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

lt

小于<，参数同上

lt(R column, Object val)
lt(boolean condition, R column, Object val)

案例演示：

    @Test
    public void ltTest02() {
   
     
        System.out.println("----- lt ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.lt(OrderTbl::getMoney,1000); //    AND (money < 1000)
        queryWrapper.lt(true,OrderTbl::getMoney,1000); 
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

le

小于等于 <=，参数同上

le(R column, Object val)
le(boolean condition, R column, Object val)

案例演示：

    @Test
    public void leTest02() {
   
     
        System.out.println("----- le ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.le(OrderTbl::getMoney,1000); //   AND (money <= 1000)
        //queryWrapper.le(true,OrderTbl::getMoney,1000);
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

between

BETWEEN 值1 AND 值2，

between(R column, Object val1, Object val2)
between(boolean condition, R column, Object val1, Object val2)

参数说明：

column: 字段
val1：BETWEEN起始值，
val2：BETWEEN结束值，
condition : 该条件是否加入最后生成的sql中

案例演示：

    @Test
    public void betweenTest02() {
   
     
        System.out.println("----- between ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.between(OrderTbl::getMoney,500,800); //  AND (money BETWEEN 500 AND 800)
        //queryWrapper.between(true,OrderTbl::getMoney,500,800);
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

notBetween

NOTBETWEEN 值1 AND 值2，参数案例同上。

notBetween(R column, Object val1, Object val2)
notBetween(boolean condition, R column, Object val1, Object val2)

like

LIKE ‘%值%’，参数同上。

like(R column, Object val)
like(boolean condition, R column, Object val)

案例演示：

    @Test
    public void likeTest02() {
   
     
        System.out.println("----- like ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.like(OrderTbl::getUserId,123); //  AND (user_id LIKE '%123%')
        //queryWrapper.like(true,OrderTbl::getUserId,123);
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

notLike

NOTLIKE ‘%值%’，参数案例同上。

notLike(R column, Object val)
notLike(boolean condition, R column, Object val)

likeLeft

LIKE ‘%值’，参数案例同上。

likeLeft(R column, Object val)
likeLeft(boolean condition, R column, Object val)

likeRight

LIKE ‘值%’，参数案例同上。

likeRight(R column, Object val)
likeRight(boolean condition, R column, Object val)

isNull

字段IS NULL

isNull(R column)
isNull(boolean condition, R column)

参数说明：

column: 字段
condition : 该条件是否加入最后生成的sql中

案例演示：

    @Test
    public void isNullTest02() {
   
     
        System.out.println("----- isNull ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.isNull(OrderTbl::getGmtCreate); //  AND (gmt_create IS NULL)
        //queryWrapper.isNull(true, OrderTbl::getGmtCreate);
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

isNotNull

字段IS NOT NULL，参数案例同上。

isNotNull(R column)
isNotNull(boolean condition, R column)

in

字段IN (value.get(0), value.get(1), …)

in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)

案例演示：

    @Test
    public void inTest02() {
   
     
        System.out.println("----- in ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        List<Long> userIdList=new ArrayList<>();
        userIdList.add(123L);
        userIdList.add(456L);
        queryWrapper.in(OrderTbl::getUserId,userIdList); //  AND (user_id IN (123,456))
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }
}

notIn

字段NOT IN (value.get(0), value.get(1), …)，参数案例同上

notIn(R column, Collection<?> value)
notIn(boolean condition, R column, Collection<?> value)
notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)

inSql

字段IN ( sql语句 )，子查询

inSql(R column, String inValue)
inSql(boolean condition, R column, String inValue)

案例演示：

    @Test
    public void inSqlTest02() {
   
     
        System.out.println("----- in ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.inSql(OrderTbl::getUserId,"Select user_id From order_tbl"); //  AND (user_id IN (Select user_id From order_tbl))
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

notInSql

字段NOT IN ( sql语句 )，参数案例同上

notInSql(R column, String inValue)
notInSql(boolean condition, R column, String inValue)

groupBy

groupBy(R... columns)
groupBy(boolean condition, R... columns)

分组：GROUP BY 字段, …

orderByAsc

排序：ORDER BY 字段, … ASC

orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)

orderByDesc

排序：ORDER BY 字段, … DESC

orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)

orderBy

排序：ORDER BY 字段, …

orderBy(boolean condition, boolean isAsc, R... columns)

having

HAVING ( sql语句 )

having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)

func

func 方法(主要方便在出现if…else下调用不同方法能不断链), 使用函数式Consumer 接口生产数据，可以用if…else对Wrapper进行构建。

func(Consumer<Children> consumer)
func(boolean condition, Consumer<Children> consumer)

案例演示：

    @Test
    public void funcTest02() {
   
     
        System.out.println("----- in ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.func((i) -> {
   
     
            if (true){
   
     
                i.eq(OrderTbl::getUserId,"123"); // AND (user_id = '123')
            }else {
   
     
                i.ne(OrderTbl::getUserId,"123");
            }
        });
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }
}

or

拼接OR，主动调用or表示紧接着下一个方法不是用and连接!(不调用or则默认为使用and连接)

or()
or(boolean condition)

OR嵌套

or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)

案例演示：
需要注意写法

    @Test
    public void orTest02() {
   
     
        System.out.println("----- or ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        //queryWrapper.eq(OrderTbl::getMoney, 1000).or().eq(OrderTbl::getCommodityCode, "Phone"); // AND (money = 1000 OR commodity_code = 'Phone')
        queryWrapper.eq(OrderTbl::getMoney, 1000).or((i) -> {
   
     
            i.eq(OrderTbl::getUserId, 123);
        });
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

and

AND嵌套

and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)

nested

正常嵌套 不带 AND 或者 OR

nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)

案例演示：

    @Test
    public void nestedTest02() {
   
     
        System.out.println("----- nested ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        // AND ((commodity_code = 'Iphone' AND count <> 0))
        queryWrapper.nested(i -> {
   
     
            i.eq(OrderTbl::getCommodityCode, "Iphone").ne(OrderTbl::getCount, 000);
        });
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

apply

拼接sql，该方法可用于数据库函数 动态入参的params对应前面applySql内部的{index}部分.这样是不会有sql注入风险的,反之会有!

apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)

last

无视优化规则直接拼接到 sql 的最后，只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用。

last(String lastSql)
last(boolean condition, String lastSql)

exists

拼接EXISTS ( sql语句 )。

exists(String existsSql)
exists(boolean condition, String existsSql)

notExists

拼接NOT EXISTS ( sql语句 )

notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)

QueryWrapper

继承自AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件及 LambdaQueryWrapper, 可以通过 new QueryWrapper().lambda() 方法获取。

select

设置查询字段，方法分为两类，第二类方法为:过滤查询字段(主键除外),入参不包含 class 的调用前需要wrapper内的entity属性有值! 这两类方法重复调用以最后一次为准

select(String... sqlSelect)
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)

案例演示：

    @Test
    public void selectTest02() {
   
     
        System.out.println("----- select ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        // SELECT dept_id,commodity_code FROM order_tbl WHERE is_deleted=0
        //queryWrapper.select(OrderTbl::getDeptId,OrderTbl::getCommodityCode);
        // SELECT id,user_id FROM order_tbl WHERE is_deleted=0
        queryWrapper.select(OrderTbl.class, i -> {
   
     
            return i.getProperty().startsWith("user");
        });
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

UpdateWrapper

继承自AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件及 LambdaUpdateWrapper, 可以通过 new UpdateWrapper().lambda() 方法获取!

set

SQLSET 字段

set(String column, Object val)
set(boolean condition, String column, Object val)

setSql

设置SET 部分 SQL

setSql(String sql)

使用 Wrapper 自定义SQL

注意事项: 需要mybatis-plus版本 >= 3.0.7 param 参数名要么叫ew,要么加上注解@Param(Constants.WRAPPER) 使用${ew.customSqlSegment} 不支持 Wrapper 内的entity生成where语句。

案例演示：

1、 Mapper添加方法；

    @Select("select * from order_tbl ${ew.customSqlSegment}")
    List<OrderTbl> getAll(@Param(Constants.WRAPPER) Wrapper wrapper);

1、 调用；

    @Test
    public void wrapperTest02() {
   
     
        System.out.println("----- wrapper ------");
        LambdaQueryWrapper<OrderTbl> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(OrderTbl::getCommodityCode,"phone");
        orderTblMapper.getAll(queryWrapper); // WHERE is_deleted=0 AND (commodity_code = 'phone')
        List<OrderTbl> list = orderTblService.list(queryWrapper);
    }

链式调用 lambda 式

wrapper支持链式调用

// 区分:
// 链式调用 普通
UpdateChainWrapper<T> update();
// 链式调用 lambda 式。注意：不支持 Kotlin 
LambdaUpdateChainWrapper<T> lambdaUpdate();

// 等价示例：
query().eq("id", value).one();
lambdaQuery().eq(Entity::getId, value).one();

// 等价示例：
update().eq("id", value).remove();
lambdaUpdate().eq(Entity::getId, value).remove();

参考：https://baomidou.com/