MybatisPlus详解

想进厂的小猫

已于 2024-08-03 15:42:52 修改

阅读量1k

点赞数 17

分类专栏： Java学习文章标签： java mybatis

于 2024-08-03 15:41:27 首次发布

本文链接：https://blog.csdn.net/qq_62892403/article/details/140891514

版权

Java学习专栏收录该内容

15 篇文章 0 订阅

订阅专栏

MybatisPlus

1、概述

官网：MyBatis-Plus 🚀 为简化开发而生 (baomidou.com)

MyBatis-Plus 是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

在这里插入图片描述

特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 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、快速入门

官网：快速开始 | MyBatis-Plus (baomidou.com)

使用第三方组件：

导入对应的依赖
研究依赖如何配置
代码如何编写
提高扩展技术能力

步骤

1、创建数据库mybatis_plus

2、创建User表

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user`
(
    id BIGINT NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);

数据：

DELETE FROM `user`;

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');
-- 真实开发中，version（乐观锁）、deleted（逻辑删除）、gmt_create、gmt_modified

3、编写项目，初始化项目！使用SpringBoot初始化

4、导入依赖

            <!--    mysql驱动依赖-->
            <dependency>
                <groupId>com.mysql</groupId>
                <artifactId>mysql-connector-j</artifactId>
                <version>8.0.33</version>
            </dependency>
<!--            lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.20</version>
            </dependency>
<!--            mybatis-plus-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
                <version>3.5.7</version>
            </dependency>

说明：我们使用Mybatis-plus可以节省我们大量的代码，尽量不要同时导入mybatis和mybatis-plus版本的差异

5、连接数据库

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis_plus
    username: root
    password: jinjiaqi123

6、传统方式pojo-dao（连接mybatis，配置mapper.xml文件）-service-controller

使用了mybatis-plus之后

pojo

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private Long id;
    private String name;
    private Integer age;
    private String email;
}

mapper接口

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

注意点，我们需要再主启动类上去扫描我们的mapper包下所有的接口@MapperScan("com.jjq.mapper")

使用,测试类中测试

@SpringBootTest
class MybatisPlusApplicationTests {

    //继承了baseMapper，所有的方法都来自父类
    //我们也可以编写自己的扩展方法
    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        //参数是一个Wrapper，条件构造器，这里我们先不用写null
        //查询全部用户
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }

}

查询结果

User(id=1, name=Jone, age=18, email=test1@baomidou.com)
User(id=2, name=Jack, age=20, email=test2@baomidou.com)
User(id=3, name=Tom, age=28, email=test3@baomidou.com)
User(id=4, name=Sandy, age=21, email=test4@baomidou.com)
User(id=5, name=Billie, age=24, email=test5@baomidou.com)

3、配置日志

我们所有的sql现在是不可见的，我们希望知道它是怎么执行的，所以我们必须要看日志

在application.yml中添加

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

查询结果

==>  Preparing: SELECT id,name,age,email FROM user
==> Parameters: 
<==    Columns: id, name, age, email
<==        Row: 1, Jone, 18, test1@baomidou.com
<==        Row: 2, Jack, 20, test2@baomidou.com
<==        Row: 3, Tom, 28, test3@baomidou.com
<==        Row: 4, Sandy, 21, test4@baomidou.com
<==        Row: 5, Billie, 24, test5@baomidou.com
<==      Total: 5
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4bf80c29]
User(id=1, name=Jone, age=18, email=test1@baomidou.com)
User(id=2, name=Jack, age=20, email=test2@baomidou.com)
User(id=3, name=Tom, age=28, email=test3@baomidou.com)
User(id=4, name=Sandy, age=21, email=test4@baomidou.com)
User(id=5, name=Billie, age=24, email=test5@baomidou.com)

4、CRUD扩展

4.1、insert插入

    //测试插入
    @Test
    public void testInsert(){
        User user = new User();
        user.setName("JJQ");
        user.setAge(3);
        user.setEmail("1347849532@qq.com");

        int result = userMapper.insert(user); // 帮我们自动生成id
        System.out.println(result); //受影响的行数
        System.out.println(user); //发现，id会自动回填
    }

测试结果：

JDBC Connection [HikariProxyConnection@663824117 wrapping com.mysql.cj.jdbc.ConnectionImpl@74a820bf] will not be managed by Spring
==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
==> Parameters: 1819351295572844546(Long), JJQ(String), 3(Integer), 1347849532@qq.com(String)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3e900e1a]
1
User(id=1819351295572844546, name=JJQ, age=3, email=1347849532@qq.com)

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

4.2、主键生成策略

默认ID_WORKER全局唯一id

分布式系统唯一id生成

雪花算法：

雪花算法就是使用64位long类型的数据存储id，最高位一位存储0或者1,0代表整数，1代表负数，一般都是0，所以最高位不变，41位存储毫秒级时间戳，10位存储机器码（包括5位datacenterId和5位workerId），12存储序列号。这样最大2的10次方的机器，也就是1024台机器，最多每毫秒每台机器产生2的12次方也就是4096个id，最后一个符号位永远是0。可以保证几乎全球唯一

主键自增

我们需要配置主键自增：

1、实体类字段上@TableId(type = IdType.ASSIGN_ID)

2、数据库字段一定要是自增

在这里插入图片描述

3、再次测试即可

源码解析

AUTO(0): 表示自动生成ID，这是许多数据库或框架支持的一种特性，通常用于主键的自动生成。这里的0是该枚举常量的内部表示（或称为“序数”），但在实际使用中，通常不会直接引用这个值。
NONE(1): 表示不使用任何特定的ID生成策略，可能意味着ID将由外部系统或手动指定。
INPUT(2): 表示ID由用户输入或外部系统提供。这种策略在需要用户指定唯一标识符的场合很有用。
ASSIGN_ID(3): 表示通过某种程序逻辑来分配ID。这可能涉及到生成序列号、时间戳加随机数等策略，以确保ID的唯一性。
ASSIGN_UUID(4): 表示UUID使用（Universally Unique Identifier，通用唯一识别码）作为ID。UUID是一种广泛使用的生成唯一标识符的方法，它基于当前的时间、机器标识和随机数生成。

4.3、更新操作

@Test
public void testUpdate(){
    User user = new User();
    //通过条件自动拼接动态sql
    user.setId(1L);
    user.setName("FK");
    //注意：updateById但是参数是一个对象
    int i = userMapper.updateById(user);
    System.out.println(i);
}

JDBC Connection [HikariProxyConnection@1641418296 wrapping com.mysql.cj.jdbc.ConnectionImpl@6aae0e6f] will not be managed by Spring
==>  Preparing: UPDATE user SET name=? WHERE id=?
==> Parameters: FK(String), 1(Long)
<==    Updates: 1

所有的sql都是自动帮你动态配置的

4.4、自动填充

创建时间、修改时间！这些操作一般都是自动化完成的，我们不希望手动更新

阿里巴巴开发手册：所有的数据库表：gmt_create、gmt_modified几乎所有的表的都要配置上！而且需要自动化

方式一：数据库级别（工作中不允许修改数据库）

1、在表中新增字段create_time,update_time

** 在这里插入图片描述
**

2、再次测试插入方法，我们需要先把实体类同步

    private Date createTime;
    private Date updateTime;

3、再次运行查看结果即可

方式二：代码级别

1、删除数据库的默认值

2、实体类字段属性上需要增加注解

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

3、编写处理器老处理这个注解即可

@Slf4j
@Component //一定不要忘记把处理器加到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
    //插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill.....");
        //setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject)
        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);
    }
}

4、测试插入

5、测试更新、观察时间即可

注意：mapUnderscoreToCamelCase在mybatis-plus中默认为true,此属性在Mybatis中原默认值为false

4.5、乐观锁

在面试过程中，我们经常会被问到乐观锁、悲观锁！

乐观锁：顾名思义十分乐观，它总是认为不会出现问题。无论干什么都不去上锁，如果出现了问题，再次更新值测试

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

我们主要说一下乐观锁：

乐观锁是一种并发控制机制，用于确保在更新记录时，该记录未被其他事务修改。MyBatis-Plus 提供了 OptimisticLockerInnerInterceptor 插件，使得在应用中实现乐观锁变得简单。

乐观锁的实现通常包括以下步骤：

读取记录时，获取当前的版本号（version）。
在更新记录时，将这个版本号一同传递。
执行更新操作时，设置 version = newVersion 的条件为 version = oldVersion。
如果版本号不匹配，则更新失败。

乐观锁：1、先查询，获得版本号 version = 1
-- A
update user set name ="jjq", version = version + 1
where id = 2 and version = 1

-- B 线程抢先完成，这个时候 version = 2,会导致A修改失败
update user set name = "jjq", version = version + 1
where id = 2 and version = 1

测试一下MP的乐观锁插件

1、给数据库中增加version字段

2、实体类加上对应的字段

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

3、注册组件

@Configuration  //配置类
//扫描我们的mapper文件夹
@MapperScan("com.jjq.config")
public class MybatisPlusConfig {
    //注册乐观锁
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}

4、测试

测试乐观锁成功

//测试乐观锁成功
@Test
public void testOptimisticLocker(){
    //1.查询用户信息
    User user = userMapper.selectById(1L);
    //2.修改用户信息
    user.setName("Karry");
    user.setEmail("4586465@qq.com");
    //3.执行更新操作
    userMapper.updateById(user);
}

测试乐观锁失败


//测试乐观锁失败
@Test
public void testOptimisticLocker2(){
    //线程1
    User user = userMapper.selectById(1L);
    user.setName("Karry111");
    user.setEmail("4586465@qq.com");
    //模拟另外一个线程执行了插队操作
    User user2 = userMapper.selectById(1L);
    user2.setName("Karry222");
    user2.setEmail("4586465@qq.com");
    userMapper.updateById(user2);
    //自旋锁来多次尝试提交
    userMapper.updateById(user); //如果没有乐观锁就会覆盖插队线程的值
}

4.6、查询操作

    //测试查询
    @Test
    public void testSelectById(){
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }
    //测试批量查询
    @Test
    public void testSelectByBatchId(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1,2,3));
        users.forEach(System.out::println);
    }
    //条件查询Map
    @Test
    public void testSelectByBatchIds(){
        HashMap<String,Object> map = new HashMap<>();
        //自定义查询
        map.put("name","Karry");

        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

4.7、分页查询

分页方法：

原始的Limit进行分页
pageHelper第三方插件
MP其实也内置了分页插件

如何使用

1、配置拦截器组件即可

//扫描我们的mapper文件夹
@Configuration //配置类
@MapperScan("com.jjq.mapper")
public class MybatisPlusConfig {
    /**
     * 添加分页插件
     */
    @Bean
    public PaginationInnerInterceptor paginationInnerInterceptor(){
        return new PaginationInnerInterceptor();
    }
}

2、直接使用Page对象即可

//测试分页查询
@Test
public void testPage(){
    //参数1：当前页
    //参数2：页面大小
    Page<User> page = new Page<>(2,5);
    userMapper.selectPage(page,null);

    page.getRecords().forEach(System.out::println);
    System.out.println(page.getTotal());
}

4.8、删除操作

基本的删除操作

    //测试删除
    @Test
    public void testDeleteById(){
        userMapper.deleteById(2);
    }
    //通过id批量删除
    @Test
    public void testDeleteBatchId(){
        userMapper.deleteBatchIds(Arrays.asList(4,5));
    }
    //通过map删除
    @Test
    public void testDeleteMap(){
        HashMap<String,Object> map = new HashMap<>();
        map.put("name","JJQ");
        userMapper.deleteByMap(map);
    }

逻辑删除：

物理删除：从数据库中直接移除

逻辑删除：在数据库中没有被移除，而是通过一个变量来让他失效！deleted = 0 => deleted = 1

管理员可以查看被删除的记录！防止数据的丢失，类似于回收站

测试：

1、在数据库表中增加一个deleted字段

2、实体类中增加属性

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

3、配置（新版需要在applicaiton.yml中配置）

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: deleted # 全局逻辑删除字段名
      logic-delete-value: 1 # 逻辑已删除值
      logic-not-delete-value: 0 # 逻辑未删除值

4、测试

//测试删除
@Test
public void testDeleteById(){
    userMapper.deleteById(1);
}

结果：走的是更新操作，并不是删除操作

在这里插入图片描述

记录依旧在数据库，但是值已经变化了

4.9、条件构造器（Wrapper）

我们写一些复杂的sql就可以使用它来替代

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

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

AbstractWrapper：这是一个抽象基类，提供了所有 Wrapper 类共有的方法和属性。它定义了条件构造的基本逻辑，包括字段（column）、值（value）、操作符（condition）等。所有的 QueryWrapper、UpdateWrapper、LambdaQueryWrapper 和 LambdaUpdateWrapper 都继承自 AbstractWrapper。
QueryWrapper：专门用于构造查询条件，支持基本的等于、不等于、大于、小于等各种常见操作。它允许你以链式调用的方式添加多个查询条件，并且可以组合使用 and 和 or 逻辑。
UpdateWrapper：用于构造更新条件，可以在更新数据时指定条件。与 QueryWrapper 类似，它也支持链式调用和逻辑组合。使用 UpdateWrapper 可以在不创建实体对象的情况下，直接设置更新字段和条件。
LambdaQueryWrapper：这是一个基于 Lambda 表达式的查询条件构造器，它通过 Lambda 表达式来引用实体类的属性，从而避免了硬编码字段名。这种方式提高了代码的可读性和可维护性，尤其是在字段名可能发生变化的情况下。
LambdaUpdateWrapper：类似于 LambdaQueryWrapper，LambdaUpdateWrapper 是基于 Lambda 表达式的更新条件构造器。它允许你使用 Lambda 表达式来指定更新字段和条件，同样避免了硬编码字段名的问题。

测试一：

@Test
void contextLoads(){
    //查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于1
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper
            .isNotNull("name")
            .isNotNull("email")
            .ge("age",1);
    userMapper.selectList(wrapper).forEach(System.out::println);
}

测试二：

@Test
void test2(){
    //查询名字
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name","Tom");
    //查询一个数据，出现多个结果使用List或者Map
    User user = userMapper.selectOne(wrapper);
    System.out.println(user);
}

测试三：

@Test
void test3(){
    //查询年龄在20-30岁之间的用户
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.between("age",20,30); //区间
    Integer count = Math.toIntExact(userMapper.selectCount(wrapper)); //查询结果数
    System.out.println(count);
}

测试四：

//模糊查询
@Test
void test4(){
    //查询年龄在20-30岁之间的用户
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //左和右 t%
    wrapper
            .notLike("name","e")
            .likeRight("email","t");
    List<Map<String,Object>> maps = userMapper.selectMaps(wrapper);
    maps.forEach(System.out::println);
}

测试五：

//模糊查询
@Test
void test5(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    // id在子查询中查出来
    wrapper.inSql("id","select id from user where id<3");
    
    List<Object> objects = userMapper.selectObjs(wrapper);
    objects.forEach(System.out::println);
}

测试六：

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

4.10、代码自动生成

全新的 MyBatis-Plus 代码生成器，通过 builder 模式可以快速生成你想要的代码，快速且优雅

安装：

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.5.7</version>
</dependency>

生成方式

代码生成器目前支持两种生成方式：

DefaultQuery (元数据查询)
- 优点： 根据通用接口读取数据库元数据相关信息，对数据库通用性较好。
- 缺点： 依赖数据库厂商驱动实现。
- 备注： 默认方式，部分类型处理可能不理想。
SQLQuery (SQL查询)
- 优点： 需要根据数据库编写对应表、主键、字段获取等查询语句。
- 缺点： 通用性不强，同数据库厂商不同版本可能会存在兼容问题（例如，H2数据库只支持1.X版本）。
- 备注： 后期不再维护。

// MYSQL 示例 切换至SQL查询方式,需要指定好 dbQuery 与 typeConvert 来生成
FastAutoGenerator.create("url", "username", "password")
                .dataSourceConfig(builder ->
                        builder.databaseQueryClass(SQLQuery.class)
                                .typeConvert(new MySqlTypeConvert())
                                .dbQuery(new MySqlQuery())
                )
                // Other Config ...

使用：可以通过以下两种形式使用代码生成器。

快速生成

在 CodeGenerator 中的 main 方法中直接添加生成器代码，并进行相关配置，然后直接运行即可生成代码。

public static void main(String[] args) {
    FastAutoGenerator.create("url", "username", "password")
            .globalConfig(builder -> {
                builder.author("baomidou") // 设置作者
                        .enableSwagger() // 开启 swagger 模式
                        .outputDir("D://"); // 指定输出目录
            })
            .dataSourceConfig(builder ->
                    builder.typeConvertHandler((globalConfig, typeRegistry, metaInfo) -> {
                        int typeCode = metaInfo.getJdbcType().TYPE_CODE;
                        if (typeCode == Types.SMALLINT) {
                            // 自定义类型转换
                            return DbColumnType.INTEGER;
                        }
                        return typeRegistry.getColumnType(metaInfo);
                    })
            )
            .packageConfig(builder ->
                    builder.parent("com.baomidou.mybatisplus.samples.generator") // 设置父包名
                            .moduleName("system") // 设置父包模块名
                            .pathInfo(Collections.singletonMap(OutputFile.xml, "D://")) // 设置mapperXml生成路径
            )
            .strategyConfig(builder ->
                    builder.addInclude("t_simple") // 设置需要生成的表名
                            .addTablePrefix("t_", "c_") // 设置过滤表前缀
            )
            .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
            .execute();
}

交互式生成

交互式生成在运行之后，会提示您输入相应的内容，等待配置输入完整之后就自动生成相关代码。

public static void main(String[] args) {
    FastAutoGenerator.create("url", "username", "password")
            // 全局配置
            .globalConfig((scanner, builder) -> builder.author(scanner.apply("请输入作者名称？")))
            // 包配置
            .packageConfig((scanner, builder) -> builder.parent(scanner.apply("请输入包名？")))
            // 策略配置
            .strategyConfig((scanner, builder) -> builder.addInclude(getTables(scanner.apply("请输入表名，多个英文逗号分隔？所有输入 all")))
                    .entityBuilder()
                    .enableLombok()
                    .addTableFills(
                            new Column("create_time", FieldFill.INSERT)
                    )
                    .build())
            // 使用Freemarker引擎模板，默认的是Velocity引擎模板
            .templateEngine(new FreemarkerTemplateEngine())
            .execute();
}

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

   // 包配置
        .packageConfig((scanner, builder) -> builder.parent(scanner.apply("请输入包名？")))
        // 策略配置
        .strategyConfig((scanner, builder) -> builder.addInclude(getTables(scanner.apply("请输入表名，多个英文逗号分隔？所有输入 all")))
                .entityBuilder()
                .enableLombok()
                .addTableFills(
                        new Column("create_time", FieldFill.INSERT)
                )
                .build())
        // 使用Freemarker引擎模板，默认的是Velocity引擎模板
        .templateEngine(new FreemarkerTemplateEngine())
        .execute();

}

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