第2460篇：AI驱动的代码迁移——从Java 8到Java 21的AI辅助重构
2026/4/30大约 6 分钟
第2460篇：AI驱动的代码迁移——从Java 8到Java 21的AI辅助重构
适读人群：Java工程师、技术负责人、架构师 | 阅读时长：约18分钟 | 核心价值：用LLM把Java 8的老代码自动迁移到Java 21，处理新特性适配和潜在风险
我们公司有一个服务，写于2016年，一直运行在Java 8上。
技术债积累了很久——Vector、Hashtable、大量的匿名内部类、手写的Optional模拟、verbose的lambda前身……每次维护这个服务的同事都跟我抱怨，但因为"能跑就别动"的惯性，一直没人真正去升级。
去年我决定做这件事。手工改当然可以，但这个服务有30万行代码，全靠人手动改，不现实。我们最终选择的方案是：用AI辅助，按模块批量迁移，每批人工验证。
整个迁移过程历时3个月，迁移了大概28万行代码，人工介入改动不到5%。这篇文章就是整理这个过程的工程实践。
Java 8到Java 21，主要迁移点是什么
先梳理清楚需要迁移的内容，才能设计迁移方案：
这些变更的难度不一样：语法层面的变更基本上是机械性的，LLM处理起来准确率很高；框架版本升级涉及的Breaking Change比较多，需要更仔细的人工验证。
迁移引擎设计
1. 整体流水线
@Service
public class JavaMigrationPipeline {
private final JavaParser javaParser;
private final LLMMigrationAgent migrationAgent;
private final TestRunner testRunner;
private final MigrationReportGenerator reportGenerator;
public MigrationResult migrate(Path sourceDir, MigrationConfig config) {
// 第一步：扫描所有Java文件
List<JavaFile> javaFiles = scanJavaFiles(sourceDir);
log.info("发现 {} 个Java文件待迁移", javaFiles.size());
// 第二步：静态分析，识别迁移点
Map<JavaFile, List<MigrationPoint>> migrationPoints = analyzeFiles(javaFiles, config);
// 第三步：按复杂度排序，从简单的开始
List<JavaFile> sortedFiles = sortByMigrationComplexity(migrationPoints);
MigrationResult.Builder result = MigrationResult.builder();
// 第四步：批量迁移
for (List<JavaFile> batch : partitionIntoBatches(sortedFiles, config.getBatchSize())) {
BatchResult batchResult = migrateBatch(batch, migrationPoints, config);
result.addBatch(batchResult);
// 批次完成后运行测试
if (config.isRunTestsAfterBatch()) {
TestResult testResult = testRunner.runAffectedTests(batch);
if (testResult.hasFailures()) {
log.warn("批次测试失败，暂停迁移: {}", testResult.getFailures());
result.paused(testResult);
break;
}
}
}
return result.build();
}
private Map<JavaFile, List<MigrationPoint>> analyzeFiles(
List<JavaFile> files, MigrationConfig config) {
Map<JavaFile, List<MigrationPoint>> result = new LinkedHashMap<>();
for (JavaFile file : files) {
List<MigrationPoint> points = new ArrayList<>();
// 使用JavaParser做AST分析
CompilationUnit cu = javaParser.parse(file.getPath()).getResult()
.orElseThrow(() -> new ParseException("无法解析: " + file.getPath()));
// 检测各类迁移点
points.addAll(detectAnonymousClasses(cu));
points.addAll(detectOldDateApi(cu));
points.addAll(detectLegacyCollections(cu));
points.addAll(detectVerboseNullChecks(cu));
points.addAll(detectOldStringOperations(cu));
if (!points.isEmpty()) {
result.put(file, points);
}
}
return result;
}
}2. AST级别的迁移点检测
用JavaParser做静态分析，精确定位迁移点：
@Component
public class MigrationPointDetector extends VoidVisitorAdapter<List<MigrationPoint>> {
@Override
public void visit(ObjectCreationExpr n, List<MigrationPoint> points) {
super.visit(n, points);
// 检测匿名内部类（函数式接口实例）
if (n.getAnonymousClassBody().isPresent()) {
List<BodyDeclaration<?>> body = n.getAnonymousClassBody().get();
// 如果只有一个方法，可能是可以改成lambda的函数式接口
if (body.size() == 1 && body.get(0) instanceof MethodDeclaration method) {
String interfaceType = n.getTypeAsString();
if (FUNCTIONAL_INTERFACES.contains(interfaceType) ||
isSingleMethodInterface(interfaceType)) {
points.add(MigrationPoint.builder()
.type(MigrationType.ANONYMOUS_CLASS_TO_LAMBDA)
.location(n.getRange().orElse(null))
.originalCode(n.toString())
.complexity(Complexity.LOW)
.build());
}
}
}
}
@Override
public void visit(MethodCallExpr n, List<MigrationPoint> points) {
super.visit(n, points);
String methodName = n.getNameAsString();
String scope = n.getScope().map(Object::toString).orElse("");
// 检测旧Date API使用
if (scope.matches(".*Date.*|.*Calendar.*|.*SimpleDateFormat.*") ||
methodName.matches("getTime|setTime|getYear|getMonth|getDate")) {
points.add(MigrationPoint.builder()
.type(MigrationType.OLD_DATE_API)
.location(n.getRange().orElse(null))
.originalCode(n.toString())
.complexity(Complexity.MEDIUM)
.build());
}
// 检测String.format可以用formatted()替换的场景
if ("String".equals(scope) && "format".equals(methodName)) {
points.add(MigrationPoint.builder()
.type(MigrationType.STRING_FORMAT_TO_FORMATTED)
.location(n.getRange().orElse(null))
.originalCode(n.toString())
.complexity(Complexity.LOW)
.build());
}
}
// 常见函数式接口列表
private static final Set<String> FUNCTIONAL_INTERFACES = Set.of(
"Runnable", "Callable", "Comparator", "Predicate", "Function",
"Consumer", "Supplier", "BiFunction", "BiConsumer", "BiPredicate",
"ActionListener", "ItemListener", "MouseListener"
);
}3. LLM迁移代理
检测到迁移点之后，让LLM做实际的代码转换：
@Service
public class LLMMigrationAgent {
private final ChatClient chatClient;
public MigratedCode migrate(JavaFile file, List<MigrationPoint> points) {
String originalCode = Files.readString(file.getPath());
// 按优先级对迁移点排序，从后往前改（避免行号变化影响后续）
List<MigrationPoint> sortedPoints = points.stream()
.sorted(Comparator.comparing(
p -> p.getLocation().begin.line,
Comparator.reverseOrder()
))
.collect(toList());
String migratedCode = migrateWithLLM(originalCode, sortedPoints, file.getPath());
return MigratedCode.builder()
.originalPath(file.getPath())
.originalCode(originalCode)
.migratedCode(migratedCode)
.diff(computeDiff(originalCode, migratedCode))
.build();
}
private String migrateWithLLM(
String originalCode,
List<MigrationPoint> points,
Path filePath) {
String migrationInstructions = buildMigrationInstructions(points);
String prompt = """
请将以下Java代码从Java 8风格迁移到Java 21风格。
需要进行的迁移：
%s
迁移原则：
1. 保持原有逻辑不变，只改写法
2. 优先使用Java 17+的新特性（record, sealed class, text block, switch expression）
3. 保留所有注释
4. 不要改变方法签名（避免破坏API兼容性）
5. 对于复杂的迁移，加上TODO注释说明需要人工验证的地方
原始代码：
```java
%s
```
只返回迁移后的完整Java代码，不要有任何解释文字。
""".formatted(migrationInstructions, originalCode);
// 对于大文件，分段处理
if (originalCode.length() > 8000) {
return migrateInChunks(originalCode, points);
}
ChatResponse response = chatClient.call(new Prompt(
new UserMessage(prompt),
OpenAiChatOptions.builder()
.withModel("gpt-4o")
.withTemperature(0.1f)
.withMaxTokens(8192)
.build()
));
String result = response.getResult().getOutput().getContent();
return extractCodeBlock(result);
}
private String buildMigrationInstructions(List<MigrationPoint> points) {
return points.stream()
.map(p -> switch (p.getType()) {
case ANONYMOUS_CLASS_TO_LAMBDA ->
"- 将匿名内部类替换为lambda或方法引用";
case OLD_DATE_API ->
"- 将Date/Calendar/SimpleDateFormat替换为java.time API（LocalDate、LocalDateTime、DateTimeFormatter等）";
case LEGACY_COLLECTIONS ->
"- 将Vector/Hashtable替换为ArrayList/HashMap";
case VERBOSE_NULL_CHECK ->
"- 将null检查模式替换为Optional";
case STRING_FORMAT_TO_FORMATTED ->
"- 将String.format(...)替换为\"...\".formatted(...)";
default -> "- " + p.getType().getDescription();
})
.distinct()
.collect(joining("\n"));
}
}4. 迁移结果验证
代码迁移之后，编译和测试是最基本的验证：
@Service
public class MigrationValidator {
private final JavaCompiler javaCompiler;
private final TestRunner testRunner;
public ValidationResult validate(MigratedCode migratedCode, Path projectRoot) {
ValidationResult.Builder result = ValidationResult.builder();
// 1. 语法检查
SyntaxCheckResult syntaxResult = checkSyntax(migratedCode);
result.syntaxCheck(syntaxResult);
if (!syntaxResult.isValid()) {
// 语法错误，尝试让LLM修复
String fixedCode = attemptAutoFix(migratedCode, syntaxResult.getErrors());
if (fixedCode != null) {
migratedCode = migratedCode.withCode(fixedCode);
result.autoFixed(true);
} else {
result.needsManualReview(true);
return result.build();
}
}
// 2. 编译检查
CompileResult compileResult = compile(migratedCode, projectRoot);
result.compileResult(compileResult);
if (!compileResult.isSuccess()) {
result.needsManualReview(true);
result.compileErrors(compileResult.getErrors());
return result.build();
}
// 3. 运行测试（仅跑与该文件相关的测试）
List<Path> relatedTests = findRelatedTests(migratedCode.getOriginalPath(), projectRoot);
if (!relatedTests.isEmpty()) {
TestResult testResult = testRunner.run(relatedTests, projectRoot);
result.testResult(testResult);
if (testResult.hasFailures()) {
result.needsManualReview(true);
result.testFailures(testResult.getFailures());
}
}
return result.build();
}
private String attemptAutoFix(MigratedCode code, List<CompileError> errors) {
String fixPrompt = """
以下Java代码有编译错误，请修复：
错误信息：
%s
代码：
```java
%s
```
只返回修复后的代码。
""".formatted(
errors.stream().map(e -> e.getLine() + ": " + e.getMessage()).collect(joining("\n")),
code.getMigratedCode()
);
ChatResponse response = chatClient.call(new Prompt(
new UserMessage(fixPrompt),
OpenAiChatOptions.builder()
.withModel("gpt-4o")
.withTemperature(0.1f)
.build()
));
return extractCodeBlock(response.getResult().getOutput().getContent());
}
}迁移过程中的真实踩坑
踩坑一：LLM会"过度迁移"
让LLM迁移一个简单的for循环，它有时候会顺手把整个方法重构了，用Stream写成一行。逻辑没错，但diff变得很大，review起来很痛苦。解决方案：在prompt里明确写"只做必要的迁移，不要做额外的重构"。
踩坑二：Date API迁移要特别小心时区
Java 8的new Date()默认是系统时区，而LocalDateTime没有时区概念，ZonedDateTime才有。LLM有时候会把Date直接替换成LocalDateTime，在跨时区场景下会有bug。这类迁移需要特别标注，强制人工review。
踩坑三：Record类不适合所有POJO
Java 16的record很好，但有限制：不可变、不能继承。如果POJO有setter、被Hibernate管理，或者有继承关系，就不能用record。LLM有时候不考虑这些约束就给你换成record了，编译没错但运行有问题。
迁移效果数字
我们的实际结果：
- 28万行代码，LLM直接迁移成功率约83%
- 约12%需要少量人工修改
- 约5%涉及复杂场景，需要人工重写
- 整体迁移时间：3个月（含全量测试），预估纯人工需要12个月