MyBatisPlus

1. MyBatisPlus 简介

MyBatis-Plus(简称 MP)，是一个 MyBatis 的增强工具包，只做增强不做改变。为简化开发工作、提高生产率而生

框架结构：

入门案例

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

配置数据源：

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.zaxxer.hikari.HikariDataSource
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&useSSL=false

创建mapper并添加扫描路径

//BaseMapper是MyBatis-Plus提供的模板mapper
//其中包含了基本的CRUD方法，泛型为操作的实体类型
public interface UserMapper extends BaseMapper<Buser> {
}


@SpringBootApplication
@MapperScan("com/demo/mybatisplus/mapper")
public class MybatisPlusApplication {

   public static void main(String[] args) {
      SpringApplication.run(MybatisPlusApplication.class, args);
   }

}

创建实体类：

@Data
public class Buser {
    private Integer id;
    private String name;
    private String password;
    private String email;
}

MyBatisPlus 底层使用了雪花算法，可能会超出integer的范围，所以主键id最好使用 BIGINT 和 Long

测试：

@SpringBootTest
public class MyTest {
    @Autowired(required = false)
    UserMapper userMapper;

    @Test
    public void test1() {
        List<Buser> list = userMapper.selectList(null);
        list.forEach(System.out::println);
    }
}

Spring只会将实体类放入容器，当我们导入userMapper时会编译报错

Wrapper条件构造器，可针对于SQL语句设置不同的条件，若没有条件，则可以为该形参赋值null，即查询（删除/修改）所有数据

我们能看到查询的结果但看不到查询的SQL语句，我们可以配置日志输出：

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

这个是自带的日志

2. 基本CURD

前面已经提到，MyBatis-Plus中的基本CRUD在内置的BaseMapper中都已得到了实现，我们可以直接使用

插入

@Test
public void test2(){
    Buser buser = new Buser(null, "小明", "123456", "xm@qq.com");
    int i = userMapper.insert(buser);
    System.out.printf("%d,%s",i,buser);
}

%d：按整型数据的实际长度输出；%s：输出字符串

MyBatis-Plus 底层默认使用雪花算法来创建id

删除

@Test
public void testDeleteById() {
    //DELETE FROM buser WHERE id=?
    int result = userMapper.deleteById(1321287682);
    System.out.println("受影响行数：" + result);
}

批量删除：

@Test
public void testDeleteBatchIds(){
    //通过多个id批量删除
    //DELETE FROM buser WHERE id IN ( ? , ? , ? )
    List idList = Arrays.asList(1, 2, 3);
    int result = userMapper.deleteBatchIds(idList);
    System.out.println("受影响行数："+result);
}

通过map条件删除记录：

@Test
public void testDeleteByMap(){
    //根据map集合中所设置的条件删除记录
    //DELETE FROM buser WHERE name = ? AND age = ?
    Map<String, Object> map = new HashMap<>();
    map.put("age", 23);
    map.put("name", "张三");
    int result = userMapper.deleteByMap(map);
    System.out.println("受影响行数："+result);
}

修改

    @Test
    public void testUpdateById() {
        //UPDATE buser SET name=?, password=?, email=? WHERE id=?
        Buser buser = new Buser(604000258, "小明", "112233", "xm@qq.com");
        int result = userMapper.updateById(buser);
        System.out.println("受影响行数：" + result);
    }

底层是根据主键(id)查询的

查询

//根据id查询用户信息：
@Test
public void testSelectById(){
    //SELECT id,name,age,email FROM buser WHERE id=?
    Buser buser = userMapper.selectById(4);
    System.out.println(user);
}

//根据多个id查询多个用户信息
@Test
public void testSelectBatchIds(){
    //SELECT id,name,age,email FROM buser WHERE id IN ( ? , ? )
    List<Long> idList = Arrays.asList(4, 5);
    List<Buser> list = userMapper.selectBatchIds(idList);
    list.forEach(System.out::println);
}

//通过map条件查询用户信息
@Test
public void testSelectByMap(){
    //通过map条件查询用户信息
    //SELECT id,name,age,email FROM buser WHERE name = ? AND age = ?
    Map<String, Object> map = new HashMap<>();
    map.put("age", 22);
    map.put("name", "admin");
    List<Buser> list = userMapper.selectByMap(map);
    list.forEach(System.out::println);
}

Service CRUD 接口

官方说明：

通用 Service CRUD 封装 IService 接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
泛型 T 为任意实体对象

MyBatis-Plus中有一个接口 IService和其实现类 ServiceImpl，封装了常见的业务层逻辑

自定义接口和实现类：

//UserService继承IService模板提供的基础功能
public interface UserService extends IService<User> {
}


/* ServiceImpl实现了IService，提供了IService中基础功能的实现
   若ServiceImpl无法满足业务需求，则可以使用自定的UserService定义方法，并在实现类中实现*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

测试功能：

@Autowired
private UserService userService;
//查询记录数
@Test
public void testGetCount(){
    int count = userService.count();
    System.out.println("总记录数：" + count);
}
//批量插入
@Test
public void testSaveBatch(){
    // SQL长度有限制，海量数据插入单条SQL无法实行，
    // 因此MP将批量插入放在了通用Service中实现，而不是通用Mapper
    ArrayList<User> users = new ArrayList<>();
    for (int i = 0; i < 5; i++) {
        User user = new User();
        user.setName("asd" + i);
        user.setAge(20 + i);
        users.add(user);
    }
    //INSERT INTO buser ( username, age ) VALUES ( ?, ? )
    userService.saveBatch(users);
}

3. 常用注解

@TableName

MyBatis-Plus操作的表由BaseMapper的泛型决定，即实体类型决定，且默认操作的表名和实体类型的类名一致(无视大小写)

当我们的实体类名与数据表不同时我们可以使用 @TableName 注解指定表名

@TableName("t_user")
public class User{..}

如果很多表都具有相同的前缀，我们可以在全局配置中设定

mybatis-plus:
  global-config:
    db-config:
      table-prefix: t_

@TableId

MyBatis-Plus在实现CRUD时，会默认将id作为主键列，并在插入数据时，默认基于雪花算法的策略生成id

若实体类中表示主键的不是id，而是其他字段，例如uid等，程序会抛出异常

我们可以通过@TableId指定表的主键：

@TableName("t_user")
public class User{
    @TableId
    private Integer uid;
    ..
}

该注解相当于一个映射，告诉MyBatis-Plus该属性对应表中主键 id，如果表中主键名不为id如 uid，我们需要在@TableId的value中注明 @TableId("uid")

type属性

type属性用来定义主键策略

@TableId(value="id",type = IdType.AUTO)

值	描述
IdType.ASSIGN_ID（默认）	基于雪花算法的策略生成数据id，与数据库id是否设置自增无关
IdType.AUTO	使用数据库的自增策略，注意，该类型请确保数据库设置了id自增，否则无效

我们也可以在全局配置中设置：

mybatis-plus:
  global-config:
    db-config:
      id-type: auto

雪花算法

背景：

需要选择合适的方案去应对数据规模的增长，以应对逐渐增长的访问压力和数据量。

数据库的扩展方式主要包括：业务分库、主从复制，数据库分表。

数据库分表；单表数据拆分有两种方式：

垂直分表
- 适合将表中某些不常用且占了大量空间的列拆分出去。
水平分表
- 水平分表适合表行数特别大的表。水平分表相比垂直分表，会引入更多的复杂性，例如要求全局唯一的数据id该如何处理

主键自增：

复杂点：分段大小的选取。分段太小会导致切分后子表数量过多，增加维护复杂度；分段太大可能会导致单表依然存在性能问题，一般建议分段大小在 100 万至 2000 万之间，具体需要根据业务选取合适的分段大小。

优点：可以随着数据的增加平滑地扩充新的表。例如，现在的用户是 100 万，如果增加到 1000 万，只需要增加新的表就可以了，原有的数据不需要动。

缺点：分布不均匀。假如按照 1000 万来进行分表，有可能某个分段实际存储的数据量只有 1 条，而另外一个分段实际存储的数据量有 1000 万条。

取模：

例如简单地用 user_id % 10 的值来表示数据所属的数据库表编号

复杂点：初始表数量的确定。表数量太多维护比较麻烦，表数量太少又可能导致单表性能存在问题。

优点：表分布比较均匀。

缺点：扩充新的表很麻烦，所有数据都要重分布。

雪花算法

雪花算法是由Twitter公布的分布式主键生成算法，它能够保证不同表的主键的不重复性，以及相同表的主键的有序性。

核心思想：长度共64bit（一个long型）。

首先是一个符号位，1bit标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0。
41bit时间截(毫秒级)，存储的是时间截的差值（当前时间截 - 开始时间截)，结果约等于69.73年。
10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID，可以部署在1024个节点）。
12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID）。

优点：整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞，并且效率较高。

@TableField

MyBatis-Plus在执行SQL语句时，也要保证实体类中的属性名和表中的字段名一致

情况1：

若实体类中的属性使用的是驼峰命名风格，而表中的字段使用的是下划线命名风格。此时MyBatis-Plus会自动将下划线命名风格转化为驼峰命名风格

情况2

此时需要在实体类属性上使用@TableField("username")设置属性所对应的字段名

@TableLogic

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

数据库中创建逻辑删除状态列，设置默认值为0；实体类中添加逻辑删除属性

@TableLogic
private Integer isDeleted

设置了该属性后，我们执行删除功能其实是执行的 update 语句，查询数据时也会自动加上WHERE is_deleted=0

4. 条件构造器和常用接口

wapper介绍

Wrapper ：条件构造抽象类，最顶端父类
- AbstractWrapper ：用于查询条件封装，生成 sql 的 where 条件
- QueryWrapper ：查询条件封装
- UpdateWrapper ： Update 条件封装
- AbstractLambdaWrapper ：使用Lambda 语法
  - LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
  - LambdaUpdateWrapper ： Lambda 更新封装Wrapper

QueryWrapper

@Test
public void test01(){
    //查询用户名包含a，并且邮箱不为null的用户信息
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.like("name", "a").isNotNull("email");
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println);
}

和Mybatis中的Example挺像

条件优先级：

@Test
public void test04() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //将（年龄大于20并且用户名中包含有a）或邮箱为null的用户信息修改
    queryWrapper
        .like("name", "a")
        .gt("age", 20)
        .or()
        .isNull("email");
    User user = new User();
    user.setAge(18);
    user.setEmail("user@123.com");
    int result = userMapper.update(user, queryWrapper);
    System.out.println("受影响的行数：" + result);
}
@Test
public void test04() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改
    //lambda表达式内的逻辑优先运算
    queryWrapper
        .like("name", "a")
        .and(i -> i.gt("age", 20).or().isNull("email"));
    User user = new User();
    user.setAge(18);
    user.setEmail("user@123.com");
    int result = userMapper.update(user, queryWrapper);
    System.out.println("受影响的行数：" + result);
}

组装select子句：

@Test
public void test05() {
    //查询用户信息的name和age字段
    //SELECT name,age FROM t_user
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("name", "age");
    List<Map<String, Object>> maps = uerMapper.selectMaps(queryWrapper);
    maps.forEach(System.out::println);
}

子查询：

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

UpdateWrapper

和QueryWrapper中的方法都差不多

@Test
public void test4() {
    UpdateWrapper<Buser> uw = new UpdateWrapper<>();
    uw.ne("password", "123456");
    uw.set("password","123456");
    int update = userMapper.update(null, uw);
    System.out.println(update);
}

相较而言，UpdateWrapper省去了我们创建对象填充数据的过程

条件组装

组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的，因此我们在组装这些条件时，必须先判断用户是否选择了这些条件

@Test
public void test08() {
    //定义查询条件，有可能为null（用户未输入或未选择）
    String name = null;
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0
    //且不由空白符(whitespace)构成
    if(StringUtils.isNotBlank(name)){
        queryWrapper.like("name","a");
    }
    if(ageBegin != null){
        queryWrapper.ge("age", ageBegin);
    }
    if(ageEnd != null){
        queryWrapper.le("age", ageEnd);
    }
    //SELECT * FROM t_user WHERE (age >= ? AND age <= ?)
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

StringUtils 是 MyBatisPlus 包中的，别导错了

MyBatisPlus 为我们提供了带condition参数的重载方法构建查询条件

@Test
public void test08UseCondition() {
    //定义查询条件，有可能为null（用户未输入或未选择）
    String name = null;
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .like(StringUtils.isNotBlank(name), "name", "a")
        .ge(ageBegin != null, "age", ageBegin)
        .le(ageEnd != null, "age", ageEnd);
    //SELECT * FROM t_user WHERE (age >=? AND age <= ?)
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

LambdaQueryWrapper

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

LambdaUpdateWrapper

@Test
public void test10() {
    //组装set子句
    LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
    updateWrapper
        .set(User::getAge, 18)
        .set(User::getEmail, "user@atguigu.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);
}

Wrappers

我们可以在日常开发中使用MyBatisPlus框架提供的Wrappers类优雅地实现我们的查询：

AuditWhiteList result = mapper.selectOne(Wrappers.lambdaQuery(new AuditWhiteList().setId(10L)));
//复杂写法
AuditWhiteList result = mapper.selectOne(Wrappers.<AuditWhiteList>lambdaQuery().eq(AuditWhiteList::getId,10L));
//示例
List<AuditWhiteList> list = auditWhiteListMapper.selectList(Wrappers.lambdaQuery(AuditWhiteList.class)
                        .in(AuditWhiteList::getProfessionId,ids));

5. 插件

分页插件

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能

@Configuration
public class MyConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

@Test
public void test5(){
    Page<Buser> page=new Page<>(1,3);
    userMapper.selectPage(page, null);
    page.getRecords().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自定义分页

/*
* 根据年龄查询用户列表，分页显示
* page 分页对象,xml从里面进行取值;传递参数 Page 即自动分页,必须放在第一位
*/
Page<User> myPage(@Param("page") Page<User> page, @Param("age") Integer age);

<!--SQL片段，记录基础字段-->
<sql id="Columns">id,name,age,email</sql>
<!--IPage<User> selectPageVo(Page<User> page, Integer age);-->
<select id="selectPageVo" resultType="User">
    SELECT <include refid="Columns"></include> FROM user WHERE age > #{age}
</select>

配置扫描JavaBean包：

mybatis-plus.type-aliases-package=com.demo.mybatisplus.pojo

乐观锁

乐观锁：多人同时修改同一条数据，只有第一次的提交生效
悲观锁：事务提交前，其他人都无法修改

乐观锁实现流程：数据库中添加version字段，更新时，version + 1，如果提交时的version版本不对，则更新失败

Mybatis-Plus实现乐观锁：@Version

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

添加乐观锁插件配置：

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

通用枚举

表中的有些字段值是固定的，例如性别，此时我们可以使用MyBatis-Plus的通用枚举来实现：@EnumValue

@Getter
public enum SexEnum {
    MALE(1, "男"),
    FEMALE(2, "女");
    //会将@EnumValue注解所标识的属性值存储到数据库
    @EnumValue
    private Integer sex;
    private String sexName;
    SexEnum(Integer sex, String sexName) {
        this.sex = sex;
        this.sexName = sexName;
    }
}

配置扫描通用枚举：

mybatis-plus.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 user ( username, age, sex ) VALUES ( ?, ?, ? )
    //Parameters: Enum(String), 20(Integer), 1(Integer)
    userMapper.insert(user);
}

6. 代码生成器

引入依赖：

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

快速生成配置：

public class MyCodeGenerator {
    public static void main(String[] args) throws IOException {
        // 获取当前Java进程的工作目录;当前项目的绝对路径
        String projectPath = System.getProperty("user.dir");
        // 使用类加载器加载配置文件
        InputStream input = MyCodeGenerator.class.getClassLoader().getResourceAsStream("mybatisPlus.properties");
        // 创建Properties对象
        Properties prop = new Properties();
        // 加载配置文件
        prop.load(input);

        FastAutoGenerator.create(prop.getProperty("codeGenerator.url"), prop.getProperty("codeGenerator.username"), prop.getProperty("codeGenerator.password"))
                .globalConfig(builder -> {
                    builder.author("Lemon") // 设置作者
                            // .enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .disableOpenDir()// 不要打开资源管理器
                            .outputDir(projectPath + "/src/main/java"); // 指定输出目录
                })
                // 策略配置
                .strategyConfig(builder -> {
                    builder.addInclude("t_train_courses") // 设置需要生成的表名
                            .addTablePrefix("t_train_")// 设置过滤表前缀
                            .serviceBuilder()
                            .formatServiceFileName("%sService")// 去掉service文件前面的i，%s会自动填充对象名
                            .entityBuilder()
                            // 使用Lombok注解并开启链式
                            .enableLombok()
                            .enableChainModel()
                            .enableRemoveIsPrefix()// 类型字段移除 is 前缀
                            .enableTableFieldAnnotation()// 开启生成实体时生成字段注解
                            .naming(NamingStrategy.underline_to_camel) // 数据库表映射到实体的命名策略
                            .columnNaming(NamingStrategy.underline_to_camel); // 数据库表字段映射到实体的命名策略

                })
                .packageConfig(builder -> {
                    builder.parent("com") // 设置父包名
                            // 这里是设置各个文件类型的包名
                            .xml("mapper")
                            .entity("domain")
                            .mapper("mapper")
                            .service("service")
                            .controller("controller")
                            .moduleName("codeGenerator"); // 设置父包模块名);
                })
                .injectionConfig(builder -> {
                    // 自定义配置Map
                    Map<String, Object> map = new HashMap<>();
                    // 修改typeConvert属性
                    map.put("typeConvert", new MySqlTypeConvert() {
                        @Override
                        public IColumnType processTypeConvert(GlobalConfig config, String fieldType) {
                            // 打印数据库字段类型，用于验证是否触发了自定义类型转换逻辑
                            System.out.println("Database Field Type: " + fieldType);

                            // 将数据库的datetime类型映射为Java的Date类型
                            if (fieldType.equalsIgnoreCase("datetime")) {
                                System.out.println("Mapping to Java Date Type");
                                return DbColumnType.DATE;
                            }
                            if (fieldType.equalsIgnoreCase("tinyint")) {
                                return DbColumnType.INTEGER;
                            }
                            return super.processTypeConvert(config, fieldType);
                        }
                    });
                    builder.customMap(map);
                })
                // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .templateEngine(new FreemarkerTemplateEngine())
                .execute();
    }
}

目前不清楚怎么指定MySQL对应Java数据的映射怎么修改

记录遇到一个小Bug，MySQL中字段名是关键字，在调用MyBatisPlus的方法时直接报错，解决方案：在注解处加``

@Getter
@Setter
@Accessors(chain = true)
@TableName("t_train_courses")
public class Courses implements Serializable {
		...
    /**
     * 课程简介
     */
    @TableField("`describe`")
    private String describe;
		...
}

交互式生成：

FastAutoGenerator.create(DATA_SOURCE_CONFIG)
    // 全局配置
    .globalConfig((scanner, builder) -> builder.author(scanner.apply("请输入作者名称？")).fileOverride())
    // 包配置
    .packageConfig((scanner, builder) -> builder.parent(scanner.apply("请输入包名？")))
    // 策略配置
    .strategyConfig((scanner, builder) -> builder.addInclude(getTables(scanner.apply("请输入表名，多个英文逗号分隔？所有输入 all")))
                    .controllerBuilder().enableRestStyle().enableHyphenStyle()
                    .entityBuilder().enableLombok().addTableFills(
                        new Column("create_time", FieldFill.INSERT)
                    ).build())
    /*
        模板引擎配置，默认 Velocity 可选模板引擎 Beetl 或 Freemarker
       .templateEngine(new BeetlTemplateEngine())
       .templateEngine(new FreemarkerTemplateEngine())
     */
    .execute();

// 处理 all 情况
protected static List<String> getTables(String tables) {
    return "all".equals(tables) ? Collections.emptyList() : Arrays.asList(tables.split(","));
}

7. 多数据源

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

引入依赖：

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

配置多数据源：

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

在创建Service的实现类时，我们需要指明操作的数据库：@DS

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

@DS 也可以加在方法上实现读写分离：将写操作方法加上主库数据源，读操作方法加上从库数据源，自动切换

8. MyBatisX 插件

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

MybatisX快速开发插件 | MyBatis-Plus (baomidou.com)

快速生成代码

直接点击就可以快速生成代码

MyBatisX还帮我们创建了很多模板：

alt+enter 还能帮我们创建好mapper映射中的SQL语句

posted @ 2023-11-23 16:40 LemonPuer 阅读(86) 评论(0) 收藏举报

刷新页面返回顶部

柠檬普洱