我让AI改4万行Java老项目,第一周就回滚了

7 阅读11分钟

第 6 天下午,我把 37 个 commit 全 revert 了。

不是因为 AI 写错了。恰恰相反——它写的每一段单看都是对的,编译过、单测过、主流程跑通。问题是它顺手把一些"看起来没用"的东西一起清理了,而那些东西正在被别的地方调用,只不过调用它的方式,静态分析看不见。

这篇文章讲那六天里到底发生了什么,以及回滚之后我改掉的验收方式。

先给结论:在老项目里,AI 改代码的失败原因很少是"写错",绝大多数是"改动范围"超出了它能看见的边界。 你能看见的是 import 关系,看不见的是配置表里的类名、反射调用、外部脚本、AOP 代理。前者是它擅长的地盘,后者是它一脚踩空的地方。


一、那六天我做了什么

给个时间线,因为失败是一步步攒出来的,不是某一天突然炸的。

天我让它做的事表面结果
D1通读三个核心模块,输出调用关系图图八成准,我据此圈定改造范围
D2给圈定的模块补特征测试,覆盖率到 41%测试全绿
D3重构第一个模块:拆大类、提取重复代码编译过,测试绿
D4重构第二个模块编译过,测试绿
D5让它"顺手清理未使用的代码"删了 1,200 行,编译过,测试绿
D6灰度上线,两小时后回滚见下

D5 那一步是我自己提的,不怪它。我当时想的是:既然已经理清了调用关系,把死代码清掉,后面接手的人少踩点坑。

这一步是我在这个项目里犯的最贵的错误。


二、回滚现场:四个具体的坑

坑 1:被配置表调用的方法

系统的定时任务不是写在代码里的,是写在数据库的一张 job_config 表里:

id | bean_name              | method_name      | cron
1  | settleJobService       | doSettle         | 0 0 2 * * ?
2  | reconJobService        | runDailyRecon    | 0 30 3 * * ?

调度器启动时读这张表,Class.forName(beanName) 拿到 bean,再按 methodName 反射调用。

AI 清理"未使用代码"的时候,reconJobService.runDailyRecon 在整个项目里没有任何一处 Java 代码引用它——IDE 会标灰,Sonar 会报未使用,AI 的判断和它们一致。它删了。

当天凌晨的自动对账没有跑。没有报错,因为任务压根没被注册上去。第二天早上财务说"对账单没出",我们才知道。

静态分析看不见字符串里拼出来的类名。 这是老 Java 项目里最常见的一类"幽灵调用"。

坑 2:看起来重复、其实是故意的重复

有一段金额计算,两个方法几乎一模一样:

// 方法 A
BigDecimal amt = order.getAmount().multiply(rateA);
// 方法 B
BigDecimal amt = order.getAmount().multiply(rateB);

AI 很自然地把它合并成一个带参数的方法。问题在于:rateA 是本币对美元的中间价,rateB 是已经含了手续费点差的成交价。这两个方法看起来重复,实际语义完全不同——一个是报价、一个是结算。 合并之后,报价链路开始按含点差的价格算,客户看到的报价比实际成交高 0.3%。

这类改动单测拦不住,因为特征测试录的快照本身就是按老逻辑录的,合并后行为变了,但测试用例只覆盖了结算那条链路(D2 补测试时,报价链路被判定为"低风险"跳过了)。

"看起来重复"是老系统里最危险的信号。 重复往往是七年间不同的人为了不同目的各自写了一遍,只是长得像。

坑 3:靠 stderr 输出的外部契约

有个批处理,失败时 e.printStackTrace()。看着很业余,AI 改成了 log.error(...),这是标准做法。

问题是运维那边有个 shell 脚本,每天扫这个批处理的 stderr 输出,正则匹配 Exception 就发告警。改成 log.error 之后,stderr 干净了,脚本再也没触发过。批处理失败三天,没人知道。

这类"外部契约"最难查,因为它不在代码里,在另一个仓库的 shell 脚本里。

坑 4:Spring 代理被绕过

有一段代码把 service 直接 new 出来用(历史遗留,为了在工具类里调用)。被 new 出来的对象没有经过 Spring 代理,@Transactional 不生效。

AI 重构时"优化"成了通过容器注入,看起来是修好了一个 bug。但实际上:老代码路径是"无事务、报错就半截数据、靠人工补",新路径变成"有事务、整体回滚"。行为变了,而下游有一个补偿任务专门处理半截数据。

它从"错"改成了"对",结果把下游的补偿逻辑搞挂了。

这个坑最值得说:在老系统里,"修复一个已知问题"和"改变系统行为"是同一件事。 你不知道哪些下游逻辑正在依赖这个 bug。


三、真正的根因:我的验收方式错了

回头看,四个坑的共同点不是"AI 蠢",是我的验收标准只覆盖了主流程。

我当时用的验收是三件事:

  1. 编译过
  2. 特征测试全绿
  3. 主流程手工点一遍

这三件事全部围绕"代码本身"。而老系统的风险恰恰在代码之外:配置、反射、外部脚本、下游补偿逻辑。

换句话说,我用"新项目"的验收方式,去管"老项目"的改动。

新项目里,代码是唯一真相。老项目里,代码只是真相的一部分,另一部分散在数据库、shell 脚本、运维习惯、以及某个没人记得为什么这么写的补偿任务里。


四、回滚那天做的六件事

回滚本身十分钟就完了(37 个 commit,按时间倒序 revert)。花时间的是回滚之后的排查。

我列了一张检查表,后来每次动老项目都跑一遍:

#检查项怎么查
1有没有被删除的 public 方法git diff 里 grep ^-.*public .*(
2被删的方法名是否出现在字符串里grep 方法名,含 .properties .xml .sql
3是否有 printStackTrace / System.exit 被改grep 这两个词的历史 diff
4常量、汇率、税率这类数字有没有被"统一"看 diff 里 BigDecimal 的乘除
5被合并的两个方法,调用方是否来自不同业务线看调用方所在包名
6new XxxService() 有没有被改成注入grep new .*Service\(

六项里第 2 项救回了我三个方法——除了 runDailyRecon,还有两个是通过 job_config 表的另一张子表配的。

关键点在第 2 项:删代码之前,先 grep 一遍被删的符号名在非 Java 文件里出现过没有。 这一步三十秒,能挡住整类问题。


五、第二周改了什么:12 个必问问题

回滚之后我没有立刻重来,先花了两天把"动代码前必须问 AI 的问题"写成了一份固定清单,每次改动前把清单丢给它,要求逐条回答。

分四组:

调用关系组

1. 这段代码有没有可能被反射调用?项目里有没有 Class.forName / getMethod / invoke?
2. 有没有可能被配置表、xml、properties 里的字符串引用?
3. 有没有可能被定时任务、MQ 消费者、外部脚本调用?

数据组

4. 我准备合并的这几段"重复代码",它们写入的字段是否语义不同?
5. 有没有哪个数字常量(汇率、税率、费率)在其他地方被独立定义过?
6. 表的状态字段,实际分布是什么?注释可不可信?

状态组

7. 这段代码失败时是抛异常还是吞掉?吞掉之后谁负责补偿?
8. 有没有下游逻辑依赖"当前这个 bug"?(我这里真的有一条)
9. 事务边界变了吗?变更后失败时的数据残留形态和变更前一样吗?

外部契约组

10. 有没有输出到 stdout / stderr 被外部抓取?
11. 有没有日志格式、字段顺序被下游解析?
12. 有没有 HTTP 接口的返回结构、错误码被外部依赖?

它的回答质量参差不齐——第一组回答得最好(因为有代码可查),第四组回答得最差(因为信息不在仓库里)。所以第四组的问题,我改成自己去问运维和下游系统的人,AI 只负责把答案记下来。

这一点很重要:清单的价值不在于让 AI 回答,在于逼我自己确认。 它答不上来的那几条,就是真正的风险点。


六、一个能跑的脚本:找出幽灵调用

第 2 项检查我做成了脚本,四十行 Python,扫出"没有被 Java 代码引用、但在别处出现过"的符号:

import re, subprocess, pathlib

# 1. 取所有 public 方法名(粗筛,够用)
java_files = pathlib.Path("src").rglob("*.java")
methods = set()
for f in java_files:
    src = f.read_text(errors="ignore")
    methods |= set(re.findall(r"public\s+[\w<>\[\],\s]+\s+(\w+)\s*\(", src))

# 2. 在 Java 代码里数引用次数
ref_count = {}
for name in methods:
    hits = subprocess.run(["grep", "-rw", name, "src", "--include=*.java"],
                          capture_output=True, text=True).stdout.count("\n")
    ref_count[name] = hits

# 3. 只被定义、没被引用的(= 候选死代码)
suspects = [n for n, c in ref_count.items() if c <= 1]

# 4. 这些名字在非 Java 文件里出现过吗?
for name in suspects:
    out = subprocess.run(
        ["grep", "-rlw", name, ".", "--include=*.xml",
         "--include=*.properties", "--include=*.yml",
         "--include=*.sql", "--include=*.sh"],
        capture_output=True, text=True).stdout.strip()
    if out:
        print(f"[幽灵调用] {name}  <- {out.replace(chr(10), ' ')}")

跑完输出了 14 个方法,其中 9 个确实是死代码,5 个是被配置或脚本调用的。这 5 个就是 AI 会删掉的东西。

这个脚本不好看,但它在真实项目里管用。 它不追求精确,只追求"把候选范围从 1,200 行缩小到 14 个方法"。


七、这套做法的代价

不写代价就是在骗人。

  1. 慢。 每动一个模块,先跑扫描、再逐条过 12 问,平均多花半天。第一个模块从"AI 两小时改完"变成"我一天改完加验证"。
  2. 它挡不住真正的新问题。 这套东西只能防"我破坏了旧约定",防不了"我引入了一个新的错"。新错还是得靠测试和灰度和时间。
  3. 12 问对 AI 来说是负担。 它回答到第 8 条开始敷衍,会写"无明显影响"这种废话。我后来的做法是每次只问 3-4 条,分三批问。
  4. 依赖运维和下游的配合。 第四组问题得靠人答,人忙的时候就不答,你只能赌。

所以我不认为这方法能推广到"所有项目"。它只对一类项目成立:跑了很多年、改一次出事成本远高于改慢一点的项目。


八、四周后的实际情况

重来的时候只动了一个模块,就是 D3 改过的那个。

  • 改动量从第一次的 1,200 行降到 380 行
  • 时间从两天变成一天
  • 上线后出了一个线上问题,是前端展示的字段顺序变了(第 11 条检查漏了),当天修好

"改动量小了 68%",比"速度快了多少"更值得记。 第一次我改得多是因为它顺手清了死代码、合并了重复、修了已知 bug;第二次这些都只做"记录"不做"修改"——死代码列成清单交给后面的人,重复代码标注语义差异,已知 bug 单独提一个 issue 排期。

在老项目里,"不做"比"做对"更值钱。


九、如果只让我留一句话

我原来以为,AI 改老项目的门槛是"它会不会写"。回滚过一次之后才知道,门槛是"我能不能说清哪些地方不许它碰"。

那条边界不在代码里。它在 job_config 表的那一行,在运维那个 shell 脚本的正则里,在七年前某个人写补偿任务时脑子里想的那个前提里。

AI 看得到代码,看不到这些。所以我得先把它写下来,它才可能不踩。


案例已脱敏,不含公司、客户与项目标识,代码为结构示意。 本文素材与判断由我本人提供,AI 辅助整理成文。


发布前校准

  • 时间线(D1-D6、37 个 commit、1,200 行)为真实经历的近似记录,非精确日志
  • 脚本在 JDK 8 + Linux 环境实测可跑,只依赖 grep 与标准库,无需额外安装
  • 「14 个候选 / 5 个幽灵调用」为该项目的实测数字,其他项目比例会不同
  • 12 问清单是项目内沉淀,不是行业标准,按自己系统调整