企业官网建设流程全解析

• 示例工程
• 文档

MetadataAwareAspectInstanceFactory是 Spring AOP 中负责"实例化 AspectJ 注解切面并携带其元数据"的核心接口。本文以 spring-reading 仓库中的spring-aop-metadataAwareAspectInstanceFactory模块为骨架，完整讲解该接口的定义、五大实现类的行为差异（单例、原型、懒加载等）、可运行的实战示例，并结合仓库源码与关联模块（AspectInstanceFactory、AspectJAdvisorFactory）逐层剖析其底层设计动机与调用关系，帮助读者彻底理解注解式 AOP 中"切面从哪来、元数据怎么用、互斥锁为何存在"这一关键链路。

一、为什么需要 MetadataAwareAspectInstanceFactory

在 Spring 使用 AspectJ 注解风格（@Aspect、@Before、@After等）实现 AOP 时，框架需要做两件事：一是拿到切面实例以调用其中的通知方法，二是拿到切面的元数据（如切面名称、切面类、perClause切点）以便解析注解、生成 Advisor。AspectInstanceFactory接口只负责前者（getAspectInstance()与getAspectClassLoader()），而MetadataAwareAspectInstanceFactory在其基础上增加了元数据能力。

为什么要把"带元数据的工厂"单独拆成一个子接口？Spring 源码中的注释给出了明确理由：理想情况下AspectInstanceFactory本身就应该包含元数据方法，但由于AspectMetadata使用了 Java 5 专属的org.aspectj.lang.reflect.AjType，为了保持接口对低版本 Java 的兼容，必须将其拆分到子接口中（参见 spring-aop-aspectInstanceFactory 模块 README 中对父接口的介绍）。

二、接口源码：两个核心方法的语义

MetadataAwareAspectInstanceFactory接口本身非常精简，只定义了两个方法，源码如下（与模块 README 中的接口源码一致）：

public interface MetadataAwareAspectInstanceFactory extends AspectInstanceFactory { /** * 返回此工厂的切面的 AspectJ AspectMetadata。 * @return 切面元数据 */ AspectMetadata getAspectMetadata(); /** * 返回此工厂的最佳创建互斥锁。 * @return 互斥锁对象（如果不需要使用锁，则可能为 {@code null}） * @since 4.3 */ @Nullable Object getAspectCreationMutex(); }

• getAspectMetadata()：返回与 AspectJ 注解类关联的AspectMetadata对象。该对象封装了切面名称（aspectName）、切面类（aspectClass）以及perClause切点（perClausePointcut），是AspectJAdvisorFactory解析通知、构建 Advisor 时的重要输入。
• getAspectCreationMutex()：返回创建切面实例时的互斥锁。注意返回值可以是null——当底层容器（如单例 Bean 工厂）本身已经保证了线程安全的单例语义时，就不需要额外的本地锁（Spring 4.3 起引入该方法的说明见接口注释）。

由于AspectInstanceFactory还继承了Ordered接口，所有MetadataAwareAspectInstanceFactory实现类都会提供getOrder()来参与通知链的排序。

三、五大实现类：行为差异一览

模块 README 归纳了该接口的五个主要实现类，它们代表了切面实例的四种典型生命周期管理策略：

其中PrototypeAspectInstanceFactory在类关系图中继承自BeanFactoryAspectInstanceFactory（见下文类关系图），它把 bean 视为原型作用域，每次getAspectInstance()都会向 BeanFactory 重新获取；SimpleMetadataAwareAspectInstanceFactory与SingletonMetadataAwareAspectInstanceFactory则分别继承自父接口模块中的SimpleAspectInstanceFactory与SingletonAspectInstanceFactory（两者的行为对比可参考 spring-aop-aspectInstanceFactory 模块 中的运行结果）。

类关系图（模块 README 原文）：

classDiagram direction BT class AspectInstanceFactory { <<Interface>> } class BeanFactoryAspectInstanceFactory class LazySingletonAspectInstanceFactoryDecorator class MetadataAwareAspectInstanceFactory { <<Interface>> } class PrototypeAspectInstanceFactory class SimpleAspectInstanceFactory class SimpleMetadataAwareAspectInstanceFactory class SingletonAspectInstanceFactory class SingletonMetadataAwareAspectInstanceFactory BeanFactoryAspectInstanceFactory ..> MetadataAwareAspectInstanceFactory LazySingletonAspectInstanceFactoryDecorator ..> MetadataAwareAspectInstanceFactory MetadataAwareAspectInstanceFactory --> AspectInstanceFactory PrototypeAspectInstanceFactory --> BeanFactoryAspectInstanceFactory SimpleAspectInstanceFactory ..> AspectInstanceFactory SimpleMetadataAwareAspectInstanceFactory ..> MetadataAwareAspectInstanceFactory SimpleMetadataAwareAspectInstanceFactory --> SimpleAspectInstanceFactory SingletonAspectInstanceFactory ..> AspectInstanceFactory SingletonMetadataAwareAspectInstanceFactory ..> MetadataAwareAspectInstanceFactory SingletonMetadataAwareAspectInstanceFactory --> SingletonAspectInstanceFactory

从图中可以清晰看出：MetadataAwareAspectInstanceFactory是AspectInstanceFactory的元数据扩展；而"简单单例"与"元数据单例"之间、"BeanFactory 工厂"与"懒加载装饰器"之间分别构成了继承与组合关系。

四、最佳实践：仓库内可运行的完整示例

模块的实战代码位于 MetadataAwareAspectInstanceFactoryDemo.java，配套的切面类 MyAspect.java 是一个只带有@Aspect注解、未声明任何通知方法的空切面：

package com.xcs.spring; import org.aspectj.lang.annotation.Aspect; @Aspect class MyAspect { }

主程序依次演示了四类工厂的行为：先分别用SimpleMetadataAwareAspectInstanceFactory与SingletonMetadataAwareAspectInstanceFactory创建单例/非单例切面；再用DefaultListableBeanFactory注册名为myAspect的单例 Bean 并交给BeanFactoryAspectInstanceFactory托管；最后用LazySingletonAspectInstanceFactoryDecorator包装前者实现懒加载。每一步都同时输出切面实例与AspectMetadata信息：

public class MetadataAwareAspectInstanceFactoryDemo { public static void main(String[] args) { // 使用 SimpleMetadataAwareAspectInstanceFactory 实例化切面 SimpleMetadataAwareAspectInstanceFactory simpleMetadataAwareAif = new SimpleMetadataAwareAspectInstanceFactory(MyAspect.class, "myAspect"); System.out.println("SimpleMetadataAwareAspectInstanceFactory (1) = " + simpleMetadataAwareAif.getAspectInstance()); System.out.println("SimpleMetadataAwareAspectInstanceFactory (2) = " + simpleMetadataAwareAif.getAspectInstance()); System.out.println("SimpleMetadataAwareAspectInstanceFactory AspectMetadata = " + JSONUtil.toJsonStr(simpleMetadataAwareAif.getAspectMetadata())); System.out.println(); // 使用 SingletonMetadataAwareAspectInstanceFactory 实例化切面 SingletonMetadataAwareAspectInstanceFactory singletonMetadataAwareAif = new SingletonMetadataAwareAspectInstanceFactory(new MyAspect(), "myAspect"); System.out.println("SingletonMetadataAwareAspectInstanceFactory (1) = " + singletonMetadataAwareAif.getAspectInstance()); System.out.println("SingletonMetadataAwareAspectInstanceFactory (2) = " + singletonMetadataAwareAif.getAspectInstance()); System.out.println("SimpleMetadataAwareAspectInstanceFactory AspectMetadata = " + JSONUtil.toJsonStr(singletonMetadataAwareAif.getAspectMetadata())); System.out.println(); // 使用 BeanFactoryAspectInstanceFactory 实例化切面 DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); beanFactory.registerSingleton("myAspect", new MyAspect()); BeanFactoryAspectInstanceFactory banFactoryAif = new BeanFactoryAspectInstanceFactory(beanFactory, "myAspect"); System.out.println("BeanFactoryAspectInstanceFactory (1) = " + banFactoryAif.getAspectInstance()); System.out.println("BeanFactoryAspectInstanceFactory (2) = " + banFactoryAif.getAspectInstance()); System.out.println("SimpleMetadataAwareAspectInstanceFactory AspectMetadata = " + JSONUtil.toJsonStr(banFactoryAif.getAspectMetadata())); System.out.println(); // 使用 LazySingletonAspectInstanceFactoryDecorator 实例化切面 LazySingletonAspectInstanceFactoryDecorator lazySingletonAifD = new LazySingletonAspectInstanceFactoryDecorator(banFactoryAif); System.out.println("LazySingletonAspectInstanceFactoryDecorator (1) = " + lazySingletonAifD.getAspectInstance()); System.out.println("LazySingletonAspectInstanceFactoryDecorator (2) = " + lazySingletonAifD.getAspectInstance()); System.out.println("LazySingletonAspectInstanceFactoryDecorator AspectCreationMutex = " + lazySingletonAifD.getAspectCreationMutex()); System.out.println("LazySingletonAspectInstanceFactoryDecorator AspectMetadata = " + JSONUtil.toJsonStr(lazySingletonAifD.getAspectMetadata())); System.out.println(); } }

运行结果（模块 README 原文）展示了各类工厂的实例化语义差异：

SimpleMetadataAwareAspectInstanceFactory (1) = com.xcs.spring.MyAspect@5f341870 SimpleMetadataAwareAspectInstanceFactory (2) = com.xcs.spring.MyAspect@553f17c SimpleMetadataAwareAspectInstanceFactory AspectMetadata = {"aspectName":"myAspect","aspectClass":"com.xcs.spring.MyAspect","perClausePointcut":{}} SingletonMetadataAwareAspectInstanceFactory (1) = com.xcs.spring.MyAspect@1da51a35 SingletonMetadataAwareAspectInstanceFactory (2) = com.xcs.spring.MyAspect@1da51a35 SimpleMetadataAwareAspectInstanceFactory AspectMetadata = {"aspectName":"myAspect","aspectClass":"com.xcs.spring.MyAspect","perClausePointcut":{}} BeanFactoryAspectInstanceFactory (1) = com.xcs.spring.MyAspect@6646153 BeanFactoryAspectInstanceFactory (2) = com.xcs.spring.MyAspect@6646153 SimpleMetadataAwareAspectInstanceFactory AspectMetadata = {"aspectName":"myAspect","aspectClass":"com.xcs.spring.MyAspect","perClausePointcut":{}} LazySingletonAspectInstanceFactoryDecorator (1) = com.xcs.spring.MyAspect@6646153 LazySingletonAspectInstanceFactoryDecorator (2) = com.xcs.spring.MyAspect@6646153 LazySingletonAspectInstanceFactoryDecorator AspectCreationMutex = null LazySingletonAspectInstanceFactoryDecorator AspectMetadata = {"aspectName":"myAspect","aspectClass":"com.xcs.spring.MyAspect","perClausePointcut":{}}

结果解读：

1. SimpleMetadataAwareAspectInstanceFactory：两次输出的对象引用（@5f341870与@553f17c）不同，说明每次调用getAspectInstance()都会通过反射新建实例——这是"原型"行为。
2. SingletonMetadataAwareAspectInstanceFactory：两次输出完全一致（@1da51a35），因为它内部持有构造时传入的单例对象。
3. BeanFactoryAspectInstanceFactory：两次结果一致（@6646153），因为示例中通过registerSingleton注册的是单例 Bean，实例化语义完全由 BeanFactory 的 bean 作用域决定。
4. LazySingletonAspectInstanceFactoryDecorator：包装的是同一个BeanFactoryAspectInstanceFactory，因此实例引用与之一致；同时AspectCreationMutex返回null——因为底层 BeanFactory 已确认该 bean 为单例，无需本地锁（这正是getAspectCreationMutex()返回值可为null的活例子）。

注意：示例中所有工厂输出的AspectMetadata均为{"aspectName":"myAspect","aspectClass":"com.xcs.spring.MyAspect","perClausePointcut":{}}，因为MyAspect未声明任何perthis/pertarget子句，元数据中的perClausePointcut为空对象。依赖方面，模块 pom.xml 引入了cn.hutool:hutool-json:5.8.27用于将AspectMetadata序列化为 JSON 输出。

五、源码分析：四个关键实现逐个拆解

5.1 SimpleMetadataAwareAspectInstanceFactory——最朴素的"每次新建"工厂

该类继承SimpleAspectInstanceFactory（后者每次调用通过ReflectionUtils.accessibleConstructor(...).newInstance()反射新建实例），构造时传入切面类与切面名称并立即构建AspectMetadata。核心源码如下：

public class SimpleMetadataAwareAspectInstanceFactory extends SimpleAspectInstanceFactory implements MetadataAwareAspectInstanceFactory { private final AspectMetadata metadata; // 切面的元数据信息 public SimpleMetadataAwareAspectInstanceFactory(Class<?> aspectClass, String aspectName) { super(aspectClass); this.metadata = new AspectMetadata(aspectClass, aspectName); // 创建切面的元数据信息 } @Override public final AspectMetadata getAspectMetadata() { return this.metadata; } @Override public Object getAspectCreationMutex() { return this; // 没有外部容器保证线程安全，用工厂自身作为互斥锁 } @Override protected int getOrderForAspectClass(Class<?> aspectClass) { return OrderUtils.getOrder(aspectClass, Ordered.LOWEST_PRECEDENCE); // 未标注 @Order 时默认最低优先级 } }

两个值得注意的实现细节：

• getAspectCreationMutex()返回this：由于该类每次创建新实例、本身不保证单例语义，多线程环境下若需要做"每线程一个实例"之外的保护，Spring 用工厂对象自身充当锁，保证同一工厂上并发实例化的安全性。
• getOrderForAspectClass()委托OrderUtils.getOrder：切面顺序优先读取类上的@Order注解，缺省回退到Ordered.LOWEST_PRECEDENCE（即Integer.MAX_VALUE，最低优先级）。

5.2 SingletonMetadataAwareAspectInstanceFactory——持有外部单例对象

与上一个实现不同，该类构造参数直接传入切面实例对象而非切面类，元数据从aspectInstance.getClass()推导，且实现了Serializable支持序列化。核心源码如下：

@SuppressWarnings("serial") public class SingletonMetadataAwareAspectInstanceFactory extends SingletonAspectInstanceFactory implements MetadataAwareAspectInstanceFactory, Serializable { private final AspectMetadata metadata; // 切面的元数据信息 public SingletonMetadataAwareAspectInstanceFactory(Object aspectInstance, String aspectName) { super(aspectInstance); // 调用父类的构造方法，传入切面的单例实例 this.metadata = new AspectMetadata(aspectInstance.getClass(), aspectName); // 创建切面的元数据信息 } @Override public final AspectMetadata getAspectMetadata() { return this.metadata; } @Override public Object getAspectCreationMutex() { return this; // 单例由外部保证，但 Spring 仍用工厂自身作为本地互斥锁 } @Override protected int getOrderForAspectClass(Class<?> aspectClass) { return OrderUtils.getOrder(aspectClass, Ordered.LOWEST_PRECEDENCE); } }

其父类SingletonAspectInstanceFactory.getOrder()会优先检查实例是否实现Ordered接口：若实现则直接返回((Ordered) aspectInstance).getOrder()，否则才回退到getOrderForAspectClass（详见 spring-aop-aspectInstanceFactory 模块 的源码分析部分）。所以此类对顺序的判定是"实例级 Ordered 优先、类级 @Order 次之、默认最低优先级兜底"。

5.3 BeanFactoryAspectInstanceFactory——与容器深度集成的工厂

这是实际生产中使用最频繁的实现：切面被注册为 Spring Bean，工厂通过 bean 名称从BeanFactory获取实例，天然支持依赖注入、作用域管理与容器级单例锁。关键源码如下：

@SuppressWarnings("serial") public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInstanceFactory, Serializable { private final BeanFactory beanFactory; // Bean 工厂 private final String name; // Bean 名称 private final AspectMetadata aspectMetadata; // 切面的元数据信息 public BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name, @Nullable Class<?> type) { Assert.notNull(beanFactory, "BeanFactory must not be null"); Assert.notNull(name, "Bean name must not be null"); this.beanFactory = beanFactory; this.name = name; Class<?> resolvedType = type; if (type == null) { resolvedType = beanFactory.getType(name); // 通过 BeanFactory 解析类型 Assert.notNull(resolvedType, "Unresolvable bean type - explicitly specify the aspect class"); } this.aspectMetadata = new AspectMetadata(resolvedType, name); // 创建切面的元数据信息 } @Override public Object getAspectInstance() { return this.beanFactory.getBean(this.name); // 实例化语义完全交给容器 } @Override @Nullable public ClassLoader getAspectClassLoader() { return (this.beanFactory instanceof ConfigurableBeanFactory ? ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() : ClassUtils.getDefaultClassLoader()); } @Override public AspectMetadata getAspectMetadata() { return this.aspectMetadata; } @Override @Nullable public Object getAspectCreationMutex() { if (this.beanFactory.isSingleton(this.name)) { // 依赖于工厂提供的单例语义 -> 没有本地锁。 return null; } else if (this.beanFactory instanceof ConfigurableBeanFactory) { // 从工厂中没有单例保证 -> 让我们本地锁定，但重用工厂的单例锁 return ((ConfigurableBeanFactory) this.beanFactory).getSingletonMutex(); } else { return this; } } @Override public int getOrder() { Class<?> type = this.beanFactory.getType(this.name); if (type != null) { if (Ordered.class.isAssignableFrom(type) && this.beanFactory.isSingleton(this.name)) { return ((Ordered) this.beanFactory.getBean(this.name)).getOrder(); } return OrderUtils.getOrder(type, Ordered.LOWEST_PRECEDENCE); } return Ordered.LOWEST_PRECEDENCE; } }

该实现有三个设计亮点：

1. 元数据类型的三级解析：构造函数支持显式传入type（适用于 BeanFactory 返回 CGLIB 子类、希望按超类解析元数据的场景）；不传则通过beanFactory.getType(name)解析；若类型不可解析则直接抛出Assert异常，提示调用方显式指定切面类。
2. 互斥锁的精细化选择：getAspectCreationMutex()做了三分支判断——bean 为单例时返回null（信任容器单例语义，无需本地锁）；非单例但 BeanFactory 可配置时返回ConfigurableBeanFactory.getSingletonMutex()（复用容器全局单例锁，避免通知 bean 的惰性依赖隐式触发单例锁造成死锁）；否则退回工厂自身。
3. 顺序判断兼顾实例与类：bean 类型实现Ordered且为单例时取实例顺序，否则取类级@Order，最后兜底LOWEST_PRECEDENCE。

注意：模块源码注释特别提醒，若切面 bean 是原型作用域，BeanFactoryAspectInstanceFactory可能多次实例化，导致与预期不符的语义；官方建议用LazySingletonAspectInstanceFactoryDecorator包装，确保只返回一个切面。

5.4 LazySingletonAspectInstanceFactoryDecorator——保证"只实例化一次"的装饰器

该类本身不负责创建实例，而是包装任意MetadataAwareAspectInstanceFactory，通过"首次调用时实例化、后续复用"的方式把非单例工厂"装饰"成单例，且利用互斥锁 + 双重检查（double-checked locking）保证多线程下只实例化一次。核心源码如下：

@SuppressWarnings("serial") public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwareAspectInstanceFactory, Serializable { private final MetadataAwareAspectInstanceFactory maaif; // 要装饰的 MetadataAwareAspectInstanceFactory 实例 @Nullable private volatile Object materialized; // 实例化的对象 public LazySingletonAspectInstanceFactoryDecorator(MetadataAwareAspectInstanceFactory maaif) { Assert.notNull(maaif, "AspectInstanceFactory must not be null"); this.maaif = maaif; } @Override public Object getAspectInstance() { Object aspectInstance = this.materialized; if (aspectInstance == null) { Object mutex = this.maaif.getAspectCreationMutex(); if (mutex == null) { // 无互斥锁：直接实例化并赋值（底层已保证线程安全） aspectInstance = this.maaif.getAspectInstance(); this.materialized = aspectInstance; } else { synchronized (mutex) { aspectInstance = this.materialized; if (aspectInstance == null) { // 双重检查：在锁内部只实例化一次 aspectInstance = this.maaif.getAspectInstance(); this.materialized = aspectInstance; } } } } return aspectInstance; } public boolean isMaterialized() { return (this.materialized != null); } @Override @Nullable public ClassLoader getAspectClassLoader() { return this.maaif.getAspectClassLoader(); } @Override public AspectMetadata getAspectMetadata() { return this.maaif.getAspectMetadata(); } @Override @Nullable public Object getAspectCreationMutex() { return this.maaif.getAspectCreationMutex(); } @Override public int getOrder() { return this.maaif.getOrder(); } }

实现要点：

• materialized字段使用volatile修饰，配合无锁路径下的直接赋值与加锁路径下的双重检查，兼顾性能与线程安全。
• 互斥锁来源完全透明：取被装饰工厂的getAspectCreationMutex()。若底层工厂返回null（如被装饰者是单例 bean 的BeanFactoryAspectInstanceFactory），则跳过加锁直接实例化——与前面示例中AspectCreationMutex = null的输出完全对应。
• 其余方法（getAspectMetadata、getOrder、getAspectClassLoader）均为透传委托，装饰器只改变"实例化时机与次数"语义。

六、在 Spring AOP 中的真实调用位置：Advisor 构建链路

理解了接口之后，一个自然的问题是：MetadataAwareAspectInstanceFactory到底在框架哪里被使用？答案是AspectJ 注解切面 → Advisor 的转换环节。在ReflectiveAspectJAdvisorFactory.getAdvisors(MetadataAwareAspectInstanceFactory)中（详见 spring-aop-aspectJAdvisorFactory 模块 的源码分析）：

1. 从aspectInstanceFactory.getAspectMetadata()取出切面类与切面名称，并validate(aspectClass)校验切面合法性；
2. 将传入的工厂包装成LazySingletonAspectInstanceFactoryDecorator——这是为了让只实例化一次的语义贯穿 Advisor 构建全过程（切面工厂会先于 Advice 实例化，且同一切面会为每个通知方法各建一个 Advisor，若不装饰则可能产生多个切面实例）；
3. 遍历切面类中的通知方法，调用getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName)为每个通知方法构建InstantiationModelAwarePointcutAdvisorImpl；
4. 若切面是perthis/pertarget的懒实例化类型，还会在最前面追加SyntheticInstantiationAdvisor触发实例化。

而在InstantiationModelAwarePointcutAdvisorImpl的构造过程中，同样会调用aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()判断是否为懒实例化切面，进而决定使用"声明切点 + perClause 切点联合"的动态切点模型，还是直接使用声明切点并立即实例化 Advice。由此可见，MetadataAwareAspectInstanceFactory的元数据能力（尤其是AspectMetadata中的perClausePointcut与isLazilyInstantiated）直接决定了 Advisor 的切点模型与实例化时机，是整个注解式 AOP 装配链路的地基。

在更上层的BeanFactoryAspectJAdvisorsBuilder（见 spring-aop-beanFactoryAspectJAdvisorsBuilder 模块）中，Spring 扫描到@Aspectbean 后，正是以BeanFactoryAspectInstanceFactory（或按需包装的懒加载装饰器）作为参数调用aspectJAdvisorFactory.getAdvisors(...)，从而把容器中的切面 Bean 转化为可参与代理的 Advisor 集合。

七、小结与延伸阅读

MetadataAwareAspectInstanceFactory用两个方法（getAspectMetadata+getAspectCreationMutex）为 Spring 的注解式 AOP 提供了一条清晰的分工线：

• 元数据驱动 Advisor 的构建与切点模型选择；
• 互斥锁保证切面实例化在复杂容器语义下依然线程安全且只实例化一次；
• 五种实现则覆盖了从纯反射原型、外部单例、容器托管到懒加载装饰的全部生命周期策略。

想要继续深入这一主题，推荐按以下顺序阅读仓库中的关联模块：

• spring-aop/spring-aop-aspectInstanceFactory/README.md——父接口AspectInstanceFactory的定义与三个基础实现；
• spring-aop/spring-aop-aspectJAdvisorFactory/README.md——ReflectiveAspectJAdvisorFactory如何消费本接口的元数据生成 Advisor 与 Advice；
• spring-aop/spring-aop-beanFactoryAspectJAdvisorsBuilder/README.md——Spring 容器中@Aspectbean 到 Advisor 的完整扫描与转换流程。

同时，本文涉及的运行示例与源码均可直接在spring-aop/spring-aop-metadataAwareAspectInstanceFactory模块下查看（示例入口、切面定义），该模块是spring-aop聚合工程（见 spring-aop/pom.xml 中的 module 列表）的 21 个 AOP 子模块之一，通过 Maven 构建后即可运行 Demo 观察各工厂的实际行为。

• 示例工程
• 文档