Mybatis-Plus中的查(select)和 Wrapper条件构造器-详解 V2.0

已于 2022-10-28 17:54:40 修改
阅读量1.1w 收藏 40
点赞数 10
分类专栏： Mybatis-Plus 文章标签： java mybatis
于 2022-08-07 10:33:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53437402/article/details/126206832
版权

 V1.0 已更新为 V-2.0  传送门→ （V-2.0）Mybatis-Plus中的查(select)和QueryWrapper条件构造器​​​​​​​

前言

         本文介绍 mybatis-plus 中查询方法 ( select ) 和 Wrapper 条件构造器的使用，目的 mapper  方法中对数据库的处理。代码中都用到了 Wrappers 类中的静态方法生成  LambdaQueryWrapper LambdaUpdateWrapper 。相比较 QueryWrapper，UpdateWrapper 前两者好处多多。

        如需了解 Wrappers 使用小技巧 请移步另一篇博客 →→→  Wrappers使用小技巧

1，selectOne()方法。

        根据 QueryWrapper 的条件 查询返回一条数据，查询出多条数据则报错。

 QueryWrapper<T> queryWrapper = new QueryWrapper<T>();
 User user = userMapper.selectOne(QueryWrapper < T > queryWrapper);

          SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address FROM user WHERE (id = ?)
==> Parameters: 13(Integer)
<==      Total: 0

2，selectList()方法。

         根据 QueryWrapper 的条件 查询返回多条数据(List<T> 集合)。

QueryWrapper<T> queryWrapper = new QueryWrapper<T>();
List<User> users = userMapper.selectList(QueryWrapper<T> queryWrapper);

        SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address FROM user WHERE (age > ?)
==> Parameters: 12(Integer)
<==    Columns: id, name, sex, age, address
<==        Row: 7, null, 男, 13, kks
<==        Row: 8, null, 男, 13, kks
<==      Total: 2

3，selectCount()方法。

        根据 QueryWrapper 的条件 查询返回总数据的条数。

QueryWrapper<T> queryWrapper = new QueryWrapper<T>();
Integer integer = userMapper.selectCount(QueryWrapper < T > queryWrapper);

         SQL 语句如下：

==>  Preparing: SELECT COUNT( * ) FROM user WHERE (age > ?)
==> Parameters: 12(Integer)
<==    Columns: COUNT( * )
<==        Row: 2
<==      Total: 1

4，selectMaps()方法。

        根据 QueryWrapper 的条件 查询返回多条数据(List<Map<String,Object>> ListMap集合)。        

QueryWrapper<T> queryWrapper = new QueryWrapper<T>();
List<Map<String, Object>> maps = userMapper.selectMaps(QueryWrapper < T > queryWrapper);

         SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address FROM user WHERE (age > ?)
==> Parameters: 12(Integer)
<==    Columns: id, name, sex, age, address
<==        Row: 7, null, 男, 13, kks
<==        Row: 8, null, 男, 13, kks
<==      Total: 2

{address=kks, sex=男, id=7, age=13}
{address=kks, sex=男, id=8, age=13}

5，selectByMap()方法。

         根据 columnMap 封装的条件 查询返回多条数据(List<T> 集合)。

Map<String, Object> columnMap = new HashMap<>();
columnMap.put("id", 7);
columnMap.put("sex", "男");
List<User> users = userMapper.selectByMap(Map<String, Object>columnMap);

        SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address FROM user WHERE sex = ? AND id = ?
==> Parameters: 男(String), 7(Integer)
<==    Columns: id, name, sex, age, address
<==        Row: 7, null, 男, 13, kks
<==      Total: 1

6，selectById()方法。

        根据传入的 id 进行查询 查询成功返回单条数据，否则返回 null

User user = userMapper.selectById(Serializable id);

        SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address FROM user WHERE id=?
==> Parameters: 7(Integer)
<==    Columns: id, name, sex, age, address
<==        Row: 7, null, 男, 13, kks
<==      Total: 1

7，selectBatchIds()方法。

        根据传入的 idList 集合 进行查询返回多条数据(List<T> 集合)。。

List<Integer> idList = new ArrayList<>();
idList.add(5);
idList.add(6);
List<User> users = userMapper.selectBatchIds(Collection<? extends Serializable> idList);

        SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address FROM user WHERE id IN ( ? , ? )
==> Parameters: 5(Integer), 6(Integer)
<==      Total: 0

8，selectPage()方法。

9，selectMapsPage()方法。

10，QueryWrapper  的使用。

  10.1， allEq() 方法。

                allEq( Map < String, Object > params ) 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 封装的条件 即便 map 参数的值为 null 仍然查询
Map<String, Object> map = new HashMap<>();
map.put("id", 7);
map.put("age", null);
queryWrapper.allEq(Map < String, Object > params);
List<User> users = userMapper.selectList(queryWrapper);

                SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address FROM user WHERE (id = ? AND age IS NULL)
==> Parameters: 7(Integer)
<==      Total: 0

                 allEq( Map < String, Object > params,boolean null2IsNull )

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
/**
* 封装的条件 map 参数的值为 null 自动忽略
*/
Map<String, Object> map = new HashMap<>();
map.put("id", 7);
map.put("age", null);
//  布尔值为 false 时自动忽略 map 参数值为空  true 时跟上边一样
queryWrapper.allEq(Map < String, Object > params,boolean null2IsNull);
List<User> users = userMapper.selectList(queryWrapper);

                SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address FROM user WHERE (id = ?)
==> Parameters: 7(Integer)
<==    Columns: id, name, sex, age, address
<==        Row: 7, null, 男, 13, kks
<==      Total: 1

  10.2， eq() 方法。        

                eq( String  column,Object val )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  多用于 判断单个字段值是否相等
        *  column：  数据库字段名
        *  val： 字段值
        * */
        .eq(User::getName,"张三")
        .eq(User::getSex,"男")
);

                SQL 语句如下： 

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (name = ? AND sex = ?)
==> Parameters: 张三(String), 男(String)
<==      Total: 0

                eq(boolean condition,String  column,0bject val)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件，如下图可以看出区别。     日常代码中可能需要此业务/(ㄒoㄒ)/~~

  10.3， ne() 方法。

                ne( String  column,Object val )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  不等于某个值
        *  column：  数据库字段名
        *  val： 字段值
        * */
        .ne(User::getName,"张三")
        .ne(User::getSex,"男")
);

                SQL 语句如下： 

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (name <> ? AND sex <> ?)
==> Parameters: 赵六(String), 男(String)
<==    Columns: id, name, sex, age, address, card
<==        Row: 29, 李四, 女, 33, 整修后是, null
<==        Row: 44, 王八蛋, 鬼怪, 0, 整修后是, 410482111
<==      Total: 2

                 ne(boolean condition,String  column,0bject val)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.4， gt() 方法。

                gt( String  column,Object val )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  大于某个值
        *  column：  数据库字段名
        *  val： 字段值
        * */
        .gt(User::getAge,100)
        .gt(User::getId,2)
);

                 SQL 语句如下： 

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age > ? AND id > ?)
==> Parameters: 100(Integer), 2(Integer)
<==      Total: 0

                gt(boolean condition,String  column,0bject val)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.5， ge() 方法。

                ge( String  column,Object val)

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  大于等于某个值
        *  column：  数据库字段名
        *  val： 字段值
        * */
        .ge(User::getAge,100)
        .ge(User::getId,2)
);

                 SQL 语句如下： 

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age >= ? AND id >= ?)
==> Parameters: 100(Integer), 2(Integer)
<==      Total: 0

                ge(boolean condition,String  column,0bject val)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.6， lt() 方法。

                lt( String column,Object val )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  小于某个值
        *  column：  数据库字段名
        *  val： 字段值
        * */
        .lt(User::getAge,100)
        .lt(User::getId,2)
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age < ? AND id < ?)
==> Parameters: 100(Integer), 2(Integer)
<==      Total: 0

                 lt(boolean condition,String  column,0bject val)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.7， le() 方法。

                le( String column,Object val )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  小于等于某个值
        *  column：  数据库字段名
        *  val： 字段值
        * */
        .le(User::getAge,100)
        .le(User::getId,2)
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age <= ? AND id <= ?)
==> Parameters: 100(Integer), 2(Integer)
<==      Total: 0

                le(boolean condition,String  column,0bject val)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.8， between() 方法。

                between( String column,Object val1,Object val2 )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  在某个区间内  闭区间 包含两头的数字
        *  column：  数据库字段名
        *  val1： 起始值
        *  val2： 终止值
        * */
        .between(User::getAge,100,200)
        .between(User::getId,2,20)
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age BETWEEN ? AND ? AND id BETWEEN ? AND ?)
==> Parameters: 100(Integer), 200(Integer), 2(Integer), 20(Integer)
<==      Total: 0

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

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.9， notBetween 方法。

                notBetween( String column,Object val1,Object val2 )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  不在某个区间内  闭区间 包含两头的数字
        *  column：  数据库字段名
        *  val1： 起始值
        *  val2： 终止值
        * */
        .notBetween(User::getAge,2,20)
        .notBetween(User::getId,28,200)
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age NOT BETWEEN ? AND ? AND id NOT BETWEEN ? AND ?)
==> Parameters: 2(Integer), 20(Integer), 28(Integer), 200(Integer)
<==      Total: 0

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

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.10， like() 方法。

                 like( String column,Object val )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  模糊查询  相当于 %XX%
        *  column：  数据库字段名
        *  val：    字段值
        * */
        .like(User::getAge, 1)
        .like(User::getCard,"上海")
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age LIKE ? AND card LIKE ?)
==> Parameters: %1%(String), %上海%(String)
<==      Total: 0

                like(boolean condition,String  column,Object val)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.11， notLike() 方法。

                notLike( String column,Object val )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  模糊查询  查询没有某个值
        *  column：  数据库字段名
        *  val：    字段值
        * */
        .notLike(User::getAge, 1)
        .notLike(User::getCard,"上海")
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age NOT LIKE ? AND card NOT LIKE ?)
==> Parameters: %1%(String), %上海%(String)
<==      Total: 0

                notLike(boolean condition,String  column,Object val)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.12，likeLeft() 方法。

                likeLeft( String column,Object val )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  左模糊查询  相当于  %XX
        *  column：  数据库字段名
        *  val：    字段值
        * */
        .likeLeft(User::getAge, 2)
        .likeLeft(User::getCard,"李")
);

                  SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age LIKE ? AND card LIKE ?)
==> Parameters: %2(String), %李(String)
<==      Total: 0

                likeLeft(boolean condition,String  column,Object val)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.13， likeRight() 方法。

                likeRight( String column,Object val )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  右模糊查询  相当于  XX%
        *  column：  数据库字段名
        *  val：    字段值
        * */
        .likeRight(User::getAge, 2)
        .likeRight(User::getName,"李")
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age LIKE ? AND name LIKE ?)
==> Parameters: 2%(String), 李%(String)
<==      Total: 0

                likeRight(boolean condition,String  column,Object val)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.14， isNull() 方法。

                isNull( String column )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  查询字段值为 null 的数据
        * */
        .isNull(User::getAge)
);

                  SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (age IS NULL)
==> Parameters: 
<==    Columns: id, name, sex, age, address, card
<==        Row: 28, 李1四, 男, null, 上海, 410482
<==      Total: 1

                isNull(boolean condition,String  column)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.15， isNotNull() 方法。

                isNotNull( String column )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  查询字段值为 null 的数据
        * */
        .isNotNull(User::getCard)
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (card IS NOT NULL)
==> Parameters: 
<==    Columns: id, name, sex, age, address, card
<==        Row: 28, 李1四, 男, null, 上海, 410482
<==      Total: 1

                isNotNull(boolean condition,String  column)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.16， in() 方法。

                in( String column,Object... values )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  column： 字段名
        *  values： 字段值  可变字符串
        * */
        .in(User::getId,"55","56")
);

                in( String column,Collection<?> coll ) 

List<String> coll = Arrays.asList("55", "56");
List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  column： 字段名
        *  values： 字段值  集合
        * */
        .in(User::getId, coll)
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (id IN (?,?))
==> Parameters: 55(String), 56(String)
<==    Columns: id, name, sex, age, address, card
<==        Row: 55, 赵六, 女, 33, 整修后是, null
<==        Row: 56, 赵六, 女, 33, 整修后是, null
<==      Total: 2

                in(boolean condition,String column,Object... values)

        和上二个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.17， notIn() 方法。

               notIn( String column,Collection<?> coll ) 

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  column： 字段名
        *  values： 字段值
        * */
        .notIn(User::getId, "55","56")
);

                 notIn( String column,Object... values )

List<String> coll = Arrays.asList("55", "56");
List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  column： 字段名
        *  values： 字段值 
        * */
        .notIn(User::getId, coll)
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user WHERE (id NOT IN (?,?))
==> Parameters: 55(String), 56(String)
<==    Columns: id, name, sex, age, address, card
<==        Row: 28, 李1四, 男, null, 上海, 410482
<==      Total: 1

                notIn(boolean condition,String column,Object... values)

        和上二个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.18， inSql() 方法。

                helpGuanWang

  10.19， notInSql() 方法。

                helpGuanWang

  10.20， groupBy() 方法。（待理解）

                groupBy( String... columns )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  分组函数 多和 having 一同使用
        *  columns： 字段名
        * */
        .groupBy(User::getSex)
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user GROUP BY sex
==> Parameters: 
<==    Columns: id, name, sex, age, address, card
<==        Row: 29, 李四, 女, 33, 整修后是, null
<==        Row: 28, 李1四, 男, null, 上海, 410482
<==        Row: 44, 王八蛋, 鬼怪, 0, 整修后是, 410482111
<==      Total: 3

                groupBy(boolean condition,String... columns)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.21， orderByAsc() 方法。

                orderbyAsc( String...  columns )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  升序排列   根据字段的顺序优先级
        *  columns： 字段名
        * */
        .orderByAsc(User::getId,User::getAge,User::getCard)
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user ORDER BY id ASC,age ASC,card ASC
==> Parameters: 
<==    Columns: id, name, sex, age, address, card
<==        Row: 28, 李1四, 男, 11, 上海, 410482
<==        Row: 29, 李四, 女, 33, 整修后是, null
<==      Total: 2

                 orderbyAsc(boolean condition,String... columns)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.22， orderByDesc() 方法。

                orderByDesc( String...  columns )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  降序排列   根据字段的顺序优先级
        *  columns： 字段名
        * */
        .orderByDesc(User::getId,User::getAge,User::getCard)
);

                  SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user ORDER BY id ASC,age ASC,card ASC
==> Parameters: 
<==    Columns: id, name, sex, age, address, card
<==        Row: 30, 李1四, 男, 11, 上海, 410482
<==        Row: 29, 李四, 女, 33, 整修后是, null
<==      Total: 2

                 orderByDesc(boolean condition,String... columns)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.23， orderBy() 方法。

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

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        * 参数一： 必须为 true 不然不用使用这个方法
        * 参数二： true 表示按照 asc 排序 false 表示按照 desc排序
        * 参数三： 排序的字段
        * */
        .orderBy(true,true,User::getId,User::getAge)
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user ORDER BY id ASC,age ASC
==> Parameters: 
<==    Columns: id, name, sex, age, address, card
<==        Row: 28, 李1四, 男, 11, 上海, 410482
<==      Total: 1

  10.24， having() 方法。

                having( String sqlHaving,Object... params )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        *  分组函数 多和 having 一同使用  having 第一个参数为 sql 语句 可以用 {0}{1}指定占位符，
        *  在后续参数中设置值
        */
        .groupBy(User::getAge,User::getSex)
        .having("age > {0} and sex ={1}",50,"女")
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user GROUP BY age,sex HAVING age > ? and sex =?
==> Parameters: 50(Integer), 女(String)
<==      Total: 0

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

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.25， or() 方法。

                helpGuanWang

  10.26， last() 方法。

                last( String lastSql )

List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
        /**
        * 只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用
        *  limit 从下标 0 开始 取 一条值
        * */
        .last("limit 0,2")
);

                 SQL 语句如下：

==>  Preparing: SELECT id,name,sex,age,address,card FROM user limit 0,2
==> Parameters: 
<==    Columns: id, name, sex, age, address, card
<==        Row: 28, 李1四, 男, 11, 上海, 410482
<==        Row: 29, 李四, 女, 33, 整修后是, null
<==      Total: 2

                 last(boolean condition,String lastSql)

        和上一个相比此方法多一个布尔值条件，用于条件的拼接，true 表示拼接此条件，false 表示不拼接此条件。     图解，看 eq 方法讲解即可。

  10.27， helpGuanWang 。

GrJava荏苒
关注
  • 10
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MybatisPlus条件构造器selectPage方法示例代码
04-22
MybatisPlus条件构造器selectPage方法示例代码
MyBatis-plus 模糊查询的使用
09-07
`QueryWrapper`是一个条件构造器，可以方便地构建复杂的查询条件。以下是如何使用`QueryWrapper`进行模糊查询的步骤： 1. 首先，你需要创建一个`QueryWrapper`实例，并指定你所操作的实体类。例如，如果你有一个名...
MyBatis-Plus 条件查询QueryWrapper、聚合函数的使用、Lambda条件查询、定义SQL、分页实现（PaginationInterceptor ）、更新和删除
最新发布
小石潭记丶
05-07 1052
<resource>-- xml放在java目录下--><includes>--指定资源的位置（xml放在resources下，可以不用指定）--><resource>
Mybatis-Plus：条件构造器select方法返回指定字段
a898712940的博客
07-29 6367
Mybatis-Plus：条件构造器select方法返回指定字段一：Mybatis-Plus 条件构造器select方法介绍二：实例实例一：查找薪水大于3500 名字里有“小”的 员工 （只显示编号和姓名）实例二：查找薪水大于3500 名字里有“小”的 员工 （排除出生日期和性别）实例三：查询每个部门的平均薪资 一：Mybatis-Plus 条件构造器select方法介绍 根据业务需求，有时候只需要返回特定的几个数据表字段，我们通过条件构造器的select方法可以指定； 还有一种情况，假如数据库字段很多的时
sql 中 exists和 in如何选择
znanj的博客
09-09 877
如果外部查询是“大”和内部查询是“小”，IN是一般效率比EXISTS好。 如果外部查询是“小”和内部查询是“大”，那么EXISTS是相当有效的。
MyBatisPlus总结
m0_60027772的博客
08-30 9505
需要合适的方案去应对数据规模的增长，以应对逐渐增长的访问压力和数据量业务分库、主从复制、数据库分表数据库分表的两种方式垂直分表水平分表//自定义接口：//mybatisplus提供的分页对象，必须为于第一个参数的位置//自定义配置文件sql//测试类//获取当前页数据//获取总记录数//获取总页数//是否有下一页//是否有上一页。...
MyabtisPlus（高级查询）
qq_45525848的博客
11-15 8900
mybatisplus查询基础使用
MyBatis-Plus
qq_49487356的博客
07-27 2428
MyBatis-Plus(简称MP)是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发、提高效率而生。
MyBatis-Plus（实用篇）
从基础到源码解析的学习记录
12-22 9214
Wrapper：条件构造抽象类，最顶端父类AbstractWrapper：用于查询条件封装，生成sql的where条件QueryWrapper：查询条件封装UpdateWrapper：update条件封装AbstractLambdaWrapper：使用Lambda语法LambdaQueryWrapper：用于Lambda语法使用的查询WrapperLambdaUpdateWrapper：用于Lambda语法更新WrapperUserMapper中定义接口方法。
详解MyBatis-Plus Wrapper条件构造器查询大全
08-24
MyBatis-Plus Wrapper 条件构造器查询大全是 MyBatis-Plus 框架中的一种强大查询功能，通过使用 Wrapper 条件构造器，可以实现复杂的查询操作。本文将通过示例代码，详细介绍 MyBatis-Plus Wrapper 条件构造器查询...
MyBatis-Plus入门+MyBatis-Plus文档手册 中文pdf高清版.rar
11-09
mybatis在持久层框架中还是比较火的，一般项目都是基于ssm。虽然mybatis可以直接在xml中...《MyBatis-Plus入门文档》主要介绍了MyBatis-Plus入门使用，以及关于mybatis-plus的更多介绍及特性，感兴趣的可以下载学习一下
Mybatis-Plus和Mybatis的区别详解
09-07
Mybatis和Mybatis-Plus是两个在Java开发中广泛使用的持久层框架，它们都致力于简化数据库操作。Mybatis-Plus是对Mybatis的扩展和增强，提供了更多的便利功能，旨在进一步提高开发效率。 **Mybatis** 是一个轻量级的...
MybatisPlus【SpringBoot】 5 条件构造器和常用接口 5.1 wrapper 介绍 & 5.2 QueryWrapper
谢谢你们的关注
10-22 577
MybatisPlus【SpringBoot】 5 条件构造器和常用接口 5.1 wrapper 介绍 & 5.2 QueryWrapper
MyBatis Plus的使用
weixin_42524843的博客
04-18 545
MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。官方文档 入门 初始化工程 通过Spring Initializr 初始化一个Spring Boot 的工程。版本选择2.2.1.RELEASE，MyBatis-Plus 版本选择3.0.5 两个要配对，不然会出问题。 引入依赖 <dependencies> <!-- spring boot --> .
MyBatisPlus——条件构造器之select细节
紫罗兰与海棠的博客
01-29 1710
在MP查询中，默认查询所有的字段，如果有需要也可以通过select方法进行指定字段 细节 使用select进行sql语句拼接时，不会识别在实体类中属性对应的操作。 当数据库表中的字段名与实体类对象属性名不一致时 ...
[转]MybatisPuls中QueryWrapper的select、update的用法
不正的博客
11-01 6685
以QueryWrapper和UpdateWrapper为例。
Mybatis-plus中自定义的sql语句调用QueryWrapper实现查询及分页IPage使用
热门推荐
shenshaoming的博客
09-21 9万+
一、引言 MP自带的条件构造器虽然很强大，有时候也避免不了写稍微复杂一点业务的sql，那...
mybatis-plus QueryWrapper条件查询器
08-15
MyBatis-Plus是一个为MyBatis框架提供增强功能的开源库，其中包含了QueryWrapper条件查询器。 QueryWrapper是MyBatis-Plus中提供的一个强大的条件构造器，它可以帮助我们使用更简洁的方式构建复杂的查询条件。 使用QueryWrapper进行条件查询时，我们可以通过链式调用的方式来添加各种条件，比如等于、不等于、大于、小于、模糊查询等等。下面是一个简单的示例： ```java QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.eq("age", 25) // 等于 .ne("name", "Tom") // 不等于 .gt("salary", 5000) // 大于 .lt("create_time", "2022-01-01") // 小于 .like("email", "@gmail.com"); // 模糊查询 List<User> userList = userMapper.selectList(queryWrapper); ``` 上述代码中，我们创建了一个QueryWrapper对象，并通过调用其中的方法来添加各种条件。最后，我们使用该QueryWrapper对象进行查询操作，得到满足条件的用户列表。 除了上述示例中使用到的方法，QueryWrapper还提供了很多其他的条件查询方法，可以根据具体需求选择使用。 希望以上信息对你有所帮助！如果有更多问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值