MyBatis-Plus3

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

1.wapper介绍

MyBatis-Plus 提供了一套强大的条件构造器(Wrapper),用于构建复杂的数据库查询条件。Wrapper 类允许开发者以链式调用的方式构造查询条件,无需编写繁琐的 SQL 语句,从而提高开发效率并减少 SQL 注入的风险。

在 MyBatis-Plus 中,Wrapper 类是构建查询和更新条件的核心工具。以下是主要的 Wrapper 类及其功能:

  • AbstractWrapper:这是一个抽象基类,提供了所有 Wrapper 类共有的方法和属性。它定义了条件构造的基本逻辑,包括字段(column)、值(value)、操作符(condition)等。所有的 QueryWrapper、UpdateWrapper、LambdaQueryWrapper 和 LambdaUpdateWrapper 都继承自 AbstractWrapper。

  • QueryWrapper :专门用于构造查询条件,支持基本的等于、不等于、大于、小于等各种常见操作。它允许你以链式调用的方式添加多个查询条件,并且可以组合使用 andor 逻辑。

  • UpdateWrapper:用于构造更新条件,可以在更新数据时指定条件。与 QueryWrapper 类似,它也支持链式调用和逻辑组合。使用 UpdateWrapper 可以在不创建实体对象的情况下,直接设置更新字段和条件。

  • LambdaQueryWrapper:这是一个基于 Lambda 表达式的查询条件构造器,它通过 Lambda 表达式来引用实体类的属性,从而避免了硬编码字段名。这种方式提高了代码的可读性和可维护性,尤其是在字段名可能发生变化的情况下。

  • LambdaUpdateWrapper:类似于 LambdaQueryWrapper,LambdaUpdateWrapper 是基于 Lambda 表达式的更新条件构造器。它允许你使用 Lambda 表达式来指定更新字段和条件,同样避免了硬编码字段名的问题。

2.功能详解

MyBatis-Plus 的 Wrapper 类是构建复杂查询和更新条件的关键工具。它允许开发者以链式调用的方式构造 SQL 的 WHERE 子句,提供了极大的灵活性和便利性。

以下是对 Wrapper 功能的提示和注意事项。

提示:

条件判断 :Wrapper 方法通常接受一个 boolean 类型的参数,用于决定是否将该条件加入到最终的 SQL 中。例如:

java 复制代码
queryWrapper.like(StringUtils.isNotBlank(name), Entity::getName, name)
            .eq(age != null && age >= 0, Entity::getAge, age);

默认行为 :如果某个方法没有显式提供 boolean 类型的参数,则默认为 true,即条件总是会被加入到 SQL 中。

泛型参数 :Wrapper 类是泛型类,其中 Param 通常指的是 Wrapper 的子类实例,如 QueryWrapper、UpdateWrapper 等。

字段引用 :在 LambdaWrapper 中,R 代表的是一个函数,用于引用实体类的属性,例如 Entity::getId。而在普通 Wrapper 中,R 代表的是数据库字段名。

字段名注意事项 :当 R 具体类型为 String 时,表示的是数据库字段名,而不是实体类数据字段名。如果字段名是数据库关键字,需要使用转义符包裹。

集合参数 :如果方法的参数是 MapList,当它们为空时,对应的 SQL 条件不会被加入到最终的 SQL 中。

学习资源 :对于不熟悉的函数式编程概念,可以参考学习资源进行学习。

注意事项:

RPC 调用中的 Wrapper:不支持也不赞成在 RPC 调用中传输 Wrapper 对象。Wrapper 对象通常包含大量信息,不适合作为传输对象。正确的做法是定义一个 DTO(数据传输对象)进行传输,然后在被调用方根据 DTO 执行相应的操作。

维护性:避免在 Controller 层使用 Map 接收值,这种做法虽然开发时方便,但会给后续的维护带来困难。

问题反馈:不接受任何关于 RPC 传输 Wrapper 报错相关的 issue 或 pr。

安全性QueryWrapper UpdateWrapper 字段部分,如有允许 前端传入 SQL 片段 这可能会导致 SQL 注入风险 需要校验,更多查看 预防安全漏洞

3.QueryWrapper

3.1组装查询条件

java 复制代码
@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);
}

3.2组装排序条件

java 复制代码
@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);
}

3.3组装删除条件

java 复制代码
@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);
}

3.4条件的优先级

java 复制代码
@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@qcby.com");
int result = userMapper.update(user, queryWrapper);
System.out.println("受影响的行数:" + result);
}
java 复制代码
@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@qcby.com");
int result = userMapper.update(user, queryWrapper);
System.out.println("受影响的行数:" + result);
}

3.5组装select子句

java 复制代码
@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);
}

3.6实现子查询

java 复制代码
@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);
}

4.UpdateWrapper

java 复制代码
@Test
public void test07() {
//将(年龄大于20或邮箱为null)并且用户名中包含有a的用户信息修改
//组装set子句以及修改条件
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
//lambda表达式内的逻辑优先运算
updateWrapper
.set("age", 18)
.set("email", "user@qcby.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);
}

5.condition

在真正开发的过程中,组装条件是常见的功能,而这些条件数据来源于用户输入,是可选的,因 此我们在组装这些条件时,必须先判断用户是否选择了这些条件,若选择则需要组装该条件,若 没有选择则一定不能组装,以免影响SQL执行的结果

5.1思路一

java 复制代码
@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);
}

5.2思路二

上面的实现方案没有问题,但是代码比较复杂,我们可以使用带condition参数的重载方法构建查 询条件,简化代码的编写

java 复制代码
@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);
}

6.LambdaQueryWrapper

java 复制代码
@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);
}

7.LambdaUpdateWrapper

java 复制代码
@Test
public void test10() {
//组装set子句
LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>(); updateWrapper
.set(User::getAge, 18)
.set(User::getEmail, "user@qcby.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自带分页插件,只要简单的配置即可实现分页功能

1.1添加配置类

java 复制代码
package com.qcby.springbootmybastplus0725.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBatisPlusConfig {

    /**
     * 配置分页插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 添加分页拦截器(支持MySQL、PostgreSQL等主流数据库)
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

1.2测试

java 复制代码
@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自定义分页

2.1UserMapper中定义接口方法

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

2.2UserMapper.xml中编写SQL

XML 复制代码
<!--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>

2.3测试

java 复制代码
@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());
}

结果

3.乐观锁

3.1场景

一件商品,成本价是80元,售价是100元。老板先是通知小李,说你去把商品价格增加50元。小 李正在玩游戏,耽搁了一个小时。正好一个小时后,老板觉得商品价格增加到150元,价格太

高,可能会影响销量。又通知小王,你把商品价格降低30元。

此时,小李和小王同时操作商品后台系统。小李操作的时候,系统先取出商品价格100元;小王 也在操作,取出的商品价格也是100元。小李将价格加了50元,并将100+50=150元存入了数据 库;小王将商品减了30元,并将100-30=70元存入了数据库。是的,如果没有锁,小李的操作就 完全被小王的覆盖了。

现在商品价格是70元,比成本价低10元。几分钟后,这个商品很快出售了1千多件商品,老板亏1 万多。

3.2乐观锁与悲观锁

上面的故事,如果是乐观锁,小王保存价格前,会检查下价格是否被人修改过了。如果被修改过 了,则重新取出的被修改后的价格, 150元,这样他会将120元存入数据库。

如果是悲观锁,小李取出数据后,小王只能等小李操作完之后,才能对价格进行操作,也会保证 最终的价格是120元。

3.3模拟修改冲突

数据库中增加商品表

sql 复制代码
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)
);

添加数据

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

添加实体

java 复制代码
package com.qcby.mybatisplus.entity;
import lombok.Data;

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

添加 mapper

java 复制代码
public interface ProductMapper extends BaseMapper<Product> {
}

测试

java 复制代码
@Test
public void testConcurrentUpdate() {

//1、小李
Product p1 = productMapper.selectById(1L);
System.out.println("小李取出的价格:" + p1.getPrice());

//2、小王
Product p2 = productMapper.selectById(1L);
System.out.println("小王取出的价格:" + p2.getPrice());
//3、小李将价格加了50元,存入了数据库
p1.setPrice(p1.getPrice() + 50);
int result1 = productMapper.updateById(p1);
System.out.println("小李修改结果:" + result1);

//4、小王将商品减了30元,存入了数据库
p2.setPrice(p2.getPrice() - 30);
int result2 = productMapper.updateById(p2);
System.out.println("小王修改结果:" + result2);

//最后的结果
Product p3 = productMapper.selectById(1L);
//价格覆盖,最后的结果:70
System.out.println("最后的结果:" + p3.getPrice())

3.4乐观锁实现流程

数据库中添加version字段

取出记录时,获取当前version

sql 复制代码
SELECT id,`name`,price,`version` FROM product WHERE id=1

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

sql 复制代码
UPDATE product SET price=price+50, `version`=`version` + 1 WHERE id=1 AND `version`=1

3.5Mybatis-Plus实现乐观锁

修改实体类

java 复制代码
@Data
 

com.baomidou.mybatisplus.annotation.Version;
lombok.Data;
 
public class Product {
private Long id;
private String name;
private Integer price;
@Version
private Integer version;
}

添加乐观锁插件配置

java 复制代码
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor(){
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
//添加分页插件
interceptor.addInnerInterceptor(new
PaginationInnerInterceptor(DbType.MYSQL));
//添加乐观锁插件
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor()); return interceptor;
}

测试修改冲突

java 复制代码
小李查询商品信息:
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=?

优化流程

java 复制代码
//乐观锁测试
    @Test
    public void test02(){
        //小李取数据
        Product p1 = productMapper.selectById(1L);

        //小王取数据
        Product p2 = productMapper.selectById(1L);

        //小李修改
        p1.setPrice(p1.getPrice() + 50);
        int result1 = productMapper.updateById(p1);
        System.out.println("小李修改结果:" + result1);

        //小王修改
        p2.setPrice(p2.getPrice() - 30);
        int result2 = productMapper.updateById(p2);
        System.out.println("小王修改结果:" + result2);
        if(result2 ==0){
            p2 = productMapper.selectById(1L);
            p2.setPrice(p2.getPrice() - 30);
            result2 = productMapper.updateById(p2);
        }
        System.out.println("小王修改结果:" + result2);

        //老板查询商品价格
        Product p3 = productMapper.selectById(1L);
        System.out.println("老板查询价格:" + p3.getPrice());
    }

结果

三、通用枚举

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

1.数据库表添加字段sex

2.创建通用枚举类型

java 复制代码
package com.qcby.springbootmybastplus0725.enums;

import com.baomidou.mybatisplus.annotation.EnumValue;
import lombok.Getter;

@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;
    }
}

3.配置扫描通用枚举

java 复制代码
mybatis-plus:
  configuration:
    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.qcby.springbootmybastplus0725.enums

4.测试

java 复制代码
package com.qcby.springbootmybastplus0725;

import com.qcby.springbootmybastplus0725.entity.User;
import com.qcby.springbootmybastplus0725.enums.SexEnum;
import com.qcby.springbootmybastplus0725.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class EnumsTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void test01(){
        User user = new User();
        user.setName("Enum");
        user.setAge(20);
        user.setSex(SexEnum.MALE);
        userMapper.insert(user);
    }
}

四、代码生成器

1.引入依赖

XML 复制代码
<!--代码生成器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.31</version>
        </dependency>

2.快速生成

java 复制代码
package com.qcby.springbootmybastplus0725.util;

import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.util.Collections;

public class FastAutoGeneratorTest {
    public static void main(String[] args) {
        FastAutoGenerator.create("jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true", "root", "lrh123456")
                .globalConfig(builder -> {
                    builder.author("qcby") // 设置作者
                            .enableSwagger() // 开启 swagger 模式
                            .fileOverride()// 覆盖已生成文件
                            .outputDir("D:\\code\\springboot\\springbootmybastplus0725\\src\\main\\java");
                })
                .packageConfig(builder -> {
                    builder.parent("com.qcby.springbootmybastplus0725") // 设置父包名
                            .moduleName("mybatisplus") // 设置父包模块名
                            .pathInfo(Collections.singletonMap(OutputFile.mapperXml,"D://mybatis_plus"));
                        })
                .strategyConfig(builder -> {
                    builder.addInclude("t_user") // 设置需要生成的表名
                            .addTablePrefix("t_", "c_");
                })
                .templateEngine(new FreemarkerTemplateEngine())
                .execute();
    }
}

结果

五、多数据源

适用于多种场景:纯粹多库、 读写分离、 一主多从、 混合模式等

目前我们就来模拟一个纯粹多库的一个场景,其他场景类似

场景说明

创建两个库,

分别为: mybatis_plus(以前的库不动)与mybatis_plus_1 (新建),将

mybatis_plus库的product表移动到mybatis_plus_1库,这样每个库一张表,通过一个测试用例 分别获取用户数据与商品数据,如果获取到说明多库模拟成功

1.创建数据库及表

创建数据库mybatis_plus_1和表product

sql 复制代码
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)
);

添加测试数据

sql 复制代码
INSERT INTO product (id, NAME, price) VALUES (1, '外星人笔记本 ', 100);

删除mybatis_plus库中的product表

2.引入依赖

XML 复制代码
<!--多数据源-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>3.5.0</version>
        </dependency>

3.配置多数据源

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

XML 复制代码
spring:
  datasource:
    dynamic:
      # 设置默认的数据源或者数据源组 ,默认值即为master
      primary: master
      # 严格匹配数据源 ,默认false.true未匹配到指定数据源时抛异常 ,false使用默认数据源
      strict: false
      datasource:
        master:
          url: jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: root
        slave_1:
          url: jdbc:mysql://localhost:3306/mybatis_plus_1?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: root

4.创建用户service

java 复制代码
package com.qcby.springbootmybastplus0725.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.qcby.springbootmybastplus0725.entity.User;


public interface UserService extends IService<User> {

}
java 复制代码
package com.qcby.springbootmybastplus0725.service.impl;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.qcby.springbootmybastplus0725.entity.User;
import com.qcby.springbootmybastplus0725.mapper.UserMapper;
import com.qcby.springbootmybastplus0725.service.UserService;
import org.springframework.stereotype.Service;

@DS("master")//指定所操作的数据源
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

6.创建商品service

java 复制代码
package com.qcby.springbootmybastplus0725.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.qcby.springbootmybastplus0725.entity.Product;

public interface ProductService extends IService<Product> {
}
java 复制代码
package com.qcby.springbootmybastplus0725.service.impl;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.qcby.springbootmybastplus0725.entity.Product;
import com.qcby.springbootmybastplus0725.mapper.ProductMapper;
import com.qcby.springbootmybastplus0725.service.ProductService;
import org.springframework.stereotype.Service;

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

}

6.测试

java 复制代码
package com.qcby.springbootmybastplus0725;

import com.qcby.springbootmybastplus0725.service.ProductService;
import com.qcby.springbootmybastplus0725.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class DynamicTest {
    @Autowired
    private ProductService productService;
    @Autowired
    private UserService userService;

    @Test
    public void test(){
        System.out.println(userService.list());
        System.out.println(productService.list());
    }
}

结果

1、都能顺利获取对象,则测试成功

2、如果我们实现读写分离,将写操作方法加上主库数据源,读操作方法加上从库数据源,自动切 换,是不是就能实现读写分离?

六、MyBatisX插件

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

但是在真正开发过程中, MyBatis-Plus并不能为我们解决所有问题,例如一些复杂的SQL,多表 联查,我们就需要自己去编写代码和SQL语句,我们该如何快速的解决这个问题呢,这个时候可 以使用MyBatisX插件

MyBatisX一款基于 IDEA 的快速开发插件,为效率而生

MyBatisX插件用法:https://baomidou.com/plugins/