【 MyBatis-Plus 】: 条件构造器

1、条件构造器

Mybatis-Plus 通过 Wrapper——条件构造器,或者 Condition来让用户自由的构建查询条件。Wrapper 是条件构造抽象类,最顶端父类。Wrapper接口的实现类关系如下:

在这里插入图片描述

从图中可以看出,AbstractWrapperAbstractChainWrapper是重点实现,接下来我们重点学习 AbstractWrapper 以及其子类。

2、AbastractWrapper 抽象类

Mybatis-Plus 提供一个 AbastractWrapper 抽象类,这个类继承了 Wrapper 抽象类。这个抽象类中包括了很多方法,这些方法用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条件

2.1、allEq

allEq表示设置所有条件相等,并将所有条件用 and 连接

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 时,调用 isNull 方法判断 map 的 value 的属性值是否为 null,反之不判断。
//参数:condition 表示这些条件是否加入最后生成的sql中,false 表示不加入

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 表示过滤函数,是否允许字段传入比对条件中
Map<String, Object> map = new HashMap<>();
map.put("id", order.getId());
map.put("uid", order.getUid());
UpdateWrapper<Order> updateWrapper = new UpdateWrapper<>();
//SELECT * FROM 表名 WHERE id = ? AND uid= ?
updateWrapper.allEq(map); 
//SELECT * FROM 表名 WHERE id = ? AND uid= ?
updateWrapper.allEq((k,v)-(k.equals("id") || k.equals("uid"), map); 
//SELECT * FROM 表名 WHERE id = ? 
updateWrapper.allEq((k,v)-(k.equals("id")), map);

2.2、基本操作

  • eqne:等同于SQL中的 =<>

    //eq 等于 =     
    //参数 condition 表示这些条件是否加入最后生成的sql中,false 表示不加入                                           
    eq(R column, Object val)
    eq(boolean condition, R column, Object val)	
    //SELECT * FROM 表名 WHERE name = '老王
    eq("name", "老王")
    
    //ne 不等于 <>
    ne(R column, Object val)
    ne(boolean condition, R column, Object val)
    //SELECT * FROM 表名 WHERE name <> '老王'
    ne("name", "老王")
    
  • gtge:等同于SQL中的 >>=

    //gt 大于 >
    gt(R column, Object val)
    gt(boolean condition, R column, Object val)
    //SELECT * FROM 表名 WHERE age > 18
    gt("age", 18)
    
    //ge 大于等于 >=
    ge(R column, Object val)
    ge(boolean condition, R column, Object val)	
    ge("age", 18) //age >= 18   
    
  • ltle:等同于SQL中的 <<=

    //lt 小于 <
    lt(R column, Object val)
    lt(boolean condition, R column, Object val)	
    //SELECT * FROM 表名 WHERE age < 18
    lt("age", 18) 
    
    //le 小于等于 <=
    le(R column, Object val)
    le(boolean condition, R column, Object val)
    //SELECT * FROM 表名 WHERE age <= 18
    le("age", 18)
    
  • betweennotBetween:等同于SQL中的区间 between andnot between and

    //between 值1 AND 值2
    between(R column, Object val1, Object val2)
    between(boolean condition, R column, Object val1, Object val2) 
    //SELECT * FROM 表名 WHERE age between 18 and 30
    between("age", 18, 30)
    
    //notBetween 值1 AND 值2
    notBetween(R column, Object val1, Object val2)
    notBetween(boolean condition, R column, Object val1, Object val2)
    //SELECT * FROM 表名 WHERE age not between 18 and 30
    notBetween("age", 18, 30)
    
  • innotIn:等同于SQL中的 IN(…)NOT IN(…)

    // in(value.get(0), value.get(1), ...)
    in(R column, Collection<?> value)
    in(boolean condition, R column, Collection<?> value)    
    //SELECT * FROM 表名 WHERE age in (1,2,3)
    in("age",{1,2,3})
    
    //IN (v0, v1, ...)
    in(R column, Object... values)
    in(boolean condition, R column, Object... values)	
    //SELECT * FROM 表名 WHERE age in (1,2,3)
    in("age", 1, 2, 3)
    
    notIn(R column, Collection<?> value)
    notIn(boolean condition, R column, Collection<?> value)
    //SELECT * FROM 表名 WHERE //age not in (1,2,3)
    notIn("age",{1,2,3}) 
    
    notIn(R column, Object... values)
    notIn(boolean condition, R column, Object... values)
    //SELECT * FROM 表名 WHERE age not in (1,2,3)
    notIn("age", 1, 2, 3) 
    

2.3、模糊查询

  • likenotLike:等同于SQL中的 %值%NOT LIKE '%值%

    //like'%值%'
    like(R column, Object val)
    like(boolean condition, R column, Object val)
    //SELECT * FROM 表名 WHERE name like '%王%'
    like("name", "王")
    
    //not like '%值%'
    notLike(R column, Object val)
    notLike(boolean condition, R column, Object val)
    //SELECT * FROM 表名 WHERE name not like '%王%'
    notLike("name", "王")
    
  • likeLeftlikeRight:等同于SQL中的 LIKE ‘%值’LIKE '值%'

    //like '%值'
    likeLeft(R column, Object val)
    likeLeft(boolean condition, R column, Object val)
    //SELECT * FROM 表名 WHERE name like '%王'
    likeLeft("name", "王")
    
    //LIKE '值%'
    likeRight(R column, Object val)
    likeRight(boolean condition, R column, Object val)
    //SELECT * FROM 表名 WHERE name like '王%'
    likeRight("name", "王")
    
    
  • isNullisNotNull:等同于SQL中的 IS NULLIS NOT NULL

    //is null
    isNull(R column)
    isNull(boolean condition, R column)    
    isNull("name") //name is null
    
    //is not null
    isNotNull(R column)
    isNotNull(boolean condition, R column)
    isNotNull("name") //name is not null
    
  • inSqlnotInSql:等同于SQL中的 子查询 in子查询 not in

    inSql(R column, String inValue)
    inSql(boolean condition, R column, String inValue)	
    inSql("age", "1,2,3,4,5,6") //age in (1,2,3,4,5,6)
    inSql("id", "select id from table where id < 3") //id in (select id from table where id < 3)
    
    notInSql(R column, String inValue)
    notInSql(boolean condition, R column, String inValue)
    notInSql("age", "1,2,3,4,5,6") //age not in (1,2,3,4,5,6)
    notInSql("id", "select id from table where id < 3") //id not in (select id from table where id < 3)
    

2.4、分组

  • groupBy:等同于SQL中的 group By
    groupBy(R... columns)
    groupBy(boolean condition, R... columns)
    //SELECT * FROM 表名 GROUP BY id,name
    groupBy("id", "name")
    
  • having:等同于SQL中的 having
    having(String sqlHaving, Object... params)
    having(boolean condition, String sqlHaving, Object... params)
    //SELECT * FROM 表名 GROUP BY XXX HAVING sum(age) > 10
    having("sum(age) > 10")
    //SELECT * FROM 表名 GROUP BY XXX HAVING sum(age) > 11
    having("sum(age) > {0}", 11)
    

2.5、排序

  • orderByAscorderByDesc:等同于SQL中的 ORDER BY 字段, … ASCORDER BY 字段, … DESC
    orderByAsc(R... columns)
    orderByAsc(boolean condition, R... columns)
    //SELECT * FROM 表名 ORDER BY id ASC,name ASC
    orderByAsc("id", "name")
    
    orderByDesc(R... columns)
    orderByDesc(boolean condition, R... columns)
    //SELECT * FROM 表名 ORDER BY id DESC,name DESC
    orderByDesc("id", "name")
    
  • orderBy:等同于SQL中的 ORDER BY 字段, …
    //参数 isAsc 表示是否是 asc 排序,为 true 表示是进行 asc 排序
    orderBy(boolean condition, boolean isAsc, R... columns)
    //SELECT * FROM 表名 ORDER BY id ASC,name ASC
    orderBy(true, true, "id", "name")
    

2.6、逻辑查询

  • or:有两种用法,一种凭借,一种嵌套。主动调用 or 表示紧接着下一个方法不是用 and 连接(不调用 or 则默认为使用 and 连接)
    //主动调用or表示紧接着下一个方法不是用and连接
    //拼接 or
    or()
    or(boolean condition)    
    //SELECT * FROM 表名  WHERE id = 1 or name = '老王'
    eq("id",1).or().eq("name","老王")
    
    //嵌套 or
    or(Consumer<Param> consumer)
    or(boolean condition, Consumer<Param> consumer)
    //SELECT * FROM 表名  WHERE XXX OR (name = '李白' and status <> '活着')
    or(i -> i.eq("name", "李白").ne("status", "活着"))
    
  • and:AND 嵌套
    and(Consumer<Param> consumer)
    and(boolean condition, Consumer<Param> consumer)
    //SELECT * FROM 表名  WHERE XXX and (name = '李白' and status <> '活着')
    and(i -> i.eq("name", "李白").ne("status", "活着"))
    
  • nested:正常嵌套 不带 AND 或者 OR
    nested(Consumer<Param> consumer)
    nested(boolean condition, Consumer<Param> consumer)
    //SELECT * FROM 表名  WHERE (name = '李白' and status <> '活着')
    nested(i -> i.eq("name", "李白").ne("status", "活着"))--->(name = '李白' and status <> '活着')
    
  • apply:拼接 SQL,该方法可用于数据库函数动态入参。
    //参数 params 对应 applySql内部的{index}部分
    apply(String applySql, Object... params)
    apply(boolean condition, String applySql, Object... params)
    apply("id = 1") //id = 1
    apply("date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")//date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")
    aepply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2008-08-08")//date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")
    
  • last:无视优化规则直接拼接到 sql 最后,只能调用一次,多次调用以最后一次为准,会造成 sql 注入问题。
    last(String lastSql)
    last(boolean condition, String lastSql)
    //SELECT * FROM 表名  LIMIT 1
    last("limit 1") 
    

3、QueryWrapper

QueryWrapper 类继承于 AbstractWrapper 抽象类,QueryWrapper 还定义了唯一一个方法select,这个方法主要用于查询语句设置查询字段。

select(String... sqlSelect)
// SELECT id,name,age FROM 表名
select("id", "name", "age")
//后面两个方法是过滤查询字段(主键除外)
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)

4、UpdateWrapper

UpdateWrapper 类继承于 AbstractWrapper 抽象类,UpdateWrapper主要用于在更新操作时。

  • set:设置需要更新的字段和其属性
    set(String column, Object val)
    set(boolean condition, String column, Object val)
    
  • setSql:直接填入 SET 部分的 SQL
    setSql(String sql)
    
  • 1
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Mybatis-Plus条件构造器是一种方便的查询条件构造工具,可以通过链式调用的方式构造出复杂的查询条件。它支持多种查询条件,包括等于、不等于、大于、小于、模糊查询等,还可以通过Lambda表达式来构造查询条件,使得代码更加简洁易懂。同时,Mybatis-Plus条件构造器还支持分页查询、排序等功能,可以满足大部分的查询需求。 ### 回答2: Mybatis-Plus 是一款增强 Mybatis 功能的开发包,它提供了很多便捷的操作方式以简化 Mybatis 的开发,其中条件构造器就是其中之一。 Mybatis-Plus条件构造器能够帮助我们构建查询条件,使我们省去了手写 SQL 语句的烦恼。在使用条件构造器之前,我们需要先导入依赖包。 下面是条件构造器的创建方式: Wrapper wrapper = new WrapperBuilder().and("name={0}", "Lucy").and("age>{0}", 18).build(); 其中,WrapperBuilder 是构造器的构建工具类,and() 方法用于添加多个条件。构建条件之后,我们可以将条件传递给 Mybatis-Plus 的查询方法进行查询操作。 除了上述的构建方式,条件构造器还支持 QueryWrapper、UpdateWrapper 和 LambdaQueryWrapper 等多种构建方式,不同的构建方式可以满足不同的查询需求。 使用 Mybatis-Plus条件构造器,我们可以通过灵活的组合多个查询条件,快速地构建满足我们需求的 SQL 语句。同时,在实际使用过程中,我们还需要注意一些常见的使用技巧: 1. 使用占位符。在构建 SQL 语句时,我们需要使用占位符来避免 SQL 注入的风险。 2. 处理字段映射。在使用条件构造器时,需要注意数据库表名和实体类属性名之间的映射关系。如果两者不一致,需要进行处理。 3. 处理关联表查询。当我们需要查询多张表时,需要通过关联查询的方式来完成,并且需要处理好关系的映射。 总之,Mybatis-Plus条件构造器能够为我们节约很多时间和精力。当然,在使用时需要注意一些使用技巧,以便更好地发挥它的能力。 ### 回答3: MyBatis-Plus是一个基于MyBatis的增强工具,为MyBatis提供了更加便捷、高效的持久层操作方式。它的条件构造器是其中一个功能强大的组件,用于链式构建SQL查询条件,无需手动拼接SQL语句,提高了代码可读性和可维护性。 条件构造器提供了多种查询方式,包括等于、大于、小于、in、between、like等,可以满足大部分的查询需求。我们可以通过Lambda表达式来指定查询条件,这种方式比传统的字符串拼接更加安全、可读,可以少写一些防注入的代码。 MyBatis-Plus条件构造器还支持分页查询,可以通过Page对象指定当前页码、每页显示数量等,方便地实现分页查询。同时,条件构造器也支持排序、自定义SQL片段等功能,使得查询功能更加多样化和灵活。 除了条件构造器MyBatis-Plus还提供了其他很多方便的功能,例如注解式CRUD、自动代码生成等。相信在项目开发中使用MyBatis-Plus可以极大地提高开发效率和代码质量,使得持久层操作更加简洁、优雅。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值