MyBatis-Plus代码生成器：自动化开发利器-优快云博客

MyBatis-Plus代码生成器：自动化开发利器

【免费下载链接】mybatis-plus mybatis 增强工具包，简化 CRUD 操作。文档 http://baomidou.com 低代码组件库 http://aizuda.com 项目地址: https://gitcode.com/baomidou/mybatis-plus

MyBatis-Plus的代码生成器是现代化Java项目开发中的核心工具，通过AutoGenerator和FastAutoGenerator两大核心组件，提供了灵活强大的代码生成能力。文章详细解析了AutoGenerator的配置体系、核心组件（数据源配置、策略配置、全局配置、包配置、注入配置）及其使用方法，并深入介绍了FastAutoGenerator的流畅API设计、交互式配置模式和多模板引擎支持。同时还涵盖了多模板引擎（Velocity、FreeMarker、Beetl、Enjoy）的配置与自定义，以及代码生成器在企业级项目中的架构优化、多环境配置管理、批量处理与CI/CD集成等高级应用实践。

AutoGenerator配置与使用详解

MyBatis-Plus的AutoGenerator是代码生成器的核心类，它提供了一种灵活且强大的方式来生成Entity、Mapper、Service、Controller等代码文件。通过合理的配置，开发者可以快速生成符合项目规范的代码，大大提升开发效率。

AutoGenerator核心配置组件

AutoGenerator的配置体系由多个核心组件构成，每个组件负责不同的配置领域：

配置组件	作用描述	核心方法
DataSourceConfig	数据源配置，连接数据库信息	Builder()
StrategyConfig	生成策略配置，控制代码生成规则	entity(), mapper(), service(), controller()
GlobalConfig	全局配置，设置作者、输出目录等	outputDir(), author()
PackageConfig	包配置，设置各层代码的包路径	parent(), moduleName()
InjectionConfig	注入配置，自定义文件生成逻辑	beforeOutputFile(), customFile()

基础配置示例

下面是一个完整的AutoGenerator配置示例：

// 数据源配置
DataSourceConfig dataSourceConfig = new DataSourceConfig.Builder(
    "jdbc:mysql://localhost:3306/mybatis_plus", 
    "root", 
    "password")
    .schema("mybatis_plus")
    .build();

// 创建AutoGenerator实例
AutoGenerator generator = new AutoGenerator(dataSourceConfig);

// 策略配置
generator.strategy(new StrategyConfig.Builder()
    .addInclude("user", "order")  // 设置需要生成的表
    .entity()  // Entity配置
        .enableLombok()  // 启用Lombok
        .enableChainModel()  // 启用链式模型
        .enableRemoveIsPrefix()  // 移除is前缀
        .get()
    .mapper()  // Mapper配置
        .enableBaseResultMap()  // 启用BaseResultMap
        .enableBaseColumnList()  // 启用BaseColumnList
        .get()
    .service()  // Service配置
        .formatServiceFileName("%sService")  // 服务类文件名格式
        .get()
    .controller()  // Controller配置
        .enableRestStyle()  // 启用REST风格
        .get()
    .build());

// 全局配置
generator.global(new GlobalConfig.Builder()
    .outputDir("/src/main/java")  // 输出目录
    .author("Developer")  // 作者
    .disableOpenDir()  // 禁止打开输出目录
    .build());

// 包配置
generator.packageInfo(new PackageConfig.Builder()
    .parent("com.example")  // 父包名
    .moduleName("system")  // 模块名
    .entity("entity")  // Entity包名
    .mapper("mapper")  // Mapper包名
    .service("service")  // Service包名
    .controller("controller")  // Controller包名
    .build());

// 执行代码生成
generator.execute();

详细配置解析

1. 数据源配置(DataSourceConfig)

数据源配置是代码生成的基础，支持多种数据库类型：

DataSourceConfig dataSourceConfig = new DataSourceConfig.Builder(
    "jdbc:mysql://localhost:3306/database", 
    "username", 
    "password")
    .schema("schema_name")  // 数据库schema
    .driverClassName("com.mysql.cj.jdbc.Driver")  // 驱动类名
    .typeConvert(new MySqlTypeConvert())  // 类型转换器
    .build();

2. 策略配置(StrategyConfig)

策略配置是代码生成的核心，控制生成的代码风格和规则：

mermaid

3. 全局配置(GlobalConfig)

全局配置设置代码生成的公共参数：

GlobalConfig globalConfig = new GlobalConfig.Builder()
    .outputDir(System.getProperty("user.dir") + "/src/main/java")  // 输出目录
    .author("YourName")  // 作者信息
    .enableKotlin()  // 启用Kotlin支持
    .enableSwagger()  // 启用Swagger注解
    .dateType(DateType.TIME_PACK)  // 日期类型
    .commentDate("yyyy-MM-dd")  // 注释日期格式
    .disableOpenDir()  // 禁止自动打开目录
    .build();

4. 包配置(PackageConfig)

包配置设置各层代码的包结构：

PackageConfig packageConfig = new PackageConfig.Builder()
    .parent("com.company.project")  // 父包名
    .moduleName("module")  // 模块名
    .entity("domain.entity")  // Entity包
    .mapper("dao")  // Mapper包
    .xml("mapper.xml")  // XML文件位置
    .service("service")  // Service接口包
    .serviceImpl("service.impl")  // Service实现包
    .controller("web")  // Controller包
    .pathInfo(Map.of(  // 自定义输出路径
        OutputFile.entity, "/custom/entity/path",
        OutputFile.mapper, "/custom/mapper/path"
    ))
    .build();

5. 注入配置(InjectionConfig)

注入配置允许在代码生成过程中进行自定义操作：

InjectionConfig injectionConfig = new InjectionConfig.Builder()
    .beforeOutputFile((tableInfo, objectMap) -> {
        // 在生成文件前执行的操作
        objectMap.put("customField", "customValue");
        System.out.println("Generating: " + tableInfo.getEntityName());
    })
    .customFile(new CustomFile.Builder()
        .fileName("CustomDTO.java")
        .templatePath("/templates/customDTO.java.vm")
        .packageName("com.example.dto")
        .build())
    .build();

模板引擎配置

AutoGenerator支持多种模板引擎，默认使用Velocity：

// 使用Freemarker模板引擎
generator.execute(new FreemarkerTemplateEngine());

// 使用Beetl模板引擎  
generator.execute(new BeetlTemplateEngine());

// 使用Enjoy模板引擎
generator.execute(new EnjoyTemplateEngine());

高级用法：自定义模板

可以通过自定义模板来生成符合特定项目规范的代码：

创建自定义模板文件：在resources/templates目录下创建模板文件
配置模板路径：通过StrategyConfig指定自定义模板
执行代码生成：使用对应的模板引擎

generator.strategy(new StrategyConfig.Builder()
    .entity()
        .javaTemplate("/templates/entity.java")  // 自定义Entity模板
        .get()
    .mapper()
        .mapperTemplate("/templates/mapper.java")  // 自定义Mapper模板
        .get()
    .build());

配置最佳实践

模块化配置：将不同环境的配置分离，如开发、测试、生产环境
配置文件管理：使用properties或yaml文件管理数据库连接信息
模板版本控制：将自定义模板纳入版本控制，便于团队共享
代码规范检查：在生成代码后运行代码规范检查工具

常见问题处理

问题1：数据库连接失败

检查数据库URL格式
确认数据库服务是否启动
验证用户名密码是否正确

问题2：表不存在或无法识别

检查表名大小写敏感性
确认数据库用户有查询权限
检查数据库schema设置

问题3：生成代码格式不符合预期

检查模板文件是否正确
确认策略配置参数设置
验证数据类型映射关系

通过合理的AutoGenerator配置，可以显著提升MyBatis-Plus代码生成的效率和质量，使开发者能够专注于业务逻辑的实现。

FastAutoGenerator快速代码生成

MyBatis-Plus的FastAutoGenerator是一个革命性的代码生成工具，它通过流畅的API设计和强大的配置能力，让开发者能够以极简的方式快速生成完整的CRUD代码。相比传统的AutoGenerator，FastAutoGenerator提供了更加现代化和便捷的使用体验。

核心特性与优势

FastAutoGenerator的核心设计理念是"配置即代码"，它通过Builder模式提供了极其灵活的配置方式：

主要特性：

🚀 流畅API设计：链式调用，配置直观易懂
⚡ 交互式配置：支持控制台输入动态配置
🎯 多模板引擎支持：Velocity、Freemarker、Beetl、Enjoy
🔧 高度可定制：每个配置项都可以精细控制
📦 开箱即用：默认配置即可生成完整代码

快速入门示例

下面是一个最简单的FastAutoGenerator使用示例：

// 创建数据源配置
DataSourceConfig.Builder dataSourceConfig = new DataSourceConfig.Builder(
    "jdbc:mysql://localhost:3306/test", "root", "password");

FastAutoGenerator.create(dataSourceConfig)
    .globalConfig(builder -> {
        builder.author("开发者")      // 设置作者
               .outputDir("/src/main/java") // 输出目录
               .disableOpenDir();    // 禁止打开输出目录
    })
    .packageConfig(builder -> {
        builder.parent("com.example") // 父包名
               .moduleName("system")  // 模块名
               .entity("entity")      // 实体类包名
               .service("service")    // Service包名
               .mapper("mapper");     // Mapper包名
    })
    .strategyConfig(builder -> {
        builder.addInclude("user", "role") // 设置需要生成的表名
               .entityBuilder()            // 实体策略配置
               .enableLombok()             // 启用Lombok
               .enableChainModel();        // 启用链式模型
    })
    .execute(); // 执行生成

详细配置说明

1. 数据源配置（DataSourceConfig）

数据源配置支持多种数据库类型，包括MySQL、PostgreSQL、Oracle等：

.dataSourceConfig(builder -> {
    builder.url("jdbc:mysql://localhost:3306/test")
           .username("root")
           .password("password")
           .schema("public")          // PostgreSQL模式
           .driverClassName("com.mysql.cj.jdbc.Driver");
})

2. 全局配置（GlobalConfig）

全局配置控制代码生成的整体行为：

.globalConfig(builder -> {
    builder.author("YourName")                // 作者
           .outputDir(System.getProperty("user.dir") + "/src/main/java") // 输出目录
           .enableKotlin()                    // 启用Kotlin模式
           .enableSwagger()                   // 启用Swagger注解
           .dateType(DateType.TIME_PACK)      // 时间类型策略
           .commentDate("yyyy-MM-dd HH:mm:ss") // 注释日期格式
           .disableOpenDir();                 // 禁止自动打开目录
})

3. 包配置（PackageConfig）

包配置定义生成的代码包结构：

.packageConfig(builder -> {
    builder.parent("com.company.project")     // 父包名
           .moduleName("auth")                // 模块名
           .entity("domain.entity")           // 实体类包
           .service("service")                // Service接口包
           .serviceImpl("service.impl")       // Service实现包
           .mapper("mapper")                  // Mapper接口包
           .xml("mapper.xml")                 // XML文件包
           .controller("controller");         // Controller包
})

4. 策略配置（StrategyConfig）

策略配置是最强大的部分，可以精细控制每个文件的生成策略：

实体策略配置：

.strategyConfig(builder -> {
    builder.entityBuilder()                   // 实体策略
           .enableLombok()                    // 启用Lombok
           .enableChainModel()                // 链式模型
           .enableRemoveIsPrefix()            // 去除is前缀
           .enableTableFieldAnnotation()      // 启用字段注解
           .versionColumnName("version")      // 乐观锁字段名
           .logicDeleteColumnName("deleted")  // 逻辑删除字段名
           .naming(NamingStrategy.underline_to_camel) // 命名策略
           .columnNaming(NamingStrategy.underline_to_camel)
           .addSuperEntityColumns("id", "create_time", "update_time") // 公共字段
           .addIgnoreColumns("tenant_id");    // 忽略字段
})

Mapper策略配置：

.strategyConfig(builder -> {
    builder.mapperBuilder()
           .enableBaseResultMap()             // 生成ResultMap
           .enableBaseColumnList()            // 生成ColumnList
           .superClass("com.baomidou.mybatisplus.core.mapper.BaseMapper")
           .formatMapperFileName("%sMapper")  // Mapper文件命名
           .formatXmlFileName("%sMapper");    // XML文件命名
})

Service策略配置：

.strategyConfig(builder -> {
    builder.serviceBuilder()
           .formatServiceFileName("I%sService") // Service接口命名
           .formatServiceImplFileName("%sServiceImpl"); // Service实现命名
})

Controller策略配置：

.strategyConfig(builder -> {
    builder.controllerBuilder()
           .enableHyphenStyle()               // 启用驼峰转连字符
           .enableRestStyle()                 // 生成@RestController
           .formatFileName("%sController");   // Controller命名
})

交互式配置模式

FastAutoGenerator支持交互式配置，非常适合在命令行环境中使用：

FastAutoGenerator.create(dataSourceConfig)
    .dataSourceConfig((scanner, builder) -> 
        builder.schema(scanner.apply("请输入schema名称: ")))
    .globalConfig((scanner, builder) -> 
        builder.author(scanner.apply("请输入作者名称: ")))
    .packageConfig((scanner, builder) -> 
        builder.parent(scanner.apply("请输入父包名: ")))
    .strategyConfig((scanner, builder) -> 
        builder.addInclude(scanner.apply("请输入表名(多个用逗号分隔): ").split(",")))
    .execute();

模板引擎配置

FastAutoGenerator支持多种模板引擎，默认使用Velocity：

// 使用Freemarker模板引擎
.templateEngine(new FreemarkerTemplateEngine())

// 使用Beetl模板引擎  
.templateEngine(new BeetlTemplateEngine())

// 使用Enjoy模板引擎
.templateEngine(new EnjoyTemplateEngine())

自定义注入配置

通过InjectionConfig可以实现高度自定义：

.injectionConfig(builder -> {
    // 自定义配置Map
    builder.customMap(Collections.singletonMap("test", "baomidou"));
    
    // 自定义文件输出
    builder.customFile(new CustomFile.Builder()
        .fileName("DTO.java")
        .templatePath("/templates/entity-dto.java.ftl")
        .build());
    
    // 文件生成前回调
    builder.beforeOutputFile((tableInfo, objectMap) -> {
        objectMap.put("config", new MyConfig());
    });
})

高级用法：多数据源生成

FastAutoGenerator支持同时为多个数据源生成代码：

// 第一个数据源
FastAutoGenerator.create(dataSourceConfig1)
    .packageConfig(builder -> builder.parent("com.project.module1"))
    .strategyConfig(builder -> builder.addInclude("table1", "table2"))
    .execute();

// 第二个数据源  
FastAutoGenerator.create(dataSourceConfig2)
    .packageConfig(builder -> builder.parent("com.project.module2")) 
    .strategyConfig(builder -> builder.addInclude("table3", "table4"))
    .execute();

配置选项汇总表

配置类别	主要配置项	说明
全局配置	outputDir	输出目录
	author	作者名称
	enableSwagger	启用Swagger
	dateType	日期类型策略
包配置	parent	父包名
	moduleName	模块名
	entity	实体包名
	service	Service包名
策略配置	addInclude	包含的表
	addExclude	排除的表
	enableLombok	启用Lombok
	namingStrategy	命名策略

生成代码结构示意图

mermaid

最佳实践建议

统一代码风格：在团队中统一FastAutoGenerator的配置，确保生成的代码风格一致
模板定制：根据项目需求自定义模板文件，生成符合项目规范的代码
配置复用：将常用配置封装成工具类，避免重复配置
版本控制：将生成器配置纳入版本管理，便于团队协作
持续集成：在CI/CD流程中集成代码生成，确保环境一致性

FastAutoGenerator通过其简洁的API和强大的配置能力，极大地提升了MyBatis-Plus项目的开发效率，是现代Java项目开发中不可或缺的利器。

多模板引擎支持与自定义配置

MyBatis-Plus代码生成器提供了强大的多模板引擎支持，允许开发者根据项目需求灵活选择不同的模板引擎，并支持高度自定义的模板配置。这种设计使得代码生成过程更加灵活，能够适应各种复杂的业务场景和编码规范。

内置模板引擎支持

MyBatis-Plus代码生成器内置了四种主流的模板引擎，每种引擎都有其独特的特点和适用场景：

模板引擎	类名	特点	适用场景
Velocity	VelocityTemplateEngine	轻量级，语法简单	传统Java项目，性能要求不高
FreeMarker	FreemarkerTemplateEngine	功能强大，语法灵活	复杂模板需求，需要丰富功能
Beetl	BeetlTemplateEngine	性能优异，语法简洁	高性能要求的场景
Enjoy	EnjoyTemplateEngine	国产引擎，易用性好	偏好国产技术栈的项目

mermaid

模板引擎配置与使用

1. 默认模板引擎配置

MyBatis-Plus默认使用Velocity模板引擎，可以通过简单的配置来切换不同的模板引擎：

// 使用Velocity模板引擎（默认）
FastAutoGenerator.create(dataSourceConfig)
    .templateEngine(new VelocityTemplateEngine())
    .execute();

// 使用FreeMarker模板引擎
FastAutoGenerator.create(dataSourceConfig)
    .templateEngine(new FreemarkerTemplateEngine())
    .execute();

// 使用Beetl模板引擎  
FastAutoGenerator.create(dataSourceConfig)
    .templateEngine(new BeetlTemplateEngine())
    .execute();

// 使用Enjoy模板引擎
FastAutoGenerator.create(dataSourceConfig)
    .templateEngine(new EnjoyTemplateEngine())
    .execute();

2. 自定义模板路径配置

每种模板引擎都支持自定义模板路径，允许开发者使用自己的模板文件：

FastAutoGenerator.create(dataSourceConfig)
    .globalConfig(builder -> {
        builder.outputDir("src/main/java");
    })
    .templateEngine(new FreemarkerTemplateEngine() {
        @Override
        public FreemarkerTemplateEngine init(ConfigBuilder configBuilder) {
            super.init(configBuilder);
            // 设置自定义模板路径
            configuration.setClassForTemplateLoading(this.getClass(), "/templates/");
            return this;
        }
    })
    .execute();

模板文件结构与自定义

1. 默认模板文件结构

MyBatis-Plus为每种模板引擎提供了默认的模板文件，位于各自的资源目录中：

resources/
├── templates/
│   ├── velocity/
│   │   ├── entity.java.vm
│   │   ├── mapper.java.vm
│   │   ├── mapper.xml.vm
│   │   ├── service.java.vm
│   │   ├── serviceImpl.java.vm
│   │   └── controller.java.vm
│   ├── freemarker/
│   ├── beetl/
│   └── enjoy/

2. 自定义模板配置

开发者可以完全自定义模板文件，通过TemplateConfig进行精细化的模板配置：

FastAutoGenerator.create(dataSourceConfig)
    .templateConfig(builder -> {
        builder
            // 自定义实体类模板
            .entity("/templates/custom/entity.java.ftl")
            // 自定义Mapper接口模板
            .mapper("/templates/custom/mapper.java.ftl")
            // 自定义XML映射文件模板
            .xml("/templates/custom/mapper.xml.ftl")
            // 自定义Service接口模板
            .service("/templates/custom/service.java.ftl")
            // 自定义Service实现类模板
            .serviceImpl("/templates/custom/serviceImpl.java.ftl")
            // 自定义Controller模板
            .controller("/templates/custom/controller.java.ftl");
    })
    .execute();

3. 模板变量与数据模型

模板引擎渲染时提供了丰富的数据模型变量，可以在自定义模板中使用：

// 模板中可用的主要变量
Map<String, Object> objectMap = new HashMap<>();
objectMap.put("config", configBuilder);          // 配置信息
objectMap.put("package", packageConfig);         // 包配置
objectMap.put("import", new ImportPackages());   // 导入包信息
objectMap.put("table", tableInfo);               // 表信息
objectMap.put("entity", tableInfo.getEntityName());// 实体类名
objectMap.put("fields", tableInfo.getFields());  // 字段列表

高级自定义配置

1. 自定义文件输出

通过InjectionConfig可以实现更灵活的文件输出控制：

FastAutoGenerator.create(dataSourceConfig)
    .injectionConfig(builder -> {
        builder
            // 添加自定义文件
            .customFile(new CustomFile.Builder()
                .fileName("CustomDTO.java")
                .templatePath("/templates/custom-dto.java.ftl")
                .packageName("com.example.dto")
                .build())
            .customFile(new CustomFile.Builder()
                .fileName("CustomVO.java")
                .templatePath("/templates/custom-vo.java.ftl")
                .packageName("com.example.vo")
                .build())
            // 前置处理
            .beforeOutputFile((tableInfo, objectMap) -> {
                // 添加自定义数据到模板
                objectMap.put("customData", "自定义数据");
                objectMap.put("currentTime", LocalDateTime.now());
            });
    })
    .execute();

2. 多模块模板配置

对于大型项目，可以配置不同模块使用不同的模板：

FastAutoGenerator.create(dataSourceConfig)
    .strategyConfig(builder -> {
        builder
            .entity().template("/templates/module1/entity.java.vm")
            .mapper().template("/templates/module1/mapper.java.vm")
            .service().template("/templates/module1/service.java.vm")
            .controller().template("/templates/module1/controller.java.vm");
    })
    .packageConfig(builder -> {
        builder
            .parent("com.example")
            .moduleName("module1")
            .entity("entity")
            .mapper("mapper")
            .service("service")
            .controller("controller");
    })
    .execute();

模板引擎性能对比

为了帮助开发者选择合适的模板引擎，以下是各引擎的性能特点对比：

特性	Velocity	FreeMarker	Beetl	Enjoy
语法复杂度	简单	中等	简单	简单
性能	一般	良好	优秀	良好
功能丰富度	基础	丰富	丰富	中等
学习曲线	平缓	中等	平缓	平缓
社区活跃度	一般	活跃	活跃	活跃

mermaid

最佳实践建议

项目初期：建议使用Velocity或Enjoy模板引擎，语法简单，快速上手
复杂业务：推荐使用FreeMarker，功能丰富，模板表达能力更强
高性能要求：选择Beetl模板引擎，性能最优
自定义需求：根据团队技术栈选择最熟悉的模板引擎
多环境部署：可以为不同环境配置不同的模板策略

通过灵活运用MyBatis-Plus的多模板引擎支持和自定义配置功能，开发者可以创建出完全符合项目需求和编码规范的代码生成方案，大幅提升开发效率和代码质量。

代码生成器在企业项目中的应用

MyBatis-Plus代码生成器在企业级项目中扮演着至关重要的角色，它不仅能够显著提升开发效率，还能确保代码质量和一致性。通过自动化生成实体类、Mapper接口、Service层和Controller层代码，开发团队可以将更多精力投入到业务逻辑的实现上。

企业级项目架构优化

在企业项目中，MyBatis-Plus代码生成器通过以下方式优化架构：

mermaid

多环境配置管理

企业项目通常需要支持多种环境（开发、测试、生产），MyBatis-Plus代码生成器提供了灵活的配置方式：

// 企业级多环境配置示例
public class EnterpriseGeneratorConfig {
    
    // 开发环境配置
    public static void generateForDev() {
        FastAutoGenerator.create(DEV_DATASOURCE_CONFIG)
            .globalConfig(builder -> builder
                .outputDir("src/main/java")
                .author("企业开发团队")
                .enableSwagger()
                .disableOpenDir())
            .packageConfig(builder -> builder
                .parent("com.enterprise.project")
                .moduleName("system")
                .entity("model.entity")
                .mapper("dao")
                .service("service")
                .serviceImpl("service.impl")
                .controller("web"))
            .strategyConfig(builder -> builder
                .addInclude("sys_user", "sys_role", "sys_menu")
                .entityBuilder()
                .enableLombok()
                .enableChainModel()
                .logicDeleteColumnName("deleted")
                .versionColumnName("version"))
            .execute();
    }
    
    // 生产环境配置（禁用Swagger）
    public static void generateForProd() {
        FastAutoGenerator.create(PROD_DATASOURCE_CONFIG)
            .globalConfig(builder -> builder
                .outputDir("src/main/java")
                .author("企业开发团队")
                .disableSwagger()  // 生产环境禁用Swagger
                .disableOpenDir())
            // 其他配置与开发环境一致
            .execute();
    }
}

自定义模板与扩展

企业项目往往有特定的编码规范和架构要求，MyBatis-Plus支持完全自定义模板：

// 企业自定义模板配置
public class CustomTemplateGenerator {
    
    public static void generateWithCustomTemplates() {
        StrategyConfig strategyConfig = new StrategyConfig.Builder()
            .entityBuilder()
            .javaTemplate("/templates/enterprise/entity.java.vm")  // 自定义实体模板
            .mapperBuilder()
            .mapperTemplate("/templates/enterprise/mapper.java.vm")  // 自定义Mapper模板
            .build();
            
        FastAutoGenerator.create(DATASOURCE_CONFIG)
            .strategyConfig(builder -> builder
                .addInclude(getEnterpriseTables())
                .entityBuilder()
                .superClass(BaseEntity.class)  // 统一基类
                .addSuperEntityColumns("create_time", "update_time", "create_by", "update_by")
                .addIgnoreColumns("deleted", "version"))
            .injectionConfig(builder -> builder
                .beforeOutputFile((tableInfo, objectMap) -> {
                    // 企业级自定义处理
                    objectMap.put("enterprisePackage", "com.enterprise.common");
                    objectMap.put("projectVersion", getProjectVersion());
                })
                .customFile(new CustomFile.Builder()
                    .fileName("DTO.java")
                    .templatePath("/templates/enterprise/dto.java.vm")
                    .packageName("model.dto")
                    .build()))
            .execute();
    }
    
    private static List<String> getEnterpriseTables() {
        return Arrays.asList(
            "sys_user", "sys_role", "sys_menu", 
            "sys_dept", "sys_log", "sys_config"
        );
    }
}

企业级代码规范实施

通过代码生成器，企业可以统一实施编码规范：

规范类型	实施方式	优势
命名规范	配置策略中的命名规则	统一团队命名风格
注释规范	自定义模板中的注释格式	提高代码可读性
架构规范	统一的基类和接口	保持架构一致性
安全规范	自动生成安全相关注解	提升系统安全性

批量处理与自动化集成

企业项目通常需要处理大量表结构，MyBatis-Plus支持批量生成：

// 企业级批量表处理
public class BatchTableGenerator {
    
    public static void generateAllTables() {
        List<String> allTables = getAllDatabaseTables();
        
        FastAutoGenerator.create(DATASOURCE_CONFIG)
            .globalConfig(builder -> builder
                .outputDir("src/main/java")
                .author("企业自动化系统")
                .commentDate("yyyy-MM-dd HH:mm:ss"))
            .packageConfig(builder -> builder
                .parent("com.enterprise")
                .pathInfo(Map.of(
                    OutputFile.entity, "domain/entity",
                    OutputFile.mapper, "infrastructure/persistence/mapper",
                    OutputFile.xml, "infrastructure/persistence/mapper/xml",
                    OutputFile.service, "application/service",
                    OutputFile.serviceImpl, "application/service/impl",
                    OutputFile.controller, "interfaces/rest"
                )))
            .strategyConfig(builder -> builder
                .addInclude(allTables)
                .addTablePrefix("t_", "sys_")  // 去除表前缀
                .entityBuilder()
                .enableSerialVersionUID()
                .enableTableFieldAnnotation()
                .enableActiveRecord()
                .controllerBuilder()
                .enableRestStyle())  // 启用REST风格
            .execute();
    }
    
    private static List<String> getAllDatabaseTables() {
        // 从数据库元数据获取所有表名
        return Arrays.asList(
            "t_user", "t_role", "t_menu", "t_dept",
            "t_order", "t_product", "t_category",
            "sys_log", "sys_config", "sys_dict"
        );
    }
}

与企业CI/CD流程集成

MyBatis-Plus代码生成器可以无缝集成到企业的CI/CD流程中：

mermaid

企业级监控与日志

为确保代码生成过程的可靠性和可追溯性，企业可以添加监控和日志：

// 企业级监控配置
public class MonitoredGenerator {
    
    private static final Logger logger = LoggerFactory.getLogger(MonitoredGenerator.class);
    
    public static void generateWithMonitoring() {
        long startTime = System.currentTimeMillis();
        
        try {
            FastAutoGenerator.create(DATASOURCE_CONFIG)
                .globalConfig(builder -> builder
                    .outputDir("src/main/java")
                    .author(getCurrentUser())
                    .commentDate(getGenerationTime()))
                .strategyConfig(builder -> builder
                    .addInclude(getTablesToGenerate())
                    .entityBuilder()
                    .enableLombok()
                    .enableChainModel())
                .execute();
            
            long endTime = System.currentTimeMillis();
            logger.info("代码生成完成，耗时：{}ms，生成表数量：{}", 
                (endTime - startTime), getTablesToGenerate().size());
                
        } catch (Exception e) {
            logger.error("代码生成失败：{}", e.getMessage(), e);
            sendAlertNotification("代码生成失败，请检查数据库连接和配置");
        }
    }
    
    private static String getCurrentUser() {
        return System.getProperty("user.name") + "@企业系统";
    }
}

通过以上企业级应用实践，MyBatis-Plus代码生成器不仅提升了开发效率，还确保了代码质量、规范统一性和系统可维护性，成为企业数字化转型中的重要技术支撑。

总结

MyBatis-Plus代码生成器作为自动化开发的利器，通过AutoGenerator和FastAutoGenerator两大核心组件，为Java开发者提供了高效、灵活的代码生成解决方案。从基础配置到高级自定义，从多模板引擎支持到企业级项目集成，代码生成器显著提升了开发效率，确保了代码质量和规范统一性。通过合理的配置和定制，开发者可以快速生成符合项目需求的Entity、Mapper、Service、Controller等代码文件，将更多精力投入到业务逻辑实现中，是现代Java项目开发中不可或缺的重要工具。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考