扩展了 {@link org.springframework.core.Ordered} 接口，用于表达链中底层切面的顺序值。 * * @author Rod Johnson * @author Juergen Hoeller * @since 2.0 * @see org.springframework.beans.factory.BeanFactory#getBean */ public interface AspectInstanceFactory extends Ordered { /** * 创建此工厂的切面实例。 * @return 切面实例（永远不会为 {@code null}） */ Object getAspectInstance(); /** * 公开此工厂使用的切面类加载器。 * @return 切面类加载器（对于引导加载器，为 {@code null}） * @see org.springframework.util.ClassUtils#getDefaultClassLoader() */ @Nullable ClassLoader getAspectClassLoader(); } ``` ### 五、主要实现 1. **SimpleAspectInstanceFactory** + 一个简单的切面实例工厂，用于创建基于注解的切面实例。 2. **SingletonAspectInstanceFactory** + 一个单例的切面实例工厂，用于创建单例的切面实例。 3. **SimpleBeanFactoryAwareAspectInstanceFactory** + 一个简单的 Bean 工厂感知切面实例工厂，用于在创建切面实例时考虑 Bean 工厂的上下文信息。 ### 六、最佳实践 使用不同类型的 `AspectInstanceFactory` 实现类来创建和管理切面实例。首先，通过 `SimpleAspectInstanceFactory` 和 `SingletonAspectInstanceFactory` 分别创建简单实例和单例实例的切面。然后，通过注册一个名为 "myAspect" 的单例 bean，并将其用于配置 `SimpleBeanFactoryAwareAspectInstanceFactory`，从而创建一个依赖于 Bean 工厂的切面实例。最后，展示了获取 `SimpleBeanFactoryAwareAspectInstanceFactory` 实例的切面对象，并输出其结果。 ```java public class AspectInstanceFactoryDemo { public static void main(String[] args) { // 使用 SimpleAspectInstanceFactory 创建切面实例 SimpleAspectInstanceFactory sAif = new SimpleAspectInstanceFactory(MyAspect.class); System.out.println("SimpleAspectInstanceFactory (1): " + sAif.getAspectInstance()); System.out.println("SimpleAspectInstanceFactory (2): " + sAif.getAspectInstance()); // 使用 SingletonAspectInstanceFactory 创建单例切面实例 SingletonAspectInstanceFactory singletonAif = new SingletonAspectInstanceFactory(new MyAspect()); System.out.println("SingletonAspectInstanceFactory (1): " + singletonAif.getAspectInstance()); System.out.println("SingletonAspectInstanceFactory (2): " + singletonAif.getAspectInstance()); // 创建一个 DefaultListableBeanFactory 实例，用于注册和管理 bean DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); // 注册一个名为 "myAspect" 的单例 bean，类型为 MyAspect beanFactory.registerSingleton("myAspect", new MyAspect()); // 创建一个切面工厂的 BeanDefinition RootBeanDefinition aspectFactoryDef = new RootBeanDefinition(SimpleBeanFactoryAwareAspectInstanceFactory.class); // 设置切面工厂的属性 aspectBeanName 为 "myAspect" aspectFactoryDef.getPropertyValues().add("aspectBeanName", "myAspect"); // 设置切面工厂为合成的，即不对外暴露 aspectFactoryDef.setSynthetic(true); // 注册名为 "simpleBeanFactoryAwareAspectInstanceFactory" 的 bean，并使用切面工厂的 BeanDefinition beanFactory.registerBeanDefinition("simpleBeanFactoryAwareAspectInstanceFactory", aspectFactoryDef); // 从 BeanFactory 中获取 SimpleBeanFactoryAwareAspectInstanceFactory 的实例 SimpleBeanFactoryAwareAspectInstanceFactory simpleBeanFactoryAwareAif = beanFactory.getBean(SimpleBeanFactoryAwareAspectInstanceFactory.class); System.out.println("SimpleBeanFactoryAwareAspectInstanceFactory (1): " + simpleBeanFactoryAwareAif.getAspectInstance()); System.out.println("SimpleBeanFactoryAwareAspectInstanceFactory (2): " + simpleBeanFactoryAwareAif.getAspectInstance()); } } ``` 运行结果，通过不同的切面实例工厂创建切面对象的情况：`SimpleAspectInstanceFactory` 每次调用 `getAspectInstance()` 都会创建一个新的切面对象，因此得到的实例不同；而 `SingletonAspectInstanceFactory` 返回的是单例对象，所以多次调用 `getAspectInstance()` 得到的是同一个实例；`SimpleBeanFactoryAwareAspectInstanceFactory` 从 `BeanFactory` 中获取指定名称的 bean，该 bean 默认是单例的，因此也得到相同的实例。 ```java SimpleAspectInstanceFactory (1): com.xcs.spring.MyAspect@6d8a00e3 SimpleAspectInstanceFactory (2): com.xcs.spring.MyAspect@548b7f67 SingletonAspectInstanceFactory (1): com.xcs.spring.MyAspect@5f375618 SingletonAspectInstanceFactory (2): com.xcs.spring.MyAspect@5f375618 SimpleBeanFactoryAwareAspectInstanceFactory (1): com.xcs.spring.MyAspect@41ee392b SimpleBeanFactoryAwareAspectInstanceFactory (2): com.xcs.spring.MyAspect@41ee392b ``` ### 七、源码分析 #### SimpleAspectInstanceFactory `SimpleAspectInstanceFactory`类是 `AspectInstanceFactory` 接口的实现。每次调用 `getAspectInstance()` 方法创建指定切面类的新实例。它通过反射机制在运行时实例化切面类，并提供了方法来获取切面类、获取切面类的类加载器以及确定切面实例的顺序。 ```java /** * {@link AspectInstanceFactory} 接口的实现类，用于在每次调用 {@link #getAspectInstance()} 方法时为指定的切面类创建一个新实例。 * 创建新实例的切面工厂。 * * @author Juergen Hoeller * @since 2.0.4 */ public class SimpleAspectInstanceFactory implements AspectInstanceFactory { // 切面类 private final Class aspectClass; /** * 为给定的切面类创建一个新的 SimpleAspectInstanceFactory。 * @param aspectClass 切面类 */ public SimpleAspectInstanceFactory(Class aspectClass) { Assert.notNull(aspectClass, "Aspect class must not be null"); this.aspectClass = aspectClass; } /** * 返回指定的切面类（永远不为 {@code null}）。 */ public final Class getAspectClass() { return this.aspectClass; } @Override public final Object getAspectInstance() { try { // 使用反射获取切面类的可访问构造函数，并创建新实例 return ReflectionUtils.accessibleConstructor(this.aspectClass).newInstance(); } catch (NoSuchMethodException ex) { throw new AopConfigException("No default constructor on aspect class: " + this.aspectClass.getName(), ex); } catch (InstantiationException ex) { throw new AopConfigException("Unable to instantiate aspect class: " + this.aspectClass.getName(), ex); } catch (IllegalAccessException ex) { throw new AopConfigException("Could not access aspect constructor: " + this.aspectClass.getName(), ex); } catch (InvocationTargetException ex) { throw new AopConfigException("Failed to invoke aspect constructor: " + this.aspectClass.getName(), ex.getTargetException()); } } @Override @Nullable public ClassLoader getAspectClassLoader() { // 返回切面类的类加载器 return this.aspectClass.getClassLoader(); } /** * 确定此工厂的切面实例的顺序， * 可通过实现 {@link org.springframework.core.Ordered} 接口表达实例特定的顺序， * 或者使用一个默认顺序。 * @see org.springframework.core.Ordered * @see #getOrderForAspectClass */ @Override public int getOrder() { return getOrderForAspectClass(this.aspectClass); } /** * 确定在切面实例没有通过实现 {@link org.springframework.core.Ordered} 接口表达实例特定顺序时的后备顺序。 *
默认实现简单地返回 {@code Ordered.LOWEST_PRECEDENCE}。 * @param aspectClass 切面类 */ protected int getOrderForAspectClass(Class aspectClass) { return Ordered.LOWEST_PRECEDENCE; } } ``` #### SingletonAspectInstanceFactory `SingletonAspectInstanceFactory` 类是 `AspectInstanceFactory` 接口的实现。该类通过指定的单例对象作为后端支持，每次调用 `getAspectInstance()` 方法时都返回相同的实例。此外，它还提供了方法来获取切面实例的类加载器以及确定切面实例的顺序，支持实现了 `Ordered` 接口的切面实例。 ```java /** * {@link AspectInstanceFactory} 接口的实现类，由指定的单例对象支持， * 每次调用 {@link #getAspectInstance()} 方法时返回相同的实例。 * 单例切面实例工厂。 * * 由指定的单例对象支持，每次调用 getAspectInstance() 方法时返回相同的实例。 * * @author Rod Johnson * @author Juergen Hoeller * @since 2.0 * @see SimpleAspectInstanceFactory */ @SuppressWarnings("serial") public class SingletonAspectInstanceFactory implements AspectInstanceFactory, Serializable { // 单例切面实例 private final Object aspectInstance; /** * 为给定的切面实例创建一个新的 SingletonAspectInstanceFactory。 * @param aspectInstance 单例切面实例 */ public SingletonAspectInstanceFactory(Object aspectInstance) { Assert.notNull(aspectInstance, "Aspect instance must not be null"); this.aspectInstance = aspectInstance; } @Override public final Object getAspectInstance() { // 返回单例切面实例 return this.aspectInstance; } @Override @Nullable public ClassLoader getAspectClassLoader() { // 返回切面实例的类加载器 return this.aspectInstance.getClass().getClassLoader(); } /** * 确定此工厂的切面实例的顺序， * 可通过实现 {@link org.springframework.core.Ordered} 接口表达实例特定的顺序， * 或者使用一个默认顺序。 * @see org.springframework.core.Ordered * @see #getOrderForAspectClass */ @Override public int getOrder() { if (this.aspectInstance instanceof Ordered) { // 如果切面实例实现了 Ordered 接口，则返回其顺序 return ((Ordered) this.aspectInstance).getOrder(); } // 否则返回切面实例类的默认顺序 return getOrderForAspectClass(this.aspectInstance.getClass()); } /** * 确定在切面实例没有通过实现 {@link org.springframework.core.Ordered} 接口表达实例特定顺序时的后备顺序。 *
默认实现简单地返回 {@code Ordered.LOWEST_PRECEDENCE}。 * @param aspectClass 切面类 */ protected int getOrderForAspectClass(Class aspectClass) { return Ordered.LOWEST_PRECEDENCE; } } ``` #### SimpleBeanFactoryAwareAspectInstanceFactory `SimpleBeanFactoryAwareAspectInstanceFactory` 类是 `AspectInstanceFactory` 接口的实现。该类通过配置的 bean 名称从 `BeanFactory` 中定位切面实例。每次调用 `getAspectInstance()` 方法时，都会查找并返回指定名称的 bean。此外，它还提供了方法来获取切面实例的类加载器以及确定切面实例的顺序，支持实现了 `Ordered` 接口的切面实例。 ```java /** * {@link AspectInstanceFactory} 接口的实现类，通过配置的 bean 名称从 {@link org.springframework.beans.factory.BeanFactory} 中定位切面。 * SimpleBeanFactoryAwareAspectInstanceFactory 类。 * * 通过配置的 bean 名称从 BeanFactory 中定位切面。 * * @author Rob Harrop * @author Juergen Hoeller * @since 2.0 */ public class SimpleBeanFactoryAwareAspectInstanceFactory implements AspectInstanceFactory, BeanFactoryAware { // 切面 bean 名称 @Nullable private String aspectBeanName; // BeanFactory @Nullable private BeanFactory beanFactory; /** * 设置切面 bean 的名称。调用 {@link #getAspectInstance()} 时返回该 bean。 * @param aspectBeanName 切面 bean 名称 */ public void setAspectBeanName(String aspectBeanName) { this.aspectBeanName = aspectBeanName; } @Override public void setBeanFactory(BeanFactory beanFactory) { this.beanFactory = beanFactory; Assert.notNull(this.aspectBeanName, "'aspectBeanName' is required"); } /** * 从 BeanFactory 中查找切面 bean 并返回。 * @see #setAspectBeanName */ @Override public Object getAspectInstance() { Assert.state(this.beanFactory != null, "No BeanFactory set"); Assert.state(this.aspectBeanName != null, "No 'aspectBeanName' set"); return this.beanFactory.getBean(this.aspectBeanName); } @Override @Nullable public ClassLoader getAspectClassLoader() { if (this.beanFactory instanceof ConfigurableBeanFactory) { return ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader(); } else { return ClassUtils.getDefaultClassLoader(); } } @Override public int getOrder() { if (this.beanFactory != null && this.aspectBeanName != null && this.beanFactory.isSingleton(this.aspectBeanName) && this.beanFactory.isTypeMatch(this.aspectBeanName, Ordered.class)) { return ((Ordered) this.beanFactory.getBean(this.aspectBeanName)).getOrder(); } return Ordered.LOWEST_PRECEDENCE; } } ``` ### 八、常见问题 1. **切面实例化方式** + 如何创建切面实例？不同的实现类可能采用不同的实例化方式，比如单例、原型等。 2. **切面对象生命周期** + 切面实例是单例还是多例？在 Spring AOP 中，切面对象通常是单例的，但也可以是原型的，这可能会影响到切面对象的状态管理和线程安全性。 3. **切面对象获取方式** + 切面对象是如何被获取的？有些实现类可能通过配置文件指定 bean 名称，然后从 `BeanFactory` 中获取，而另一些可能直接实例化切面对象。 4. **切面对象依赖注入** + 切面对象是否可以依赖注入其他 Spring 管理的 bean？如果是，如何实现依赖注入？ 5. **切面对象的顺序** + 如果多个切面对象同时存在，它们的执行顺序是如何确定的？是否可以通过实现 `Ordered` 接口或其他方式指定切面对象的执行顺序？