这是我参与「掘金日新计划 · 2 月更文挑战」的第二十天

简介

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

愿景

我们的愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。

特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

1、创建数据库及表

1.1、创建表

CREATE DATABASE `mybatis_plus`;

USE `mybatis_plus`;

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`)
        
)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

1.2、添加数据

DELETE FROM user;
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');

2、创建Spring Boot工程

2.1、初始化工程

使用Spring Initializr 快速初始化一个Spring Boot 工程

MySQL、lombok、mybatis-plus依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

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

        <!--mysql驱动器-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--lombok依赖用于简化实体类开发-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

安装lombok插件 File——>Settings——>Plugins 搜lombok

2.2、配置application.yml(application.properties)

application.yml

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&useSSL=false&serverTimezone=GMT2%B8
    username: root
    password: ****

application.properties

spring.datasource.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=****

3、创建实体类及lombok的简单使用

3.1、创建实体类

@Data
public class User {

    private long id;
    
    private String name;
    
    private Integer age;
    
    private String email;
    
}

3.2、创建mapper接口

@Repository
public interface UserMapper extends BaseMapper<User> {

}

在启动类上添加@MapperScan

@SpringBootApplication
// 扫描mapper所在的包
@MapperScan("com.chen.mapper")
public class MybatisPlusApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusApplication.class, args);
    }

}

3.3、编写测试类

MybatisPlusTest

@SpringBootTest
public class MybatisPlusTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList() {
        // 通过条件构造器查询一个list集合，若有条件，则可以设置为null
        List<User> list = userMapper.selectList(null);
        list.forEach(System.out::println);
    }
}

3.4、加入日志功能

在application.yml中加入以下代码

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

运行之后，可以查看生成SQL语句，也可以使用Log4jImpl对日志进行打印

4、BaseMapper

4.1、BaseMapper的添加方法测试

@Test
public void testInsert() {
    // 实现新增用户信息
    // INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
    User user = new User();
    user.setName("张三");
    user.setAge(18);
    user.setEmail("zhangsan@atguigu.com");
    int result = userMapper.insert(user);
    System.out.println("result:" + result);
    System.out.println("id:" + user.getId());
}

4.2、BaseMapper的删除方法测试

@Test
public void testDelete() {
    // 通过ID删除一个用户
    // DELETE FROM user WHERE id=?
    /*int result = userMapper.deleteById(1499047219186933761L);
    System.out.println(result);*/

    // 根据map集合中的所设置的条件删除用户信息
    // DELETE FROM user WHERE name = ? AND age = ?
    /*Map<String, Object> map = new HashMap<>();
    map.put("name","张三");
    map.put("age",18);
    int result = userMapper.deleteByMap(map);
    System.out.println(result);*/


    // 通过多个id实现批量删除
    // DELETE FROM user WHERE id IN ( ? , ? )
    List<Long> list = Arrays.asList(1499047368323870722L, 1499047451270430721L);
    int result = userMapper.deleteBatchIds(list);
    System.out.println(result);
}

4.3、BaseMapper的更新方法测试

@Test
public void testUpdate() {
    // 通过id来更新用户的信息
    // UPDATE user SET name=?, age=? WHERE id=?
    User user = new User();
    user.setId(1499050741030797314L);
    user.setName("张三");
    user.setAge(23);
    int result = userMapper.updateById(user);
    System.out.println(result);
}

4.4、BaseMapper的查询方法测试

@Test
public void testSelect() {
    // 通过id查询用户信息
    // SELECT id,name,age,email FROM user WHERE id=?
    User user = userMapper.selectById(1L);
    System.out.println(user);

    // 通过多个id实现批量查询用户的信息
    // SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? )
    List<Long> list = Arrays.asList(1L, 2L, 3L);
    List<User> userList = userMapper.selectBatchIds(list);
    userList.forEach(System.out::println);

    // 根据map集合中的条件来查询用户信息
    // SELECT id,name,age,email FROM user WHERE id = ? AND age = ?
    Map<String, Object> map = new HashMap<>();
    map.put("id",1L);
    map.put("age",18);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);

    // 查询所有数据的
    // SELECT id,name,age,email FROM user
    List<User> userList = userMapper.selectList(null);
    userList.forEach(System.out::println);
}

4.5、自定义功能

Mapper

@Repository
public interface UserMapper extends BaseMapper<User> {

    /**
     * 根据id查询用户信息为map集合
     * @param id
     * @return
     */
    Map<String, Object> selectMapById(Long id);

}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.chen.mapper.UserMapper">
    <select id="selectMapById" resultType="java.util.Map" parameterType="java.lang.Long">
        SELECT id,name,age,email FROM mybatis_plus.user WHERE id = #{id}
    </select>
</mapper>

Test

@Test
public void selectMapById() {
    Map<String, Object> map = userMapper.selectMapById(1L);
    System.out.println(map);
}

5、通用Service接口

说明:

通用 Service CRUD 封装IService (opens new window)接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
泛型 T 为任意实体对象
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
对象 Wrapper 为条件构造器
官网地址：baomidou.com/pages/49cc8…

5.1、自定义的Service接口

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

}

// Service 接口
public interface UserService extends IService<User> {
}

测试Service接口查询总数

@SpringBootTest
public class MybatisPlusServiceTest {

    @Autowired
    private UserService userService;
    
    @Test
    public void testGetCount() {
        // 查询总记录数的
        // SELECT COUNT( * ) FROM user
        long count = userService.count();
        System.out.println(count);
    }

}

Service测试批量添加数据

@Test
public void testInsertMore() {
    // Service接口实现批量添加
    // INSERT INTO user ( id, name, age ) VALUES ( ?, ?, ? )
    List<User> list = new ArrayList<>();
    for (int i = 0; i <= 10; i++) {
        User user = new User();
        user.setName("ch" + i);
        user.setAge(20 + i);
        list.add(user);
    }

    boolean b = userService.saveBatch(list);
    System.out.println(b);
}

5.2、常用注解

5.2.1、@TableName

// 设置实体类所对应的表名
@TableName("t_user")

mybatis-plus:
# 设置Mybatis-plus的全局配置
    global-config:
        db-config:
         # 设置实体类所对应的标的统一前缀
            table-prefix: t_

5.2.2、TableId注解

将属性所对应字段作为主键

@TableId
// 将uid作为主键
private Long uid;

TableId的value属性

@TableId(value = "uid")
// 将uid作为主键
private Long uid;

TableId的type属性

可以设置主键生成策略

@TableId(value = "uid", type = IdType.AUTO)
// 将uid作为主键
private Long uid;

全局配置主键生成策略

# 设置Mybatis-plus的全局配置
  global-config:
    db-config:
      # 设置统一的主键生成策略
      id-type: auto

雪花算法

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。可以保证几乎全球唯一！

其余源码的解释

public enum IdType {
    AUTO(0), // 数据库id自增
    NONE(1), // 未设置主键
    INPUT(2), // 手动输入，自己写id
    ID_WORKER(3), // 默认的全局唯一id
    UUID(4), // 全局唯一id uuid
    ID_WORKER_STR(5); // ID_WORKER 字符串表示法
}

5.2.3、TableField注解

在数据库字段名和自己定义的字段名不一致时可以使用该注解

// 指定属性所对应的字段名
@TableField("name")
private String name;

5.2.4、TableLogic注解

可以实现对数据库中的数据进行逻辑删除，可以进行数据恢复

在数据库中添加字段is deleted

@TableLogic
private Integer isDeleted;

6、条件构造器

6.1、wrapper介绍

在学习Wapper之前，先来看一下它的类图结构。

类图关键类说明：

Wrapper ：条件构造抽象类，最顶端父类
- AbstractWrapper ：用于查询条件封装，生成 sql 的 where 条件
  - QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
  - UpdateWrapper ： Update 条件封装，用于Entity对象更新操作
  - AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
    - LambdaQueryWrapper ：看名称也能明白就是用于Lambda语法使用的查询Wrapper
    - LambdaUpdateWrapper ： Lambda 更新封装Wrapper

6.2、QueryWrapper条件构造器

组装条件查询并测试

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

组装排序条件并测试

@Test
public void test02() {
    // 查询用户信息，按照年龄的降序排序，若年龄相同，则按照id升序排序
    // SELECT id,name,age,email FROM user ORDER BY age DESC,id ASC
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderByDesc("age")
                .orderByAsc("id");
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println);
}

组装删除条件并测试

@Test
public void test03() {
    // 删除邮箱地址null的用户信息
    // DELETE FROM user WHERE (email IS NULL)
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.isNull("email");
    int i = userMapper.delete(queryWrapper);
    System.out.println(i);
}

组装修改功能并测试

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

条件优先级的测试

@Test
public void test05() {
    // 将用户名中包含a并且（年龄大于20或邮箱为null）的用户信息修改
    // Lambda中的条件优先执行
    // UPDATE user SET name=?, email=? WHERE (name LIKE ? AND (age > ? OR email IS NULL))
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.like("name", "a")
            .and(i -> i.gt("age", 20)
            .or()
            .isNull("email"));
    User user = new User();
    user.setName("小红");
    user.setEmail("tset@atguigu.com");
    int result = userMapper.update(user, queryWrapper);
    System.out.println(result);
}

组装select语句

@Test
public void test06() {
    // 查询用户的用户名，年龄，邮箱信息
    // SELECT name,age,email FROM user
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("name", "age", "email");
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    maps.forEach(System.out::println);
}

组装子查询并测试

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

使用UpdateWrapper实现修改功能

@Test
public void test08() {
    // 将用户名中包含a并且（年龄大于20或邮箱为null）的用户信息修改
    // UPDATE user SET name=?,email=? WHERE (name LIKE ? AND (age > ? OR email IS NULL))
    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    updateWrapper.like("name", "a")
            .and(i -> i.gt("age", 20)
                    .or()
                    .isNull("email"));
    updateWrapper.set("name", "小黑");
    updateWrapper.set("email", "abc@atguigu.com");
    int result = userMapper.update(null, updateWrapper);
    System.out.println(result);
}

模拟开发中的组装条件

@Test
public void test09() {
    String username = "";
    Integer ageBegin = 20;
    Integer ageEnd = 30;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    if (StringUtils.isNotBlank(username)) {
        // 判断某个字符串是否不为空字符串，不为null，不为空白符
        // SELECT id,name,age,email FROM user WHERE (age >= ? AND age <= ?)
        queryWrapper.like("name", username);
    }

    if (ageBegin != null) {
        queryWrapper.ge("age", ageBegin);
    }
    if (ageEnd != null) {
        queryWrapper.le("age", ageEnd);

    }
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println);
}

使用condition动态组装条件

@Test
public void test() {
    String username = "a";
    Integer ageBegin = null;
    Integer ageEnd = 30;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.like(StringUtils.isNotBlank(username), "name", username)
            .ge(ageBegin != null, "age", ageBegin)
            .lt(ageEnd != null, "age", ageEnd);
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println);

}

LambdaQueryWrapper

@Test
public void test11() {
    // SELECT id,name,age,email FROM user WHERE (name LIKE ? AND age < ?)
    String username = "a";
    Integer ageBegin = null;
    Integer ageEnd = 30;

    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.like(StringUtils.isNotBlank(username), User::getName, username)
            .ge(ageBegin != null, User::getAge, ageBegin)
            .lt(ageEnd != null, User::getAge, ageEnd);
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println);
}

LambdaUpdateWrapper

@Test
public void test12() {
    // 将用户名中包含a并且（年龄大于20或邮箱为null）的用户信息修改
    LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
    updateWrapper.like(User::getName, "a")
            .and(i -> i.gt(User::getAge, 20)
                    .or()
                    .isNull(User::getEmail));
    updateWrapper.set(User::getName, "小黑").set(User::getName, "abc@atguigu.com");
    int result = userMapper.update(null, updateWrapper);
    System.out.println(result);
}

7、插件

7.1、分页插件

Mybatis-plus自带分页插件，自己需要简单的配置计科实现分页功能

添加配置

可以把启动类上的扫描mapper的注解放在MyBatisPlusConfig上

@Configuration
// 扫描mapper所在的包
@MapperScan("com.chen.mapper")
public class MyBatisPlusConfig {

    @Bean
    // 配置MybatisPlus中的插件
    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, 3);
    userMapper.selectPage(page, null);
    System.out.println(page);
}

获取分页相关的数据

@Test
public void testPage() {
    Page<User> page = new Page<>(2, 3);
    userMapper.selectPage(page, null);
    System.out.println(page.getRecords());
    System.out.println(page.getPages());
    System.out.println(page.getTotal());
    System.out.println(page.hasNext());
    System.out.println(page.hasPrevious());
}

自定义的分页功能

/**
 * 通过年龄查询用户信息并分页
 * @param page  Mybatis-Plus所提供的分页对象，必须位于第一个参数的位置
 * @param age   参数值
 * @return  返回值
 */
Page<User> selectPageVo(@Param("page") Page<User> page, @Param("age") Integer age);

<select id="selectPageVo" resultType="com.chen.pojo.User">
     SELECT id, name, age, email FROM mybatis_plus.user WHERE age > #{age}
</select>

@Test
public void testPageVo() {
    Page<User> page = new Page<>();
    userMapper.selectPageVo(page, 20);
    System.out.println(page.getRecords());
    System.out.println(page.getPages());
    System.out.println(page.getTotal());
    System.out.println(page.hasNext());
    System.out.println(page.hasPrevious());
}

6.2、乐观锁

6.2.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 t_product (id, NAME, price) VALUES (1, '外星人', 10000);

创建实体类

package com.chen.pojo;

import lombok.Data;

@Data
public class Product {

    private Long id;

    private String name;

    private Integer price;

    private Integer version;

}

添加Mapper

@Repository
// 持久化注解
public interface ProductMapper extends BaseMapper<Product> {

}

模拟修改冲突问题

@Test
public void testProduct01() {
    // 小李查询商品价格
    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 productBOSS = productMapper.selectById(1);
    System.out.println("老板查询的商品价格：" + productBOSS.getPrice());
}

乐观锁的实现流程

取出记录是，获取当前的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;

Mybatis-plus实现乐观锁

修改实体类

@Data
public class Product {

    private Long id;

    private String name;

    private Integer price;

    // 表示乐观锁版本号字段
    @Version
    private Integer version;

}

在配置文件中添加乐观锁插件

// 添加乐观锁插件
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

重新进行测试

@Test
public void testProduct01() {
    // 小李查询商品价格
    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 productBoss = productMapper.selectById(1);
    System.out.println("老板查询的商品价格：" + productBoss.getPrice());
}

8、通用枚举

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

数据库添加字段sex

在实体类中添加属性

private SexEnum 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;
    }
}

创建测试类

@SpringBootTest
public class MybatisPlusEnumTest {

    @Autowired
    private UserMapper userMapper;

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

}

需要在配置文件中配置通用枚举的扫描包

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  # 设置Mybatis-plus的全局配置
  global-config:
    db-config:
      # 设置实体类所对应的标的统一前缀
      # table-prefix: t_
      # 设置统一的主键生成策略
      id-type: auto
  # 配置类型别名所对应的包
  type-aliases-package: com.chen.pojo
  # 扫描通用枚举的包
  type-enums-package: com.chen.enums

9、代码生成器

9.1、引入依赖

<!--代码生成器的依赖-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.4.1</version>
</dependency>
<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
</dependency>

9.2、快速生成

public class FastAutoGeneratorTest {
    public static void main(String[] args) {
        FastAutoGenerator.create("jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&serverTimezone=GMT%2B8",
                "root", "root")
                .globalConfig(builder -> {
                    builder.author("chen") // 设置作者
                            //.enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .outputDir("D://mybatis-plus"); // 指定输出目录
                })
                .packageConfig(builder -> {
                    builder.parent("com.chen") // 设置父包名
                            .moduleName("mybatis-plus") // 设置父包模块名
                            .pathInfo(Collections.singletonMap(OutputFile.mapperXml, "D://mybatis-plus")); // 设置mapperXml生成路径
                })
                .strategyConfig(builder -> {
                    builder.addInclude("user") // 设置需要生成的表名
                            .addTablePrefix("t_", "c_"); // 设置过滤表前缀
                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();
    }

}

10、多数据源

10.1、创建数据库及表

创建数据库mybatis_plus_1和表product

CREATE DATABASE mybatis_plus_1;

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

删除mybatis_plus库和product表

USE mybatis_plus;
DROP TABLE IF EXISTS product;

10.2、引入依赖

<dependency>
	<groupId>com.baomidou</groupId>
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    <version>3.5.0</version>
</dependency>

10.3、配置多数据源

说明：注释掉之前的数据库连接，添加新配置

spring:
  # 配置数据源信息
  datasource:
    dynamic:
      # 设置默认的数据源或数据源组，默认值即为master
      primary: master
      # 严格匹配数据源，默认false，true未匹配到指定数据源时抛异常，false使用默认数据源
      strict: false
      datasource:
        master:
          url: jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&serverTimezone=GMT%2B8
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: root
        save_1:
          url: jdbc:mysql://localhost:3306/mybatis_plus_1?useSSL=false&serverTimezone=GMT%2B8
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: root

10.4、创建用户service

public interface UserService extends IService<User> {
}

@DS("master")
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

10.5、创建商品service

public interface ProductService extends IService<Product> {
}

@DS("slave_1")
@Service
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements ProductService {
}

10.6、测试

@Autowired
private UserService userService;

@Autowired
private ProductService productService;


@Test
public void test() {
    System.out.println(userService.getById(1));
    System.out.println(productService.getById(1));

}

11、MybatisX插件

安装

MybatisX插件的用法：baomidou.com/pages/ba5b2…

SSM框架之Mybatis Plus

这是我参与「掘金日新计划 · 2 月更文挑战」的第 二十 天

简介

特性