MybatisPlus快速学习

最新推荐文章于 2024-05-26 17:53:24 发布

追阿

最新推荐文章于 2024-05-26 17:53:24 发布

阅读量457

点赞数

文章标签：学习 mybatis 数据库

本文链接：https://blog.csdn.net/qq_45043813/article/details/126918463

版权

MybatisPlus

一、快速开始

①创建数据库和表

CREATE DATABASE `mybatis_plus` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
use `mybatis_plus`;
CREATE TABLE `user` (
`id` bigint(20) NOT NULL COMMENT '主键ID',
`name` varchar(30) DEFAULT NULL COMMENT '姓名',
`age` int(11) DEFAULT NULL COMMENT '年龄',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

②搭建springboot环境

③导入依赖

<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.1</version>
</dependency>

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>

④配置数据源

spring:
    # 配置数据源信息
    datasource:
      #配置数据源
      type: com.zaxxer.hikari.HikariDataSource
      #配置连接数据库的各个信息
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql//localhost:3306/mybatis_plus?characterEncoding=utf-8&userSSL=false
      username: root
      password: root
# 添加mybatisPlus日志
mybatis-plus:
   configuration:
     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl 
  #  设置Mybatis-plus的全局配置
   global-config:
     db-config:
      # 设置实体类读取表的前缀
       table-prefix: yhq_

二、基本CRUD

1.BaseMapper

Mybatis-plus中的基本CRUD在内置的BaseMapper中都已经实现，我们可以直接使用，接口如下：

/**
* 插入一条记录 
* @param entity 实体对象 
*/
int insert(T entity);
/**
* 根据 ID 删除 
* @param id 主键ID 
*/
int deleteById(Serializable id);
/**
* 根据实体(ID)删除 
* @param entity 实体对象 
* @since 3.4.4 
*/
int deleteById(T entity);

/**
* 根据columnMap条件删除记录
* @param columnMap 表字段 map 对象
*/
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
@Test 
public void testDeleteByMap(){ 
    //根据map集合中所设置的条件删除记录 
    //DELETE FROM user WHERE name = ? AND age = ? 
    Map<String, Object> map = new HashMap<>(); map.put("age", 23); 
    map.put("name", "张三"); 
    int result = userMapper.deleteByMap(map); 
    System.out.println("受影响行数："+result); }

/**
* 根据 entity 条件，删除记录 
* @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 删除（根据ID 批量删除） 
* @param idList 主键ID列表(不能为 null 以及 empty) 
*/
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
例子：
@Test 
public void testDeleteBatchIds(){ 
    //通过多个id批量删除 
    //DELETE FROM user WHERE id IN ( ? , ? , ? ) 
    List<Long> idList = Arrays.asList(1L, 2L, 3L); 
    int result = userMapper.deleteBatchIds(idList); 
    System.out.println("受影响行数："+result); 
}

/**
* 根据 ID 修改 该对象值
* @param entity 实体对象 
*/
int updateById(@Param(Constants.ENTITY) T entity);
@Test 
public void testUpdateById(){ 
    User user = new User(4L, "admin", 22, null); 
    //UPDATE user SET name=?, age=? WHERE id=? int result = userMapper.updateById(user); 
    System.out.println("受影响行数："+result); }

/**
* 根据 whereEntity 条件，更新记录 
* @param entity 实体对象 (set 条件值,可以为 null) 
* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句） 
*/
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
/**
* 根据 ID 查询 
* @param id 主键ID 
*/
T selectById(Serializable id);

/**
* 查询（根据ID 批量查询） 
* @param idList 主键ID列表(不能为 null 以及 empty) 
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
@Test 
public void testSelectBatchIds(){ 
    //根据多个id查询多个用户信息 
    //SELECT id,name,age,email FROM user WHERE id IN ( ? , ? ) 
    List<Long> idList = Arrays.asList(4L, 5L); 
    List<User> list = userMapper.selectBatchIds(idList); 				               list.forEach(System.out::println); }


/**
* 查询（根据 columnMap 条件） 
* @param columnMap 表字段 map 对象 
*/
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
@Test 
public void testSelectByMap(){ 
    //通过map条件查询用户信息 
    //SELECT id,name,age,email FROM user WHERE name = ? AND age = ? 
    Map<String, Object> map = new HashMap<>(); 
    map.put("age", 22); map.put("name", "admin"); 
    List<User> list = userMapper.selectByMap(map);                                     list.forEach(System.out::println); }

/**
* 根据 entity 条件，查询一条记录 
* <p>查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常 </p> 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) { 
    List<T> ts = this.selectList(queryWrapper); 
    if (CollectionUtils.isNotEmpty(ts)) { 
        if (ts.size() != 1) { 
            throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records"); 
        }
        return ts.get(0); 
    }
    return null; 
}
/**
* 根据 Wrapper 条件，查询总记录数 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
Long selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 entity 条件，查询全部记录 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
@Test 
public void testSelectList(){ 
    //查询所有用户信息 
    //SELECT id,name,age,email FROM user 
    List<User> list = userMapper.selectList(null);                                     list.forEach(System.out::println); }

/**
* 根据 Wrapper 条件，查询全部记录 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录 
* <p>注意： 只返回第一个字段的值</p> 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 entity 条件，查询全部记录（并翻页） 
* @param page 分页查询条件（可以为 RowBounds.DEFAULT） 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
<P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录（并翻页） 
* @param page 分页查询条件 * @param queryWrapper 实体对象封装操作类 
*/
<P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

三、常用注解

1、@TableName （表名和类名不一致）

Mybatis-Plus在确定操作的表时，由BaseMapper的泛型决定是哪一张数据表，即就是实体类型决定。且默认操作的表名和实体类型的类名一致。

①此注解用于解决实体类和数据库表名不一致时的问题，在实体类的类上使用@TableName(“数据库表名”)；

@TableName("yhq_user")
public class User {
    ...
}

②使用全局配置解决数据不一致的情况

mybatis-plus: 
  configuration: 
     # 配置MyBatis日志 
     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl 
  global-config: 
     db-config: 
       # 配置MyBatis-Plus操作表的默认前缀 
       table-prefix: t_

2、@Tableld (类中id不叫id)

MyBatis-Plus在实现CRUD时，会默认将id作为主键列，并在插入数据时，默认基于雪花算法的策略生成id。

a>问题：若实体类和表中表示主键的不是id，而是其他字段，例如uid，MyBatis-Plus会自动识别uid为主键列吗？

b>通过@TableId解决问题：在实体类中uid属性上通过@TableId将其标识为主键，即可成功执行SQL语句。

c>@TableId的value属性：若实体类中主键对应的属性为id，而表中表示主键的字段为uid，此时若只在属性id上添加注解@TableId，则抛出异常Unknown column ‘id’ in ‘field list’，即MyBatis-Plus仍然会将id作为表的主键操作，而表中表示主键的是字段uid此时需要通过@TableId注解的value属性，指定表中的主键字段，@TableId(“uid”)或@TableId(value=“uid”)；

d>@TableId的type属性：type属性用来定义主键策略。

常用的主键策略：

值	描述
IdType.ASSIGN_ID(默认)	基于雪花算法的策略生成数据id,与数据库id是否设置自增无关
IdType.AUTO	使用数据库的自增策略，注意，该类型请确保数据库设置了id自增,否则无效

配置全局主键策略：

mybatis-plus: 
  configuration: 
    # 配置MyBatis日志 
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl 
  global-config: 
    db-config: 
      # 配置MyBatis-Plus操作表的默认前缀 
      table-prefix: t_ 
      # 配置MyBatis-Plus的主键策略 
      id-type: auto

e>雪花算法：雪花算法是由Twitter公布的分布式主键生成算法，它能够保证不同表的主键的不重复性，以及相同表的主键的有序性。

**背景：**需要选择合适的方案去应对数据规模的增长，以应对逐渐增长的访问压力和数据量。数据库的扩展方式主要包括：业务分库、主从复制，数据库分表。

**数据库分表：**将不同业务数据分散存储到不同的数据库服务器，能够支撑百万甚至千万用户规模的业务，但如果业务继续发展，同一业务的单表数据也会达到单台数据库服务器的处理瓶颈。例如，淘宝的几亿用户数据，如果全部存放在一台数据库服务器的一张表中，肯定是无法满足性能要求的，此时就需要对单表数据进行拆分。

**垂直分表：**假设我们是一个婚恋网站，用户在筛选其他用户的时候，主要是用 age 和 sex 两个字段进行查询，而 nickname 和 description 两个字段主要用于展示，一般不会在业务查询中用到。description 本身又比较长，因此我们可以将这两个字段独立到另外一张表中，这样在查询 age 和 sex 时，就能带来一定的性能提升。

**水平分表：**水平分表适合表行数特别大的表，有的公司要求单表行数超过 5000 万就必须进行分表，这个数字可以作为参考，但并不是绝对标准，关键还是要看表的访问性能。对于一些比较复杂的表，可能超过 1000万就要分表了；而对于一些简单的表，即使存储数据超过 1 亿行，也可以不分表。但不管怎样，当看到表的数据量达到千万级别时，作为架构师就要警觉起来，因为这很可能是架构的性能瓶颈或者隐患。

水平分表相比垂直分表，会引入更多的复杂性，例如要求全局唯一的数据id该如何处理？

主键自增：

①以最常见的用户 ID 为例，可以按照 1000000 的范围大小进行分段，1 ~ 999999 放到表 1中，

1000000 ~ 1999999 放到表2中，以此类推。

②复杂点：分段大小的选取。分段太小会导致切分后子表数量过多，增加维护复杂度；分段太大可能会

导致单表依然存在性能问题，一般建议分段大小在 100 万至 2000 万之间，具体需要根据业务选取合适

的分段大小。

③优点：可以随着数据的增加平滑地扩充新的表。例如，现在的用户是 100 万，如果增加到 1000 万，

只需要增加新的表就可以了，原有的数据不需要动。

④缺点：分布不均匀。假如按照 1000 万来进行分表，有可能某个分段实际存储的数据量只有 1 条，而

另外一个分段实际存储的数据量有 1000 万条。

3、@TableField(名不同时，属性指定对应的字段)

如果实体类中的属性名和字段名不一致的情况，会出现什么问题呢？

**a>情况1：**若实体类中的属性使用的是驼峰命名风格，而表中的字段使用的是下划线命名风格

例如实体类属性userName，表中字段user_name
此时MyBatis-Plus会自动将下划线命名风格转化为驼峰命名风格
相当于在MyBatis中配置

b>情况2：

若实体类中的属性和表中的字段不满足情况1
例如实体类属性name，表中字段username
此时需要在实体类属性上使用@TableField(“username”)设置属性所对应的字段名

4、TableLogic（逻辑删除）

物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据
逻辑删除：假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录
使用场景：可以进行数据恢复

四、条件构造器和常用接口

1、wapper介绍

Wrapper ：条件构造抽象类，最顶端父类
- AbstractWrapper ：用于查询条件封装，生成 sql 的 where 条件
  - QueryWrapper ：查询条件封装
  - UpdateWrapper ： Update 条件封装
  - AbstractLambdaWrapper ：使用Lambda 语法
    - LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
    - LambdaUpdateWrapper ： Lambda 更新封装Wrapper

2、QueryWrapper

a>列1：组装查询条件

@Test 
public void test01(){ 
    //查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息 
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (username LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL) 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    queryWrapper.like("username", "a") .between("age", 20, 30) 
                .isNotNull("email"); 
    List<User> list = userMapper.selectList(queryWrapper); 
    list.forEach(System.out::println); }

b>例2：组装排序条件

@Test 
public void test02(){ 
    //按年龄降序查询用户，如果年龄相同则按id升序排列 
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 ORDER BY age DESC,id ASC 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    queryWrapper .orderByDesc("age") .orderByAsc("id"); 
    List<User> users = userMapper.selectList(queryWrapper); 
    users.forEach(System.out::println); }

c>例3：组装删除条件

@Test 
public void test03(){ 
    //删除email为空的用户 
    //DELETE FROM t_user WHERE (email IS NULL) 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    queryWrapper.isNull("email"); 
    //条件构造器也可以构建删除语句的条件 
    int result = userMapper.delete(queryWrapper); 
    System.out.println("受影响的行数：" + result); }

d>例4：条件的优先级

@Test 
public void test04() { 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    //将（年龄大于20并且用户名中包含有a）或邮箱为null的用户信息修改 
    //UPDATE t_user SET age=?, email=? WHERE (username LIKE ? AND age > ? OR email IS NULL) 
    queryWrapper .like("username", "a") .gt("age", 20) .or() .isNull("email"); 
    User user = new User(); 
    user.setAge(18); 
    user.setEmail("user@atguigu.com"); 
    int result = userMapper.update(user, queryWrapper); 
    System.out.println("受影响的行数：" + result); }

@Test 
public void test04() { 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    //将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改 
    //UPDATE t_user SET age=?, email=? WHERE (username LIKE ? AND (age > ? OR email IS NULL)) 
    //lambda表达式内的逻辑优先运算 
    queryWrapper.like("username", "a") .and(i -> i.gt("age", 20).or().isNull("email"));
    User user = new User(); 
    user.setAge(18); 
    user.setEmail("user@atguigu.com"); 
    int result = userMapper.update(user, queryWrapper); 
    System.out.println("受影响的行数：" + result); }

e>例5：组装select子句

@Test 
public void test05() { 
    //查询用户信息的username和age字段 
    //SELECT username,age FROM t_user 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    queryWrapper.select("username", "age"); 
    //selectMaps()返回Map集合列表，通常配合select()使用，避免User对象中没有被查询到的列值 为null
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper); 
    maps.forEach(System.out::println); }

f>例6：实现子查询

@Test 
public void test06() { 
    //查询id小于等于3的用户信息 
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (id IN (select id from t_user where id <= 3)) 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    queryWrapper.inSql("id", "select id from t_user where id <= 3"); 
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println); }

3、UpdateWrapper

@Test 
public void test07() { 
    //将（年龄大于20或邮箱为null）并且用户名中包含有a的用户信息修改 
    //组装set子句以及修改条件 UpdateWrapper<User> updateWrapper = new UpdateWrapper<>(); 
    //lambda表达式内的逻辑优先运算 
    updateWrapper .set("age", 18) .set("email", "user@atguigu.com") .like("username", "a") .and(i -> i.gt("age", 20).or().isNull("email")); 
    //这里必须要创建User对象，否则无法应用自动填充。如果没有自动填充，可以设置为null 
    //UPDATE t_user SET username=?, age=?,email=? WHERE (username LIKE ? AND (age > ? OR email IS NULL))
    //User user = new User(); 
    //user.setName("张三");
    //int result = userMapper.update(user, updateWrapper); 
    //UPDATE t_user SET age=?,email=? WHERE (username LIKE ? AND (age > ? OR email IS NULL)) 
    int result = userMapper.update(null, updateWrapper); System.out.println(result); }

4、condition

//方式一
@Test 
public void test08() { 
    //定义查询条件，有可能为null（用户未输入或未选择） 
    String username = null; 
    Integer ageBegin = 10; 
    Integer ageEnd = 24; 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace) 构成 
    if(StringUtils.isNotBlank(username)){ 
        queryWrapper.like("username","a"); 
    }if(ageBegin != null){ 
        queryWrapper.ge("age", ageBegin); 
    }if(ageEnd != null){ 
        queryWrapper.le("age", ageEnd); }
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (age >= ? AND age <= ?) 
    List<User> users = userMapper.selectList(queryWrapper); 
    users.forEach(System.out::println); } 

//方式二
@Test 
public void test08UseCondition() { 
    //定义查询条件，有可能为null（用户未输入或未选择） 
    String username = null; 
    Integer ageBegin = 10; 
    Integer ageEnd = 24; 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace) 构成 
    queryWrapper .like(StringUtils.isNotBlank(username), "username", "a")
        		.ge(ageBegin != null, "age", ageBegin) .le(ageEnd != null, "age", ageEnd); 
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (age >= ? AND age <= ?) 
    List<User> users = userMapper.selectList(queryWrapper); 
    users.forEach(System.out::println); }

5、LambdaQueryWrapper

@Test 
public void test09() { 
    //定义查询条件，有可能为null（用户未输入） 
    String username = "a"; 
    Integer ageBegin = 10; 
    Integer ageEnd = 24; 
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>(); 
    //避免使用字符串表示字段，防止运行时错误 
    queryWrapper .like(StringUtils.isNotBlank(username), User::getName, username) .ge(ageBegin != null, User::getAge, ageBegin) .le(ageEnd != null, User::getAge, ageEnd); 
    List<User> users = userMapper.selectList(queryWrapper); 
    users.forEach(System.out::println); }

6、LambdaUpdateWrapper

@Test 
public void test10() { 
    //组装set子句 
    LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>(); 
    updateWrapper .set(User::getAge, 18) .set(User::getEmail, "user@atguigu.com") .like(User::getName, "a") .and(i -> i.lt(User::getAge, 24).or().isNull(User::getEmail));
    //lambda 表达式内的逻辑优先运算 
    User user = new User(); int result = userMapper.update(user, updateWrapper); 
    System.out.println("受影响的行数：" + result); }

六、插件

1、分页插件 MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能

a>添加配置类

@Configuration 
@MapperScan("com.atguigu.mybatisplus.mapper") 
//可以将主类中的注解移到此处 
public class MybatisPlusConfig { 
    @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { 
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); 
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor; } 
}

b>测试

@Test 
public void testPage(){ 
    //设置分页参数 
    Page<User> page = new Page<>(1, 5); 
    userMapper.selectPage(page, null); 
    //获取分页数据 
    List<User> list = page.getRecords(); 
    list.forEach(System.out::println); 
    System.out.println("当前页："+page.getCurrent()); 
    System.out.println("每页显示的条数："+page.getSize());
    System.out.println("总记录数："+page.getTotal()); 
    System.out.println("总页数："+page.getPages()); 
    System.out.println("是否有上一页："+page.hasPrevious()); 
    System.out.println("是否有下一页："+page.hasNext()); }

2、xml自定义分页

a>UserMapper中定义接口方法

/**
* 根据年龄查询用户列表，分页显示 
* @param page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位 
* @param age 年龄 
* @return */ 
I Page<User> selectPageVo(@Param("page") Page<User> page, @Param("age") Integer age);

b>UserMapper.xml中编写SQL

<!--SQL片段，记录基础字段--> 
    <sql id="BaseColumns">id,username,age,email</sql> 
    <!--IPage<User> selectPageVo(Page<User> page, Integer age);--> 
    <select id="selectPageVo" resultType="User"> 
        SELECT <include refid="BaseColumns"></include> 
        FROM t_user WHERE age > # {age} 
	</select>

追阿

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
MybatisPlus快速学习

Wrapper ：条件构造抽象类，最顶端父类AbstractWrapper ：用于查询条件封装，生成 sql 的 where 条件QueryWrapper ：查询条件封装UpdateWrapper ： Update 条件封装AbstractLambdaWrapper ：使用Lambda 语法LambdaQueryWrapper ：用于Lambda语法使用的查询WrapperLambdaUpdateWrapper ： Lambda 更新封装Wrapper/**
复制链接

扫一扫