Spring中AOP源码深入解析

有关AOP相关概念以及Spring AOP相关概念和Spring AOP的使用不再重复。关于AOP在Spring中的地位,不用说相信我们都知道,也都会用,但是对于更深入的东西,还未接触过,这里就对Spring AOP的相关源码进行说明一下,看看到底Spring中AOP是怎么实现的。

有关AOP的概念和Spring AOP相关配置,请参考其他两篇文章:AOP概念,原理,应用介绍Spring中AOP的配置从1.0到5.0的演进

另外,本文使用的源码是Spring1.1.1版本的,之所以使用这么老的版本,是觉得相对来说简单一些,并且无关的东西更少,这样更容易去理解。对于后续版本新增功能可以在此基础上进行对比,理解的效果会更好。

示例程序

首先我们还是先使用一个实例来看一下怎么使用,再从实例中一步一步跟进到源码中。

先定义业务接口和实现:

LoginService:

1
2
3
4
5
6
7
8
package me.cxis.spring.aop;

/**
* Created by cheng.xi on 2017-03-29 12:02.
*/
public interface LoginService {
String login(String userName);
}

LoginServiceImpl:

1
2
3
4
5
6
7
8
9
10
11
12
package me.cxis.spring.aop;

/**
* Created by cheng.xi on 2017-03-29 10:36.
*/
public class LoginServiceImpl implements LoginService {

public String login(String userName){
System.out.println("正在登录");
return "success";
}
}

接着是三个通知类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//这里只是在登录方法调用之前打印一句话
public class LogBeforeLogin implements MethodBeforeAdvice {
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println("有人要登录了。。。");
}
}

package me.cxis.spring.aop.proxyfactory;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
* Created by cheng.xi on 2017-03-29 10:56.
*/
public class LogAfterLogin implements AfterReturningAdvice {

public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("有人已经登录了。。。");
}
}

package me.cxis.spring.aop.proxyfactory;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
* Created by cheng.xi on 2017-03-30 23:36.
*/
public class LogAroundLogin implements MethodInterceptor {
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("有人要登录。。。");
Object result = invocation.proceed();
System.out.println("登录完了");
return result;
}
}

测试方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package me.cxis.spring.aop.proxyfactory;

import org.springframework.aop.framework.ProxyFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* Created by cheng.xi on 2017-03-29 10:34.
*/
public class Main {


public static void main(String[] args) {
ProxyFactory proxyFactory = new ProxyFactory();//创建代理工厂
proxyFactory.setTarget(new LoginServiceImpl());//设置目标对象
proxyFactory.addAdvice(new LogBeforeLogin());//前置增强
proxyFactory.addAdvice(new LogAfterLogin());//后置增强
//proxyFactory.addAdvice(new LogAroundLogin());//环绕增强

LoginService loginService = (LoginService) proxyFactory.getProxy();//从代理工厂中获取代理
loginService.login("x");
}
}

关于实例中要说明的:我们看到在使用的时候,直接获取的是一个代理,不是要使用的实现类,这也很好懂,之前文章都说过AOP其实就是代理模式,在编译期或者运行期,给我们原来的代码增加一些功能,变成一个代理。当我们调用的时候,实际就是调用的代理类。

源码解析

对于源码的解析,我们这里使用的是代码的方式,没有选择xml配置文件的方式。关于xml配置的方式,后面再讲解。

创建AOP代理

首先我们要明白,Spring中实现AOP,就是生成一个代理,然后在使用的时候调用代理。

创建代理工厂

代码中首先创建一个代理工厂实例ProxyFactory proxyFactory = new ProxyFactory();代理工厂的作用就是使用编程的方式创建AOP代理。ProxyFactory继承自AdvisedSupport,AdvicedSupport是AOP代理的配置管理器。

设置目标对象

然后是设置要代理的目标对象proxyFactory.setTarget(new LoginServiceImpl());,看下setTarget方法:

1
2
3
4
5
public void setTarget(Object target) {
//先根据给定的目标实现类,创建一个单例的TargetSource
//然后设置TargetSource
setTargetSource(new SingletonTargetSource(target));
}

TargetSource

TargetSource用来获取当前的Target,也就是TargetSource中会保存着我们的的实现类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public interface TargetSource {

//返回目标类的类型
Class getTargetClass();

//查看TargetSource是否是static的
//静态的TargetSource每次都返回同一个Target
boolean isStatic();

//获取目标类的实例
Object getTarget() throws Exception;

//释放目标类
void releaseTarget(Object target) throws Exception;

}

SingletonTargetSource

TargetSource的默认实现,是一个单例的TargetSource,isStatic方法直接返回true。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public final class SingletonTargetSource implements TargetSource, Serializable {

//用来保存目标类
private final Object target;
//构造方法
public SingletonTargetSource(Object target) {
this.target = target;
}
//直接返回目标类的类型
public Class getTargetClass() {
return target.getClass();
}
//返回目标类
public Object getTarget() {
return this.target;
}
//释放目标类,这里啥也没做
public void releaseTarget(Object o) {
// Nothing to do
}
//直接返回true
public boolean isStatic() {
return true;
}

//equals方法
public boolean equals(Object other) {
//相等,返回true
if (this == other) {
return true;
}
//不是SingletonTargetSource类型的返回false
if (!(other instanceof SingletonTargetSource)) {
return false;
}
SingletonTargetSource otherTargetSource = (SingletonTargetSource) other;
//判断目标类是否相等
return ObjectUtils.nullSafeEquals(this.target, otherTargetSource.target);
}

//toString方法
public String toString() {
return "SingletonTargetSource: target=(" + target + ")";
}
}

上面是有关TargetSource和SingletonTargetSource的说明,接着往下一步就是设置目标类setTargetSource方法,在AdvisedSupport类中:

1
2
3
4
5
6
7
public void setTargetSource(TargetSource targetSource) {
if (isActive() && getOptimize()) {
throw new AopConfigException("Can't change target with an optimized CGLIB proxy: it has its own target");
}
//么有做什么处理,只是将我们构建的TargetSource缓存起来
this.targetSource = targetSource;
}

添加通知

上面设置了要代理的目标类之后,接着是添加通知,也就是添加增强类,proxyFactory.addAdvice()方法是添加增强类的方法。我们在例子中是这么使用的:

1
2
3
proxyFactory.addAdvice(new LogBeforeLogin());//前置增强
proxyFactory.addAdvice(new LogAfterLogin());//后置增强
//proxyFactory.addAdvice(new LogAroundLogin());//环绕增强

addAdvice方法的参数是一个Advice类型的类,也就是通知或者叫增强,可以去我们的增强类中查看,我们都继承了各种Advice,比如MethodBeforeAdviceAfterReturningAdviceMethodInterceptor,这里先讲一下有关通知Advice的代码,然后再继续说明addAdvice方法。

Advice接口

Advice不属于Spring,是AOP联盟定义的接口。Advice接口并没有定义任何方法,是一个空的接口,用来做标记,实现了此接口的的类是一个通知类。Advice有几个子接口:

  • BeforeAdvice,前置增强,意思是在我们的目标类之前调用的增强。这个接口也没有定义任何方法。
  • AfterReturningAdvice,方法正常返回前的增强,该增强可以看到方法的返回值,但是不能更改返回值,该接口有一个方法afterReturning
  • ThrowsAdvice,抛出异常时候的增强,也是一个标志接口,没有定义任何方法。
  • Interceptor,拦截器,也没有定义任何方法,表示一个通用的拦截器。不属于Spring,是AOP联盟定义的接口
  • DynamicIntroductionAdvice,动态引介增强,有一个方法implementsInterface。
MethodBeforeAdvice

MethodBeforeAdvice接口,是BeforeAdvice的子接口,表示在方法前调用的增强,方法前置增强不能阻止方法的调用,但是能抛异常来使目标方法不继续执行。

1
2
3
4
5
6
7
8
public interface MethodBeforeAdvice extends BeforeAdvice {

//在给定的方法调用前,调用该方法
//参数method是被代理的方法
//参数args是被代理方法的参数
//参数target是方法调用的目标,可能为null
void before(Method m, Object[] args, Object target) throws Throwable;
}
MethodInterceptor

MethodInterceptor不属于Spring,是AOP联盟定义的接口,是Interceptor的子接口,我们通常叫做环绕增强。

1
2
3
4
5
6
public interface MethodInterceptor extends Interceptor {

//在目标方法调用前后做一些事情
//返回的是invocation.proceed()方法的返回值
Object invoke(MethodInvocation invocation) throws Throwable;
}

参数MethodInvocation是一个方法调用的连接点,接下来先看看MethodInvocation相关的代码。

Joinpoint连接点

JointPoint接口,是一个通用的运行时连接点,运行时连接点是在一个静态连接点发生的事件。

1
2
3
4
5
6
7
8
9
10
11
12
public interface Joinpoint {

//开始调用拦截器链中的下一个拦截器
Object proceed() throws Throwable;

//
Object getThis();

//
AccessibleObject getStaticPart();

}
Invocation接口

Invocation接口是Joinpoint的子接口,表示程序的调用,一个Invocation就是一个连接点,可以被拦截器拦截。

1
2
3
4
5
6
public interface Invocation extends Joinpoint {

//获取参数
Object[] getArguments();

}
MethodInvocation接口

MethodInvocation接口是Invocation的子接口,用来描述一个方法的调用。

1
2
3
4
5
6
7
public interface MethodInvocation extends Invocation
{

//获取被调用的方法
Method getMethod();

}

另外还有一个ConstructorInvocation接口,也是Invocation的子接口,描述的是构造器的调用。

上面介绍完了Advice的相关定义,接着看往代理工厂中添加增强的addAdvice方法,addAdvice方法在AdvisedSupport类中:

1
2
3
4
5
6
7
8
public void addAdvice(Advice advice) throws AopConfigException {
//advisors是Advice列表,是一个LinkedList
//如果被添加进来的是一个Interceptor,会先被包装成一个Advice
//添加之前现获取advisor的大小,当做添加的Advice的位置
int pos = (this.advisors != null) ? this.advisors.size() : 0;
//添加Advice
addAdvice(pos, advice);
}

接着看addAdvice(pos, advice)方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void addAdvice(int pos, Advice advice) throws AopConfigException {
//只能处理实现了AOP联盟的接口的拦截器
if (advice instanceof Interceptor && !(advice instanceof MethodInterceptor)) {
throw new AopConfigException(getClass().getName() + " only handles AOP Alliance MethodInterceptors");
}
//IntroductionInfo接口类型,表示引介信息
if (advice instanceof IntroductionInfo) {
//不需要IntroductionAdvisor
addAdvisor(pos, new DefaultIntroductionAdvisor(advice, (IntroductionInfo) advice));
}
//动态引介增强的处理
else if (advice instanceof DynamicIntroductionAdvice) {
//需要IntroductionAdvisor
throw new AopConfigException("DynamicIntroductionAdvice may only be added as part of IntroductionAdvisor");
}
else {
//添加增强器,需要先把我们的增强包装成增强器,然后添加
addAdvisor(pos, new DefaultPointcutAdvisor(advice));
}
}

我们看到添加增强的时候,实际调用添加增强器这个方法,首先需要把我们的Advice包装成一个PointCutAdvisor,然后在添加增强器。这里先了解一下有关PointCutAdvisor的相关信息。

Advisor接口

Advisor,增强器,它持有一个增强Advice,还持有一个过滤器,来决定Advice可以用在哪里。

1
2
3
4
5
6
7
8
9
public interface Advisor {

//判断Advice是不是每个实例中都有
boolean isPerInstance();

//返回持有的Advice
Advice getAdvice();

}

PointcutAdvisor

是一个持有Pointcut切点的增强器,PointcutAdvisor现在就会持有一个Advice和一个Pointcut。

1
2
3
4
5
6
public interface PointcutAdvisor extends Advisor {

//获取Pointcut
Pointcut getPointcut();

}

Pointcut接口

切入点,定义了哪些连接点需要被织入横切逻辑。可以

1
2
3
4
5
6
7
8
9
10
public interface Pointcut {
//类过滤器,可以知道哪些类需要拦截
ClassFilter getClassFilter();
//方法匹配器,可以知道哪些方法需要拦截
MethodMatcher getMethodMatcher();

// could add getFieldMatcher() without breaking most existing code
Pointcut TRUE = TruePointcut.INSTANCE;

}

ClassFilter接口

1
2
3
4
5
6
7
8
public interface ClassFilter {

//判断给定的类是不是要拦截
boolean matches(Class clazz);

ClassFilter TRUE = TrueClassFilter.INSTANCE;

}

MethodMatcher接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public interface MethodMatcher {

/ 静态方法匹配
boolean matches(Method m, Class targetClass);

//是否是运行时动态匹配
boolean isRuntime();

//运行是动态匹配
boolean matches(Method m, Class targetClass, Object[] args);

MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;

}

看完相关的定义之后,接着看方法new DefaultPointcutAdvisor(advice),将Advice包装成一个DefaultPointcutAdvisor。其实就是将advice和默认的Pointcut包装进DefaultPointcutAdvisor。

DefaultPointcutAdvisor是Advisor的最常用的一个实现,可以使用任意类型的Pointcut和Advice,但是不能使用Introduction。

构造完成了DefaultPointcutAdvisor只有,接着就是添加增强器方法addAdvisor:

1
2
3
4
5
6
7
8
9
10
public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
//引介增强器处理
if (advisor instanceof IntroductionAdvisor) {
addAdvisor(pos, (IntroductionAdvisor) advisor);
}
else {
//其他的增强器处理
addAdvisorInternal(pos, advisor);
}
}

首先看下非引介增强器的添加方法addAdvisorInternal:

1
2
3
4
5
6
7
8
9
10
11
private void addAdvisorInternal(int pos, Advisor advice) throws AopConfigException {
if (isFrozen()) {
throw new AopConfigException("Cannot add advisor: config is frozen");
}
//把Advice添加到LinkedList中指定位置
this.advisors.add(pos, advice);
//同时更新一下Advisors数组
updateAdvisorArray();
//通知监听器
adviceChanged();
}

然后看下关于引介增强器的添加addAdvisor,我们知道引介就是对目标类增加新的接口,所以引介增强,也就是对接口的处理:

1
2
3
4
5
6
7
8
9
10
11
12
public void addAdvisor(int pos, IntroductionAdvisor advisor) throws AopConfigException {
//对接口进行校验
advisor.validateInterfaces();

// 遍历要添加的接口,添加
for (int i = 0; i < advisor.getInterfaces().length; i++) {
//就是添加到interfaces集合中,interfaces是一个HashSet
addInterface(advisor.getInterfaces()[i]);
}
//然后添加到advisors中
addAdvisorInternal(pos, advisor);
}

对于添加增强的步骤,就是把我们的增强器添加进代理工厂中,保存在一个LinkedList中,顺序是添加进来的顺序。

获取代理

到目前为止,我们看到的都还是在组装代理工厂,并没有看到代理的生成,接下来proxyFactory.getProxy()这一步就是获取代理的过程,我们继续看ProxyFactory的getProxy方法:

1
2
3
4
5
6
public Object getProxy() {
//创建一个AOP代理
AopProxy proxy = createAopProxy();
//返回代理
return proxy.getProxy();
}

我们知道一般创建代理会有两种方式,一种是JDK动态代理,另外一种是CGLIB动态代理,而这里的创建AOP代理就是生成这两种代理中的一种。先看createAopProxy()方法,在AdvisedSupport类中:

1
2
3
4
5
6
7
protected synchronized AopProxy createAopProxy() {
if (!this.isActive) {
activate();
}
//获取AOP代理工厂,然后创建代理
return getAopProxyFactory().createAopProxy(this);
}

获取代理工厂这一步,这里就是默认获取一个DefaultAopProxyFactory实例,然后调用createAopProxy创建AOP代理:

1
2
3
4
5
6
7
8
9
10
11
public AopProxy createAopProxy(AdvisedSupport advisedSupport) throws AopConfigException {
//对于指定了使用CGLIB方式,或者代理的是类,或者代理的不是接口,就使用CGLIB的方式来创建代理
boolean useCglib = advisedSupport.getOptimize() || advisedSupport.getProxyTargetClass() || advisedSupport.getProxiedInterfaces().length == 0;
if (useCglib) {
return CglibProxyFactory.createCglibProxy(advisedSupport);
}
else {
//使用JDK动态代理来创建代理
return new JdkDynamicAopProxy(advisedSupport);
}
}

获取完AOP代理之后返回,然后就是调用getProxy方法获取代理,这里分为CGLIB的获取方式和JDK动态代理的获取方式两种。

JDK动态代理方式获取代理

JDK动态代理方式获取代理,实现在JdkDynamicAopProxy中:

1
2
3
public Object getProxy() {
return getProxy(Thread.currentThread().getContextClassLoader());
}
1
2
3
4
5
6
7
public Object getProxy(ClassLoader cl) {
//JDK动态代理只能代理接口类型,先获取接口
//就是从AdvisedSupport中获取保存在interfaces中的接口
Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advisedSupport);
//使用Java的反射机制创建一个代理实例
return Proxy.newProxyInstance(cl, proxiedInterfaces, this);
}

关于JDK反射创建代理之类的,这里不做解析。

CGLIB方式获取代理

CGLIB获取方式,实现在Cglib2AopProxy中:

1
2
3
4
public Object getProxy() {
//使用CGLIB的方式来获取,CGLIB这里不做解析
return getProxy(Thread.currentThread().getContextClassLoader());
}

使用代理

上面获取代理之后,就剩最后一步,使用,当我们调用业务方法的时候,实际上是调用代理中的方法,对于CGLIB生成的代理,调用的是DynamicAdvisedInterceptor的intercept方法;JDK动态代理生成的代理是调用invoke方法。

JDK动态代理

看下JDK动态代理的方式,对于方法的调用,实际上调用的是代理类的invoke方法,在JdkDynamicAopProxy中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation = null;
Object oldProxy = null;
boolean setProxyContext = false;
//代理的目标对象
TargetSource targetSource = advisedSupport.targetSource;
Class targetClass = null;
Object target = null;

try {
//equals方法
if (method.getDeclaringClass() == Object.class && "equals".equals(method.getName())) {
return equals(args[0]) ? Boolean.TRUE : Boolean.FALSE;
}
else if (Advised.class == method.getDeclaringClass()) {
//???
return AopProxyUtils.invokeJoinpointUsingReflection(this.advisedSupport, method, args);
}

Object retVal = null;

//代理目标对象
target = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}
//???
if (this.advisedSupport.exposeProxy) {
// Make invocation available if necessary
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}

//获取配置的通知Advicelian
List chain = this.advisedSupport.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
this.advisedSupport, proxy, method, targetClass);

//没有配置通知
if (chain.isEmpty()) {
//直接调用目标对象的方法
retVal = AopProxyUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {
//配置了通知,创建一个MethodInvocation
invocation = new ReflectiveMethodInvocation(proxy, target,
method, args, targetClass, chain);

//执行通知链,沿着通知器链调用所有的通知
retVal = invocation.proceed();
}

//返回值
if (retVal != null && retVal == target) {
//返回值为自己
retVal = proxy;
}
//返回
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
targetSource.releaseTarget(target);
}

if (setProxyContext) {
AopContext.setCurrentProxy(oldProxy);
}
}
}

CGLIB动态代理

CGLIB的是调用DynamicAdvisedInterceptor的intercept方法对目标对象进行处理,具体暂先不解析。

使用ProxyFactoryBean创建AOP代理

ProxyFactoryBean对Pointcut和Advice提供了完全的控制,还包括应用的顺序。ProxyFactoryBean的getObject方法会返回一个AOP代理,包装了目标对象。

Spring在初始化的过程中,createBean的时候,如果是FactoryBean的话,会调用((BeanFactoryAware)bean).setBeanFactory(this);

1
2
3
4
5
6
7
8
9
10
11
12
13
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
//创建通知器链
this.createAdvisorChain();
if(this.singleton) {
//刷新目标对象
this.targetSource = this.freshTargetSource();
//获取单例实例
this.getSingletonInstance();
this.addListener(this);
}

}

看下获取单例实例的方法:

1
2
3
4
5
6
7
private Object getSingletonInstance() {
if(this.singletonInstance == null) {
this.singletonInstance = this.createAopProxy().getProxy();
}

return this.singletonInstance;
}

createAopProxy方法在AdvisedSupport类中,下面创建的流程跟上面解析的都一样了。

到这里AOP的一个流程的源码算是走完了,这只是其中一小部分,还有很多的没有涉及到,包括AOP标签的解析,CGLIB生成代理以及调用代理等等。其中有些还没明白的已经画上了问号,慢慢的在研究下。

坚持原创技术分享,您的支持将鼓励我继续创作!
Fork me on GitHub