10. Spring AOP源码解析

10 Spring AOP源码解析

目录

10 Spring AOP源码解析

Pt1 Spring AOP基础知识

Pt1.1 AOP核心概念

Pt1.2 AOP切点配置规则

(1) execution

(2) within

(3) args

Pt2 Spring AOP使用示例

Pt2.1 AOP日志（XML）

pom.xml

spring.xml配置AOP信息

加载spring.xml

定义切面

定义Controller

运行Controller

Pt2.2 JDBC（Annotation）

pom.xml

AOP配置

Controller

测试请求

Pt3 Spring AOP核心类

Pt3.1 BeanPostProcessor

Pt3.2 TargetSource

Pt3.3 Advice

Pt3.4 Advisor

Pt3.5 Advised

(1) TargetClassAware

(2) Advised

(3) ProxyConfig

(4) AdvisedSupport

(5) ProxyCreatorSupport

(6) ProxyFactory

Pt3.6 Pointcut

Pt3.7 ClassFilter

Pt3.8 MethodMatcher

Pt3.9 Aware

Pt4 Spring AOP初始化剖析

Pt4.1 寻找入口

Pt4.2 选择代理策略

Pt4.3 生成AOP代理类

Pt4.4 执行代理方法

Pt4.5 触发AOP通知

Pt4.6 流程图

参考资料

---

Pt1 Spring AOP基础知识

AOP是Aspect Oriented Programming的缩写，意思是面向切面编程，通过预编译和运行时的动态代理，实现在不修改源代码的情况下给程序动态添加功能。同时AOP也为服务方和调用方实现解耦提供了很有效的方式。

在日常编码中，通常分为业务代码和非业务代码，比如事务、日志等，这些代码和业务代码混在一起。举个最常见的例子，就是JDBC的事务处理，有大量的模板代码是的事务处理代码，这些大量重复的、复制粘贴的、和业务处理无关的代码，为维护带来了风险和困难。AOP通过代理机制，可以将这些非业务代码剥离，使得他们可以独立于业务代码存在，从而降低维护的难度和风险。

所以，Spring AOP是一种编程范式，主要目的是将非功能性需求从功能型需求中分离出来，达到解耦的目标。

 

---

Pt1.1 AOP核心概念

• Aspect（切面）

  Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

   

• Jointpoint（连接点）

  表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。

   

• Pointcut（切点）

  表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。

   

• Advice（增强）

  Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

  • @Before：该注解标注的方法在业务模块代码执行之前执行，其不能阻止业务模块的执行，除非抛出异常；

  • @AfterReturning：该注解标注的方法在业务模块代码执行之后执（正常返回）行；

  • @AfterThrowing：该注解标注的方法在业务模块抛出指定异常后执行；

  • @After：该注解标注的方法在所有的Advice执行完成后执行，无论业务模块是否抛出异常，类似于finally的作用；

  • @Around：该注解功能最为强大，其所标注的方法用于编写包裹业务模块执行的代码，其可以传入一个ProceedingJoinPoint用于调用业务模块的代码，无论是调用前逻辑还是调用后逻辑，都可以在该方法中编写，甚至其可以根据一定的条件而阻断业务模块的调用；

  • @DeclareParents：其是一种Introduction类型的模型，在属性声明上使用，主要用于为指定的业务模块添加新的接口和相应的实现。

  • @Aspect：严格来说，其不属于一种Advice，该注解主要用在类声明上，指明当前类是一个组织了切面逻辑的类，并且该注解中可以指定当前类是何种实例化方式，主要有三种：singleton、perthis和pertarget，具体的使用方式后面会进行讲解。

   

• Target（目标对象）

  织入 Advice 的目标对象.。目标对象可以被一个或者多个切面织入。

   

• Weaving（织入）

  将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程，就是执行method同时执行advice。

   

• AOP代理（AopProxy）

  在Spring中有两种形式的代理：JDK动态代理和CGLib代理。后面会详细介绍。

 

---

Pt1.2 AOP切点配置规则

(1) execution

由于Spring切面粒度最小是达到方法级别，而execution表达式可以用于明确指定方法返回类型，类名，方法名和参数名等与方法相关的部件，并且在Spring中，大部分需要使用AOP的业务场景也只需要达到方法级别即可，因而execution表达式的使用是最为广泛的。

 

如下是execution表达式的语法：

 execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

这里问号表示当前项可以有也可以没有，其中各项的语义如下：

• modifiers-pattern：方法的可见性，如public，protected；

• ret-type-pattern：方法的返回值类型，如int，void等；

• declaring-type-pattern：方法所在类的全路径名，如com.spring.Aspect；

• name-pattern：方法名类型，如buisinessService()；

• param-pattern：方法的参数类型，如java.lang.String；

• throws-pattern：方法抛出的异常类型，如java.lang.Exception；

 

如下是一个使用execution表达式的例子：

 execution(public * com.spring.service.BusinessObject.businessService(java.lang.String,..))

上述切点表达式将会匹配使用public修饰，返回值为任意类型，并且是com.spring.BusinessObject类中名称为businessService的方法，方法可以有多个参数，但是第一个参数必须是java.lang.String类型的方法。上述示例中我们使用了..通配符，关于通配符的类型，主要有两种：

 

• *通配符，该通配符主要用于匹配单个单词，或者是以某个词为前缀或后缀的单词。

如下示例表示返回值为任意类型，在com.spring.service.BusinessObject类中，并且参数个数为零的方法：

 execution(* com.spring.service.BusinessObject.*())

下述示例表示返回值为任意类型，在com.spring.service包中，以Business为前缀的类，并且是类中参数个数为零方法：

 execution(* com.spring.service.Business*.*())

 

• ..通配符，该通配符表示0个或多个项，主要用于declaring-type-pattern和param-pattern中，如果用于declaring-type-pattern中，则表示匹配当前包及其子包，如果用于param-pattern中，则表示匹配0个或多个参数。

如下示例表示匹配返回值为任意类型，并且是com.spring.service包及其子包下的任意类的名称为businessService的方法，而且该方法不能有任何参数：

 execution(* com.spring.service..*.businessService())

这里需要说明的是，包路径service...businessService()中的..应该理解为延续前面的service路径，表示到service路径为止，或者继续延续service路径，从而包括其子包路径；后面的.businessService()，这里的*表示匹配一个单词，因为是在方法名前，因而表示匹配任意的类。

如下示例是使用..表示任意个数的参数的示例，需要注意，表示参数的时候可以在括号中事先指定某些类型的参数，而其余的参数则由..进行匹配：

 execution(* com.spring.service.BusinessObject.businessService(java.lang.String,..))

 

(2) within

within表达式的粒度为类，其参数为全路径的类名（可使用通配符），表示匹配当前表达式的所有类都将被当前方法环绕。如下是within表达式的语法：

 within(declaring-type-pattern)

 

within表达式只能指定到类级别，如下示例表示匹配com.spring.service.BusinessObject中的所有方法：

 within(com.spring.service.BusinessObject)

 

within表达式路径和类名都可以使用通配符进行匹配，比如如下表达式将匹配com.spring.service包下的所有类，不包括子包中的类：

within(com.spring.service.*)

 

如下表达式表示匹配com.spring.service包及子包下的所有类：

within(com.spring.service..*)

 

(3) args

args表达式的作用是匹配指定参数类型和指定参数数量的方法，无论其类路径或者是方法名是什么。这里需要注意的是，args指定的参数必须是全路径的。如下是args表达式的语法：

args(param-pattern)

 

如下示例表示匹配所有只有一个参数，并且参数类型是java.lang.String类型的方法：

args(java.lang.String)

 

也可以使用通配符，但这里通配符只能使用..，而不能使用*。如下是使用通配符的实例，该切点表达式将匹配第一个参数为java.lang.String，最后一个参数为java.lang.Integer，并且中间可以有任意个数和类型参数的方法：

args(java.lang.String,..,java.lang.Integer)

 

---

Pt2 Spring AOP使用示例

Pt2.1 AOP日志（XML）

• pom.xml

    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.4.4
         
    
    com.example
    spring-demo
    0.0.1-SNAPSHOT
    spring-demo
    Demo project for Spring Boot
    
        11
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.projectlombok
            lombok
            true
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        

        
        
            org.aspectj
            aspectjweaver
            1.9.6
        

    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        
                            org.projectlombok
                            lombok
                        
                    
                
            
        
    

 

• spring.xml配置AOP信息

 

• 加载spring.xml

@Configuration
@ImportResource(locations = {"classpath:spring.xml"})
public class ConfigClass {
}

 

• 定义切面

public class LogAspect {

    public LogAspect() {
        System.out.println("init");
    }

    public void logBefore() {
        System.out.println("Before execution log.");
    }

    public void logAfter() {
        System.out.println("After execution log.");
    }
}

 

• 定义Controller

@RestController
public class LogController {

    @RequestMapping(value = "logAop", method = RequestMethod.GET)
    public String LogDemo() {
        return "Execute Log Aop test.";
    }
}

 

• 运行Controller

Before execution log.
After execution log.

 

---

Pt2.2 JDBC（Annotation）

• pom.xml

    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.4.4
         
    
    com.example
    spring-demo
    0.0.1-SNAPSHOT
    spring-demo
    Demo project for Spring Boot
    
        11
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.projectlombok
            lombok
            true
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        

        
        
            org.aspectj
            aspectjweaver
            1.9.6
        

    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        
                            org.projectlombok
                            lombok
                        
                    
                
            
        
    

 

• AOP配置

@Component
@Aspect
public class JdbcAspect {

    // 定义切点
    @Pointcut("execution(* com.example.springdemo.controller.JdbcController.jdbcDemo(..))")
    public void jdbcPointcut() {
    }

    @Before("JdbcAspect.jdbcPointcut()")
    public void jdbcBefore() {
        System.out.println("begin transaction");
    }

    @AfterReturning("JdbcAspect.jdbcPointcut()")
    public void jdbcAfter() {
        System.out.println("commit transaction");
    }

    @AfterThrowing("JdbcAspect.jdbcPointcut()")
    public void jdbcException() {
        System.out.println("rollback transaction");
    }
}

 

• Controller

@RestController
public class JdbcController {

    @RequestMapping(value = "jdbcAop", method = RequestMethod.GET)
    public String jdbcDemo() {
        return "Execute jdbc Aop test.";
    }
}

 

• 测试请求

​​​​​​​

begin transaction 
commit transaction

 

 

---

Pt3 Spring AOP核心类

Pt3.1 BeanPostProcessor

BeanPostProcessor是Spring IOC容器给我们提供的一个扩展接口，它可以监听容器触发的Bean生命周期事件。向容器中注册BeanPostProcessor之后，容器中管理的Bean就具备了接受IoC容器回调事件的能力。

源码如下：

/**
 * BeanPostProcessor是Spring IOC容器给我们提供的一个扩展接口，它可以监听容器触发的Bean生命周期事件。
 * 向容器中注册BeanPostProcessor之后，容器中管理的Bean就具备了接受IoC容器回调事件的能力。
 *
 * 他提供的两个回调方法和容器管理的Bean生命周期事件密切相关，可以为用户提供在Spring IoC容器初始化Bean过程中，去自定义的处理操作提供钩子事件。
 */
public interface BeanPostProcessor {

	// 在Bean的初始化之前提供回调入口
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	// 在Bean的初始化之后提供回调入口
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}

 

---

Pt3.2 TargetSource

在Spring代理目标bean的时候，其并不是直接创建一个目标bean的对象实例的，而是通过一个TargetSource类型的对象将目标bean进行封装，Spring Aop获取目标对象始终是通过TargetSource.getTarget()方法进行的。

换句话说，proxy(代理对象)代理的不是target，而是TargetSource。

 

通常情况下，一个proxy(代理对象)只能代理一个target，每次方法调用的目标也是唯一固定的target。但是,如果让proxy代理TargetSource，可以使得每次方法调用的target实例都不同(当然也可以相同，这取决于TargetSource实现)。这种机制使得方法调用变得灵活，可以扩展出很多高级功能，如: target pool(目标对象池)、hot swap(运行时目标对象热替换)，等等。

 

源码实现：

/**
 * 在Spring代理目标bean的时候，其并不是直接创建一个目标bean的对象实例的，而是通过一个TargetSource类型的对象将目标bean进行封装，
 * Spring Aop获取目标对象始终是通过TargetSource.getTarget()方法进行的。
 * 换句话说,proxy(代理对象)代理的不是target,而是TargetSource。
 *
 * 通常情况下,一个proxy(代理对象)只能代理一个target,每次方法调用的目标也是唯一固定的target。但是,如果让proxy代理TargetSource,
 * 可以使得每次方法调用的target实例都不同(当然也可以相同,这取决于TargetSource实现)。
 * 这种机制使得方法调用变得灵活,可以扩展出很多高级功能,如:target pool(目标对象池)、hot swap(运行时目标对象热替换),等等。
 */
public interface TargetSource extends TargetClassAware {

	// 本方法主要用于返回目标bean的Class类型
	@Override
	@Nullable
	Class getTargetClass();

	// 这个方法用户返回当前bean是否为静态的，比如常见的单例bean就是静态的，而prototype就是动态的，
	// 这里这个方法的主要作用是，对于静态的bean，spring是会对其进行缓存的，在多次使用TargetSource
	// 获取目标bean对象的时候，其获取的总是同一个对象，通过这种方式提高效率
	boolean isStatic();

	// 获取目标bean对象，这里可以根据业务需要进行自行定制
	@Nullable
	Object getTarget() throws Exception;

	// Spring在用完目标bean之后会调用这个方法释放目标bean对象，对于一些需要池化的对象，这个方法是必须
	// 要实现的，这个方法默认不进行任何处理
	void releaseTarget(Object target) throws Exception;
}

 

---

Pt3.3 Advice

Advice表示的是在Pointcut切点上应该执行的方法，即切面Aspect中定义的方法逻辑。

这些方法可以在目标方法之前、之后、包裹、抛出异常等等任何地方执行。

 

源码：

// 标记通知方法
public interface Advice {

}

 

---

Pt3.4 Advisor

Advisor是 Pointcut 与 Advice 的组合，Advice 是执行的通知方法，而要知道方法何时执行，则 Advice 必需与 Pointcut 组合在一起，这就诞生了 Advisor 。

• Advice表示通知的内容

• Pointcut表示通知的时机

• Advisor表示通知人（它知道通知的时机，且知道是通知的内容）

 

下图是Advisor的类图：

 

Advisor是顶层抽象接口，定义了操作Advice的行为：

// Pointcut 与 Advice 的组合
public interface Advisor {

	// 空的Advice通知
	Advice EMPTY_ADVICE = new Advice() {};

	// 获取通知方法
	Advice getAdvice();

	// 判定当前Advice是否和特定目标值相关
	boolean isPerInstance();
}

 

PointcutAdvisor继承Advisor，定义了操作Pointcut行为，此时具体了可以操作Pointcut和Advice的行为：

public interface PointcutAdvisor extends Advisor {

	// 获取Advisor关联的Pointcut
	Pointcut getPointcut();
}

 

AbstractPointcutAdvisor新增了排序和序列化的能力：

// AbstractPointcutAdvisor是在PointcutAdvisor的基础上，增加Ordered和Serializable接口的能力。
// Spring就提供了Ordered这个接口，来处理相同接口实现类的优先级问题。
@SuppressWarnings("serial")
public abstract class AbstractPointcutAdvisor implements PointcutAdvisor, Ordered, Serializable {
	// order用于标记执行的优先级。
	@Nullable
	private Integer order;

	// 调用者可以手动来指定Order
	public void setOrder(int order) {
		this.order = order;
	}

	// 获取执行顺序
	@Override
	public int getOrder() {
		if (this.order != null) {
			return this.order;
		}

		// 若调用者没有指定Order，那就拿advice的order为准（若有），否则LOWEST_PRECEDENCE表示最后执行
		Advice advice = getAdvice();
		if (advice instanceof Ordered) {
			return ((Ordered) advice).getOrder();
		}
		return Ordered.LOWEST_PRECEDENCE;
	}

	// 该属性还没有被Spring使用，永远返回TURE
	@Override
	public boolean isPerInstance() {
		return true;
	}


	@Override
	public boolean equals(@Nullable Object other) {
		if (this == other) {
			return true;
		}
		if (!(other instanceof PointcutAdvisor)) {
			return false;
		}
		PointcutAdvisor otherAdvisor = (PointcutAdvisor) other;
		return (ObjectUtils.nullSafeEquals(getAdvice(), otherAdvisor.getAdvice()) &&
				ObjectUtils.nullSafeEquals(getPointcut(), otherAdvisor.getPointcut()));
	}

	@Override
	public int hashCode() {
		return PointcutAdvisor.class.hashCode();
	}
}

 

AbstractGenericPointcutAdvisor保存Advice对象：

public abstract class AbstractGenericPointcutAdvisor extends AbstractPointcutAdvisor {
	// 保存Advisor关联的Advice
	private Advice advice = EMPTY_ADVICE;

	// setter and getter
	public void setAdvice(Advice advice) {
		this.advice = advice;
	}
	@Override
	public Advice getAdvice() {
		return this.advice;
	}

	@Override
	public String toString() {
		return getClass().getName() + ": advice [" + getAdvice() + "]";
	}
}

 

DefaultPointcutAdvisor是功能最强大的Advisor，保存了Advice和Pointcut对象，同时具备操作这两个对象的能力：

public class DefaultPointcutAdvisor extends AbstractGenericPointcutAdvisor implements Serializable {
	// 保存Advisor关联的Pointcut对象
	private Pointcut pointcut = Pointcut.TRUE;

	// 获取空的Advisor，在使用前必须指定Pointcut对象和Advice对象。
	public DefaultPointcutAdvisor() {
	}

	// 根据指定Advice和默认的Pointcut生成Advisor对象，使用默认Pointcut时，Advice将匹配所有方法。
	public DefaultPointcutAdvisor(Advice advice) {
		this(Pointcut.TRUE, advice);
	}

	// 根据指定Pointcut和Advice生成Advisor对象
	public DefaultPointcutAdvisor(Pointcut pointcut, Advice advice) {
		this.pointcut = pointcut;
		setAdvice(advice);
	}

	// setter and getter
	public void setPointcut(@Nullable Pointcut pointcut) {
		this.pointcut = (pointcut != null ? pointcut : Pointcut.TRUE);
	}
	@Override
	public Pointcut getPointcut() {
		return this.pointcut;
	}

	@Override
	public String toString() {
		return getClass().getName() + ": pointcut [" + getPointcut() + "]; advice [" + getAdvice() + "]";
	}
}

 

---

Pt3.5 Advised

Advised是对整个代理执行的抽象，创建代理的工厂ProxyFactory，Bean工厂BeanFactory都在该接口中保存。该接口维护了一些代理必要的属性，以及对 Advice，Advisor，Interceptor 的操作，任何被 Spring 代理的对象都可以强转为 Advised。

 

从Advised类图中可以看到，实现类ProxyFactory是创建AOP代理类的工厂。

 

(1) TargetClassAware

接口TargetClassAware表明代理类拥有对目标代理类的操作权限git，具体可以看Aware接口的介绍。

 

(2) Advised

Advised是核心接口，拥有对代理工厂、目标工厂、目标类的操作能力。

// Advised 接口的实现着主要是代理生成的对象与AdvisedSupport (Advised的支持器)
public interface Advised extends TargetClassAware {

	// 这个 frozen 决定是否 AdvisedSupport 里面配置的信息是否改变
	boolean isFrozen();

	// 是否代理指定的类, 而不是一些 Interface
	boolean isProxyTargetClass();

	// 返回代理的接口
	Class[] getProxiedInterfaces();

	// 判断这个接口是否是被代理的接口
	boolean isInterfaceProxied(Class intf);

	// 设置代理的目标对象
	void setTargetSource(TargetSource targetSource);

	// 获取代理的对象
	TargetSource getTargetSource();

	// 判断是否需要将 代理的对象暴露到 ThreadLocal中, 而获取对应的代理对象则通过 AopContext 获取
	void setExposeProxy(boolean exposeProxy);

	// 返回是否应该暴露 代理对象
	boolean isExposeProxy();

	// 设置 Advisor 是否已经在前面过滤过是否匹配 Pointcut (极少用到)
	void setPreFiltered(boolean preFiltered);

	// 获取 Advisor 是否已经在前面过滤过是否匹配 Pointcut (极少用到)
	boolean isPreFiltered();

	// 获取所有的 Advisor
	Advisor[] getAdvisors();

	// 增加 Advisor 到链表的最后
	void addAdvisor(Advisor advisor) throws AopConfigException;

	// 在指定位置增加 Advisor
	void addAdvisor(int pos, Advisor advisor) throws AopConfigException;

	// 删除指定的 Advisor
	boolean removeAdvisor(Advisor advisor);

	// 删除指定位置的 Advisor
	void removeAdvisor(int index) throws AopConfigException;

	// 返回 Advisor 所在位置de index
	int indexOf(Advisor advisor);

	// 将指定的两个 Advisor 进行替换
	boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException;

	// 增加 Advice <- 这个Advice将会包裹成 DefaultPointcutAdvisor
	void addAdvice(Advice advice) throws AopConfigException;

	// 在指定 index 增加 Advice <- 这个Advice将会包裹成 DefaultPointcutAdvisor
	void addAdvice(int pos, Advice advice) throws AopConfigException;

	// 删除给定的 Advice
	boolean removeAdvice(Advice advice);

	// 获取 Advice 的索引位置
	int indexOf(Advice advice);

	// 将 ProxyConfig 通过 String 形式返回
	String toProxyConfigString();
}

 

(3) ProxyConfig

保存了创建代理类的配置属性。

// 创建AOP代理类的配置
public class ProxyConfig implements Serializable {

	/** use serialVersionUID from Spring 1.2 for interoperability. */
	private static final long serialVersionUID = -8409359707199703185L;

	// 标记是否直接对目标类进行代理，而不是通过接口产生代理
	// 或者说，标记是否使用CGLIB动态代理，true，表示使用CGLIB的方式产生代理对象，false，表示使用JDK动态代理
	private boolean proxyTargetClass = false;

	// 标记是否进行优化。启动优化通常意味着在代理对象被创建后，增强的修改将不会生效，因此默认值为false。
	// 如果exposeProxy设置为true，即使optimize为true也会被忽略。
	private boolean optimize = false;

	// 标记是否需要阻止通过该配置创建的代理对象转换为Advised类型，默认值为false，表示代理对象可以被转换为Advised类型
	boolean opaque = false;

	// 标记代理对象是否应该被aop框架通过AopContext以ThreadLocal的形式暴露出去。
	// 当一个代理对象需要调用它自己的另外一个代理方法时，这个属性将非常有用。默认是是false，以避免不必要的拦截。
	boolean exposeProxy = false;

	// 标记该配置是否需要被冻结，如果被冻结，将不可以修改增强的配置。
	// 当我们不希望调用方修改转换成Advised对象之后的代理对象时，这个配置将非常有用。
	private boolean frozen = false;

	// setter and getter
	public void setProxyTargetClass(boolean proxyTargetClass) {
		this.proxyTargetClass = proxyTargetClass;
	}
	public boolean isProxyTargetClass() {
		return this.proxyTargetClass;
	}

	public void setOptimize(boolean optimize) {
		this.optimize = optimize;
	}
	public boolean isOptimize() {
		return this.optimize;
	}

	public void setOpaque(boolean opaque) {
		this.opaque = opaque;
	}
	public boolean isOpaque() {
		return this.opaque;
	}

	public void setExposeProxy(boolean exposeProxy) {
		this.exposeProxy = exposeProxy;
	}
	public boolean isExposeProxy() {
		return this.exposeProxy;
	}

	public void setFrozen(boolean frozen) {
		this.frozen = frozen;
	}
	public boolean isFrozen() {
		return this.frozen;
	}

	// 浅拷贝
	public void copyFrom(ProxyConfig other) {
		Assert.notNull(other, "Other ProxyConfig object must not be null");
		this.proxyTargetClass = other.proxyTargetClass;
		this.optimize = other.optimize;
		this.exposeProxy = other.exposeProxy;
		this.frozen = other.frozen;
		this.opaque = other.opaque;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("proxyTargetClass=").append(this.proxyTargetClass).append("; ");
		sb.append("optimize=").append(this.optimize).append("; ");
		sb.append("opaque=").append(this.opaque).append("; ");
		sb.append("exposeProxy=").append(this.exposeProxy).append("; ");
		sb.append("frozen=").append(this.frozen);
		return sb.toString();
	}
}

 

(4) AdvisedSupport

AdvisedSupport是用于生成Aop代理类的辅助类，保存了目标类、Advisor和method之间的关系。

public class AdvisedSupport extends ProxyConfig implements Advised {

	/** use serialVersionUID from Spring 2.0 for interoperability. */
	private static final long serialVersionUID = 2651364800145442165L;

	// 默认空的TargetSource
	public static final TargetSource EMPTY_TARGET_SOURCE = EmptyTargetSource.INSTANCE;
	TargetSource targetSource = EMPTY_TARGET_SOURCE;

	/** Whether the Advisors are already filtered for the specific target class. */
	// 当前Advisor是否已经过滤了目标类
	private boolean preFiltered = false;

	/** The AdvisorChainFactory to use. */
	AdvisorChainFactory advisorChainFactory = new DefaultAdvisorChainFactory();

	/** Cache with Method as key and advisor chain List as value. */
	// 缓存method和Advisor之间关系
	private transient Map> methodCache;

	// 目标代理类继承的接口
	private List> interfaces = new ArrayList<>();

	// 关联的Advisor
	private List advisors = new ArrayList<>();
	private Advisor[] advisorArray = new Advisor[0];

    // 方法基本都是对于属性的操作
    // ......
}

 

(5) ProxyCreatorSupport

生成代理类的辅助类ProxyCreatorSupport。

public class ProxyCreatorSupport extends AdvisedSupport {

	// AOP代理类生成工厂，用于创建代理类。
	private AopProxyFactory aopProxyFactory;

	// 监听Advisor的变化
	private final List listeners = new ArrayList<>();

	// 第一个AopProxyu对象生成时置为True
	private boolean active = false;

	public ProxyCreatorSupport() {
		this.aopProxyFactory = new DefaultAopProxyFactory();
	}
	public ProxyCreatorSupport(AopProxyFactory aopProxyFactory) {
		Assert.notNull(aopProxyFactory, "AopProxyFactory must not be null");
		this.aopProxyFactory = aopProxyFactory;
	}

	// aopProxyFactory的setter/getter
	public void setAopProxyFactory(AopProxyFactory aopProxyFactory) {
		Assert.notNull(aopProxyFactory, "AopProxyFactory must not be null");
		this.aopProxyFactory = aopProxyFactory;
	}
	public AopProxyFactory getAopProxyFactory() {
		return this.aopProxyFactory;
	}

	// 操作AdvisedSupportListener
	public void addListener(AdvisedSupportListener listener) {
		Assert.notNull(listener, "AdvisedSupportListener must not be null");
		this.listeners.add(listener);
	}
	public void removeListener(AdvisedSupportListener listener) {
		Assert.notNull(listener, "AdvisedSupportListener must not be null");
		this.listeners.remove(listener);
	}


	// 获取AopProxy，用于生成Bean的代理类
	protected final synchronized AopProxy createAopProxy() {
		// 第一个AopProxy被创建时，执行以下激活操作。
		if (!this.active) {
			activate();
		}

		// 获取AopProxy，用于生成Bean的代理类
		return getAopProxyFactory().createAopProxy(this);
	}

	// 激活AopProxy配置。
	private void activate() {
		this.active = true;
		for (AdvisedSupportListener listener : this.listeners) {
			listener.activated(this);
		}
	}

	// 监听advice变更事件
	@Override
	protected void adviceChanged() {
		super.adviceChanged();
		synchronized (this) {
			if (this.active) {
				for (AdvisedSupportListener listener : this.listeners) {
					listener.adviceChanged(this);
				}
			}
		}
	}

	protected final synchronized boolean isActive() {
		return this.active;
	}
}

 

(6) ProxyFactory

ProxyFactory是生成目标AOP代理类的工厂类。

public class ProxyFactory extends ProxyCreatorSupport {

	public ProxyFactory() {
	}

	// 根据目标类生成代理类
	public ProxyFactory(Object target) {
		setTarget(target);
		setInterfaces(ClassUtils.getAllInterfaces(target));
	}

	// 根据目标接口生成代理类
	public ProxyFactory(Class... proxyInterfaces) {
		setInterfaces(proxyInterfaces);
	}

	public ProxyFactory(Class proxyInterface, Interceptor interceptor) {
		addInterface(proxyInterface);
		addAdvice(interceptor);
	}

	public ProxyFactory(Class proxyInterface, TargetSource targetSource) {
		addInterface(proxyInterface);
		setTargetSource(targetSource);
	}

	// 生成代理类
	public Object getProxy() {
		return createAopProxy().getProxy();
	}

	// 基于指定的ClassLoader和Factory设置，创建AOP代理类。
	public Object getProxy(@Nullable ClassLoader classLoader) {
		// createAopProxy()：获取AOP代理类，有JdkDynamicAopProxy和CglibAopProxy两种。
		// getProxy：使用AOP代理类，生成目标Bean的代理类。
		// 这里假定使用JdkDynamicAopProxy的方式执行getProxy方法
		return createAopProxy().getProxy(classLoader);
	}

	// 生成代理类
	public static  T getProxy(Class proxyInterface, Interceptor interceptor) {
		return (T) new ProxyFactory(proxyInterface, interceptor).getProxy();
	}

	// 生成代理类
	@SuppressWarnings("unchecked")
	public static  T getProxy(Class proxyInterface, TargetSource targetSource) {
		return (T) new ProxyFactory(proxyInterface, targetSource).getProxy();
	}

	// 生成代理类
	public static Object getProxy(TargetSource targetSource) {
		if (targetSource.getTargetClass() == null) {
			throw new IllegalArgumentException("Cannot create class proxy for TargetSource with null target class");
		}
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.setTargetSource(targetSource);
		proxyFactory.setProxyTargetClass(true);
		return proxyFactory.getProxy();
	}
}

 

---

Pt3.6 Pointcut

Pointcut是AOP中非常重要的一个类，它定义了AOP切点逻辑，约定了Advice通知的时机。

 

我们先来看看其中一个实现类AspectJExpressionPointcut类的相关类图。

 

从类图上可以看出，AspectJExpressionPointcut主要有4个顶层接口：

• Pointcut：定义和切点相关的能力。

• Aware：标记当前类具备某种行为的感知能力。

• MethodMatcher：用来匹配mehtod是否匹配切点的规则，从而决定是否需要通知Advice。

• ClassFilter：用来匹配Class是否匹配切点规则。

ClassFilter限定在类级别上，MethodMatcher限定在方法级别上。

 

首先来看Pointcut顶层接口的能力：

// 切点的顶层抽象接口
public interface Pointcut {

	// 返回当前Pointcut的ClassFilter，用于匹配Class是否符合切点逻辑。
	ClassFilter getClassFilter();

	// 返回当前Pointcut的MethodMatcher对象，用于匹配method规则。
	MethodMatcher getMethodMatcher();

	// 默认值，如果返回此结果表明所有method都会被匹配成功。
	Pointcut TRUE = TruePointcut.INSTANCE;
}

 

// 匹配规则使用String表达式的Pointcut
public interface ExpressionPointcut extends Pointcut {

	// 返回切点规则表达式
	@Nullable
	String getExpression();
}

 

public abstract class AbstractExpressionPointcut implements ExpressionPointcut, Serializable {

	// 切点位置
	@Nullable
	private String location;

	// 切点匹配规则表达式
	@Nullable
	private String expression;


	// setter and getter
	public void setLocation(@Nullable String location) {
		this.location = location;
	}
	@Nullable
	public String getLocation() {
		return this.location;
	}

	public void setExpression(@Nullable String expression) {
		this.expression = expression;
		try {
			onSetExpression(expression);
		}
		catch (IllegalArgumentException ex) {
			// Fill in location information if possible.
			if (this.location != null) {
				throw new IllegalArgumentException("Invalid expression at location [" + this.location + "]: " + ex);
			}
			else {
				throw ex;
			}
		}
	}
	protected void onSetExpression(@Nullable String expression) throws IllegalArgumentException {
	}
	@Override
	@Nullable
	public String getExpression() {
		return this.expression;
	}
}

 

最终实现类是AspectJExpressionPointcut类：

// Pointcut实现类。
@SuppressWarnings("serial")
public class AspectJExpressionPointcut extends AbstractExpressionPointcut
		implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {

	private static final Set SUPPORTED_PRIMITIVES = new HashSet<>();
    
    ......
        
}

 

---

Pt3.7 ClassFilter

比较简单，直接看源码：

// ClassFilter限定在类级别上，判断是否符合Pointcut规则。
@FunctionalInterface
public interface ClassFilter {

	// true表示能够匹配。那就会进行织入的操作
	boolean matches(Class clazz);

	// 默认值。会匹配所有的类，TrueClassFilter不是public得class，所以只是Spring内部自己使用的。
	ClassFilter TRUE = TrueClassFilter.INSTANCE;
}

 

---

Pt3.8 MethodMatcher

MethodMatcher用于定义Pointcut匹配method的逻辑：

// Pointcut匹配逻辑：判断方法是否符合Pointcut规则，执行Advice通知。
public interface MethodMatcher {

	// 这个称为静态匹配：在匹配条件不是太严格时使用，可以满足大部分场景的使用
	boolean matches(Method method, Class targetClass);

	// 这个称为动态匹配（运行时匹配）: 它是严格的匹配。在运行时动态的对参数的类型进行匹配
	boolean matches(Method method, Class targetClass, Object... args);

	// 两个方法的分界线就是boolean isRuntime()方法，步骤如下
	// 1、先调用静态匹配，若返回true。此时就会继续去检查isRuntime()的返回值
	// 2、若isRuntime()还返回true，那就继续调用动态匹配
	// (若静态匹配都匹配上，动态匹配那铁定更匹配不上得~~~~)
	boolean isRuntime();

	// 默认值
	MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
}

 

实现接口：

// 校验方法是否匹配Pointcut规则
public interface IntroductionAwareMethodMatcher extends MethodMatcher {
   boolean matches(Method method, Class targetClass, boolean hasIntroductions);
}

 

---

Pt3.9 Aware

我们在介绍下Aware接口。

打开Aware接口可以看到，他是一个空接口，没有任何实现。他标识的其实是一种能力，Spring容器中的Bean能够具备感知某一对象的能力。

// Aware是顶层超类，用于标识是否具备一种能力。
public interface Aware {

}

 

比如，BeanFactoryAware是继承了Aware的接口，它就代表Bean对归属Spring IoC容器的感知能力。

// 实现了BeanFactoryAware接口的类，能够感知到他所属的BeanFactory。直白点，就是Bean能够获得他所属的BeanFactory对象。
// 这就是Aware接口的能力，他使得继承类能够具备某一种感知的能力。
public interface BeanFactoryAware extends Aware {

	// 设置当前Bean所属的BeanFactory实例
	void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}

 

还有TargetClassAware接口：

// 该接口使得，对应的代理类拥有感知TargetClass的能力，就是能够操作目标代理类。
public interface TargetClassAware {
	// 获得目标代理类。
	@Nullable
	Class getTargetClass();
}

 

---

Pt4 Spring AOP初始化剖析

Pt4.1 寻找入口

在AOP基础部分中，介绍过AOP的原理是生成原始Bean对象的代理类，从而在执行过程中通过动态代理完成逻辑横切。

所以AOP的初始化是在Bean初始化完成之后发生的。在DI部分，通过调用BeanFactory.getBean()触发Bean的初始化和依赖注入，当整个Bean初始化逻辑之心完成后，会继续执行AOP初始化处理，为Bean创建AOP代理类。

 

DI操作是通过调用#getBean()触发的，其核心逻辑是在AbstractAutowireCapableBeanFactory#doCreateBean()执行。我们跳过IoC、DI和MVC部分的详细逻辑介绍，直接从doCreateBean()来找AOP的入口。

先来看#doCreateBean()实例化逻辑：

// org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
protected  T doGetBean(
    String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {

    // ......
    
	// 跳过DI前后其他逻辑，这部分在DI部分已经详细介绍过。
    // 不管Bean的Scope是那种，最终都是通过#createBean()·。
    return createBean(beanName, mbd, args);
    
    // ......
}

 

还没到AOP的地方，继续往下：

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
// 真正完成指定Bean对象创建的方法
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {

    // ......
    
    // 跳过DI前后其他逻辑，这部分在DI部分已经详细介绍过。
    // Bean的处理只要分为三个步骤：
    //    1. 实例化，执行构造器；
    //    2. 依赖注入；
    //    3. 调用init-method；
    // 到这里，DI已经完成Bean的实例化操作，这是第一步，我们继续往下看。
    
    // 2、对Bean进行依赖注入
    populateBean(beanName, mbd, instanceWrapper);

    // 3、Bean实例对象依赖注入完成后，开始对Bean实例对象进行初始化，为Bean实例对象应用BeanPostProcessor后置回调处理
    // AOP的逻辑在这里执行
    exposedObject = initializeBean(beanName, exposedObject, mbd);
       
    // ......
}

 

找到#initializeBean，这里才是真正开始的地方：

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)
// 初始化容器创建的Bean实例对象，为其添加BeanPostProcessor后置处理器
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    // JDK安全机制验证权限
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction