springboot在线状态管理 springboot wms

1、需要引入的依赖：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.2</version>
        </dependency>

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

2、注意事项：

尽量不要同时导入MyBatios和MyBatis-Plus，会有版本兼容的问题产生。

3、实现流程：

（1）pojo;

package com.syf.mind.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private String password;
    private Integer sex;
    private String email;
    private Integer status;
}

(2)mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.syf.mind.pojo.User;
import org.springframework.stereotype.Repository;

//在对应的Maper上面继承基本的类BaseMapper
@Repository //持久层
public interface UserMapper extends BaseMapper<User> {
       //所有的CRUD操作都已经编写完成了
       //不需要再像以前的那样配置一大堆文件了！
}

注意点，我们需要在主启动类上去扫描我们的mapper包下的所有接口@MapperScan("com.syf.mind.mapper") (3)使用;
在测试类中去玩一把：

@SpringBootTest
class MindApplicationTests {

    @Autowired
    UserMapper userMapper;
    @Test
    void contextLoads() {
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }

}

结果全部查出来即可：

思考：我们并没有写查询的SQL语句，但实现了查询效果，是如何做到的呢？CRUD的方法从哪里来的呢？

对的，是Mybatis-Plus帮我们完成的。

4、配日志

在applicatio.yml配置文件中加入如下的内容即可：

#配置日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

配置好日志以后的运行结果就会显示mybatis-plus是如何自动帮我们实现CRUD：

5、CRUD扩展：

5.1、执行插入操作：

@Test
    public void testInsert(){
        User user=new User();
        user.setName("石宇峰");
        user.setPassword("admin");
        user.setEmail("[e-mail]");
        user.setSex(0);
        int result=userMapper.insert(user);//帮我们自动生成Id
        System.out.println(user);//受影响的行数
        System.out.println(result);//发现Id会自动回填
    }

运行结果如图所示：

数据库插入的id默认值为：全局的唯一Id。

5.1.2、主键的生成策略：

分布式系统唯一ID生成：点击进入 1、数据库自增长序列或字段：
最常见的方式，利用数据库，全数据库唯一。
2、UUID:
常见的方式。可以利用数据库也可以利用程序生成，一般来说全球唯一。
3、UUID的变种：
（1）为了解决UUID不可读，可以使用UUID to int64的方法。
（2）为了解决UUID无序的问题，Hibernate在其主键生成方法中提供了Comb算法。
4、Redis生成ID：
当使用数据库来生成ID性能不够要求的时候，我们可以尝试使用Redis来生成ID。这主要依赖于Redis是单线程的，所以也可以用生成全局唯一的ID。可以用Redis的原子操作 INCR和INCRBY来实现。
5、利用zookeeper生成唯一ID：
（1）zookeeper主要通过其znode数据版本来生成序列号，可以生成32位和64位的数据版本号，客户端可以使用这个版本号来作为唯一的序列号。
很少会使用zookeeper来生成唯一ID。主要是由于需要依赖zookeeper，并且是多步调用API，如果在竞争较大的情况下，需要考虑使用分布式锁。因此，性能在高并发的分布式环境下，也不甚理想。
6、MongDB的ObjectID:
MongoDB的ObjectId和snowflake算法类似。它设计成轻量型的，不同的机器都能用全局唯一的同种方法方便地生成它。MongoDB 从一开始就设计用来作为分布式数据库，处理多个节点是一个核心要求。使其在分片环境中要容易生成得多。
7、Twitter的snowflake算法：
snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。

5.1.3、主键自增：

我们需要配置主键自增：

1、在字段实体类的Id属性上加注解：@TableId(type = IdType.AUTO)；

2、数据库的Id字段一定是自动生成的：

然后我们接着在执行一次插入操作,看是否实现了Id自增的效果：

可以看到我们新添加数据的ID确实自增了，尾数由762增至763了。

3、不同主键生成策略的源码解析：

public enum IdType {
    AUTO(0),//数据库自增Id
    NONE(1),//未设置主键
    INPUT(2),//手动输入，自己必须配置ID
    ASSIGN_ID(3),
    ASSIGN_UUID(4),
    /** @deprecated */
    @Deprecated
    ID_WORKER(3),//默认的全局唯一ID
    /** @deprecated */
    @Deprecated
    ID_WORKER_STR(3),//ID_WORKER的字符串表示法，全局唯一ID
    /** @deprecated */
    @Deprecated
    UUID(4);//uuid也也是全局唯一的

    private final int key;

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

    public int getKey() {
        return this.key;
    }
}

5.2、更新操作：

5.2.1、将主键为6的一行数据修改一下：

@Test
    public void testUpdate(){
        User user=new User();
        user.setId(6L);
        user.setName("充电器");
        user.setPassword("admin");
        user.setEmail("[e-mail]");
        user.setSex(1);
        userMapper.updateById(user);
    }

修改前的数据库：

修改后的数据库：

可以看到已经成功修改了。

我们看看日志信息：

可以发现MybatisPlus已经帮我们自动拼接条件查询的SQL语句了。

5.2.2、自动填充

创建时间（create_time），修改时间(upate_time)，这些我们希望都是自动完成的，不希望手动去操作！

如何实现呢？一般有如下做法：

（1）数据库级别：

在数据库表中添加需要记录时间的字段，并设置默认值（一般是根据当前时间戳更新）：

当然对应的实体类也要做修改：

public class User {
    //配置主键生成策略
    @TableId(type = IdType.INPUT)
    private Long id;
    private String name;
    private String password;
    private Integer sex;
    private String email;
    private Integer status;
    //创建时间
    private Date createTime;
    //更新时间
    private Date updateTime;
}

然后我们再执行一次插入操作,看看数据库的变化：

@Test
    public void testInsert(){
        User user=new User();
        user.setId(8L);
        user.setName("宋欣12");
        user.setPassword("admin");
        user.setEmail("[e-mail]");
        user.setSex(0);
        int result=userMapper.insert(user);//帮我们自动生成Id
        System.out.println(user);//受影响的行数
        System.out.println(result);//发现Id会自动回填
    }

可以看到时间戳已近加上去了。

（2）代码级别

实体类字段属性上加注解：

//字段添加填充内容
    @TableField(fill= FieldFill.INSERT)
    private Date createTime;
    @TableField(fill=FieldFill.INSERT_UPDATE)
    private Date updateTime;

然后编写一个Handler处理器：

@Slf4j
@Component  //将我们自己写的处理器加入到IOC容器当中
public class MyDataObjectedHandler implements MetaObjectHandler {
    //插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        //setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject)
        log.info("start insert fill......");
        this.setFieldValByName("createTime", new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }

    //更新时的填充策略
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill......");
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

测试一把：
先来个插入操作：

@Test
    public void testInsert(){
        User user=new User();
        user.setName("李文凤");
        user.setPassword("admin");
        user.setEmail("[e-mail]");
        user.setSex(0);
        int result=userMapper.insert(user);//帮我们自动生成Id
        System.out.println(user);//受影响的行数
        System.out.println(result);//发现Id会自动回填
    }

可以看时间戳已近加上去了。

再来个更新操作：

@Test
    public void testUpdate(){
        User user=new User();
        user.setId(1385148305511669766L);
        user.setName("课题，立场");
        user.setPassword("admin");
        user.setEmail("[e-mail]");
        user.setSex(0);
        userMapper.updateById(user);
    }

可以清晰的看到只是修改了update_time字段的值。5.3.3、乐观锁

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

乐观锁实现方式：

取出记录时，获取当前version

更新时，带上这个version

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

如果version不对，就更新失败

MP如何实现呢？

（1）先在数据库中的表中加上对应字段：version

说明:
支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
整数类型下 newVersion = oldVersion + 1
newVersion 会回写到 entity 中
仅支持 updateById(id) 与 update(entity, wrapper) 方法
在 update(entity, wrapper) 方法下, wrapper 不能复用!!!
(2)根据ORM，对应的实体类也要加上一个version的属性。

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

（3）注册组件

// Spring Boot 方式
@Configuration
@MapperScan("按需修改")
public class MybatisPlusConfig {
    /**
     * 旧版
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
    
    /**
     * 新版
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

这里是我的项目配置示例：

@MapperScan("com.syf.mind.mapper")
@Configuration
@EnableTransactionManagement
public class MybatisPlusConfig {
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

（4）测试一把

@Test
    public void optimisticLockerTest(){
        //1、查询用户信息
        User user=userMapper.selectById(2L);
        //2、修改用户信息
        user.setName("小美");
        user.setEmail("[e-mail]");
        //3、执行修改操作
        userMapper.updateById(user);
    }

可以看到version的值确实增加为2了，说在单线程的情况下确实执行成功了。

模拟多线程情况下，多个线程访问统一资源的情况：

@Test
    public void optimisticLockerTest2(){
        //1、查询用户信息
        User user=userMapper.selectById(3L);
        //2、修改用户信息
        user.setName("小美111");
        user.setEmail("[e-mail]");

        //模拟一个线程插队
        //1、查询用户信息
        User user2=userMapper.selectById(3L);
        //2、修改用户信息
        user2.setName("小美222");
        user2.setEmail("[e-mail]");
        //第二个线程插队执行修改操作
        userMapper.updateById(user2);
        
        //然后第一个线程执行修改操作
        userMapper.updateById(user);
    }

可以看到插队的线程完成了更新，乐观锁还是起作用了。

5.3查询

5.3.1基本查询

//测试查询
  @Test
    public void testSelectBatchIds(){
        User user = userMapper.selectById(3L);
        System.out.println(user);
    }
    //测试批量查询
    @Test
    public void testSelectBatchIds(){
        List<User> users =userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.forEach(System.out::println);
    }
    @Test//按条件查询值使用Map
    public void testSelectByMap(){
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("password","admin");
        List<User> users=userMapper.selectByMap(hashMap);
        users.forEach(System.out::println);
    }

5.3.2分页查询
（1）分页组件：
有原始的limit进行分页、pagHelper第三方插件、MP内置的分页插件等。
在SpringBot项目中我们首先配置拦截器组件即可，以下是官方文档中的写法：

//Spring boot方式
@Configuration
@MapperScan("com.baomidou.cloud.service.*.mapper*")
public class MybatisPlusConfig {

    // 旧版
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        // paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        // paginationInterceptor.setLimit(500);
        // 开启 count 的 join 优化,只针对部分 left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }
    
    // 最新版
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }
    
}

也可以简化一下，这里我采用最简单的配置即可：

//分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        //这里使用最基本的配置即可
        return new PaginationInterceptor();
    }

（2）直接使用Page对象即可：
测试一把：

@Test
    public void testPage(){
       /* public Page(long current, long size)
       第一个参数是起始页，第二个参数是每一页数据的个数*/
        Page<User> page = new Page<>(1,3);
        userMapper.selectPage(page, null);
        page.getRecords().forEach(System.out::println);
        //总共有多少条记录
        System.out.println(page.getTotal());
    }

可以看到确实查出了三条数据，显示总共有10条记录。

5.4、删除

5.4.1、基本的删除操作

@Test
    public void testDelete(){
        userMapper.deleteById(1385148305511669766L);
    }


   @Test
   public void testDeleteBatchIds(){
       //通过Id批量删除
        userMapper.deleteBatchIds(Arrays.asList(6L,8L));
   }

    @Test
    public void testDeleteByMap(){
        //通过Map删除
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","宋欣");
        userMapper.deleteByMap(map);
    }

5.4.2、逻辑删除
（1）说明:

只对自动注入的sql起效:

插入: 不作限制
查找: 追加where条件过滤掉已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段
更新: 追加where条件防止更新到已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段
删除: 转变为 更新
例如:

删除: update user set deleted=1 where id = 1 and deleted=0
查找: select id,name,deleted from user where deleted=0
字段类型支持说明:

支持所有数据类型(推荐使用 Integer,Boolean,LocalDateTime)
如果数据库字段使用datetime,逻辑未删除值和已删除值支持配置为字符串null,另一个值支持配置为函数来获取值如now()
附录:

逻辑删除是为了方便数据恢复和保护数据本身价值等等的一种方案，但实际就是删除。
如果你需要频繁查出来看就不应使用逻辑删除，而是以一个状态去表示。

（2）使用步骤：

首先在数据库表中加上逻辑删除的字段：

维护POJO，在想、实体类中加上逻辑删除字段对应的属性：

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

然后写配置文件，例: application.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)

当然还有逻辑删除组件要配好：

测试一把，进行一次删除操作：

@Test
    public void testDelete(){
        userMapper.deleteById(1385148305511669762L);
    }

可以看到在删除时，MP底层自动帮我们完成了更新逻辑删除字段值的操作。

6、条件构造器

@Test
    void contextLoads() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //查询姓名和密码不为空且年龄大于20岁的人员的信息
        wrapper.isNotNull("name")
                .isNotNull("password")
                .ge("age",20);
        userMapper.selectList(wrapper).forEach(System.out::println);
    }

@Test
    void testWrapper(){
        //查询姓名是石宇峰的人
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name", "石宇峰");
        User user = userMapper.selectOne(wrapper);
        System.out.println(user);
    }

@Test
    void testWrapper2(){
        //查询年龄18到24岁之间的人
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",18,24);
        Integer count = userMapper.selectCount(wrapper);
        System.out.println(count);
    }

@Test
    void testWrapper3(){
        //模糊查询,name中不包含J并且email中右匹配能匹配到a的信息
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.notLike("name","x")
                .likeRight("email","s");
        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

@Test
    void testWrapper4(){
        //拼接sql语句进行查询
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.inSql("id","select id from user where id<3");
        List<Object> objects = userMapper.selectObjs(wrapper);
        objects.forEach(System.out::println);
    }

@Test
    void testWrapper5(){
        //根据Id进行降序排序
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("id");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

7、代码自动生成器

dao、pojo、service、controller都自动生成。
按照官网的说法，我们添加相应的依赖，并写一个工具类即可。
引入依赖：

<!--代码生成器依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.3.2</version>
        </dependency>
        <!--模板引擎 依赖-->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.31</version>
        </dependency>

写一个工具类：

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.TableInfo;
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;

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

        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        //输出路径
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("石宇峰");
        gc.setOpen(false);
        // gc.setSwagger2(true); 实体属性 Swagger2 注解
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/syf?useUnicode=true&useSSL=false&characterEncoding=utf8");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("yybadmin");
        mpg.setDataSource(dsc);

        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName(scanner("模块名"));
        //自动生成的东西会在那个包下面
        pc.setParent("com.syf");
        mpg.setPackageInfo(pc);

        // 自定义配置
        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
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return projectPath + "/src/main/resources/mapper/" + pc.getModuleName()
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });
        /*
        cfg.setFileCreate(new IFileCreate() {
            @Override
            public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
                // 判断自定义文件夹是否需要创建
                checkDir("调用默认方法创建的目录，自定义目录用");
                if (fileType == FileType.MAPPER) {
                    // 已经生成 mapper 文件判断存在，不想重新生成返回 false
                    return !new File(filePath).exists();
                }
                // 允许生成模板文件
                return true;
            }
        });
        */
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);

        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();

        // 配置自定义输出模板
        //指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
        // templateConfig.setEntity("templates/entity2.java");
        // templateConfig.setService();
        // templateConfig.setController();

        templateConfig.setXml(null);
        mpg.setTemplate(templateConfig);

        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        //strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
        strategy.setEntityLombokModel(true);
        strategy.setRestControllerStyle(true);
        // 公共父类
        //strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
        // 写于父类中的公共字段
        strategy.setSuperEntityColumns("id");
        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
        strategy.setControllerMappingHyphenStyle(true);
        strategy.setTablePrefix(pc.getModuleName() + "_");
        mpg.setStrategy(strategy);
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        mpg.execute();
    }
}

如图所示的红色标注的就是自动生成的。