Riley Shen | MyBatis-Plus for Beginners 3

组装排序条件

/按年龄降序查询用户，如果年龄相同则按 id 升序排列

** SELECT id,name,age,email,deleted FROM user WHERE deleted=0 ORDER BY age DESC,id ASC

 @Autowired
    private UserMapper userMapper;
    @Test
    public void test1() {
         QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        queryWrapper.orderByDesc("age")
                .orderByAsc("id");
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);

组装删除条件

删除 email 为空的用户

UPDATE user SET deleted=1 WHERE deleted=0 AND (email IS NULL)

querywarpper 里面就是放条件， usermapper 承担删除功能

 @Autowired
    private UserMapper userMapper;
    @Test
    public void test1() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        queryWrapper.isNull("email");
        int delete = userMapper.delete(queryWrapper);
        System.out.println(delete);

QueryWrapper 修改功能

将（年龄大于 20 并且用户名中包含有 a）或邮箱为 null 的用户信息修改

UPDATE user SET name=?, email=? WHERE deleted=0 AND (age > ? AND name LIKE ? OR email IS NULL)

 @Autowired
    private UserMapper userMapper;
    @Test
    public void test1() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        queryWrapper.gt("age", 20)
                .like("name", "a")
                .or()
                .isNull("email");
        User user = new User();
        user.setName("美女");
        user.setEmail("[email protected]");
        int update = userMapper.update(user, queryWrapper);
        System.out.println(update);

条件的优先级

将用户名中包含有 a 并且（年龄大于 20 或邮箱为 null）的用户信息修改

UPDATE user SET name=?, email=? WHERE deleted=0 AND (age > ? AND name LIKE ? OR email IS NULL)

 @Autowired
    private UserMapper userMapper;
    @Test
    public void test1() {
         QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        queryWrapper.like("name", "a")
                .and(i -> i.gt("age", 20)
                        .or()
                        .isNull("email"));
        User user = new User();
        user.setName("帅哥");
        user.setEmail("[email protected]");
        int update = userMapper.update(user, queryWrapper);
        System.out.println(update);

组装 select 子句

查询用户信息的 username 和 age 字段

 @Autowired
    private UserMapper userMapper;
    @Test
    public void test1() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        queryWrapper.select("name", "age", "email");
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        System.out.println(maps);

实现子查询

查询 id 小于等于 3 的用户信息

 @Autowired
    private UserMapper userMapper;
    @Test
    public void test1() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        queryWrapper.inSql("id", "select id from user where id <= 100");
        List<User> users = userMapper.selectList(queryWrapper);
        System.out.println(users);

UpdateWrapper

将（年龄大于 20 或邮箱为 null）并且用户名中包含有 a 的用户信息修改

组装 set 子句以及修改条件

 @Autowired
    private UserMapper userMapper;
    @Test
    public void test1() {
        //将（年龄大于20或邮箱为null）并且用户名中包含有a的用户信息修改
        //组装set子句以及修改条件
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        //lambda表达式内的逻辑优先运算
        updateWrapper
        .set("age", 18)
        .set("email", "[email protected]")
        .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);

condition

在真正开发的过程中，组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的，

因此我们在组装这些条件时，必须先判断用户是否选择了这些条件，若选择则需要组装该条件，

若没有选择则一定不能组装，以免影响SQL执行的结果

@Test
public void test08() {
    //定义查询条件，有可能为null（用户未输入或未选择）
    String name = a;
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //StringUtils.isNotBlank() com.baomidou.mybatisplus.core.toolkit 里面的判断某字符串是否不为空且长度不为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);

使用带 condition 参数的重载方法构建查询条件，简化代码的编写

@Test
public void test08() {
    //定义查询条件，有可能为null（用户未输入或未选择）
    String name = a;
    Integer ageBegin = null;
    Integer ageEnd = 24;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //StringUtils.isNotBlank() com.baomidou.mybatisplus.core.toolkit 里面的判断某字符串是否不为空且长度不为0且不由空白符(whitespace)
    queryWarpper
        .like(StringUtils.isNotBlank(name), "name", name)
        .ge(ageBegin != null, "age", ageBegin)
        .le((ageEnd != null, "age", ageEnd);
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);

LambdaQueryWrappe

public void test08() {
    //定义查询条件，有可能为null（用户未输入或未选择）
    String name = a;
    Integer ageBegin = null;
    Integer ageEnd = 24;
    LamdaQueryWrapper<User> queryWrapper = new LamdaQueryWrapper<>();
    //StringUtils.isNotBlank() com.baomidou.mybatisplus.core.toolkit 里面的判断某字符串是否不为空且长度不为0且不由空白符(whitespace)
    queryWarpper
        .like(StringUtils.isNotBlank(name), User::getName, name)
        .ge(ageBegin != null, User::getAge, ageBegin)
        .le((ageEnd != null, User::getAge, ageEnd);
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);

LambdaUpdateWrapper

 @Test
    public void test1() {
        //将（年龄大于20或邮箱为null）并且用户名中包含有a的用户信息修改
        //组装set子句以及修改条件
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        //lambda表达式内的逻辑优先运算
        updateWrapper
        .like(User::getName, "a")
        .and(i -> i.gt(User::getAge, 20).or().isNull(User::getEmail));
        updateWrapper.set(User::getName, "b").set(User::getEmail, "qw.com");
        int result = userMapper.update(null, updateWrapper);
        System.out.println(result);
1.添加配置类
config -> MyBatisPlusConfig
@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;
@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());
xml 自定义分页
1.UserMapper 中定义接口方法
* 根据年龄查询用户列表，分页显示
* @param page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位
* @param age 年龄
* @return
Page<User> selectPageVo(@Param("page") Page<User> page, @Param("age")
Integer age);
2.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>
@Test
public void testSelectPageVo(){
//设置分页参数
Page<User> page = new Page<>(1, 5);
userMapper.selectPageVo(page, 20);
//获取分页数据
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());
一件商品，成本价是80元，售价是100元。老板先是通知小李，说你去把商品价格增加50元。小
李正在玩游戏，耽搁了一个小时。正好一个小时后，老板觉得商品价格增加到150元，价格太
高，可能会影响销量。又通知小王，你把商品价格降低30元。
此时，小李和小王同时操作商品后台系统。小李操作的时候，系统先取出商品价格100元；小王
也在操作，取出的商品价格也是100元。小李将价格加了50元，并将100+50=150元存入了数据
库；小王将商品减了30元，并将100-30=70元存入了数据库。是的，如果没有锁，小李的操作就
完全被小王的覆盖了。
现在商品价格是70元，比成本价低10元。几分钟后，这个商品很快出售了1千多件商品，老板亏1





    
2.乐观锁与悲观锁
上面的故事，如果是乐观锁，小王保存价格前，会检查下价格是否被人修改过了。如果被修改过
了，则重新取出的被修改后的价格，150元，这样他会将120元存入数据库。
如果是悲观锁，小李取出数据后，小王只能等小李操作完之后，才能对价格进行操作，也会保证
最终的价格是120元。
3.模拟修改冲突
3.1 数据库中增加商品表
create table t_product (
    id bigint(20) not null comment '主键ID',
    name varchar(30) not default null comment '商品名称',
    price int(11) default 0 comment '价格',
    version int(11) default 0 comment '乐观锁版本号',
    primary key (id)
3.2 添加数据
insert into t_product (id, name, price) values (1, ‘外星人笔记本’, 100);
3.3 添加实体
public class Product {
    private Long id;
    private String name;
    private Integer price;
    private Integer version;
3.4 添加 mapper
@Repository
public interface ProductMapper extends BaseMapper<Projuct>{}
3.5 测试
@Test
public void testConcurrentUpdate() {
    // 小李
    Projuct p1 = productMapper.selectById(1L);
    System.out.println("小李取出的价格： " + p1.getPrice());
     // 小王
    Projuct p2 = productMapper.selectById(1L);
    System.out.println("小王取出的价格： " + p2.getPrice());
    // 小李价格加了 50， 存入数据库
    p1.setPrice(p1.getPrice() + 50);
    int res1 = productMapper.updateById(p1);
    System.out.println("小李修改价格： " + res1);
    // 小王价格减了 30， 存入数据库
    p2.setPrice(p2.getPrice() - 30);
    int res2 = productMapper.updateById(p2);
    System.out.println("小王修改价格： " + res2);
    // 最后价格
    Product p3 = productMapper.selectById(1L);
    System.out.println("价格： " +  p3.getPrice());
最后结果是 70
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
5.Mybatis-Plus 实现乐观锁
5.1 修改实体类
public class Product {
    private Long id;
    private String name;
    private Integer price;
    @Version
    private Integer version;
5.2 添加乐观锁插件配置
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    //添加分页插件
    interceptor.addInnerInterceptor(new PaginationInnerInterceptor(Dbtype.MYSQL));
    //添加乐观锁插件
    interceptor.addInnerInterceptor (new OptimisticLockerInnerInterceptor());
    return interceptor;
加入后同样的代码，得到结果是 150， p2 没执行
5.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=?
5.4 优化流程
@Test
public void testConcurrentUpdate() {
    // 小李
    Projuct p1 = productMapper.selectById(1L);
    System.out.println("小李取出的价格： " + p1.getPrice()); // version 0
     // 小王
    Projuct p2 = productMapper.selectById(1L);
    System.out.println("小王取出的价格： " + p2.getPrice());  // version 0
    // 小李价格加了 50， 存入数据库
    p1.setPrice(p1.getPrice() + 50);
    int res1 = productMapper.updateById(p1);
    System.out.println("小李修改价格： " + res1);  // version 1
    // 小王价格减了 30， 存入数据库
    p2.setPrice(p2.getPrice() - 30);  // version 0, 不满足版本号，无法操作
    int res2 = productMapper.updateById(p2);
    System.out.println("小王修改价格： " + res2);
    if (res2 == 0) {
        // 小王操作失败，重新操作
        p2 = productMapper.selectById(1L); // version 1, 满足版本号，操作
        p2.setPriice(p2.getPrice() - 30);
    // 最后价格
    Product p3 = productMapper.selectById(1L);
    System.out.println("价格： " +  p3.getPrice());
结果是 120
表中的有些字段值是固定的，例如性别（男或女），此时我们可以使用 MyBatis-Plus 的通用枚举
数据库表添加字段 sex
创建通用枚举类型
@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;
@EnumValue 的注解很重要，如果没有这个值，后代码中 user.setSex(SexEnum.MALE) 传入的是 sexName， 但是表格需要的是 integer， 0， 1 表示性别。如果需要这个注解以及在配置文件中加入扫描枚举的包
配置扫描通用枚举
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
# 配置扫描通用枚举
type-enums-package: com.demo.mybatisplus.enums
@Test
public void testSexEnum(){
    User user = new User();
    user.setName("Enum");
    user.setAge(20);
    //设置性别信息为枚举项，会将@EnumValue注解所标识的属性值存储到数据库
    user.setSex(SexEnum.MALE);
    //INSERT INTO t_user ( username, age, sex ) VALUES ( ?, ?, ? )
    //Parameters: Enum(String), 20(Integer), 1(Integer)
    userMapper.insert(user);
代码生成器
1. 创建数据库及表
创建数据库 mybatis_plus_1 和 表 product
CREATE DATABASE `mybatis_plus_1` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
use `mybatis_plus_1`;
CREATE TABLE 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)
INSERT INTO product (id, NAME, price) VALUES (1, '外星人笔记本', 100);
2. 引入依赖
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    <version>3.5.0</version>
</dependency>
<dependency>
    <groupId>com.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>2.3.31</version>
</dependency>
3. 配置多数据源
4. 创建用户 service
5. 创建商品 service
6. 测试
Ok, It’s time for mybatis3
mybatis2

            MyBatis-PlusPlusInterceptorOptimisticLockerInnerInterceptor