Spring AOP源码分析（四）Spring AOP的JDK动态代理

[size=medium]本篇文章将会介绍上一个例子中的源码执行情况，从中熟悉整个SpringAOP的一些概念和接口设计。

首先整个SpringAOP的分两大过程。
第一个过程：根据xml文件或者注解中配置的拦截信息，生成相应的代理对象，这个代理对象包含了对应的拦截器。
第二个过程：执行所拦截的方法时，就是调用代理对象的执行逻辑，完成各种拦截。

本文章先对第二个过程进行源码解析。
对第一个过程先做简单概述，如果拦截的类的对应方法是接口方法，则使用JDK的Proxy进行代理对象的创建否则使用CGLIB进行代理对象的创建。

本工程采用的之前文章所给出案例链接：[url]http://www.iteye.com/topic/336873[/url]
[/size]
[size=medium]简单概述如下：
拦截类：TestAspect[/size]

public void doAfter(JoinPoint jp) {  
        System.out.println("log Ending method: "  
                + jp.getTarget().getClass().getName() + "."  
                + jp.getSignature().getName());  
    }  

    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {  
        long time = System.currentTimeMillis();  
        Object retVal = pjp.proceed();  
        time = System.currentTimeMillis() - time;  
        System.out.println("process time: " + time + " ms");  
        return retVal;  
    }  

    public void doBefore(JoinPoint jp) {  
        System.out.println("log Begining method: "  
                + jp.getTarget().getClass().getName() + "."  
                + jp.getSignature().getName());  
    }  

    public void doThrowing(JoinPoint jp, Throwable ex) {  
        System.out.println("method " + jp.getTarget().getClass().getName()  
                + "." + jp.getSignature().getName() + " throw exception");  
        System.out.println(ex.getMessage());  
    }

xml的配置：

  
          

            
                            expression="execution(* com.lg.aop.service.*.*(..))" />  
              
              
            
              
          
      

[size=medium]建立单元测试类：[/size]

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "file:src/main/webapp/WEB-INF/mvc-servlet.xml")
public class AOPTest {

	@Autowired
	private AService aService;
	@Autowired
	private BServiceImpl bServiceImpl;

	@Test
	public void testAOP(){
		aService.barA();
		bServiceImpl.fooB();
	}

}

[size=medium]运行，效果如下：[/size]

log Begining method: com.lg.aop.service.impl.AServiceImpl.barA
AServiceImpl.barA()
process time: 0 ms
log Ending method: com.lg.aop.service.impl.AServiceImpl.barA
log Begining method: com.lg.aop.service.BServiceImpl.fooB
BServiceImpl.fooB()
process time: 12 ms
log Ending method: com.lg.aop.service.BServiceImpl.fooB

[size=medium]接下来就是分析这一过程。
首先我们会看到：此时的AService不再是它的实现者AServiceImpl，而是一个代理对象。
由于barA()是接口方法，所以会选择使用JDK的Proxy进行代理对象的创建。如下在JdkDynamicAopProxy中：[/size]

@Override
	public Object getProxy(ClassLoader classLoader) {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
		}
		Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
	}

[size=medium]来看下Proxy.newProxyInstance(classLoader, proxiedInterfaces, this)（详情见上一篇文章[url]http://lgbolgger.iteye.com/blog/2117215[/url]）这个代码就是创建代理对象，第一个参数指定classLoader，第二个参数指定代理对象要实现的接口，第三个对象那个是InvocationHandler类型。来看下InvocationHandler：[/size]

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

[size=medium]一个代理对象和一个InvocationHandler绑定，当执行代理对象的方法时，就会去执行InvocationHandler的invoke(Object proxy, Method method, Object[] args)方法，在该方法中你可以选择相应的处理或者不执行代理对象的method方法。
JdkDynamicAopProxy继承了InvocationHandler，所以上文中在创建代理对象时传的参数是this,即这个代理对象的方法的执行拦截情况全部在JdkDynamicAopProxy的invoke(Object proxy, Method method, Object[] args)方法中。
我们先来了解下JdkDynamicAopProxy的一些属性：[/size]

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
	/** Config used to configure this proxy */
	private final AdvisedSupport advised;

	private boolean equalsDefined;
	private boolean hashCodeDefined;
        //略
}

[size=medium]最关键的就是这个AdvisedSupport advised属性，它包含了我们在xml中配置的拦截信息，同时还包含了这个JdkDynamicAopProxy要代理的接口及其实现类，对于本文来说就是AService和AServiceImpl。JdkDynamicAopProxy可以根据这些配置信息来创建一个代理对象实现拦截，同时又可以执行AServiceImpl本身的业务方法。

AdvisedSupport有两个重要的内容：TargetSource和List advisors和List> interfaces。
TargetSource是目标类型和目标对象的包裹，在这里是AServiceImpl类和AServiceImpl对象。
List> interfaces：包含了目标类型实现的接口，在这里就是AService
List advisors：这里包含了我们在xml文件中配置的所有信息。这一部分是每个AdvisedSupport所共享的信息，而前面两个是每个AdvisedSupport所独有的信息。

在详细看下AdvisedSupport：[/size]

public class AdvisedSupport extends ProxyConfig implements Advised

[size=medium]接口Advised：主要包含TargetSource和List advisors和List> interface
ProxyConfig：则是对要产生的代理对象的一些配置，如下：[/size]

public class ProxyConfig implements Serializable {

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


	private boolean proxyTargetClass = false;

	private boolean optimize = false;

	boolean opaque = false;

	boolean exposeProxy = false;

	private boolean frozen = false;
}

[size=medium]其中proxyTargetClass：表示是否强制使用CGLIB进行代理对象的创建
exposeProxy ：表示是否暴漏代理对象，实现线程内共享，这里又是使用ThreadLocal模式。
他们分别对应xml配置中的[/size]

[size=medium]继续回到AdvisedSupport ，对于它的List advisors则分别对应xml中的配置：[/size]

[size=medium]则产生的Advisor如下：每一个都是AspectJPointcutAdvisor对象，该对象所包含的内容如下：[/size]

private final AbstractAspectJAdvice advice;
private final Pointcut pointcut;
private Integer order;

[size=medium]分别和xml配置中的内容相对应，在xml中你还可以指定order值，用来排序，这个顺序关系到这些拦截方法的执行顺序，之后我们会详细分析这个拦截器链的执行情况。
如aop:before产生的AspectJPointcutAdvisor的AbstractAspectJAdvice 为AspectJMethodBeforeAdvice，Pointcut 为ComposablePointcut。具体的内容已在上文中接口说明中给出了说明。

至此xml中的配置对应到AdvisedSupport基本上简单的了解了，这些内容的创建都是为下文方法的拦截做准备。
下面继续回到JdkDynamicAopProxy，来看看拦截过程，即调用代理对象的方法，然后被拦截到代理对象的InvocationHandler的invoke方法，JdkDynamicAopProxy的invoke方法如下：[/size]

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		MethodInvocation invocation;
		Object oldProxy = null;
		boolean setProxyContext = false;

		TargetSource targetSource = this.advised.targetSource;
		Class targetClass = null;
		Object target = null;

		try {
			if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
				// The target does not implement the equals(Object) method itself.
				return equals(args[0]);
			}
			if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
				// The target does not implement the hashCode() method itself.
				return hashCode();
			}
			if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
					method.getDeclaringClass().isAssignableFrom(Advised.class)) {
				// Service invocations on ProxyConfig with the proxy config...
				return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
			}

			Object retVal;

//我们关注的重点1
			if (this.advised.exposeProxy) {
				// Make invocation available if necessary.
				oldProxy = AopContext.setCurrentProxy(proxy);
				setProxyContext = true;
			}

			// May be null. Get as late as possible to minimize the time we "own" the target,
			// in case it comes from a pool.
			target = targetSource.getTarget();
			if (target != null) {
				targetClass = target.getClass();
			}
//关注的重点2
			// Get the interception chain for this method.
			List