核心逻辑
上文中提到了 AOP 创建代理等等的具体操作都是在 AnnotationAwareAspectAutoProxyCreator 类中来成的,通过上文的自动注册,下面让我们看 AnnotationAwareAspectAutoProxyCreator 是如何工作的,首先是 AnnotationAwareAspectAutoProxyCreator 的继承关系图:
然后是 AnnotationAwareAspectAutoProxyCreator 的层次结构图:
这里需要特别注意的是 BeanPostProcessor 接口,我们知道实际运用中,如果你需要对项目中的 Bean 进行代理,在 Spring 的 xml 的配置一个 BeanPostProcessor 就行。由此,我们可以知道 AnnotationAwareAspectAutoProxyCreator 实现代理也是通过 BeanPostProcessor 接口来完成的,所以我们对于 AOP 逻辑分析也是由 BeanPostProcessor 实例化前的 postProcessAfterInitialization 方法开始,而 AnnotationAwareAspectAutoProxyCreator 的 postProcessAfterInitialization 具体实现是在其父类 AbstractAutoProxyCreator 中完成的。我们对 AOP 逻辑的分析也由此开始。
AbstractAutoProxyCreator.java
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean != null) {
// 根据给定的 bean 的 class 和 name 构建出个 key,格式:beanClassName_beanName
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {
// 如果它适合被代理,则需要封装指定 bean。
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// 是否已经处理过
if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
// 无需增强
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
// 给定的 bean 类是否代表一个基础设施类,基础设施类不应代理,或者配置了指定 bean 不需要自动代理
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// 如果存在增强方法则创建代理
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
// 如果获取到了增强则需要针对增强创建代理
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 创建代理
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
以上两个方法构成了创建代理的雏形,当然,开始前还有些判断工作。而创建代理的核心逻辑部分是在 AbstractAutoProxyCreator 类中完成的,而创建代理前的准备工作主要分为两步:(1)获取增强方法或者增强器。(2)根据获取的增强进行代理。下面是 AbstractAutoProxyCreator 的时序图:
结合时序图,我们知道真正创建代理地方是从 getAdvicesAndAdvisorsForBean 开始的。虽然看起来很简单,但其实每一步都有大量复杂的逻辑。但在分析源码前,我们必须先对增强以及其具体逻辑有所了解。
设计的基石
增强
Advice(也翻作 通知)定义了连接点做什么,为切面增强提供了织入的接口。在 Spring AOP 中,它主要描述 Spring AOP 围绕方法调用而注入的切面行为。Advice 是 AOP 联盟定义的一个接口,具体的接口定义在 org.aopalliance.aop.Advice 中。在 Spring AOP 的实现中,使用了这个统一接口,并通过这个接口,为 AOP 切面增强的注入功能做了更多的细化和扩展,比如前面提到的具体通知类型,如BeforeAdvice、AfterAdvice、ThrowsAdvice等。作为 Spring AOP 定义的接口类,具体的切面增强可以通过这些接口集成到 AOP 框架中去发挥作用。对于这些接口类,下面是他的主要接口继承图:
下面是 Advice 接口继承的层次图:
看一个程序的具体设计思路没有比看接口来的更直接的了,下面我们就从第一个 BeforeAdvice 的继承接口 MethodBeforeAdvice 开始(BeforeAdvice 里没有任何东西)
MthodInterceptor.java
public interface MethodInterceptor extends Interceptor {
void before(Method method, Object[] args, Object target) throws Throwable;
}
明显能够看出这是一个回调函数,他的具体参数有:Method 对象,这个参数是目标方法的反射对象,Object[]对象数组,这个对象数组中包含没办法发的输入参数。而我们根据继承关系看他的具体实现类 AspectJMethodBeforeAdvice。
AspectJMethodBeforeAdvice.java
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
AbstractAspectJAdvice.java
protected Object invokeAdviceMethod(JoinPointMatch jpMatch, Object returnValue, Throwable ex) throws Throwable {
return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));
}
protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
Object[] actualArgs = args;
if (this.aspectJAdviceMethod.getParameterTypes().length == 0) {
actualArgs = null;
}
try {
ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
// 激活增强
return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
}
catch (IllegalArgumentException ex) {
throw new AopInvocationException("Mismatch on arguments to advice method [" +
this.aspectJAdviceMethod + "]; pointcut expression [" +
this.pointcut.getPointcutExpression() + "]", ex);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
invokeAdviceMethodWithGivenArgs 方法中的 aspectJAdviceMethod 正是对于前置增强的方法,在这里实行了调用。下面是 AfterAdvice 的继承接口 AfterReturningAdvice 接口:
AfterReturningAdvice.java
public interface AfterReturningAdvice extends AfterAdvice {
void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;
}
而 AfterReturningAdvice 接口的核心逻辑是在其实现父类 AspectJAfterReturningAdvice 中完成的。
AspectJAfterReturningAdvice.java
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
if (shouldInvokeOnReturnValueOf(method, returnValue)) {
invokeAdviceMethod(getJoinPointMatch(), returnValue, null);
}
}
后面的和 BeforeAdvice 一样。根据分析我们可以知道 BeforeAdvice 和 AfterAdvice。尽管,这两个增强行为一致,旦因为它实现的 AOP 通知不同,所以就被 AOP 编织到不同的调用场合中了。而其他的增强基本思路都是如此,这里就不展开了。
切点
Pointcut(关注点,也称 切点)用于决定 Advice 增强作用于哪个连接点,也就是说通过 Pointcut 来定义需要增强的方法集合,而这些集合的选取可以通过一定的规则来完成,例如:这些需要增强的地方可以由某个正则表达式来进行标识,或根据某个方法名来进行匹配等。下面是 Pointcut 的层次结构图:
下面是 Pointcut 接口:
Pointcut.java
public interface Pointcut {
ClassFilter getClassFilter();
MethodMatcher getMethodMatcher();
Pointcut TRUE = TruePointcut.INSTANCE;
}
通过 Pointcut 接口的基本定义我们可以看到,需要返回一个 MethodMatcher。对于 Point 的匹配判断功能,具体是由这个返回的 MethodMatcher 来完成的,也就是说,有这个 MethodMatcher 来判断是否需要对当前方法调用进行增强或者配置应用。我接着对 MethodMatcher 接口进行分析:
MethodMatcher.java
public interface MethodMatcher {
boolean matches(Method method, Class<?> targetClass);
boolean isRuntime();
boolean matches(Method method, Class<?> targetClass, Object[] args);
MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
}
通过阅读注释我们知道了 Pointcut 的核心逻辑是在 matches 方法中完成的,我就以通过方法名匹配的 NameMatchMetchMethodPointcut 类的 matches 方法来说明:
NameMatchMetchMethodPointcut.java
@Override
public boolean matches(Method method, Class<?> targetClass) {
for (String mappedName : this.mappedNames) {
if (mappedName.equals(method.getName()) || isMatch(method.getName(), mappedName)) {
return true;
}
}
return false;
}
从源码我们看到他的实现是非常简单的,匹配条件就是方法名相同或者方法名匹配。
通知器
Advisor(通知器)用一个对象将对目标方法的切面增强设计(Advice)和关注点的设计(Pointcut)结合起来。下面是 Advisor 接口的层次继承图:
这是一个 Advisor 接口的设计,我们从中可以看出通过 Advisor,可以定义应该使用哪个增强并且在哪个关注点使用它,也就是通过 Advisor,把 Advice 和 Pointcut 结合起来,这个结合为使用 IOC 容器配置 AOP应用,提供了便利。下面是 Advisor 接口:
Advisor.java
public interface Advisor {
Advice getAdvice();
boolean isPerInstance();
}
下面我们以一个 Advisor 的实现(DefaultPointcutAdvisor)为例,进而了解 Advisor 的工作原理。
DefaultPointcutAdvisor.java
public class DefaultPointcutAdvisor extends AbstractGenericPointcutAdvisor implements Serializable {
private Pointcut pointcut = Pointcut.TRUE;
public DefaultPointcutAdvisor() {
}
public DefaultPointcutAdvisor(Advice advice) {
this(Pointcut.TRUE, advice);
}
public DefaultPointcutAdvisor(Pointcut pointcut, Advice advice) {
this.pointcut = pointcut;
setAdvice(advice);
}
public void setPointcut(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() + "]";
}
}
这个类主要职责是 Pointcut 的设置或者获取,在 DefaultPointcutAdvisor 中,Pointcut 默认被设置为 Pointcut.True,这个 Pointcut.True 接口被定义为 Pointcut True = TruePointcut.INSTANCE。而关于 Advice 部分的设置与获取是由其父类 AbstractGenericPointcutAdvisor 来完成的。
指定Bean的增强方法
下面就让我们回到源码分析,前面已经提到了通知器,这里就不冗述了,他的主要作用是用来整合切面增强设计(Advice)和切入点设计(Pointcut)。而对于指定 bean 的增强方法的获取,一般包含获取所有增强以及寻找所有增强中适合于 bean 的增强并应用这两个步骤。
AnnotationAwareAspectAutoProxyCreator.java
@Override
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
List<Advisor> candidateAdvisors = findCandidateAdvisors();
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
从源码看,这两个步骤一定是由 findCandidateAdvisors 和 findAdvisorsThatCanApply 来完成。还有值得注意的是,如果无法找到对应的通知器便会返回 DO_NOT_PROXY(null)。
——水门(2016年3月于杭州)