笔记 · 架构演进 / KNOWLEDGE-BASE

带着一具失败的容器,重读 Spring

2026-09-09约 15,974 字spring-ioc-aop-webflux.md

用一次失败的复刻,反向读一遍 Spring 的源码设计

解剖对象:ioc_framework review-fix 快照,Python,源码 1826 行(6 文件)、 测试 1350 行(37 个测试函数)——就是前篇提到的”早期版核心源码 1826 行”那一版, 也是整个系列里最像 Spring 逐句翻译的一版:@aspect / @pointcut / @before / @around、动态子类代理、条件装配、@value 配置注入、包扫描,全套都在。

前篇《为了异步 AOP,我们造了一个 IoC 容器》站在终点 (封存版 2762 行)回答”该不该做”;本篇站在起点回答另一个问题:Spring 在源码层 到底是怎么设计的,我们翻译时漏掉了什么。 Java 视角为主,Python 只作对照。

系列:《PyMapper 的诞生》 → 《从显式鉴权到声明式事务》 → 《为了异步 AOP,我们造了一个 IoC 容器》 → 本篇


先说结论

把失败版和 Spring 并排读完,差别可以压缩成三句话:

  1. Spring 的 IoC 内核不认识 AOP,是 AOP 认识 IoC。 依赖方向是单向的: spring-aop 依赖 spring-beans,反过来一行都没有。我们的 container.py 第 34 行 from .aop import ProxyFactory 把方向写反了,846 行单体从这一个 import 开始注定。
  2. IoC 与 AOP 的”强相关”不是模块耦合,而是生命周期寄生。 AOP 的全部入口是一个 BeanPostProcessor:织入发生在 bean 初始化完成后的最后一刻,循环依赖场景则由 三级缓存把这个时机提前。Spring 为”代理何时出场”专门改造了单例注册表——这才是 两者真正咬合的深度。
  3. 异步 AOP 的本质是把”调用边界”换成”信号边界”。 WebFlux 下 advice 拿到的 永远是 Mono/Flux 载体,不是结果。Spring 没有让旧 advice 自动适配,而是给 事务单独写了 reactive 分支。我们失败版里的 pop(0) 拦截链、ThreadLocal 式 上下文、吞取消信号,每一条都对应信号边界上的一个具体设计缺口。

对照之外,本篇的三、四两节把镜头移回 Spring 本身:同一套 IoC×AOP 机制如何长出 从 @Transactional 到 Spring Data 仓库接口的整个功能生态(大众的和冷门的都有), 以及 bean 统一管理在内存与 JVM 层面结出的账——元数据缓存、代理类共享、对象寿命 与分代 GC 的对齐,一直到 AOT。


一、IoC 内核的骨架:为什么它可以不认识任何高级特性

refresh() 是一张剧本,不是一个函数

AbstractApplicationContext.refresh() 是 Spring 容器的总入口,主干十二步:

prepareRefresh
obtainFreshBeanFactory              ← 建 BeanFactory,装载 BeanDefinition
prepareBeanFactory
postProcessBeanFactory
invokeBeanFactoryPostProcessors     ← 改"图纸"的机会(操作 BeanDefinition)
registerBeanPostProcessors          ← 改"成品"的机会先就位(AOP 在这里注册)
initMessageSource
initApplicationEventMulticaster
onRefresh
registerListeners
finishBeanFactoryInitialization     ← 到这里才实例化普通单例
finishRefresh

值得盯住的是第 5、6、11 步的间距:修改定义的扩展、修改实例的扩展、真正实例化, 被排成三个不可颠倒的阶段。 任何 BeanPostProcessor(包括 AOP 的那一个)一定在 普通 bean 实例化之前就位,这不靠文档约定,靠的是 refresh 的阶段序。

失败版里有一段一模一样的约束,写法完全不同(container.py:151):

def _add_aspect(self, cls):
    if self._singletons:
        raise RuntimeError("切面必须在首次解析 Bean 之前完成注册")

同一个不变量,Spring 把它做成结构(阶段过了就不可能违反),我们把它做成 运行期炸弹(违反了才炸,且靠使用者自觉不踩)。这是这次对照里我认为最值得 带走的单条经验:时序约束应该编译进流程的形状里,而不是散布在防御性 if 里。

BeanDefinition:注册期与实例化期的彻底分离

Spring 里”你写的类”和”容器造的对象”之间隔着一层 BeanDefinition:scope、 是否懒加载、构造参数、属性值、init/destroy 方法名、是否 primary……注册期只编译 图纸,实例化期只按图施工,两期之间还留了 BeanFactoryPostProcessor 这个官方改图 入口(占位符替换、@Configuration 增强都在这层做)。

失败版的”图纸”是这样的(container.py:142):

self._definitions[cls] = {'scope': scope}

一个只有一个键的字典。后果不是少了功能,而是每加一个功能都无处安放:条件装配 塞进了 _pending_conditionals 旁路列表,配置注入靠运行期反射猜构造参数默认值, AOP 元数据挂在类属性 _ioc_aspect 上。图纸层缺失,所有元数据只能寄生在别处, 容器主干于是被迫认识每一个特性——单体就是这么长出来的。

BeanPostProcessor:主干上的插座

Spring 实例化一个 bean 的主干只有三件事(AbstractAutowireCapableBeanFactory.doCreateBean):

createBeanInstance     实例化(构造器注入在这里)
populateBean           属性填充
initializeBean         初始化:
  ├─ applyBeanPostProcessorsBeforeInitialization
  ├─ invokeInitMethods(afterPropertiesSet / init-method)
  └─ applyBeanPostProcessorsAfterInitialization   ← AOP 从这里换走原对象

主干本身几乎什么都不做,所有”Spring 味”的特性全是挂在前后两个插座上的后处理器:

特性实现它的 BeanPostProcessor
@Autowired / @ValueAutowiredAnnotationBeanPostProcessor
@PostConstruct / @PreDestroyCommonAnnotationBeanPostProcessor
Aware 回调ApplicationContextAwareProcessor
AOP 自动代理AbstractAutoProxyCreator
@AsyncAsyncAnnotationBeanPostProcessor

DefaultListableBeanFactory 里没有一行代码知道代理会发生;spring-beans 模块 根本不依赖 spring-aop。内核提供的不是功能,是协议。

失败版抄对了生命周期的顺序(构造 → @inject → @value → @post_construct, 和 Spring 的三段一一对应),但把每一段都写死成了容器的私有方法: _invoke_inject_methods、_invoke_value_methods、_maybe_create_proxy 全是 Container 的成员。顺序抄到了,插座没抄到——这就是”翻译”和”设计”的差距: 翻译复制行为,设计复制的是扩展点的位置。


二、AOP 不是一个模块,是寄生在 Bean 生命周期上的后处理器

织入发生在最后一刻,而且必须是最后一刻

@EnableAspectJAutoProxy 做的唯一一件事是往容器里注册一个 AnnotationAwareAspectJAutoProxyCreator——它是个 BeanPostProcessor。织入点在 postProcessAfterInitialization:bean 已经构造完、注入完、init 方法跑完,才被 判断要不要换成代理。这个时机选择带来两个直接收益:

  • 目标对象以干净的形态完整存在过:它的构造、注入、初始化和 AOP 完全无关;
  • 织入决策可以看到 bean 的最终形态(所有注解、所有接口),不必在实例化前预判。

失败版的织入点在实例化之内(container.py:473):

actual_cls = self._maybe_create_proxy(cls)   # 先决定代理
instance = actual_cls(**kwargs)              # 直接 new 代理类

代理类就是实例本身。构造函数在代理子类上跑,@post_construct 在代理上执行, “干净的原对象”从未存在过。这不是写错,是另一种取舍——但当时我们不知道自己在取舍。

代理与目标分离:自调用失效是”选”出来的

Spring 的代理(JDK 动态代理和 CGLIB 都一样)本质是组合:代理只是一层壳, 持有 TargetSource,每次调用委托给里面的目标对象。CGLIB 虽然生成子类,但代理 实例经 Objenesis 创建、不执行构造函数,业务状态全在被包裹的 target 上。于是:

public void a() { this.b(); }   // this 是裸 target,b() 的事务注解不生效
@Transactional
public void b() { ... }

自调用绕过代理,是 Spring 最著名的坑。官方逃生门是 @EnableAspectJAutoProxy(exposeProxy = true) + AopContext.currentProxy(), 或者干脆 AspectJ 编译期织入。

失败版因为”代理类即实例”,self.b() 走的就是子类覆盖后的方法——自调用能被 拦截,这一点反而比 Spring 强。代价在另一头:织入被迫提前到实例化期、目标与 代理无法分离、想”先拿到干净对象再决定包不包”做不到。Spring 用自调用失效换正交性, 我们用正交性换自调用——两边都是完整的 trade-off,输的不是方案,是无意识。

切面必须豁免自己

AbstractAutoProxyCreator 有一条不起眼但致命的防线:isInfrastructureClass 把 Advice、Pointcut、Advisor、AopInfrastructureBean 排除在代理之外, shouldSkip 再把切面 bean 本身排掉。没有这条防线,一个 execution(* *(..)) 级别的宽切点会让切面反过来代理自己,advice 调用 advice。

失败版没有这个豁免:_maybe_create_proxy 对所有类一视同仁,一条 *.* 切点 会把切面类也套上代理。测试里没炸只是因为切点都写得窄——防线不存在和防线没被 触发,是两回事。

三级缓存:循环依赖 × 代理时机的联立方程

DefaultSingletonBeanRegistry 的三级缓存常被当成面试题背,它真正解的是一个 联立方程:循环依赖要求”提前暴露半成品”,AOP 要求”暴露出去的必须是最终形态 (可能是代理)”。

singletonObjects        一级:成品
earlySingletonObjects   二级:提前暴露的早期引用
singletonFactories      三级:ObjectFactory —— 关键在这层

第三级存的不是对象,是工厂。取用时才回调 SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference—— AbstractAutoProxyCreator 实现了这个接口:如果这个 bean 需要代理,早期引用 直接给代理,并记入 earlyProxyReferences;等正常织入点 postProcessAfterInitialization 到来时检查该记录,避免二次代理。

只解循环依赖,两级缓存就够;第三级完全是为”代理时机不确定”而设。IoC 与 AOP 的强相关,最深的一处咬合就在这里——单例注册表这种最内核的数据结构,为 AOP 留了一个回调位。

有意思的是结局:Spring Boot 2.6 起 allow-circular-references 默认 false。 框架花了三级缓存的复杂度把问题解干净,然后默认建议你别用。失败版只支持构造器 注入,循环依赖一律抛 CircularDependencyError——歪打正着站在了 Boot 2.6 的 立场上。当时我们把它当成”没能力实现三级缓存”,现在看它是个立场:能力和立场 是两回事,框架可以既有能力又劝你别用。

proceed 链:可变游标 + 显式克隆协议

前篇写过封存版用 proceed_at(index) 闭包修好了拦截链,这个 review-fix 快照里 还留着原始病灶(aop.py:95):

def proceed(self):
    if self._proceed_chain:
        advice_callable = self._proceed_chain.pop(0)   # 链是消费品
        return advice_callable(self)
    return self.method(self.target, *self.args, **self.kwargs)

重试型 advice 第二次调 proceed() 时链已被吃空,直接裸调目标方法——内层的 事务 advice 被静默绕过。

Spring 的 ReflectiveMethodInvocation.proceed() 用的也是可变状态——一个递增 游标 currentInterceptorIndex,同一个 invocation 同样不可重放。区别是它把 “重放”升级成了显式协议:ProxyMethodInvocation.invocableClone()。spring-retry 的拦截器每次重试前克隆整个 invocation 再 proceed,游标各归各的:

// RetryOperationsInterceptor 的每次 attempt
MethodInvocation clone = ((ProxyMethodInvocation) invocation).invocableClone();
return clone.proceed();

所以正确答案不止”链不可变”一种;“可变游标 + 谁要重放谁克隆”同样成立。 失败的根源是链的重放语义从未被定义——重试拦截器和链的实现各自假设了 对方不存在的性质。


三、一个审批方法背后的机制生态

前两节讲骨架和挂载点,都是框架视角。换成业务视角,看这套机制咬合起来之后, 一个普通的业务方法到底活在什么环境里。

八行业务代码,三层横切

订单系统里最普通的一个方法:

@Service
public class OrderService {

    private final OrderRepository repo;      // IoC:构造器注入
    private final NotifyService notify;

    public OrderService(OrderRepository repo, NotifyService notify) {
        this.repo = repo;
        this.notify = notify;
    }

    @PreAuthorize("hasRole('AUDITOR')")               // 鉴权
    @Transactional                                    // 事务
    @CacheEvict(cacheNames = "orders", key = "#id")   // 缓存失效
    public Order approve(long id) {
        Order order = repo.findById(id).orElseThrow();
        order.approve();
        notify.auditPassed(order);           // 它内部标了 @Async
        return order;
    }
}

调用方注入到手的 OrderService 是个 CGLIB 代理,一次 approve(42) 的真实路径:

caller
 └─ OrderService$$SpringCGLIB 代理
     ├─ 方法安全拦截器    没有 AUDITOR 角色 → AccessDeniedException,方法体根本不进
     ├─ 缓存拦截器        登记待驱逐的 orders::42
     ├─ 事务拦截器        getTransaction → 提交或回滚
     └─ approve() 本体    八行纯业务

鉴权、缓存、事务、异步通知,四种横切能力,业务类里一行基础设施代码都没有。 这是使用者看到的效果;机制生态藏在下面三条规则里。

规则一:AOP 的零件全是 IoC 的 bean

每个注解背后是一组 bean:一个 Advisor(切点 + 拦截器),加一个真正干活的服务—— 事务拦截器背后是 TransactionManager,缓存拦截器背后是 CacheManager,鉴权 拦截器背后是 AuthorizationManager。它们全由容器创建、注入、按条件替换:缓存 从 Caffeine 换 Redis,是换一个 CacheManager bean 的事,六个业务模块里的 @Cacheable 一行不动;测试里用 @MockBean 把 NotifyService 换成假的,也是 同一本账上的操作。

前面说”内核不认识 AOP”,这里是它的另一半:AOP 的所有零件都活在 IoC 里。 切面可以注入依赖、可以被条件装配替换、可以被测试替身顶掉——因为它们就是普通 bean。寄生关系是双向供养的。

规则二:进场只需注册,不需修改

AbstractAutoProxyCreator 收集容器里所有 Advisor 类型的 bean,逐个 bean 做 切点匹配。于是”新增一种横切能力”的成本收敛为:往容器注册一个 advisor。 spring-retry、Spring Security 的方法安全、Micrometer 的 @Observed、你自己写的 审计切面,全按同一协议进场,彼此不知道对方存在,内核一行不改。

生态的定义就在这里:扩展彼此不认识,只认识容器协议。 对照失败版:我们每加 一个特性改一次 container.py——那不是生态,是加建。

规则三:组合顺序是一等问题,不能靠碰运气

拦截器可以自由叠放,叠放顺序却直接改变语义。@Cacheable 和 @Transactional 是经典案例:缓存拦截器若在事务外层,缓存命中时事务根本不开——省了资源,但读到 的值绕过了事务隔离;两者默认都不声明优先级,相对顺序没有保证,官方文档明确建议 同时使用时显式设 order。@Order、@EnableTransactionManagement(order = ...) 这些接口不是装饰——允许自由组合的生态,必须把组合语义做成显式配置,否则 每次叠放都在掷骰子。失败版的切面连 order 参数都有(_ioc_aspect_order),漏的 是”顺序错了会发生什么”的语义定义。

这套生态造出来的东西

大众款,Java 后端每天都在用的:

功能机制效果
@TransactionalTransactionInterceptor提交回滚从业务代码消失
@Cacheable / @CacheEvictCacheInterceptor + CacheManager方法级缓存,实现可整体替换
@AsyncAsyncExecutionInterceptor + TaskExecutor方法调用变线程池任务投递
@PreAuthorize方法安全拦截器 + AuthorizationManager鉴权下沉到任意方法
@ValidatedMethodValidationInterceptor参数校验织入任意 bean
@RetryableRetryOperationsInterceptor声明式重试(invocableClone 那位)
Spring Data 仓库接口ProxyFactory + QueryExecutorMethodInterceptor只写接口,实现由代理凭空生成
@HttpExchangeHttpServiceProxyFactory接口直接变 HTTP 客户端

后两行值得单独一句:代理的用法在这里升了一级。前面的场景都是装饰——包住 一个已有对象;Spring Data 仓库和 HTTP Interface 是凭空实现——根本没有目标 对象,拦截器本身就是实现,findByStatusAndUserId 这样的方法名被解析成查询。 同一套 ProxyFactory,两种存在方式。

冷门款,机制上反而更有嚼头:

@Lookup——容器直接改写你的类。 单例 Service 每次需要一个全新的有状态 bean(比如攒状态的报表构建器),字段注入只发生一次,满足不了。把 @Lookup 标在抽象方法上,容器用 CGLIB 生成子类,把方法体实现为”向容器要一个新实例”。 不是包住你的类,是补完你的类——作用域不匹配的时间差被一个方法调用抹平。

Scoped Proxy——把短命对象装进长命字段。 request 作用域的购物车上下文注入 单例 Controller,注入的其实是代理,每次方法调用经 RequestContextHolder 找到 “当前请求”的那一份。Spring Cloud 的 @RefreshScope 把同一机制反过来用:代理 不动,配置刷新时丢弃背后的 target 重建——引用不变,实现热替换,“改配置 不重启”就是这一个代理换目标的把戏。

@Configuration 的自我增强。 配置类里 @Bean 方法互相调用,为什么不会 new 出第二份?因为配置类本身被 CGLIB 增强过,@Bean 方法被拦截成”先查容器”。 你以为在写普通的 Java 方法调用,其实每一次都是容器查表——AOP 深到连”如何定义 bean”这件事本身都被代理了。

@Lazy 注入点代理。 依赖先给你一个壳,第一次真调用才解析目标。既是拆 循环依赖的官方逃生门,也能把昂贵 bean 的构造推迟到真正用到的那天。

@TransactionalEventListener。 “订单提交成功后再发 MQ”——发早了,事务 一回滚就是幽灵消息。把事件监听挂到 AFTER_COMMIT 相位,靠的是事务拦截器一路 维护的 synchronization 设施。事务在这里不只是提交回滚,它成了一条别的横切 能力可以挂靠的时间轴。

这张单子上没有一个功能改过容器内核。全部是 BeanPostProcessor、Advisor、 FactoryBean、Scope 四个协议的排列组合——协议少而稳定、组合面大,这是”生态” 两个字在源码层的含义。


四、Bean 统一管理在内存与 JVM 上的回报

容器常被当成”方便注入的工具”讨论,它对内存和 JVM 的影响说得少。这一节把账 算出来。

对象寿命与分代 GC 对齐

分代 GC 的前提假设是:对象要么朝生夕死,要么长命百岁。容器的”默认单例 + 无状态服务”约定恰好把应用切成这两类——singleton 启动期创建、晋升老年代后终生 不动,GC 从不回收它们;请求态对象(DTO、entity、局部变量)在 eden 出生即死, young GC 一扫而空。最伤 GC 的是中间寿命的对象,而没有容器纪律的代码恰好爱造 这种:每请求 new 一个 service、service 字段里缓存上一次请求的数据。单例约定 省下的不是 new 的钱(分配本身很便宜),是对象寿命的混乱。

昂贵资源有账本

连接池、线程池、HTTP 客户端全是单例 bean,享受同一套账本:destroySingletons 按创建逆序回调销毁、SmartLifecycle 的 phase 控制停机次序(先停流量入口,再关 资源池)、shutdown hook 兜底。JVM 视角,泄漏的非 daemon 线程和没关的池,是 “进程退不出去”和内存泄漏的头号常客——容器把”谁负责关”从每个开发者头上收走, 记在一本按序执行的账上。前篇写的异步生命周期泥潭(所有权、逆序、停机预算), Spring 在同步世界早把这套账本做完了,我们是在异步世界重修这门课。

反射元数据全线缓存

反射慢、产垃圾,而注解驱动的框架处处是反射。Spring 的对策是让每个决策只发生 一次:

缓存存什么
CachedIntrospectionResultsJavaBean 属性描述,按类缓存
ReflectionUtils / MergedAnnotationsdeclaredMethods、注解合并结果
RootBeanDefinition已解析的构造器 / 工厂方法
AdvisedSupport 的 methodCache每个方法要过的拦截器链
TransactionAttributeSource 的 attributeCache每个方法的事务属性

稳态运行时,注解解析、切点匹配、签名反射全部退出热路径:代理调用的额外开销 收敛为一次 map 查找加固定数组遍历。这是 BeanDefinition 那层”图纸”的第二笔 回报——元数据是数据,数据才有 key,有 key 才能缓存。 失败版每次实例化都 重跑 dir() 扫描和 inspect.signature 解析,同一个类的第一千次创建和第一次 一样贵,正是缺了这层意识。

代理类按类生成,按 ClassLoader 缓存

一千个 prototype 实例只对应一个代理类:JDK 代理类由 JDK 按 ClassLoader 缓存, CGLIB 类由 Spring 缓存,metaspace 里各占一份。失败版的 _proxy_cache 干的是 同一件事——为数不多天然抄对的地方。反面账也要记:每个代理类终归是 metaspace 里一个真实的类。所以 Boot 2.2 把全部自动配置类改成 proxyBeanMethods = false (@Bean 互调改为参数注入),一刀省掉几百个 CGLIB 增强类,启动时间和 metaspace 占用双降——框架自己也在给自己的 AOP 机制做减法:哪里需要增强、哪里只是 写着顺手,它分得很清。

动态性从运行期挪到启动期,JIT 才有得做

所有扫描、匹配、装配决策发生在 refresh() 里;稳态请求路径上没有一次容器查询—— 依赖是普通字段引用,拦截器链是形状固定的数组。调用图启动后不再变化,JIT 的 分层编译和内联才有稳定的观测对象。对照 Service Locator 风格(每次调用查一次 注册表):热路径上多一次哈希查找是小账,调用目标不稳定让 JIT 难以优化才是大账。 依赖注入与 Service Locator 之争,在 JVM 层面也有裁决。

走到头就是 AOT

Spring 6 的 AOT 把”启动期决策”再往前搬到构建期:BeanDefinition 图被冻结成 生成的 Java 配置代码,反射点登记进 reachability metadata,代理类构建期预生成—— GraalVM native image 运行期造不了字节码,这条路必须提前走完。启动时间和常驻 内存的量级下降,本质是同一句话的第三次兑现:装配是数据,数据可以被搬到任何 时机执行——经典模式在运行期,元数据缓存把它摊到启动期,AOT 把它压进构建期。 Boot 3.3 的 CDS 支持走的也是这个方向(训练启动导出类归档,下次启动内存映射共享)。

有账就有租

诚实的部分:BeanDefinition 表、元数据缓存、单例池全部常驻,强引用一持到底; 几千个 bean 的应用,启动期类路径扫描和注解解析的 CPU 开销可观;开发期热重载 没关干净老 context,是 metaspace 泄漏的经典现场。Spring 的对冲是全局 lazy-initialization 开关、AOT、按需裁剪依赖。成本不会消失,只是被摊成 可预测的固定成本——而可预测,恰恰是内存治理里最值钱的性质。


五、把失败推到 WebFlux:异步切面怎么设计才站得住

问题加倍:调用边界变成信号边界

前篇已经论证过:async 方法返回的是载体不是结果,advice 只包住方法调用就什么 都测不到。WebFlux 把这个问题再加倍——组装、订阅、执行三相分离,且执行还会 跨线程。一个请求可能从 reactor-http-nio-3 组装、在 boundedElastic-1 执行 阻塞段、回到另一条 nio 线程发响应;同一条 nio 线程又同时服务几百个请求。 ThreadLocal 式的事务上下文在这里不是”偶尔丢”,是结构性失效。

失败版在 Python 里对应的坑一模一样:ContextVar 会复制进 create_task 的 子任务,但子任务的写入不回传父任务——gather() 下三个子任务各建一份”当前连接”。 载体不同,病是同一种:上下文的传播模型没有跟着执行模型换。

Spring 自己的答案:不适配旧 advice,给事务单独写 reactive 分支

TransactionAspectSupport.invokeWithinTransaction 里有一个显式分叉:先用 ReactiveAdapterRegistry 看方法返回类型,是 Publisher/Kotlin Flow 且配了 ReactiveTransactionManager,就走一条完全独立的路径——事务上下文不进 ThreadLocal,进 Reactor Context,经 TransactionContextManager 存取, 提交回滚挂在 onComplete/onError 信号上。

注意 Spring 没有做的事:它没有提供”让任意旧 advice 自动理解 Mono”的魔法。 计时、重试、审计想覆盖真实执行,各自要写 reactive 版本。这印证了前篇的判断 (每种异步载体都需要明确的完成信号协议),也给出了工程答案:逐个切面显式适配, 不做通用透明层。

从失败经验推出来的五条设计

1. 载体白名单,不做鸭子判断。 失败版用 inspect.isawaitable() 到处试探,唯一做对的是启动期直接拒绝异步生成器 (aop.py:445 的 validate_compatibility)。Spring 的做法是把这个”做对的局部” 制度化:ReactiveAdapterRegistry 显式登记每种载体(Mono、Flux、 CompletionStage、RxJava、Flow)和它的适配器,登记表之外的返回类型不享受任何 异步语义。能力的边界要用注册表画出来,不能用 if 试出来。

2. 组装期必须纯,副作用全部挂到信号上。 pop(0) 之所以致命,是因为组装期存在可变状态。Reactor 的重试是”重新订阅 整条已组装的管道”——retryWhen 能工作的前提是管道组装是纯的、源是冷的,每次 订阅从头重放。advice 一旦在组装期吃状态,重放即坏。所以 reactive advice 的纪律是: 拦截器本体只做包装,计时、日志、清理一律挂信号钩子:

public Object invoke(MethodInvocation invocation) throws Throwable {
    Object result = invocation.proceed();          // 组装期:只拿到载体
    if (result instanceof Mono<?> mono) {
        return mono.transformDeferred(m -> {       // 每次订阅执行一次
            long startedAt = System.nanoTime();    // 订阅期才起表
            return m.doFinally(signal ->           // 完成/出错/取消都停表
                record(System.nanoTime() - startedAt, signal));
        });
    }
    return result;                                 // 同步方法走老路
}

transformDeferred 保证重试(= 重订阅)时计时器重开,这正是 pop(0) 链在 重试下断裂的镜像修复。

3. 上下文只走 Context,并接受它的反直觉方向。 Reactor Context 是不可变的,随订阅信号自下而上传播:contextWrite 写入的 内容只对它上游(更靠近源)的算子可见。第一次用几乎必然写反位置——但这个 方向恰好是对的:订阅者决定环境,源适应环境,事务边界(最外层 advice)写入, 数据源(最内层)读取。需要和 ThreadLocal 世界互通时,Reactor 3.5 的 Hooks.enableAutomaticContextPropagation() 配合 Micrometer context-propagation 做桥接,MDC 日志就是靠它救回来的。

4. 取消是一等信号,不是异常。 WebFlux 里客户端断连、timeout() 超时都表现为 cancel 信号沿管道上传。advice 若只处理 onError,取消场景下资源照漏;doFinally 的 SignalType.CANCEL 分支必须有交代。这是失败版”宽捕获吞 CancelledError”教训的 Java 版: Python 里取消是 BaseException,Reactor 里取消干脆不走异常通道——两边都在 说同一件事,取消有自己的语义通道,不能折叠进错误处理。

5. 自调用在 WebFlux 下加倍隐蔽。

public Mono<Order> approve(long id) {
    return saveAndAudit(id);        // this 调用:事务没挂上
}
@Transactional
public Mono<Order> saveAndAudit(long id) { ... }

同步世界里自调用失效至少行为立刻不对;这里组装成功、订阅成功、每条 SQL 各自 auto-commit,没有任何报错,只在部分失败需要回滚的那天爆开。防御手段按成本 排序:ArchUnit 架构测试禁掉带注解方法的同类调用、TransactionalOperator 显式圈边界、AspectJ 编译期织入兜底。

边界:方法级 AOP 不是唯一位置

前篇的结论在 WebFlux 里同样成立,甚至更成立:请求级横切(日志、鉴权、trace) 在 WebFilter 里天然覆盖完整信号周期;数据访问横切在 TransactionalOperator / R2DBC 层;真正剩给方法级注解 AOP 的,只有”必须按方法签名批量匹配”的那一小块。 Spring 给事务单独写 reactive 分支而不做通用透明层,本身就是这个判断的官方背书。

Python 回望

如果按这套认识重写失败版的 aop.py,改动收敛成三条:proceed_at(index) 闭包 (即 invocableClone 语义,封存版已做);载体注册表替换 isawaitable 试探 (coroutine → async wrapper,async generator → 显式迭代包装或启动期拒绝); advice 分裂为”包装型”(组装期,必须纯)与”信号型”(执行期,允许副作用)两类 接口。但结论仍是前篇那个:Buyer 的横切需求用 @transactional() + middleware 就覆盖了,通用 AOP 的收益撑不起这套协议的维护成本。认识升级不改变决策, 它只是让决策从”做不出来所以不做”变成”做得出来但不该做”。


六、这次对照最值得带走的四条

  1. 依赖方向是框架设计的第一决策。 内核不认识扩展,扩展认识内核; spring-beans 不 import spring-aop。审查自己的设计时先画 import 箭头, 箭头反了,后面全是补丁。
  2. 不变量要做成结构,不做成异常。 “切面必须先于 bean 实例化注册”这一条, Spring 写成 refresh 的阶段序,我们写成 RuntimeError。凡是靠运行期防御守住的 时序约束,都值得问一句:能不能改成流程形状本身?
  3. 异步 AOP 的接口必须以载体为一等公民。 组装期纯、副作用挂信号、上下文走 Context、取消独立通道、载体白名单——五条都满足才算 reactive advice,缺一条 就只是同步 AOP 的翻译。翻译我们已经做过一次了,1826 行,结论在前篇。
  4. 元数据层的投资是复利的。 BeanDefinition 让新功能有处安放(第一节)、让 整个 advisor 生态有统一入口(第三节)、让缓存有 key、让 AOT 有输入(第四节)。 同一层设计,多次兑现——评估”要不要为这堆字典加一层正式的元数据”时,别只按 第一次收益算账,失败版就是这么把它省掉的。

附:数据口径

解剖对象 ioc_framework(review-fix 快照)按 UTF-8 物理行统计:

项目结果
源码1826 行 / 6 文件(container.py 872、aop.py 466)
测试1350 行 / 4 文件,37 个测试函数
与封存版关系即前篇所称”早期版核心源码 1826 行”,后续演进为封存版 2762 行

Java 侧机制均指 Spring Framework 6.x 主线源码(AbstractApplicationContext、 AbstractAutowireCapableBeanFactory、DefaultSingletonBeanRegistry、 AbstractAutoProxyCreator、ReflectiveMethodInvocation、 TransactionAspectSupport),行为描述以类与方法名为锚,未标注具体行号—— 版本间行号会漂,方法名基本不漂。