MyBatis-Plus(spring版)学习笔记

目录

• 前言
• 1 MyBatis-Plus简介
• • 1.1 简介
  • 1.2 特性
  • 1.3 支持数据库
  • 1.4 框架结构
  • 1.5 代码及文档地址
• 2 入门案例
• • 2.1 开发环境
  • 2.2 准备工作
  • • 2.2.1 创建maven工程并引入依赖
    • 2.2.2 物理建模:创建数据库及表
    • 2.2.3 逻辑建模：创建实体类
    • • [1] lombok插件的使用
      • [2] 创建实体类
    • 2.2.4 加入日志配置文件
  • 2.3 连接数据库
  • • 2.3.1 创建jdbc.properties
    • 2.3.2 创建Spring配置文件并完成测试所需配置
    • 2.3.3 创建junit测试类测试
  • 2.4 spring整合mybatis
  • • 2.4.1 创建mybatis的配置文件
    • 2.4.2 创建mapper接口
    • 2.4.3 创建mapper映射文件
    • 2.4.4 完善spring配置文件
    • 2.4.5 测试
  • 2.5 使用mybatisplus
  • • 2.5.1 修改spring配置文件
    • 2.5.2 修改mapper接口
    • 2.5.3 测试
• 3 基本的CRUD
• • 3.1 BaseMapper
  • 3.2 基于BaseMapper的测试
  • 3.3 通用service
  • • 3.3.1 IService
    • 3.3.2 创建service接口及实现类
    • 3.3.3 在spring配置文件中设置自动扫描service的包
    • 3.3.4 测试（查询总记录数和批量添加）
• 4 常用注解
• • 4.1 @TableName（类名与表名）
  • • 4.1.1 问题引出
    • 4.1.2 通过@TableName解决问题
    • 4.1.3 通过GlobalConfig解决问题
  • 4.2 @TableId（主键属性与表中字段）
  • • 4.2.1 问题引出
    • 4.2.2 通过@TableId解决问题
    • 4.2.3 @TableId的value属性
    • 4.2.4 @TableId的type属性
    • • [1] 配置全局主键策略：
    • 4.2.5 雪花算法
  • 4.3 @TableField（普通属性与表中字段）
  • • 4.3.1 情况1
    • 4.3.2 情况2
  • 4.4 @TableLogic（逻辑删除）
  • • 4.4.1 逻辑删除
    • 4.4.2 实现逻辑删除
    • • [1] 数据库中创建逻辑删除状态列，设置默认值为0
      • [2] 实体类中添加逻辑删除属性
      • [3] 测试
• 5 条件构造器和常用接口
• • 5.1 wapper介绍
  • 5.2 QueryWrapper
  • • 5.2.1 组装查询条件
    • 5.2.2 组装排序条件
    • 5.2.3 组装删除条件
    • 5.2.4 条件的优先级
    • 5.2.5 组装select子句
    • 5.2.6 实现子查询
  • 5.3 UpdataWrapper
  • 5.4 condition
  • 5.5 LambdaQueryWrapper
  • 5.6 LambdaUpdateWrapper
• 6 插件
• • 6.1 分页插件
  • • 6.1.1 添加配置
    • 6.1.2 测试
  • 6.2 xml自定义分页
  • • 6.2.1 UserMapper中定义接口方法
    • 6.2.2 UserMapper.xml中编写SQL
    • 6.2.3 测试
  • 6.3 乐观锁
  • • 6.3.1 场景
    • 6.3.2 乐观锁与悲观锁
    • 6.3.3 模拟修改冲突
    • • [1] 数据库中增加商品表
      • [2] 添加数据
      • [3] 创建product实体类
      • [4] 创建ProductMapper
      • [5] 测试
    • 6.3.4 乐观锁实现流程
    • 6.3.5 Mybatis-Plus实现乐观锁
    • • [1] 修改实体类
      • [2] 添加乐观锁插件配置
      • [3] 测试修改冲突
      • [4] 优化流程
• 7 通用枚举
• • 7.1 数据库表添加字段sex
  • 7.2 创建通用枚举类型
  • 7.3 配置扫描通用枚举
  • 7.4 测试
• 8 代码生成器
• • 8.1 引入依赖
  • 8.2 快速生成
• 9 MyBatisX插件
• • 9.1 安装插件
  • 9.2 功能
  • • 9.2.1 XML跳转
    • 9.2.2 快速生成代码
    • • [1]首先需要在datasource中进行配置
• 总结

前言

基于尚硅谷杨博超老师讲解的Mybtaisplus(spring版)的学习笔记。
windows系统下的mysql密码是：abc123。
项目地址

从github导入maven项目时，因为我们设置了ignore文件，所以在复制导入的时候，本地是没有src目录的，我们需要自己创建。即srcmainjava 和srcmainresources及srctestjava。

---

1 MyBatis-Plus简介 1.1 简介

1.2 特性

1.3 支持数据库

1.4 框架结构

工作原理：扫描实体类，通过反射抽取实体类中的属性，然后再分析我们要操作的表是谁？需要操作的实体类的属性是谁？也就是表中的字段是谁？然后再生成对应的sql语句，然后再注入到mybatis容器中。

1.5 代码及文档地址

2 入门案例 2.1 开发环境

以maven工程为例，以ssm整合为技术框架。

工具	版本
IDE	idea 2021.3
JDK	JDK1.8
MAVEN	maven 3.8.4
MySQL	MySQL5.7
Spring	5.3.1
MyBatis-Plus	3.4.3.4

---

2.2 准备工作 2.2.1 创建maven工程并引入依赖

新建一个maven工程。引入需要的依赖。
注意使用mybatis-plus代替mybatis和spring的依赖。
完整版依赖在项目地址中。此处的依赖仅仅只是为了先构建框架。

    4.0.0

    com.atguigu.ssm
    ssm-integration
    1.0-SNAPSHOT
    jar

    
        
        
            org.springframework
            spring-context
            ${spring.version}
        
        
        
            org.springframework
            spring-test
            ${spring.version}
        

        
        
            ch.qos.logback
            logback-classic
            1.2.3
        

        
        
            mysql
            mysql-connector-java
            5.1.3
        

        
        
            com.alibaba
            druid
            1.0.31
        

        
        
            org.junit.jupiter
            junit-jupiter-api
            5.7.0
            test
        

        
        
            org.projectlombok
            lombok
            1.16.16
        

        
        
            com.baomidou
            mybatis-plus
            3.4.3.4
        



    
    
        8
        8
        5.3.1
    

注意

1. MySQL5.7版本的url：
jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&useSSL=false

2. MySQL8.0版本的url：
jdbc:mysql://localhost:3306/mybatis_plus?
serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false

3. 否则运行测试用例报告如下错误：
java.sql.SQLException: The server time zone value 'Öйú±ê׼ʱ¼ä' is unrecognized orrepresents more

2.2.2 物理建模:创建数据库及表

2.2.3 逻辑建模：创建实体类 [1] lombok插件的使用

简化实体类开发，即我们不需要手动去创建有参和无参构造以及get和set方法还有tostring等。

我们只需要在类上加入注解：

然后重新进行编译之后就会自动帮助我们创建。
但是如果在一个类上写如此多的注解，我们可以使用一个Data注解来代替上面设置的5 个注解。

注意：data注解中不包括有参构造，但是新增了一个tostring方法，所以说相当于还是代替5个注解。

这个注解是我们使用最多的。

[2] 创建实体类

这里我们使用lombok插件简化实体类开发。

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

注意此处的id类型是Long类型，不要写成long类型，否则雪花算法不会实现。因为雪花算法要求就是Long。

2.2.4 加入日志配置文件

日志文件对于我们进行调试代码有很好的作用，我们可以使用日志配置文件进行更好的查询到异常问题所在。
注意：配置文件全部放在resources目录下。

logback.xml

    
    
    
    
        
            
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50}
                - %msg%n
        
    
    
    
        
    

    
    
    

---

2.3 连接数据库 2.3.1 创建jdbc.properties

在resources目录下创建jdbc.properties文件。

jdbc.username=root
jdbc.password=abc123
jdbc.url=jdbc:mysql://localhost:13306/mybatis_plus
jdbc.driver=com.mysql.jdbc.Driver

2.3.2 创建Spring配置文件并完成测试所需配置

因为目前我们只是先进行数据库连接的测试，所以我们需要配置的很少。只需要引入jdbc.properties文件和配置数据源既可。

spring-persist

2.3.3 创建junit测试类测试

测试类写法有两种。按自己喜好选择。

spring测试类写法1
//    //在spring的环境中进行测试
//@RunWith(SpringJUnit4ClassRunner.class)
指定spring的配置文件
//@ContextConfiguration("classpath:spring-persist.xml")


//spring测试类写法2
@SpringJUnitConfig(locations = {"classpath:spring-persist.xml"})
public class MyBatisPlusTest {

    @Autowired
    private DruidDataSource dataSource;

    Logger logger = LoggerFactory.getLogger(getClass());


    @Test
    public void getConn() throws SQLException {
        DruidPooledConnection connection = dataSource.getConnection();

        logger.debug(connection.toString());

    }

}

执行操作，测试成功。

2.4 spring整合mybatis 2.4.1 创建mybatis的配置文件

在resources下创建mybatis-config.xml。

注意此处不需要设置驼峰式命名，因为mybatisplus就是默认会转换为驼峰式命名。

驼峰式命名
包名：xxxyyyzzz
类名、接口名：XxxYyyZzz
变量名、方法名：xxxYyyZzz
常量名：XXX_YYY_ZZZ

2.4.2 创建mapper接口

public interface UserMapper  {
    

    List getAllUser();
}

2.4.3 创建mapper映射文件

    
    
        select id,name,age,email from user
    


 
2.4.4 完善spring配置文件 


    
    

    
    
        
        
        
        
    

    
    
        
        
        
        
//使用mybatisplus
public interface UserMapper extends BaseMapper {
  
}
 
 
 
BaseMapper是MyBatis-Plus提供的基础mapper接口，泛型为所操作的实体类型，其中包含
 CRUD的各个方法，我们的mapper继承了BaseMapper之后，就可以直接使用BaseMapper所提
 供的各种方法，而不需要编写映射文件以及SQL语句，大大的提高了开发效率
 
 
2.5.3 测试 
注意此时出现错误：
 
 
 
Caused by: java.lang.NoClassDefFoundError: org/springframework/dao/support/DaoSupport
 
 
原因：
 缺少 spring-jdbc 依赖
 
 
            org.springframework
            spring-jdbc
            ${spring.version}
        
 
在pom.xml中加入依赖后重新进行测试。
 
  @Autowired
    private UserMapper userMapper;

    //使用mybatisplus
    @Test
    public  void testMybatisPlus(){
        //根据id查询用户信息
        System.out.println(userMapper.selectById(1));
    }
 
测试通过。
 
3 基本的CRUD 
3.1 BaseMapper 
MyBatis-Plus中的基本CRUD在内置的BaseMapper中都已得到了实现，我们可以直接使用，接口如下：
 
 
 
 
 
 
 
 
3.2 基于BaseMapper的测试 
 	//插入
    @Test
    public void testInsert(){
	// INSERT INTO user  ( id, name, age, email )  VALUES  ( ?, ?, ?, ? )
        User user = new User(6,"张三",23,"zhangsan@126.com");

        int result = userMapper.insert(user);

        System.out.println("result="+result);

    }

    //删除
    @Test
    public void testDelete(){
     	 //根据Id删除用户
       	//DELETE FROM user WHERe id=?
      	int result = userMapper.deleteById(2L);

        //根据map集合删除
        //DELETE FROM user WHERe name = ? AND age = ?
        Map map = new HashMap<>();
        map.put("name","张三");
        map.put("age",23);
        int result = userMapper.deleteByMap(map);

        // 根据id批量删除
		// DELETE FROM user WHERe id IN ( ? , ? , ? )
        List list = Arrays.asList(1, 2, 3);

        int result = userMapper.deleteBatchIds(list);
        System.out.println("result="+result);
    }

    //修改
    @Test
    public void testUpdate(){
//        UPDATE user SET name=?, email=? WHERe id=?
        User user = new User();
        user.setId(4L);
        user.setName("李四");
        user.setEmail("lisi@atguigu.com");
        int result = userMapper.updateById(user);
        System.out.println("result="+result);
    }

    //查询
    @Test
    public void testSelect(){
        //根据Id查询用户
//        SELECT id,name,age,email FROM user WHERe id=?
	 	User user = userMapper.selectById(5L);
	 	System.out.println(user);

//        SELECT id,name,age,email FROM user WHERe id IN ( ? , ? , ? )
		List list = Arrays.asList(1, 2, 4);
		List users = userMapper.selectBatchIds(list);
		users.forEach(System.out::println);

        Map map = new HashMap<>();
        map.put("age",23);
        List users = userMapper.selectByMap(map);
        users.forEach(System.out::println);

    }
 
3.3 通用service 
说明:
 
通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行； remove 删除 ；list 查询集合 ；page 分页； 前缀命名方式区分 Mapper 层避免混淆，泛型 T 为任意实体对象。
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承Mybatis-Plus 提供的基类。
官网地址：https://baomidou.com/pages/49cc81/#service-crud-%E6%8E%A5%E5%8F%A3
 
3.3.1 IService 
MyBatis-Plus中有一个接口 IService和其实现类 ServiceImpl，封装了常见的业务层逻辑详情查看源码IService和ServiceImpl。
 
 
3.3.2 创建service接口及实现类 
UserServiceImpl
 
@Service
public class UserServiceImpl extends ServiceImpl implements UserService {

}
 
ServiceImpl泛型是mapper和实体类。当我们对于继承的userservice中方法无法满足业务需求的时候，我们可以让类继承serviceimpl这个类。
 
UserService
 
public interface UserService  extends IService {

}
 
 
 
注意：
 
 
UserService继承IService模板提供的基础功能
ServiceImpl实现了IService，提供了IService中基础功能的实现 ；若ServiceImpl无法满足业务需求，则可以使用自定的UserService定义方法，并在实现类中实现
 
 
3.3.3 在spring配置文件中设置自动扫描service的包 

    
 
3.3.4 测试（查询总记录数和批量添加） 
//测试service接口
    @Autowired
    private UserService userService;

    //总记录数
    @Test
    public void testGetCount(){
        long count = userService.count();
        System.out.println("总记录数："+count);
    }

    //批量添加
    //单个Insert语句循环i次完成批量添加
    @Test
    public void testAllInsert(){
        List list = new ArrayList<>();
        for (int i = 0; i < 100 ; i++) {
            User user = new User();
            user.setName("abc"+i);
            user.setAge(20+i);
            list.add(user);
        }
        boolean b = userService.saveBatch(list);
        System.out.println("b:"+b);
    }
 
错误：
 
 
 
Duplicate entry ‘0’ for key ‘PRIMARY’
 原因：发现了是数据库表设计不合理导致的；
 因为主键设置不能为空，因此默认是以"0"来进行填充的。因此在数据插入时数据的主键id值被0占据，但由于之前已经有数据了，id为“0”的索引已经被占，在使用就会报这个错误，因此我们只需要对表中的主键“id”设置成自增即可。
 
 
纠正：为什么会出现这个问题，是因为在创建实体类的时候id属性的类型写成long了，应该写成Long，不然雪花算法是不会实现的。
 大小写要注意啊。
 
4 常用注解 
4.1 @TableName（类名与表名） 
经过以上的测试，在使用MyBatis-Plus实现基本的CRUD时，我们并没有指定要操作的表，只是在Mapper接口继承BaseMapper时，设置了泛型User，而操作的表为user表。
 由此得出结论，MyBatis-Plus在确定操作的表时，由BaseMapper的泛型决定，即实体类型决定，且默认操作的表名和实体类型的类名一致。
 
4.1.1 问题引出 
若实体类类型的类名和要操作的表的表名不一致，会出现什么问题？
 我们将表user更名为t_user，测试查询功能程序抛出异常，Table ‘mybatis_plus.user’ doesn’t exist，因为现在的表名为t_user，而默认操作的表名和实体类型的类名一致，即user表。
 
 
4.1.2 通过@TableName解决问题 
在实体类类型上添加@TableName(“t_user”)，标识实体类对应的表，即可成功执行SQL语句。
 
 
4.1.3 通过GlobalConfig解决问题 
在开发的过程中，我们经常遇到以上的问题，即实体类所对应的表都有固定的前缀，例如t_或tbl_，此时，可以使用MyBatis-Plus提供的全局配置，为实体类所对应的表名设置默认的前缀，那么就不需要在每个实体类上通过@TableName标识实体类对应的表。
 在spring-persist.xml中的sqlsessionfactorybean处进行修改。
 
 
    
        
        
        
         
 
@Test
    public void test05(){
        //将用户名中包含王并且（年龄大于80或邮箱为null）的用户信息修改
        //当条件构造器中有and和or时，lambda中的条件优先执行
       // UPDATE t_user SET user_name=?, email=? WHERe is_deleted=0 AND (user_name LIKE ? AND (age > ? AND email IS NULL))
       //i 指的是条件构造器 
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.like("user_name","王")
                .and(i -> i.gt("age",80).isNull("email"));
        User user  = new User();
        user.setName("小红");
        user.setEmail("test@atguigu.com");
        int result = userMapper.update(user, queryWrapper);
        System.out.println("result:"+result);

    }
 
5.2.5 组装select子句 
	@Test
    public void test06(){
        //查询用户的用户名，年龄，邮箱信息
        //SELECT user_name,age,email FROM t_user WHERe is_deleted=0
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.select("user_name","age","email");
        List> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);
    }
 
 
5.2.6 实现子查询 
  @Test
    public void test07(){
        //查询id小于等于3的用户信息
        //SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERe is_deleted=0 AND (uid IN (select uid from t_user where uid <= 3))
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.inSql("uid","select uid from t_user where uid <= 3");
        List list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }
 
 
5.3 UpdataWrapper 
//

    @Test
    public void test08(){
        //将用户名中包含王并且（年龄大于80或邮箱为null）的用户信息修改
        //UPDATE t_user SET user_name=?,email=? WHERe is_deleted=0 AND (user_name LIKE ? AND (age > ? OR email IS NULL))
        //lambda 中消费者接口模型
        //updatewrapper可以直接设置查询条件和填充值。
        UpdateWrapper updateWrapper = new UpdateWrapper<>();
        updateWrapper.like("user_name","王")
                .and(i -> i.gt("age","80").or().isNull("email"));
        updateWrapper.set("user_name","小黑").set("email","abc@atguigu.com");
        userMapper.update(null,updateWrapper);
    }
 
5.4 condition 
在真正开发的过程中，组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的，因此我们在组装这些条件时，必须先判断用户是否选择了这些条件，若选择则需要组装该条件，若没有选择则一定不能组装，以免影响SQL执行的结果。
 方案1：
 
 @Test
    public void test09(){
        //接收到的浏览器的数据传输到服务器中
        String username= "";
        Integer ageBegin = 20;
        Integer ageEnd = 30;
        QueryWrapper queryWrapper = new QueryWrapper<>();
        //SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERe is_deleted=0 AND (age >= ? AND age <= ?)
        if(StringUtils.isNotBlank(username)){
            //isnotblank判断某个字符不为空字符串，不为null,不为空白符
            queryWrapper.like("user_name",username);
        }
        if(ageBegin != null){
            queryWrapper.ge("age",ageBegin);
        }
        if(ageEnd != null){
            queryWrapper.le("age",ageEnd);
        }
        List list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }

 
上面的实现方案没有问题，但是代码比较复杂，我们可以使用带condition参数的重载方法构建查询条件，简化代码的编写.
 
方案2：使用condition
 
    @Test
    public void test10(){
        //接收到的浏览器的数据传输到服务器中
        //SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERe is_deleted=0 AND (age >= ? AND age <= ?)
        String username= "";
        Integer ageBegin = 20;
        Integer ageEnd = 30;
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.like(StringUtils.isNotBlank(username),"user_name",username)
                .ge(ageBegin != null,"age",ageBegin)
                .le(ageEnd != null,"age",ageEnd);

        List list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);

    }
 
5.5 LambdaQueryWrapper 
 @Test
    public void test11(){
        //接收到的浏览器的数据传输到服务器中
        //SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERe is_deleted=0 AND (age >= ? AND age <= ?)
        //LambdaQueryWrapper防止字段名写错，可以使用函数式接口（User::getAge），来访问实体类中的某一个属性所对应的字段名。自动将其作为我们的条件。
        String username= "";
        Integer ageBegin = 20;
        Integer ageEnd = 30;
        LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(StringUtils.isNotBlank(username),User::getName,username)
                .ge(ageBegin != null,User::getAge,ageBegin)
                .le(ageEnd != null,User::getAge,ageEnd);

        List list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);

    }
 
5.6 LambdaUpdateWrapper 
 @Test
    public void test12(){
        //将用户名中包含王并且（年龄大于80或邮箱为null）的用户信息修改
        //UPDATE t_user SET user_name=?,email=? WHERe is_deleted=0 AND (user_name LIKE ? AND (age > ? OR email IS NULL))
        //lambda 中消费者接口模型
        //updatewrapper可以直接设置查询条件和设置修改的字段并设置值。不需要设置实体类。
        LambdaUpdateWrapper updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.like(User::getName,"王")
                .and(i -> i.gt(User::getAge,"80").or().isNull(User::getEmail));
        updateWrapper.set(User::getName,"小黑").set(User::getEmail,"abc@atguigu.com");
        userMapper.update(null,updateWrapper);
    }
 
6 插件 
6.1 分页插件 
6.1.1 添加配置 
 
    
        
        
        
         page,@Param("age") Integer age);


}
 
6.2.2 UserMapper.xml中编写SQL 

        
            select uid,user_name,age,email from t_user where age > #{age}
        

6.2.3 测试

  //测试xml自定义分页

    @Test
    public void testPageVo(){
        Page page = new Page<>(1,3);
        userMapper.selectPageVo(page,20);
        System.out.println("当前页："+page.getCurrent());
        System.out.println("每页显示的条数："+page.getSize());
        System.out.println("总记录数："+page.getTotal());
        System.out.println("是否有上一页："+page.hasPrevious());
        System.out.println("是否有下一页："+page.hasNext());

    }

6.3 乐观锁 6.3.1 场景

一件商品，成本价是80元，售价是100元。老板先是通知小李，说你去把商品价格增加50元。小李正在玩游戏，耽搁了一个小时。正好一个小时后，老板觉得商品价格增加到150元，价格太高，可能会影响销量。又通知小王，你把商品价格降低30元。
此时，小李和小王同时操作商品后台系统。小李操作的时候，系统先取出商品价格100元；小王也在操作，取出的商品价格也是100元。小李将价格加了50元，并将100+50=150元存入了数据库；小王将商品减了30元，并将100-30=70元存入了数据库。是的，如果没有锁，小李的操作就完全被小王的覆盖了。
现在商品价格是70元，比成本价低10元。几分钟后，这个商品很快出售了1千多件商品，老板亏1万多。

6.3.2 乐观锁与悲观锁

上面的故事，如果是乐观锁，小王保存价格前，会检查下价格是否被人修改过了。如果被修改过了，则重新取出的被修改后的价格，150元，这样他会将120元存入数据库。
如果是悲观锁，小李取出数据后，小王只能等小李操作完之后，才能对价格进行操作，也会保证最终的价格是120元。

6.3.3 模拟修改冲突 [1] 数据库中增加商品表

CREATE TABLE t_product
(
id BIGINT(20) NOT NULL COMMENT '主键ID',
NAME VARCHAr(30) NULL DEFAULT NULL COMMENT '商品名称',
price INT(11) DEFAULT 0 COMMENT '价格',
VERSION INT(11) DEFAULT 0 COMMENT '乐观锁版本号',
PRIMARY KEY (id)
);

[2] 添加数据

INSERT INTO t_product (id, NAME, price) VALUES (1, '外星人笔记本', 100);

[3] 创建product实体类

@Data
public class Product {
    private long id;
    private String name;
    private Integer price;
    private Integer version;
}

[4] 创建ProductMapper

public interface ProductMapper extends BaseMapper {
}

[5] 测试

@Test
    public void test01(){
        //小李查询商品价格
        Product productli = productMapper.selectById(1);
        System.out.println("小李查询的商品价格："+productli.getPrice());
        //小王查询商品价格
        Product productwang = productMapper.selectById(1);
        System.out.println("小王查询的商品价格："+productwang.getPrice());
        //小李将价格+50
        productli.setPrice(productli.getPrice() + 50);
        productMapper.updateById(productli);
        //小王将价格-30
        productwang.setPrice(productwang.getPrice() - 30);
        productMapper.updateById(productwang);
        //老板查询价格
        Product productlaoban = productMapper.selectById(1);
        System.out.println("老板查询的商品价格："+productlaoban.getPrice());
    }

6.3.4 乐观锁实现流程

• 数据库中添加version字段
• 取出记录时，获取当前version

SELECT id,name,price,version FROM product WHERe id=1

更新时，version + 1，如果where语句中的version版本不对，则更新失败

UPDATe product SET price=price+50, version=version + 1 WHERe id=1 AND
version=1

6.3.5 Mybatis-Plus实现乐观锁 [1] 修改实体类

@Data
public class Product {
    private long id;
    private String name;
    private Integer price;
    @Version  //表示乐观锁版本号字段
    private Integer version;
}

[2] 添加乐观锁插件配置

[3] 测试修改冲突

小李查询商品信息：
SELECT id,name,price,version FROM t_product WHERe id=?
小王查询商品信息：
SELECt id,name,price,version FROM t_product WHERe id=?
小李修改商品价格，自动将version+1
UPDATe t_product SET name=?, price=?, version=? WHERe id=? AND version=?
Parameters: 外星人笔记本(String), 150(Integer), 1(Integer), 1(Long), 0(Integer)
小王修改商品价格，此时version已更新，条件不成立，修改失败
UPDATE t_product SET name=?, price=?, version=? WHERe id=? AND version=?
Parameters: 外星人笔记本(String), 70(Integer), 1(Integer), 1(Long), 0(Integer)
最终，小王修改失败，查询价格：150
SELECT id,name,price,version FROM t_product WHERe id=?

[4] 优化流程

@Test
    public void test01(){
        //小李查询商品价格
        Product productli = productMapper.selectById(1);
        System.out.println("小李查询的商品价格："+productli.getPrice());
        //小王查询商品价格
        Product productwang = productMapper.selectById(1);
        System.out.println("小王查询的商品价格："+productwang.getPrice());
        //小李将价格+50
        productli.setPrice(productli.getPrice() + 50);
        productMapper.updateById(productli);
        //小王将价格-30
        productwang.setPrice(productwang.getPrice() - 30);
        int result = productMapper.updateById(productwang);
        if(result == 0){
            //操作失败，重新尝试
            Product productNew = productMapper.selectById(1);
            productNew.setPrice(productNew.getPrice() - 30);
            productMapper.updateById(productNew);
        }
        //老板查询价格
        Product productlaoban = productMapper.selectById(1);
        System.out.println("老板查询的商品价格："+productlaoban.getPrice());
    }

7 通用枚举

通用枚举表中的有些字段值是固定的，例如性别（男或女），此时我们可以使用MyBatis-Plus的通用枚举来实现。

7.1 数据库表添加字段sex

7.2 创建通用枚举类型

@Getter
public enum SexEnum {
    MALE(1,"男"),
    FEMALE(2,"女");

    @EnumValue //将注解标识的属性加入到数据库中
    private Integer sex;
    private String sexName;

    SexEnum(Integer sex, String sexName) {
        this.sex = sex;
        this.sexName = sexName;
    }
}

7.3 配置扫描通用枚举

配置扫描通用枚举

7.4 测试

  //测试Enum

    @Test
    public void testEnum(){
        User user = new User();
        user.setName("admin");
        user.setAge(33);
        user.setSex(SexEnum.MALE);
        int result = userMapper.insert(user);
        System.out.println(result);
    }

8 代码生成器 8.1 引入依赖

        
            com.baomidou
            mybatis-plus-generator
            3.5.1
        
        
        
            org.freemarker
            freemarker
            2.3.31
        

8.2 快速生成

创建一个类：FastAutoGeneratorTest

public class FastAutoGeneratorTest {
    public static void main(String[] args) {
        FastAutoGenerator.create("jdbc:mysql://127.0.0.1:13306/mybatis_plus",
                "root", "abc123")
                .globalConfig(builder -> {
                    builder.author("atguigu") // 设置作者
//.enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .outputDir("E://javacode//mybatis_plus"); // 指定输出目录
                })
                .packageConfig(builder -> {
                    builder.parent("com.atguigu") // 设置父包名
                            .moduleName("mybatisplus") // 设置父包模块名
                            .pathInfo(Collections.singletonMap(OutputFile.mapperXml, "E://javacode//mybatis_plus"));
// 设置mapperXml生成路径
                })
                .strategyConfig(builder -> {
                    builder.addInclude("t_user") // 设置需要生成的表名
                            .addTablePrefix("t_", "c_"); // 设置过滤表前缀
                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();
    }
}

9 MyBatisX插件

MyBatis-Plus为我们提供了强大的mapper和service模板，能够大大的提高开发效率
但是在真正开发过程中，MyBatis-Plus并不能为我们解决所有问题，例如一些复杂的SQL，多表联查，我们就需要自己去编写代码和SQL语句，我们该如何快速的解决这个问题呢，这个时候可以使用MyBatisX插件。
MyBatisX一款基于 IDEA 的快速开发插件，为效率而生。

MyBatisX插件用法：https://baomidou.com/pages/ba5b24/

9.1 安装插件

安装方法：打开 IDEA，进入 File -> Settings -> Plugins -> Browse Repositories，输入 mybatisx 搜索并安装

9.2 功能 9.2.1 XML跳转

当mapper映射文件和mapper很多的时候，可以快速定位并跳转到对应的类容上。

9.2.2 快速生成代码 [1]首先需要在datasource中进行配置

1. 连接mysql
   

2. 选择驱动
   

3. 可以直接选择旧版本的驱动。或者按提示下载
   

4. 登录后选择数据库、表，然后点击右键选择mybatisx.
   

5. 表的基本配置
   

6. 生成的基本配置
   

7. 选择好后会自动帮我们生成各种组件
   

8. 如果我们要自定义查询功能，我们只需要在mapper中写我们的方法名，插件会自动帮助我们补全方法名并且快速生成相对应的sql语句放在mapper映射文件中。

此处报错是因为本案例最开始使用的存放mapper映射文件的目录名是mappers。实际应该是mapper。

---

总结

mybatsi-plus可以快速帮助我们完成spring和mybatsi的整合及搭建功能。