Mybatis-Plus详解

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 操作智能分析阻断，也可自定义拦截规则，预防误操作

快速开始

官网地址

基本思路

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, ''), (2, 'Jack', 20, ''), (3, 'Tom', 28, ''), (4, 'Sandy', 21, ''), (5, 'Billie', 24, ''); 

3、初始化项目

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

4、引入对应依赖

  
    <dependency> <groupId>mysql 
     groupId> <artifactId>mysql-connector-java 
      artifactId>  
       dependency>  
       <dependency> <groupId>org.projectlombok 
        groupId> <artifactId>lombok 
         artifactId>  
          dependency>  
          <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:  #其中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是对应的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.

日志配置

使用yml添加日志配置项

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

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

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

插入测试

插入及日志分析

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

日志分析

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

注意，数据库插入的默认值是全局唯一的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。具体实现的代码可以参看https://github.com/twitter/snowflake。雪花算法支持的TPS可以达到419万左右（2^22*1000）,几乎保证全球唯一。

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

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

更新测试

更新及日志分析

 //更新测试 @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 { 
    //源码 ..... / * 字段自动填充策略 * 
 * 在对应模式下将会忽略 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、接下来的代码执行插入、更新时都会自动设置时间了

乐观锁

乐观锁原理

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

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

官方乐观锁写法

乐观锁（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(""); user.setName("小垃圾"); //3、更新操作 userMapper.updateById(user); } 

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

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

 @Test public void testOptimisticLocker2(){ 
    //模拟多线程 User user = userMapper.selectById(3L); user.setEmail(""); user.setName("帅小伙111");//我们在这里对线程1修改值 //线程2插队 User user2 = userMapper.selectById(3L); user2.setEmail(""); 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); } 

日志分析

分页查询

官方分页插件写法

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 selectPage(P page, @Param(Constants.WRAPPER) Wrapper           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

删除测试

常见删除

 //删除测试 @Test public void testDeleteById(){ 
    userMapper.deleteById(L); // 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); } 

性能分析插件

官方使用的p6spy性能有损耗，推荐使用其他第三方性能分析插件，比如阿里巴巴的Druid。

条件构造器Wrapper（重点）

之前我们写crud时候经常碰到一个参数叫做wrapper，我们写的都是null，他到底是什么。

官方链接，条件构造器

我们之前一直是增删改查，没有一个是带条件的，而这个条件构造器就相当于sql中加了一个where,

QueryWrapper和 UpdateWrapper,分别是用于生成查和改 的 sql 的 where 条件

例如, 查询多条记录与单条记录

 @Test void contextLoads() { 
    //----------查询多个 //查询一个复杂的，比如查询用户name、邮箱不为空，年龄大于20的用户 QueryWrapper<User> wrapper = new QueryWrapper<>(); //首先新建一个 QueryWrapper //链式编程 添加查询条件 wrapper.isNotNull("name") .eq("email","@.com") .ge("age",12); userMapper.selectList(wrapper).forEach(System.out::println); //----------查询单个 User user = userMapper.selectOne(wrapper); //出现多个结果会报错，查询一个 System.out.println("user = " + user); } // eq相等 ne不相等， gt大于， lt小于 ge大于等于 le 小于等于 // equal/ not equal/ greater than/ less than/ less than or equal/ great than or equal/ 

日志分析，就是在where中添加了多个条件

区间查询与计数，between()，selectCount()

@Test void test2() { 
    //查询区间内的记录 QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.between("age",20,30); Integer count = userMapper.selectCount(wrapper); System.out.println("count = " + count); } 

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z14L81qV-45)(C:/Users/Dell/AppData/Roaming/Typora/typora-user-images/image-.png)]

模糊查询

@Test void test3() { 
    //模糊查询 QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.like("name",99) // 名字中 存在 99 .notLike("name",6) // 名字中 不存在 6 .likeRight("email",2) // 邮箱 最右边是m %m .likeLeft("email","m"); // 邮箱 最左边是2 2% userMapper.selectMaps(wrapper); } 

子查询（多表查询）

void test4() { 
    //子查询 QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.inSql("id","select id from table where id <2"); userMapper.selectObjs(wrapper).forEach(System.out::println); } 

排序

@Test void test5() { 
    //排序  QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.orderByAsc("id"); //根据id升序排列 降序orderByDesc()略 userMapper.selectList(wrapper).forEach(System.out::println); } 

分组，条件

@Test void test7() { 
    //分组排序 QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.groupBy("version").having("version = 1"); userMapper.selectList(wrapper).forEach(System.out::println); } 

其他warpper条件见官网官方链接，条件构造器

代码自动生成器（重点）

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

使用步骤

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

  
    <dependency> <groupId>com.baomidou 
     groupId> <artifactId>mybatis-plus-generator 
      artifactId> <version>3.4.1 
       version>  
        dependency>  
        <dependency> <groupId>io.swagger 
         groupId> <artifactId>swagger-annotations 
          artifactId> <version>1.5.20 
           version>  
            dependency>  
            <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 { 
    / * 
 * 读取控制台内容 * 
 */ 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(""); 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 
   
     的链表 
    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(); } } 

写在后面

感谢你看到这篇博客，博主目前是一名大四的在校生，目前也是处于学习阶段，希望我们一起进步。

对于mybatis plus的使用，如果各位有什么疑问欢迎骚扰，有时间我会回复，你的支持是我学习最大的动力，谢谢!

代码已经开源GitHub：本博客全部代码地址