Wong Kosheng1. 为什么我们需要代码生成器？
在Java企业级开发领域，Spring Boot和Spring Cloud已经成为事实上的标准框架组合。但每次新建项目时，我们都要重复编写大量样板代码：实体类、DTO、Mapper接口、Service层、Controller层...这些代码结构高度相似却又必不可少。我曾统计过一个典型微服务模块的开发时间分配：
- 30%时间在编写重复的CRUD代码
- 20%时间在调试接口参数
- 只有50%时间在处理真正的业务逻辑
这就是代码生成器的价值所在——它能将我们从重复劳动中解放出来，专注于核心业务创新。我团队在采用代码生成器后，新模块开发效率提升了40%以上。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 主流代码生成器横向对比
2.1 MyBatis Generator
作为MyBatis官方出品，这款工具的特点是：
xml复制<!-- 典型配置示例 -->
<generatorConfiguration>
<context id="mysql" targetRuntime="MyBatis3">
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/test"
userId="root"
password="123456"/>
<javaModelGenerator targetPackage="com.example.model"
targetProject="src/main/java"/>
<sqlMapGenerator targetPackage="mapper"
targetProject="src/main/resources"/>
<javaClientGenerator type="XMLMAPPER"
targetPackage="com.example.mapper"
targetProject="src/main/java"/>
<table tableName="%"/>
</context>
</generatorConfiguration>
优势：
- 与MyBatis无缝集成
- 生成的Mapper XML格式规范
- 支持多种生成策略
不足：
- 仅生成DAO层代码
- 配置复杂，学习曲线陡峭
- 生成的代码风格固定
2.2 JHipster
全栈式生成工具的代表作：
bash复制# 安装与使用
npm install -g generator-jhipster
mkdir myapp && cd myapp
jhipster
特点：
- 支持前端(Angular/React/Vue)+后端全栈生成
- 集成Spring Boot + Spring Cloud
- 内置监控、认证等企业级功能
局限：
- 对国内开发环境适配不足
- 生成结构过于复杂
- 二次开发成本高
2.3 其他工具对比表
| 工具名称 | 支持框架 | 代码定制能力 | 学习成本 | 适合场景 |
|---|---|---|---|---|
| MyBatis-Plus | Spring Boot | 中等 | 低 | 快速CRUD开发 |
| Renren-generator | Spring Cloud | 高 | 中 | 企业级应用 |
| CodeSmith | 多语言支持 | 极高 | 高 | 复杂代码生成 |
| JFinal-generator | JFinal框架 | 低 | 低 | 小型项目 |
3. 手把手打造自定义生成器
3.1 技术选型决策树
选择生成器实现方案时，我通常考虑以下维度：
- 是否需要可视化界面？
- 是 → 考虑Web+模板引擎方案
- 否 → 直接使用代码模板
- 生成代码的复杂度？
- 简单CRUD → Velocity/Freemarker
- 复杂逻辑 → 自定义代码构建器
- 是否需要动态扩展？
- 是 → 插件化架构
- 否 → 单体实现
3.2 基于Freemarker的实现方案
核心目录结构：
code复制src/
├── main/
│ ├── java/
│ │ └── com/
│ │ └── example/
│ │ ├── generator/
│ │ │ ├── engine/ # 模板引擎封装
│ │ │ ├── metadata/ # 元数据模型
│ │ │ └── writer/ # 文件写入器
│ ├── resources/
│ │ └── templates/ # 模板文件
│ │ ├── controller.ftl
│ │ ├── service.ftl
│ │ └── ...
关键代码片段：
java复制public class CodeGenerator {
private final Configuration cfg;
public CodeGenerator() {
cfg = new Configuration(Configuration.VERSION_2_3_31);
cfg.setClassForTemplateLoading(getClass(), "/templates");
}
public void generate(TableMeta table) throws Exception {
Map<String, Object> data = new HashMap<>();
data.put("table", table);
data.put("basePackage", "com.example");
// 生成Controller
Template controllerTpl = cfg.getTemplate("controller.ftl");
StringWriter controllerOut = new StringWriter();
controllerTpl.process(data, controllerOut);
writeFile("Controller", controllerOut.toString());
// 其他层代码生成类似...
}
}
3.3 模板设计技巧
实体类模板示例（entity.ftl）：
java复制package ${basePackage}.entity;
import lombok.Data;
import javax.persistence.*;
<#list table.imports as imp>
import ${imp};
</#list>
@Data
@Entity
@Table(name = "${table.name}")
public class ${table.entityName} {
<#list table.columns as col>
<#if col.primaryKey>
@Id
<#if col.autoIncrement>
@GeneratedValue(strategy = GenerationType.IDENTITY)
</#if>
</#if>
<#if col.javaType == "Date">
@Temporal(TemporalType.TIMESTAMP)
</#if>
private ${col.javaType} ${col.fieldName};
</#list>
}
重要提示：模板中应添加合理的空值检查，比如
<#if table.columns??>，避免元数据缺失导致生成失败。
4. 高级功能实现
4.1 数据库逆向工程
使用SchemaCrawler进行元数据提取：
java复制public TableMeta analyzeTable(DataSource ds, String tableName) throws SQLException {
SchemaCrawlerOptions options = SchemaCrawlerOptionsBuilder
.newSchemaCrawlerOptions()
.withSchemaInfoLevel(SchemaInfoLevelBuilder.maximum())
.toOptions();
try (Connection conn = ds.getConnection()) {
SchemaCrawler crawler = new SchemaCrawler(conn, options);
Catalog catalog = crawler.crawl();
Table table = catalog.lookupTable(null, tableName).orElseThrow();
TableMeta meta = new TableMeta(table.getName());
for (Column column : table.getColumns()) {
ColumnMeta col = new ColumnMeta();
col.setName(column.getName());
col.setType(column.getType().getName());
col.setNullable(column.isNullable());
// 其他属性处理...
meta.addColumn(col);
}
return meta;
}
}
4.2 动态模板加载
实现热更新模板机制：
java复制public class HotTemplateLoader implements TemplateLoader {
private final File templateDir;
private final Map<String, Long> lastModifiedMap = new ConcurrentHashMap<>();
public HotTemplateLoader(String templatePath) {
this.templateDir = new File(templatePath);
}
@Override
public Object findTemplateSource(String name) throws IOException {
File file = new File(templateDir, name);
if (file.exists()) {
lastModifiedMap.put(name, file.lastModified());
return file;
}
return null;
}
@Override
public long getLastModified(Object templateSource) {
return (Long) lastModifiedMap.getOrDefault(
((File)templateSource).getName(), 0L);
}
// 其他必要方法实现...
}
5. 工程化实践
5.1 Maven插件集成
创建自定义Mojo：
java复制@Mojo(name = "generate", defaultPhase = LifecyclePhase.GENERATE_SOURCES)
public class CodeGenMojo extends AbstractMojo {
@Parameter(property = "jdbcUrl")
private String jdbcUrl;
@Parameter(property = "tables", required = true)
private String[] tables;
@Override
public void execute() throws MojoExecutionException {
CodeGenerator generator = new CodeGenerator();
DataSource ds = createDataSource();
for (String table : tables) {
getLog().info("Generating code for table: " + table);
TableMeta meta = generator.analyzeTable(ds, table);
generator.generate(meta);
}
}
}
5.2 生成代码质量保障
建议采用以下检查策略：
- 编译时检查：
xml复制<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<executions>
<execution>
<phase>generate-sources</phase>
<goals>
<goal>compile</goal>
</goals>
</execution>
</executions>
</plugin>
- 静态代码分析：
bash复制mvn pmd:pmd checkstyle:checkstyle
- 单元测试生成：
java复制public class TestTemplate {
@Test
public void testController() {
String code = generateCode("controller.ftl", testData);
assertThat(code)
.contains("@RestController")
.contains("@RequestMapping");
}
}
6. 常见问题解决方案
6.1 字段类型映射问题
创建类型转换器：
java复制public class TypeConverter {
private static final Map<String, String> TYPE_MAPPING = new HashMap<>();
static {
TYPE_MAPPING.put("VARCHAR", "String");
TYPE_MAPPING.put("TIMESTAMP", "Date");
// 其他类型映射...
}
public static String toJavaType(String dbType) {
return TYPE_MAPPING.getOrDefault(dbType, "Object");
}
}
6.2 命名风格转换
实现命名策略接口：
java复制public interface NamingStrategy {
String className(String tableName);
String fieldName(String columnName);
}
public class CamelCaseStrategy implements NamingStrategy {
@Override
public String className(String tableName) {
return Arrays.stream(tableName.split("_"))
.map(word -> word.substring(0,1).toUpperCase()
+ word.substring(1).toLowerCase())
.collect(Collectors.joining());
}
@Override
public String fieldName(String columnName) {
String[] parts = columnName.split("_");
return parts[0].toLowerCase() +
Arrays.stream(parts)
.skip(1)
.map(word -> word.substring(0,1).toUpperCase()
+ word.substring(1).toLowerCase())
.collect(Collectors.joining());
}
}
6.3 循环依赖处理
在生成多表关联代码时，建议：
- 拓扑排序表依赖关系
- 分批次生成代码
- 使用延迟注入技巧：
java复制@RestController
@RequestMapping("/orders")
@RequiredArgsConstructor
public class OrderController {
private final ObjectProvider<OrderService> orderServiceProvider;
@GetMapping("/{id}")
public Order getOrder(@PathVariable Long id) {
return orderServiceProvider.getObject().getById(id);
}
}
7. 性能优化实践
7.1 模板预编译
在初始化时预加载所有模板：
java复制public class TemplateCache {
private final Map<String, Template> templateMap = new ConcurrentHashMap<>();
public Template getTemplate(String name) {
return templateMap.computeIfAbsent(name, n -> {
try {
return cfg.getTemplate(n);
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
}
7.2 并行生成策略
利用多线程加速大批量表生成：
java复制ExecutorService executor = Executors.newFixedThreadPool(
Runtime.getRuntime().availableProcessors() * 2);
List<Future<?>> futures = tables.stream()
.map(table -> executor.submit(() -> {
generator.generate(analyzer.analyzeTable(ds, table));
}))
.collect(Collectors.toList());
for (Future<?> future : futures) {
future.get(); // 等待所有任务完成
}
7.3 缓存机制设计
三级缓存架构：
- 元数据缓存：缓存数据库schema分析结果
- 模板缓存：缓存已编译的模板对象
- 代码缓存：缓存生成的代码文本
实现示例：
java复制public class GenerationCache {
private final Cache<String, TableMeta> metaCache = Caffeine.newBuilder()
.maximumSize(1000)
.expireAfterWrite(1, TimeUnit.HOURS)
.build();
public TableMeta getTableMeta(String tableName, Supplier<TableMeta> loader) {
return metaCache.get(tableName, k -> loader.get());
}
}
8. 企业级功能扩展
8.1 多数据源支持
配置数据源路由：
java复制public class DynamicDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
return DataSourceContextHolder.getDataSource();
}
}
// 在生成器中指定数据源
DataSourceContextHolder.setDataSource("productDB");
generator.generate(productTable);
DataSourceContextHolder.clear();
8.2 多语言支持
国际化模板设计：
code复制resources/
├── templates/
│ ├── en/
│ │ └── controller.ftl
│ └── zh/
│ └── controller.ftl
生成时根据Locale选择模板：
java复制String templatePath = "templates/" + locale.getLanguage() + "/controller.ftl";
Template template = cfg.getTemplate(templatePath);
8.3 审计日志集成
自动添加审计字段：
java复制public class AuditTemplateDecorator implements TemplateDecorator {
@Override
public void decorate(TableMeta table) {
table.addColumn(new ColumnMeta("create_time", "TIMESTAMP", false));
table.addColumn(new ColumnMeta("create_by", "VARCHAR(32)", true));
// 其他审计字段...
}
}
// 使用装饰器
generator.addDecorator(new AuditTemplateDecorator());
9. 前沿技术整合
9.1 生成响应式编程代码
Spring WebFlux控制器模板：
java复制@RestController
@RequestMapping("/api/${entityNameLower}")
public class ${entityName}Controller {
private final ${entityName}Service service;
@GetMapping
public Flux<${entityName}DTO> list() {
return service.findAll();
}
@PostMapping
public Mono<Void> create(@RequestBody ${entityName}DTO dto) {
return service.save(dto).then();
}
}
9.2 生成GraphQL Schema
Schema生成器实现：
java复制public class GraphQLSchemaGenerator {
public String generate(TableMeta table) {
return "type " + table.getEntityName() + " {\n" +
table.getColumns().stream()
.map(col -> " " + col.getFieldName() + ": "
+ toGraphQLType(col.getJavaType()))
.collect(Collectors.joining("\n")) +
"\n}";
}
private String toGraphQLType(String javaType) {
switch(javaType) {
case "String": return "String";
case "Integer": return "Int";
default: return "String";
}
}
}
9.3 云原生支持
生成Kubernetes部署文件：
yaml复制apiVersion: apps/v1
kind: Deployment
metadata:
name: ${appName}-service
spec:
replicas: 2
selector:
matchLabels:
app: ${appName}
template:
metadata:
labels:
app: ${appName}
spec:
containers:
- name: ${appName}
image: ${dockerImage}
ports:
- containerPort: 8080
env:
- name: SPRING_PROFILES_ACTIVE
value: "kubernetes"
10. 最佳实践总结
经过多个项目的实践验证，我总结了以下黄金法则：
-
80/20原则：生成80%的通用代码，手动编写20%的业务逻辑代码。不要追求100%生成，保留必要的灵活性。
-
分层生成策略：
- 基础层：实体类、Mapper接口等100%生成
- 服务层：生成骨架代码，填充业务逻辑
- 控制层：生成标准CRUD接口，特殊接口手动扩展
-
版本控制策略：
bash复制# 生成代码应放在单独目录，不与手写代码混合 src/ ├── generated/ # 生成的代码（.gitignore） └── main/ # 手写代码 -
模板维护建议：
- 每个模板文件不超过200行
- 添加模板版本注释
- 配套编写模板测试用例
-
团队协作规范：
- 生成器版本与项目版本绑定
- 生成代码前必须先更新模板
- 禁止直接修改生成代码（应通过模板调整）
这套方案在我最近参与的电商平台项目中表现优异：原本需要2周完成的20个微服务基础模块，通过代码生成器仅用3天就完成了初始版本开发，且代码风格统一、质量稳定。特别是在应对需求变更时，只需调整模板重新生成，维护效率提升显著。