Mybatis-Plus基础

1.Mybatis-Plus介绍（了解）

简介

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

特性

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑

• 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作，BaseMapper

• 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求，简单的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 操作智能分析阻断，也可自定义拦截规则，预防误操作

2.快速开始（操作）

官网地址

基本思路

1、导入对应的依赖

2、研究依赖的配置

3、代码如何编写

4、提高扩展技术

实现步骤

1、创建数据库myBatis-plus

2、创建user表插入数据

DROP TABLE IF EXISTS user;
​
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)
);
-- 真实开发中，version(乐观锁)、deleted(逻辑删除)、gmt_create(创建时间)、gmt_modified(修改时间)
​
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');

3、初始化项目

新建一个springboot，maven项目,详略

4、引入对应依赖

        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- lombok 简化set get toString -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3.1</version>
        </dependency>

注意：使用mybatis-plus可以节省大量代码，不要同时导入mybatis和mybatis-plus，可能存在版本冲突

5、链接数据库(同mybatis)

注意，mysql 8 的驱动不同，而且需要加上时区的配置

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
#其中url中，数据库名称？是否使用安全链接，字符集编码，是否使用解码，设置时区
​
#mysql数据库用的是gbk编码，而项目数据库用的是utf-8编码。这时候如果添加了useUnicode=true&characterEncoding=UTF-8
#存数据时：
#数据库在存放项目数据的时候会先用UTF-8格式将数据解码成字节码，然后再将解码后的字节码重新使用GBK编码存放到数据库中。
#取数据时：
#在从数据库中取数据的时候，数据库会先将数据库中的数据按GBK格式解码成字节码，然后再将解码后的字节码重新按UTF-8格式编码数据，最后再将数据返回给客户端。

6.使用mybatis-plus

6.传统方式pojo层 dao层(链接mybatis, 配置mapper.xml文件) service层 controller层很繁琐

• 创建pojo类

  @Data
  @AllArgsConstructor #有参构造器
  @NoArgsConstructor  #无参构造器
  public class User {
      //常见的数据库中主键自动设置方法有（uuid、自增id、雪花算法、redis生成、zookeeper生成）
      private Long id;
      private String name;
      private Integer age;
      private String email;
  }

• 在启动类加上@mapper注解,扫描mapper文件夹

  @SpringBootApplication
  @MapperScan("com.jdw.mapper")

• mapper接口

  //在对应的Mapper 接口上 基础基本的 BaseMapper<T> T是对应的pojo类
  @Repository   //告诉容器你是持久层的 @Repository是spring提供的注释，能够将该类注册成Bean
  public interface UserMapper extends BaseMapper<User> {
      //所有的crud都编写完成了
  }

  支持，mybatis-plus已经配置完成，可以直接使用，CRUD。

• 使用测试类@Test测试

  //继承了BaseMapper ,所有方法来自父类，可扩展
  @Autowired
  private UserMapper userMapper;
  ​
  @Test
  void contextLoads() {
      System.out.println(("----- selectAll method test 测试查询所有用户方法 ------"));
      //selectList 的参数wrapper 是条件构造器，可以先写null
      List<User> userList = userMapper.selectList(null);
      //forEach 的参数是 Consumer类型的 语法糖
      userList.forEach(System.out::println);
  }

  思考,我们没有写sql就查询了结果，那么，sql谁写的，方法哪来的？答案都是mybatis-plus.

3.日志配置（操作）

使用yml添加日志配置项

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

执行查询方法查看分析日志

执行上面的查询所有用户的方法查看日志

4.插入测试（操作）

插入及日志分析

//测试插入
@Test
public void testInsert(){
    User user = new User();
    user.setName("小蒋");
    user.setAge(3);
    user.setEmail("2474950959@qq.com");
    //没有设置ID却自动生成的ID
    int result = userMapper.insert(user);
    System.out.println("result = " + result);
    System.out.println("user = " + user);
}

日志分析

我们可以看到，并没有给user设置id，数据库自动插入了id=1453311479846608897，

注意，数据库插入的默认值是全局唯一的id,这个id看起来也太奇怪了，到底是怎么生成的呢？

主键生成策略

因为在最开始建表的sql语句中就指明了，id是数据库的主键，主键不能唯一，

常见的数据库中主键自动设置方法有（uuid、自增id、雪花算法、redis生成、zookeeper生成）

详情见：分布式系统唯一ID生成方案

雪花算法

这里生成的id默认采用的是雪花算法：

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。具体实现的代码可以参看GitHub - twitter-archive/snowflake: Snowflake is a network service for generating unique ID numbers at high scale with some simple guarantees.。雪花算法支持的TPS可以达到419万左右（2^22*1000）,几乎保证全球唯一。

雪花算法在工程实现上有单机版本和分布式版本。单机版本如下，分布式版本可以参看美团leaf算法：GitHub - Meituan-Dianping/Leaf: Distributed ID Generate Service

可以在User类的id属性上加入注解TableId更改和查看策略

type = IdType.ASSIGN_ID，全局唯一id，雪花算法

public class User {
    @TableId(type = IdType.ASSIGN_ID,value = "id")//枚举注解,使用ID_WORKER策略,全局唯一ID，数据库设置自增也没用
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

进入这个注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})  //枚举注解
public @interface TableId {
    //可以设置以下两个参数
    String value() default "";
    IdType type() default IdType.NONE; //ID策略
}

主键自增策略

要是自增策略，在id上加入下列代码

@TableId(type = IdType.AUTO)
private Long id;

同时数据库设计时，一定要将id设计为自增，这样自增id会设置在最大值上加1

其他策略

public enum IdType {
    /**
     * 数据库ID自增
     * <p>该类型请确保数据库设置了 ID自增 否则无效</p>
     */
    AUTO(0),
    /**
     * 该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)
     */
    NONE(1),
    /**
     * 用户输入ID
     * <p>该类型可以通过自己注册自动填充插件进行填充</p>
     */
    INPUT(2),

    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
    /**
     * 分配ID (主键类型为number或string）,
     * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(雪花算法)
     *
     * @since 3.3.0
     */
    ASSIGN_ID(3),
    /**
     * 分配UUID (主键类型为 string)
     * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(UUID.replace("-",""))
     */
    ASSIGN_UUID(4);

    private final int key;

    IdType(int key) {
        this.key = key;
    }
}

5.更新测试（操作）

更新及日志分析

	//更新测试
	@Test
    public void testUpdateByID() {
        User user = new User();
        user.setId(7L);
        user.setName("小小");
        user.setAge(18);//这一行后加
        int i = userMapper.updateById(user);//受影响的行数,参数是一个user不是id,点击看源码
        System.out.println("i = " + i);
    }

我可以发现，先只更新了名字，后面更新名字和年龄。mybatis-plus通过条件自动把我们进行了动态sql拼接，

自动填充

创建时间、更新时间！这个操作是自动化完成的，不要手动更新！

gmt_create、gmt_modified几乎在所有表都要配置上，而且自动化填充。gmt是时间时间的意思

方式一、数据库级别（不建议）

在数据库种添加字段gmt_create、gmt_modified，然后在pojo类中添加这两个属性，下次就可以查看了.(博主使用的是Navigat)

private Data gmtCreate;
private Data gmtModified;

方式二、代码级别

1、在数据库中删除掉根据当前时间戳更新的选项

2、在实体类的成员变量上添加注解@TableField

@TableField字段注解描述

    //字段添加填充内容
    @TableField(fill = FieldFill.INSERT ,value = "create_time")
    private LocalDateTime createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE ,value = "update_time")
    private LocalDateTime updateTime;

public @interface TableField { //源码
   .....

​ /** ​ * 字段自动填充策略 ​ * <p> ​ * 在对应模式下将会忽略 insertStrategy 或 updateStrategy 的配置,等于断言该字段必有值 ​ */ ​ FieldFill fill() default FieldFill.DEFAULT; ​ ... }

//填充策略
public enum FieldFill {
    /**
     * 默认不处理
     */
    DEFAULT,
    /**
     * 插入时填充字段
     */
    INSERT,
    /**
     * 更新时填充字段
     */
    UPDATE,
    /**
     * 插入和更新时填充字段
     */
    INSERT_UPDATE
}

3、编写处理器来处理这个注解

官方填充处理器写法

@Slf4j //日志
@Component//以组件的形式把这个处理器注册到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {

    //插入时启动  第三个参数 LocalDateTime 一定要和 createTime成员变量的值的类型一致，不然是null 如果是date就都设置date
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill ....");
        this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐使用)
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐)
    }

    //更新时候启动
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill ....");
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐)
    }
}

4、接下来的代码执行插入、更新时都会自动设置时间了

6.乐观锁（了解）

乐观锁原理

乐观锁：顾名思义十分乐观，他总是认为不会出现问题，无论干什么都不会上锁！如果出现了问题，就再次更新值加锁处理

悲观锁：顾名思义十分悲观，他总是认为无论干什么都会出现问题，所以都会上锁，再操作！

官方乐观锁写法

乐观锁（OptimisticLockerInnerInterceptor）机制:

当要更新一条记录的时候，希望这条记录没有被别人更新

乐观锁实现方式：

• 取出记录时，获取当前version

• 更新时，带上这个version

• 执行更新时， set version = newVersion where version = oldVersion

• 如果version不对，就更新失败

相当于给每一个记录都加一个version字段。当我们要改记录时，把version字段拿出来看一看，对比一下这个version 有没有在你操作数据时被其他线程更改，如果依然等于oldVersion，你就对数据进行操作同时把 version = newVersion 更新（比如+1），以此你在改数据的途中告诉其他线程不要读了脏数据。

--A 线程
update user set name = "jdw" ,version = version + 1   --version = newVersion  version有默认值比如1 
where id = 2 and version = 1  -- version = oldVersion
--B 线程 抢先完成，此时version=2,导致A线程的  version = oldVersion 不匹配A的oldVersion A将会修改失败,防止数据库产生脏数据
update user set name = "jdw" ,version = version + 1   --version = newVersion  version有默认值比如1 
where id = 2 and version = 1  -- version = oldVersion

乐观锁的应用

测试更新

1、在数据库添加version字段，int型,默认0,长度10,不自增

2、在User类中添加对应属性：

@Version //乐观锁注解
private int version;

说明: Version

• 支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime

• 整数类型下 newVersion = oldVersion + 1

• newVersion 会回写到 entity 中

• 仅支持 updateById(id) 与 update(entity, wrapper) 方法

• 在 update(entity, wrapper) 方法下, wrapper 不能复用!!!

3、在config下注册组件，开启乐观锁拦截器

@EnableTransactionManagement  //开启事务
@Configuration  //配置类注解
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());//乐观锁插件拦截器OptimisticLockerInnerInterceptor
        return mybatisPlusInterceptor;
    }
}

4.测试乐观锁

@Test
public void testOptimisticLocker(){
    //1、查询用户信息
    User user = userMapper.selectById(1L);
    //2、修改用户信息
    user.setEmail("123@qq.com");
    user.setName("小垃圾");
    //3、更新操作
    userMapper.updateById(user);
}

在测试代码中我们并没有更新version数据库的version已经变成2了，下面是日志分析：

5.模拟多线程下乐观锁失败案例

 @Test
    public void testOptimisticLocker2(){
        //模拟多线程
        User user = userMapper.selectById(3L);
        user.setEmail("123jdw@qq.com");
        user.setName("帅小伙111");//我们在这里对线程1修改值

        //线程2插队
        User user2 = userMapper.selectById(3L);
        user2.setEmail("321jdw@qq.com");
        user2.setName("帅小伙222");
        userMapper.updateById(user2); //线程2抢先提交

        userMapper.updateById(user);//线程1失败，乐观锁在这种情况下防止了脏数据存在，没有乐观锁就会有覆盖掉线程2的操作
    }

测试查询

1、查询单用户

//查询单用户
@Test
public void testSelectBatchId(){
    User user = userMapper.selectById(1L);
    System.out.println(user);
}

2、多用户查询

//查询指定多用户
@Test
public void testSelectBatchIds() {
    //Arrays.asList()创建了一个固定大小的集合   
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));//参数Collection的集合
    users.forEach(System.out::println);
}

Arrays.asList()详解

//  selectBatchIds 源码
/**
 * 查询（根据ID 批量查询）
 *
 * @param idList 主键ID列表(不能为 null 以及 empty)
 */
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

日志分析：内部解析的是一个 IN 条件

3、条件查询

//条件查询，-- HashMap
@Test
public void testSelectByMap() {
    HashMap<String, Object> map = new HashMap<>();
    //定义查询条件
    map.put("name", "小蒋"); //where k = v
    map.put("age",3);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}

日志分析

7.分页查询（操作）

官方分页插件写法

1、配置拦截器

public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());//创建乐观锁拦截器 OptimisticLockerInnerInterceptor
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); //插件分页拦截器，我的是mysql
        return mybatisPlusInterceptor;
    }
}

2、使用page对象即可

    //测试分页查询
    @Test
    public void testPage() {
        Page<User> page = new Page<>(1,5); //开启拦截器后，会注册一个page对象  当前页，每页条数
        //方法源码：   <P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
        userMapper.selectPage(page,null); //分页查询
        page.getRecords().forEach(System.out::println); //获取分页后的数据 打印
        System.out.println(page.getTotal()); //获取记录总数
    }

/**源码
 * 分页构造函数
 *
 * @param current 当前页
 * @param size    每页显示条数
 */
public Page(long current, long size) {
    this(current, size, 0);
}

日志分析

底层也是把他转化成limit

8.删除测试（操作）

常见删除

    //删除测试
    @Test
    public void testDeleteById(){
        userMapper.deleteById(1453324799370616833L);
    	// userMapper.delete(null); //全部删除
    }

从上往下分别是：根据id删除，根据 entity 条件删除记录，通过多个id批量删除，根据map条件删除

逻辑删除

物理删除：在数据库中移除

逻辑删除：数据库中没有移除，而是在代码中使用一个变量来使他失效！(如：delete = 0 => delete = 1; )

就比如，管理员可以查看被删除的记录！防止数据丢失。类似于回收站。用户就没法查看删除记录。

逻辑删除官网链接

1、在数据库添加deleted字段

2、同步实体类中，同时添加@TableLogic//逻辑删除注解

@TableLogic//逻辑删除
private Integer deleted;

3、在配置文件yml中配置

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: flag  # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以不加步骤2的注解)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

4、测试删除

执行删除操作，实际上是执行更新操作，把deleted字段改为1了

        @Test
    public void testDeleteById(){
        userMapper.deleteById(1L);
    	// userMapper.delete(null); //全部删除
    }

数据库中也是没被上，改了值而已

如果我们再去查询这个id=1的用户发现，查不到，mybatis-plus 自动拼接了deleted字段在where中判断。

@Test
public void testSelectBatchId() {
    User user = userMapper.selectById(1L);
    System.out.println(user);
}

9.代码自动生成器（操作）

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

使用步骤

配置依赖，添加如下依赖，当然，不要忘记还要 快速开始第一章节的依赖

		<!-- mp 代码生成器 依赖 -->
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-generator</artifactId>
			<version>3.4.1</version>
		</dependency>
		<!-- 导入swagger -->
        <dependency>
            <groupId>io.swagger</groupId>
            <artifactId>swagger-annotations</artifactId>
            <version>1.5.20</version>
        </dependency>
		<!-- 添加模板引擎，thymeleaf 还有freemarker都是模板引擎 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-freemarker</artifactId>
		</dependency>

在任意文件夹新建立一个类进行配置

类的代码如下

package com.jdw;
​
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
​
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
​
// 演示例子，执行 main 方法控制台输入模块表名回车自动生成对应项目目录中
public class CodeGenerator {
​
    /**
     * <p>
     * 读取控制台内容
     * </p>
     */
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotBlank(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }
​
    public static void main(String[] args) {
        // 代码生成器
        //构建一个代码自动生成器对象
        AutoGenerator mpg = new AutoGenerator();
​
        // 1、创建全局配置类的对象
        GlobalConfig gc = new GlobalConfig();
        //获取当前项目路径
        String projectPath = System.getProperty("user.dir");
        System.out.println("projectPath = " + projectPath);
        //自动生成代码存放的路径
        gc.setOutputDir(projectPath + "/src/main/java");
        //设置 --作者注释
        gc.setAuthor("jdw");
        //是否打开文件夹
        gc.setOpen(false);
        //是否覆盖已有文件
        gc.setFileOverride(false);
        //各层文件名称方式，例如： %sAction 生成 UserAction  %s占位符
        gc.setServiceName("%sService");
        //设置日期策略  date类型
        gc.setDateType(DateType.ONLY_DATE);
        //设置主键策略 雪花算法
        gc.setIdType(IdType.ASSIGN_ID);
        //设置开启 swagger2 模式
        gc.setSwagger2(true);
        //把全局配置放入代码生成器
        mpg.setGlobalConfig(gc);
​
        // 2、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/vueblog?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("123456");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc); //把数据源配置加入到代码生成器
​
        // 3、包配置
        PackageConfig pc = new PackageConfig();
        pc.setParent("com.jdw");
        pc.setEntity("entity");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        // ...  有默认值，点击查看源码
        mpg.setPackageInfo(pc);//包加入代码生成器
​
        // 4、策略配置
        StrategyConfig strategy = new StrategyConfig();
        //下划线转驼峰命名  表
        strategy.setNaming(NamingStrategy.underline_to_camel);
        // 下划线转驼峰命名字段
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        //实体类是否加上lombok注解
        strategy.setEntityLombokModel(true);
        //控制层采用RestControllerStyle注解
        strategy.setRestControllerStyle(true);
        // RequestMapping中 驼峰转连字符 -
        strategy.setControllerMappingHyphenStyle(true);
        //要映射的数据库表名  （重点）
        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
        //添加表名前缀
        //strategy.setTablePrefix("m_"); //自动拼接上m_
        //逻辑删除字段名
        strategy.setLogicDeleteFieldName("deleted");
        //乐观锁字段名
        strategy.setVersionFieldName("version");
        // -------自动填充策略
        ArrayList<TableFill> fillList = new ArrayList<>();
        fillList.add(new TableFill("createTime", FieldFill.INSERT));
        fillList.add(new TableFill("updateTime",FieldFill.INSERT_UPDATE));
        // 参数是 List<TableFill> 的链表
        strategy.setTableFillList(fillList);
        mpg.setStrategy(strategy);
​
        //---------------------------------
        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };
​
        // 如果模板引擎是 freemarker
        String templatePath = "/templates/mapper.xml.ftl";
        // 如果模板引擎是 velocity
        // String templatePath = "/templates/mapper.xml.vm";
​
        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override 
            //输出了 静态资源下的 Mapper
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return projectPath + "/src/main/resources/mapper/" + pc.getModuleName()
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });
​
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);
​
        //        FreemarkerTemplateEngine模板引擎
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        mpg.execute();
    }
}