MyBatis-Plus

MyBatis-Plus最优持久化开发

一、MyBatis-Plus快速入门

1.1 MyBatis-Plus简介

MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window) 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

mybatis-plus总结：

  • 自动生成单表的CRUD功能
  • 提供丰富的条件拼接方式
  • 全自动ORM类型持久层框架

官方文档地址

1.2 快速入门

1.2.1 准备数据库

DROP TABLE IF EXISTS user;

CREATE TABLE user
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);


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');

1.2.2 导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
    </parent>
    <groupId>com.atguigu</groupId>
    <artifactId>springboot-starter-mybatis-plus-06</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>


    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        
        <!-- 测试环境 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        
        <!-- mybatis-plus  -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>

        <!-- 数据库相关配置启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!-- druid启动器的依赖  -->
       <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-3-starter</artifactId>
            <version>1.2.22</version>
        </dependency>

        <!-- 驱动类-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.28</version>
        </dependency>

    </dependencies>


    <!--    SpringBoot应用打包插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

1.2.3 配置文件和启动类

连接池配置：application.yaml

# 连接池配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      url: jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 控制台输出sql语句

启动类

@MapperScan("com.yue.mapper")
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class,args);
    }   
}

1.2.4 实体类和Mapper接口

实体类User.java(此处使用了 Lombok 简化代码）

import lombok.Data;
@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

UserMapper接口

// 必须继承 BaseMapper
public interface UserMapper extends BaseMapper<User> {}

继承mybatis-plus提供的基础Mapper接口，自带crud方法！

1.2.5 测试

@SpringBootTest //springboot下测试环境注解
public class SampleTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect() {
        System.out.println(("----- selectAll method test ------"));
        List<User> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);
    }
}

二、MyBatis-Plus核心功能

2.1 Mapper接口的CURD方法

通用 CRUD 封装BaseMapper (opens new window)接口， Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器! 内部包含常见的单表操作！

Inser方法

类型 参数名 描述
T entity 实体对象 
// 插入一条记录
// T 就是要插入的实体对象，默认主键生成策略为雪花算法
int insert(T entity);

实测

// 增
@Test
public void insert(){
    User user = new User();
    user.setAge(20);
    user.setName("张三");
    user.setEmail("test6@baomidou.com");
    // baseMapper提供的数据库插入方法
    int i = userMapper.insert(user);

}

Delete方法

类型 参数名 描述
Wrapper wrapper 实体对象封装操作类（可以为 null）
Collection<? extends Serializable> idList 主键 ID 列表(不能为 null 以及 empty)
Serializable id 主键 ID
Map<String, Object> columnMap 表字段 map 对象 
// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

// 根据 ID 删除
int deleteById(Serializable id);

// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

实测

// 删
@Test
public void delete(){

    // 根据主键id删除
    userMapper.deleteById(1798957637098815489L);

    // 根据条件 年龄age=20删除
    Map param = new HashMap();
    param.put("age",20);
    userMapper.deleteByMap(param);

    // wrapper条件封装对象，无限的封装对象
    // userMapper.delete(wrapper);
}

Upate方法

类型 参数名 描述
T entity 实体对象 (set 条件值,可为 null)
Wrapper updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句） 
// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, 
            @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);

// 根据 ID 修改  主键属性必须值
int updateById(@Param(Constants.ENTITY) T entity);

实测

// 改
@Test
public void update(){

    // 将id=1的年龄改为30
    User user = new User();
    user.setId(1L);
    user.setAge(30);
    // 相当于 update user set age=30 where id=1
    userMapper.updateById(user);

    // 将所有人的年龄改为20
    User user1 = new User();
    user1.setAge(20);
    userMapper.update(user1,null); // null没条件
}

Select方法

类型 参数名 描述
Serializable id 主键 ID
Wrapper queryWrapper 实体对象封装操作类（可以为 null）
Collection<? extends Serializable> idList 主键 ID 列表(不能为 null 以及 empty)
Map<String, Object> columnMap 表字段 map 对象
IPage page 分页查询条件（可以为 RowBounds.DEFAULT） 
// 根据 ID 查询
T selectById(Serializable id);

// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

实测

// 查
@Test
public void select(){

    User user = userMapper.selectById(1l);

    // 根据ID批量查询
    List<Long> ids = new ArrayList<>();
    ids.add(1l);
    ids.add(2L);
    userMapper.selectBatchIds(ids);
}

2.2 Service接口CRUD

通用 Service CRUD 封装IService (opens new window)接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆。

2.2.1 对比Mapper接口CRUD区别：

  • service添加了批量方法
  • service层的方法自动添加事务

2.2.2 使用Iservice接口方式

接口继承IService接口

public interface UserService extends IService<User> {}

类继承ServiceImpl实现类

ServiceImpl<mapper接口，实体类对象>

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService{}

save方法

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);

// 插入（批量）
boolean saveBatch(Collection<T> entityList);

// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);
类型 参数名 描述
T entity 实体对象
Collection entityList 实体对象集合
int batchSize 插入批次数量

saveOrUpdate方法

// TableId 注解属性值存在则更新记录，否插入一条记录
boolean saveOrUpdate(T entity);

// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);

// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);

// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

功能描述： 根据实体对象的主键 ID 进行判断，存在则更新记录，否则插入记录。

类型 参数名 描述
T entity 实体对象
Wrapper updateWrapper 实体对象封装操作类 UpdateWrapper
Collection entityList 实体对象集合
int batchSize 插入批次数量

remove方法

// 根据 queryWrapper 设置的条件，删除记录
boolean remove(Wrapper<T> queryWrapper);

// 根据 ID 删除
boolean removeById(Serializable id);

// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);

// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);
类型 参数名 描述
Wrapper queryWrapper 实体包装类 QueryWrapper
Serializable id 主键 ID
Map<String, Object> columnMap 表字段 map 对象
Collection<? extends Serializable> idList 主键 ID 列表

update方法

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);

// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);

// 根据 ID 选择修改
boolean updateById(T entity);

// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);

// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);
类型 参数名 描述
Wrapper updateWrapper 实体对象封装操作类 UpdateWrapper
T entity 实体对象
Collection entityList 实体对象集合
int batchSize 更新批次数量

2.3 分页查询实现

2.3.1 在启动类配置Mybatis-Plus分页插件PaginationInnerInterceptor

@MapperScan("com.yue.mapper")
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class,args);
    }
    
    // 将mybatis-plus插件加入到ioc容器中
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        // mybatis-plus的插件集合【分页插件，乐观锁插件等等】
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();

        // 分页插件
        mybatisPlusInterceptor.addInnerInterceptor(
            new PaginationInnerInterceptor(DbType.MYSQL));
        
        return mybatisPlusInterceptor;
    }
}

PaginationInnerInterceptor 提供了以下属性来定制分页行为：

属性名 类型 默认值 描述
overflow boolean false 溢出总页数后是否进行处理
maxLimit Long 单页分页条数限制
dbType DbType 数据库类型
dialect IDialect 方言实现类

2.3.2 使用分页查询

@Test
public void testPageQuery(){
    //设置分页参数 Page<>(页码, 页容量)
    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.3.3 自定义的mapper方法使用分页

// 使用这种
IPage<User> selectPageById(IPage<User> page, Integer id);

// 或者自定义分页类
MyPage selectPageVo(MyPage page);

// 或者返回 List
List<UserVo> selectPageVo(IPage<UserVo> page, Integer state);

UserMapper接口实现

<select id="selectPageById" resultType="xxx.xxx.xxx.User">
    SELECT * FROM user WHERE id > #{id}
</select>

测试

@Test
public void testQuick(){

    IPage page = new Page(1,2);

    userMapper.selectPageById(page,null);

    System.out.println("当前页码："+page.getCurrent()); // 页码
    System.out.println("每页显示的条数："+page.getSize()); // 页容量
    System.out.println("总记录数："+page.getTotal()); // 总条数
    System.out.println("总页数："+page.getPages());	// 总页数
}

2.4 条件构造器

2.4.1 条件构造器作用

可以构建灵活、高效的查询条件，而不需要手动编写复杂的 SQL 语句。它提供了许多方法来支持各种条件操作符，并且可以通过链式调用来组合多个条件。

2.4.2 条件构造器继承结构

条件构造器类结：

Wrapper ： 条件构造抽象类，最顶端父类

  • AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
    • QueryWrapper ： 查询/删除条件封装
    • UpdateWrapper ： 修改条件封装
    • AbstractLambdaWrapper ： 使用Lambda 语法
      • LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
      • LambdaUpdateWrapper ： Lambda 更新封装Wrapper

2.4.3 QueryWrapper组装条件

组装查询
// querywrapper 查询
@Test
public void test_select(){
    //查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息

    // 创建 QueryWrapper 实例
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();

    // SELECT * FROM user WHERE name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL
    // 条件，动态调用wrapper的方法实现sql拼接
    queryWrapper.like("name","a");
    queryWrapper.between("age",20,30);
    queryWrapper.isNotNull("email");

    // 链式调用
    queryWrapper.like("name","a")
        .between("age",20,30)
        .isNotNull("email");

    List<User> userList = userMapper.selectList(queryWrapper);
    userList.forEach(System.out::println);
}
组装排序
// querywrapper 排序
@Test
public void test_order(){
    // 按年龄降序查询用户，如果年龄相同则按id升序排列
    // SELECT * FROM user where ORDER BY age DESC,id ASC
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();

    queryWrapper.orderByDesc("age")
        .orderByAsc("id");
    List<User> userList = userMapper.selectList(queryWrapper);
    userList.forEach(System.out::println);
}
组装删除
// querywrapper 删除
@Test
public void test_delete(){
    //删除email为空的用户
    //DELETE FROM t_user WHERE (email IS NULL)
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();

    queryWrapper.isNull("email");
    int delete = userMapper.delete(queryWrapper);
    System.out.println("删除条数 = " + delete);
}
and和or关键字使用

默认使用and;

使用or()时必须紧跟它的后面

// querywrapper的 and和or关键字使用
@Test
public void test_and_or(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();

    //将年龄大于20并且用户名中包含有a或邮箱为null的用户信息修改
    //UPDATE user SET age=?, email=? WHERE name LIKE ? AND age > ? OR email IS NULL
    queryWrapper.gt("age",20)
        .like("name","a")
        .or()
        .isNull("email");

    List<User> userList = userMapper.selectList(queryWrapper);
    userList.forEach(System.out::println);
}
指定字段映射查询（selectMaps）
// querywrapper 指定字段查询
@Test
public void test_exactSelect(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //查询用户信息的username和age字段
    //SELECT name,age FROM user
    queryWrapper.select("name","age");
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    maps.forEach(System.out::println);
}
condition判断条件
// querywrapper condition判断条件
@Test
public void test_condition(){

    String name = "root";
    int age = 18; // int默认值为 0， Integer默认值为 NULL

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

    //判断条件拼接
    //当name不为null拼接等于, age > 1 拼接等于判断
    //方案1: 手动判断
    if (!StringUtils.isEmpty(name)){
        queryWrapper.eq("name",name);
    }
    if (age > 1){
        queryWrapper.eq("age",age);
    }

    //方案2: 拼接condition判断
    //每个条件拼接方法都condition参数,这是一个比较运算,为true追加当前条件!
    //eq(condition,列名,值)
    queryWrapper.eq(!StringUtils.isEmpty(name),"name",name)
        .eq(age>1,"age",age);
}

2.4.4 UpdateWrapper组装条件

注意：使用queryWrapper + 实体类形式可以实现修改，但是无法将字段值修改为null值！

@Test
public void testQuick2(){

    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    //将id = 3 的email设置为null, age = 18
    updateWrapper.eq("id",3)
            .set("email",null)  // set 指定列和结果
            .set("age",18);
    //如果使用updateWrapper 实体对象写null即可!
    int result = userMapper.update(null, updateWrapper);
    System.out.println("result = " + result);

}

2.4.5 LambdaQueryWrapper组装条件

LambdaQueryWrapper 使用了实体类的属性引用（例如 User::getName、User::getAge），而不是字符串来表示字段名，这提高了代码的可读性和可维护性。

QueryWrapper 示例代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John")
  .ge("age", 18)
  .orderByDesc("create_time")
  .last("limit 10");
List<User> userList = userMapper.selectList(queryWrapper);

LambdaQueryWrapper 示例代码：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.eq(User::getName, "John")
  .ge(User::getAge, 18)
  .orderByDesc(User::getCreateTime)
  .last("limit 10");
List<User> userList = userMapper.selectList(lambdaQueryWrapper);
  1. lambda表达式回顾

Lambda 表达式是 Java 8 引入的一种函数式编程特性，它提供了一种更简洁、更直观的方式来表示匿名函数或函数式接口的实现。Lambda 表达式可以用于简化代码，提高代码的可读性和可维护性。

Lambda 表达式的语法可以分为以下几个部分：

  • 参数列表： 参数列表用小括号 () 括起来，可以指定零个或多个参数。如果没有参数，可以省略小括号；如果只有一个参数，可以省略小括号。

    示例：(a, b), x ->, () ->

  • 箭头符号： 箭头符号 -> 分割参数列表和 Lambda 表达式的主体部分。

    示例：->

  • Lambda 表达式的主体： Lambda 表达式的主体部分可以是一个表达式或一个代码块。如果是一个表达式，可以省略 return 关键字；如果是多条语句的代码块，需要使用大括号 {} 括起来，并且需要明确指定 return 关键字。

    示例：

    • 单个表达式：x -> x * x
    • 代码块：(x, y) -> { int sum = x + y; return sum; }

Lambda 表达式的语法可以更具体地描述如下：

// 使用 Lambda 表达式实现一个接口的方法
interface Greeting {
    void sayHello();
}

public class LambdaExample {
    public static void main(String[] args) {
    
        //原始匿名内部类方式
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello(int a) {
                System.out.println("Hello, world!");
            }
        };
        
        a->System.out.println("Hello, world!")
        
        // 使用 Lambda 表达式实现接口的方法
        greeting = () -> System.out.println("Hello, world!");

          System.out::println;
           () ->  类.XXX(); -> 类::方法名
        // 调用接口的方法
        greeting.sayHello();
    }
}

3. 方法引用回顾:

方法引用是 Java 8 中引入的一种语法特性，它提供了一种简洁的方式来直接引用已有的方法或构造函数。方法引用可以替代 Lambda 表达式，使代码更简洁、更易读。

Java 8 支持以下几种方法引用的形式：

  1. 静态方法引用： 引用静态方法，语法为 类名::静态方法名。
  2. 实例方法引用： 引用实例方法，语法为 实例对象::实例方法名。
  3. 对象方法引用： 引用特定对象的实例方法，语法为 类名::实例方法名。
  4. 构造函数引用： 引用构造函数，语法为 类名::new。

2.4.6 LambdaUpdateWrapper组装条件

是在UpdateWrapper的基础上是使用Lambda的方法引用修改字段值为null

@Test
public void testQuick2(){

    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    //将id = 3 的email设置为null
    updateWrapper.eq("id",3)
            .set("email",null)  // set 指定列和结果
    //如果使用updateWrapper 实体对象写null即可!
    int result = userMapper.update(null, updateWrapper);
    System.out.println("result = " + result);

    //使用lambdaUpdateWrapper
    LambdaUpdateWrapper<User> updateWrapper1 = new LambdaUpdateWrapper<>();
    updateWrapper1.eq(User::getId,3)
            .set(User::getEmail,null)
        
    updateWrapper1.forEach(System.out::println);
}

2.5 核心注解使用

总结：

理解：BaseMapper接口—>User实体类—>实体类的名字—>表名数据库操作

@TableName

当数据库的表名和实体类命名不同（忽略大小写），可以使用@TableName。

@TableName("sys_user") //对应数据库表名
public class User {
    private Long id;
    private String name;
}

全局设置表名前缀：

mybatis-plus: # mybatis-plus的配置
  global-config:
    db-config:
      table-prefix: sys_ # 表名前缀字符串

@TableId

  • 描述：主键注解
  • 使用位置：实体类主键字段
@TableName("sys_user")
public class User {
    @TableId(value="主键列名",type=主键策略)
    private Long id;
    private String name;
}
属性 类型 必须指定 默认值 描述
value String 否 "" 主键字段名
type Enum 否 IdType.NONE 指定主键类型

IdType属性可选值：

值 描述
AUTO 数据库 ID 自增 (需mysql配置主键自增长)
ASSIGN_ID（默认） 分配 ID(主键类型为 Number(Long )或 String)(since 3.3.0),使用接口IdentifierGenerator的方法nextId(默认实现类为DefaultIdentifierGenerator雪花算法)

全局配置修改主键策略:

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

在以下场景下，添加@TableId注解是必要的：

  • 实体类的字段与数据库表的主键字段不同名：如果实体类中的字段与数据库表的主键字段不一致，需要使用@TableId注解来指定实体类中表示主键的字段。
  • 主键生成策略不是默认策略：如果需要使用除了默认主键生成策略以外的策略，也需要添加@TableId注解，并通过value属性指定生成策略。

  1. 雪花算法使用场景

    雪花算法（Snowflake Algorithm）是一种用于生成唯一ID的算法。它由Twitter公司提出，用于解决分布式系统中生成全局唯一ID的需求。

    在传统的自增ID生成方式中，使用单点数据库生成ID会成为系统的瓶颈，而雪花算法通过在分布式系统中生成唯一ID，避免了单点故障和性能瓶颈的问题。

    雪花算法生成的ID是一个64位的整数，由以下几个部分组成：

    1. 时间戳：41位，精确到毫秒级，可以使用69年。
    2. 节点ID：10位，用于标识分布式系统中的不同节点。
    3. 序列号：12位，表示在同一毫秒内生成的不同ID的序号。

    通过将这三个部分组合在一起，雪花算法可以在分布式系统中生成全局唯一的ID，并保证ID的生成顺序性。

    雪花算法的工作方式如下：

    1. 当前时间戳从某一固定的起始时间开始计算，可以用于计算ID的时间部分。
    2. 节点ID是分布式系统中每个节点的唯一标识，可以通过配置或自动分配的方式获得。
    3. 序列号用于记录在同一毫秒内生成的不同ID的序号，从0开始自增，最多支持4096个ID生成。

    需要注意的是，雪花算法依赖于系统的时钟，需要确保系统时钟的准确性和单调性，否则可能会导致生成的ID不唯一或不符合预期的顺序。

    雪花算法是一种简单但有效的生成唯一ID的算法，广泛应用于分布式系统中，如微服务架构、分布式数据库、分布式锁等场景，以满足全局唯一标识的需求。

    你需要记住的: 雪花算法生成的数字,需要使用Long 或者 String类型主键!!

@TableField

描述：字段注解（非主键）

属性 类型 必须指定 默认值 描述
value String 否 "" 数据库字段名
exist boolean 否 true 是否为数据库表字段 
@TableName("sys_user")
public class User {
    @TableId
    private Long id;
    @TableField("nickname")
    private String name;
}

三、Mybatis-plus高级扩展

3.1 逻辑删除实现

概念:

逻辑删除，可以方便地实现对数据库记录的逻辑删除而不是物理删除。逻辑删除是指通过更改记录的状态或添加标记字段来模拟删除操作，从而保留了删除前的数据，便于后续的数据分析和恢复。

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

逻辑删除实现:

  1. 数据库表添加逻辑删除字段

    可以是一个布尔类型、整数类型或枚举类型。

    ALTER TABLE USER ADD deleted INT DEFAULT 0 ;  # int 类型 1 逻辑删除 0 未逻辑删除

  2. 实体类添加逻辑删除属性

    单一指定

    @Data
public class User {

   // @TableId
    private Integer id;
    private String name;
    private Integer age;
    private String email;
    
    @TableLogic
    //逻辑删除字段 int mybatis-plus下,默认 逻辑删除值为1 未逻辑删除 1 
    private Integer deleted;
}

    全局指定

    mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: deleted # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

  3. 演示逻辑删除操作

    逻辑删除以后,没有真正的删除语句,删除改为修改语句!

    @SpringBootTest
public class TableLogicTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void test_tableLogic(){
		
        // 逻辑删除id为1的信息
        userMapper.deleteById(1);
		
        // 查询所有数据
        userMapper.selectList(null);
    }
}

    上面执行的删除语句实际上是修改deleted：

    UPDATE user SET deleted=1 WHERE id=? AND deleted=0

    查询的语句的条件变为deleted=0未删除状态：

    SELECT * FROM user WHERE deleted=0

3.2 乐观锁实现

3.2.1 悲观锁和乐观锁场景和介绍

并发问题场景演示:

**解决思路: **

乐观锁和悲观锁是在并发编程中用于处理并发访问和资源竞争的两种不同的锁机制!!

悲观锁：
悲观锁的基本思想是，在整个数据访问过程中，将共享资源锁定，以确保其他线程或进程不能同时访问和修改该资源。悲观锁的核心思想是"先保护，再修改"。在悲观锁的应用中，线程在访问共享资源之前会获取到锁，并在整个操作过程中保持锁的状态，阻塞其他线程的访问。只有当前线程完成操作后，才会释放锁，让其他线程继续操作资源。这种锁机制可以确保资源独占性和数据的一致性，但是在高并发环境下，悲观锁的效率相对较低。

乐观锁：
乐观锁的基本思想是，认为并发冲突的概率较低，因此不需要提前加锁，而是在数据更新阶段进行冲突检测和处理。乐观锁的核心思想是"先修改，后校验"。在乐观锁的应用中，线程在读取共享资源时不会加锁，而是记录特定的版本信息。当线程准备更新资源时，会先检查该资源的版本信息是否与之前读取的版本信息一致，如果一致则执行更新操作，否则说明有其他线程修改了该资源，需要进行相应的冲突处理。乐观锁通过避免加锁操作，提高了系统的并发性能和吞吐量，但是在并发冲突较为频繁的情况下，乐观锁会导致较多的冲突处理和重试操作。

理解点: 悲观锁和乐观锁是两种解决并发数据问题的思路,不是具体技术!!!

具体技术和方案:

  1. 乐观锁实现方案和技术：
    • 版本号/时间戳：为数据添加一个版本号或时间戳字段，每次更新数据时，比较当前版本号或时间戳与期望值是否一致，若一致则更新成功，否则表示数据已被修改，需要进行冲突处理。
    • CAS（Compare-and-Swap）：使用原子操作比较当前值与旧值是否一致，若一致则进行更新操作，否则重新尝试。
    • 无锁数据结构：采用无锁数据结构，如无锁队列、无锁哈希表等，通过使用原子操作实现并发安全。
  2. 悲观锁实现方案和技术：
    • 锁机制：使用传统的锁机制，如互斥锁（Mutex Lock）或读写锁（Read-Write Lock）来保证对共享资源的独占访问。
    • 数据库锁：在数据库层面使用行级锁或表级锁来控制并发访问。
    • 信号量（Semaphore）：使用信号量来限制对资源的并发访问。

介绍版本号乐观锁技术的实现流程:

  • 每条数据添加一个版本号字段version
  • 取出记录时，获取当前 version
  • 更新时，检查获取版本号是不是数据库当前最新版本号
  • 如果是[证明没有人修改数据], 执行更新, set 数据更新 , version = version+ 1
  • 如果 version 不对[证明有人已经修改了]，我们现在的其他记录就是失效数据!就更新失败

3.2.2 使用mybatis-plus数据使用乐观锁

  1. 添加版本号更新插件
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
    return interceptor;
}
  1. 乐观锁字段添加@Version注解

注意: 数据库也需要添加version字段

  • 支持的数据类型只有：int,Integer,long,Long,Date,Timestamp,LocalDateTime
  • 仅支持 updateById(id) 与 update(entity, wrapper) 方法
ALTER TABLE USER ADD VERSION INT DEFAULT 1 ;  # int 类型 乐观锁字段

在实体类添加version属性并添加@Vserion注解

@Version
private Integer version;
  1. 正常更新使用即可
//演示乐观锁生效场景
@Test
public void testQuick7(){
    //步骤1: 先查询,在更新 获取version数据
    //同时查询两条,但是version唯一,最后更新的失败
    User user  = userMapper.selectById(5);
    User user1  = userMapper.selectById(5);

    user.setAge(20);
    user1.setAge(30);

    userMapper.updateById(user); // 修改数据为20 -> version为2
    //乐观锁生效,失败!
    userMapper.updateById(user1); // 修改数据失败 -> version为1
}

3.3 防全表更新和删除实现

针对 update 和 delete 语句 作用: 阻止恶意的全表更新删除

添加防止全表更新和删除拦截器

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
  MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
  return interceptor;
}
}

测试全部更新或者删除

@Test
public void testQuick8(){
    User user = new User();
    user.setName("custom_name");
    user.setEmail("xxx@mail.com");
    //Caused by: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException: Prohibition of table update operation
    //全局更新,报错
    userService.saveOrUpdate(user,null);
}

四、MyBatis-Plus代码生成器（MyBatisX插件）

4.1 MyBatisX 插件逆向工程

MyBatis-Plus为我们提供了强大的mapper和service模板，能够大大的提高开发效率

img

image-20240608130338751

image-20240608130411143

4.2 MyBatisX 快速代码生成

使用mybatisX插件,自动生成sql语句实现

官方文档

posted @ 2024-06-09 13:10  粤先生  阅读(59)  评论(0)    收藏  举报