Spring源码学习（十四）-- AOP底层源码解析下

上篇文章学习了动态代理的使用以及spring中动态代理的基础使用和aop的基本概念，本篇文章首先学习spring中ProxyFactory原理以及aop源码

ProxyFactory选择cglib或jdk动态代理原理

OrderService target = new OrderService();

		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.setTarget(target);
		proxyFactory.setInterfaces(OrderInterface.class);
		proxyFactory.addAdvice(new MethodInterceptor() {
			@Override
			public Object invoke(MethodInvocation invocation) throws Throwable {
				System.out.println("before...");
				Object result = invocation.proceed();
				System.out.println("after...");
				return result;
			}
		});
		OrderInterface proxy = (OrderInterface) proxyFactory.getProxy();
		proxy.test();
		System.out.println(proxy.getClass().getName());

org\springframework\aop\framework\ProxyFactory.java 

org.springframework.aop.framework.ProxyCreatorSupport 

ProxyFactory在生成代理对象之前需要决定到底是使用JDK动态代理还是CGLIB技术：

org.springframework.aop.framework.DefaultAopProxyFactory

	@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		// 如果ProxyFactory的isOptimize为true，
		// 或者isProxyTargetClass为true，
		// 或者被代理对象没有实现接口，
		// 或者只实现了SpringProxy这个接口
		// 那么则利用Cglib进行动态代理，但如果被代理类是接口，或者被代理类已经是进行过JDK动态代理而生成的代理类了则只能进行JDK动态代理

		// 其他情况都会进行JDK动态代理，比如被代理类实现了除SpringProxy接口之外的其他接口
        // config就是ProxyFactory对象
        // optimize为true,或proxyTargetClass为true,或用户没有给ProxyFactory对象添加interface
		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
			Class targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
            // targetClass是接口，直接使用Jdk动态代理
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
            // cgllib
			return new ObjenesisCglibAopProxy(config);
		}
		else {
            // jdk
			return new JdkDynamicAopProxy(config);
		}
	}

代理对象创建过程

JdkDynamicAopProxy

在构造JdkDynamicAopProxy对象时，会先拿到被代理对象自己所实现的接口，并且额外的增加SpringProxy、Advised、DecoratingProxy三个接口，组合成一个Class[]，并赋值给proxiedInterfaces属性

org.springframework.aop.framework.JdkDynamicAopProxy

	public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
		Assert.notNull(config, "AdvisedSupport must not be null");
		if (config.getAdvisorCount() == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
			throw new AopConfigException("No advisors and no TargetSource specified");
		}
		// config是ProxyFactory对象
		this.advised = config;
		// 设置JDK动态代理所要代理的接口
		// 先拿到被代理对象自己所实现的接口，并且额外的增加SpringProxy、Advised、DecoratingProxy三个接口，组合成一个Class[]，并赋值给proxiedInterfaces属性
		this.proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
		// 检查这些接口中是否定义了equals()、hashcode()方法
		findDefinedEqualsAndHashCodeMethods(this.proxiedInterfaces);
	}

并且检查这些接口中是否定义了equals()、hashcode()方法

org.springframework.aop.framework.JdkDynamicAopProxy

	private void findDefinedEqualsAndHashCodeMethods(Class[] proxiedInterfaces) {
		// 判断被代理的接口中是否定义了equals()、hashCode()方法，如果程序员在接口中手动定义了这两个方法，则也会进行代理
		// 否则这两个方法是不会走代理逻辑的
		for (Class proxiedInterface : proxiedInterfaces) {
			Method[] methods = proxiedInterface.getDeclaredMethods();
			for (Method method : methods) {
				if (AopUtils.isEqualsMethod(method)) {
					this.equalsDefined = true;
				}
				if (AopUtils.isHashCodeMethod(method)) {
					this.hashCodeDefined = true;
				}
				if (this.equalsDefined && this.hashCodeDefined) {
					return;
				}
			}
		}
	}

执行Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this)，得到代理对象，JdkDynamicAopProxy作为InvocationHandler，代理对象在执行某个方法时，会进入到JdkDynamicAopProxy的**invoke()**方法中

	@Override
	public Object getProxy() {
		return getProxy(ClassUtils.getDefaultClassLoader());
	}

	@Override
	public Object getProxy(@Nullable ClassLoader classLoader) {
		if (logger.isTraceEnabled()) {
			logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
		}
		// this实现了InvocationHandler
		return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
	}

ObjenesisCglibAopProxy

org.springframework.aop.framework.CglibAopProxy#getProxy(java.lang.ClassLoader)

获取被代理类

 创建Enhancer对象

 设置Enhancer的superClass为通过ProxyFactory.setTarget()所设置的对象的类

			// 被代理类，代理类的父类
			enhancer.setSuperclass(proxySuperClass);

设置Enhancer的interfaces为通过ProxyFactory.addInterface()所添加的接口，以及SpringProxy、Advised、DecoratingProxy接口

// 代理类额外要实现的接口
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));

设置Enhancer的Callbacks为DynamicAdvisedInterceptor

			// 获取和被代理类所匹配的Advisor
			Callback[] callbacks = getCallbacks(rootClass);
			Class[] types = new Class[callbacks.length];
			for (int x = 0; x < types.length; x++) {
				types[x] = callbacks[x].getClass();
			}
			// fixedInterceptorMap only populated at this point, after getCallbacks call above
			enhancer.setCallbackFilter(new ProxyCallbackFilter(
					this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
			enhancer.setCallbackTypes(types);

			// Generate the proxy class and create a proxy instance.
			return createProxyClassAndInstance(enhancer, callbacks);

 最后创建一个代理对象，代理对象在执行某个方法时，会进入到DynamicAdvisedInterceptor的intercept()方法中

	protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
		enhancer.setInterceptDuringConstruction(false);
		enhancer.setCallbacks(callbacks);
		return (this.constructorArgs != null && this.constructorArgTypes != null ?
				enhancer.create(this.constructorArgTypes, this.constructorArgs) :
				enhancer.create());
	}

代理对象执行过程

在使用ProxyFactory创建代理对象之前，需要往ProxyFactory先添加Advisor

		UserService target = new UserService();
 
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.setTarget(target);
		proxyFactory.addAdvisor(new PointcutAdvisor() {
			@Override
			public Pointcut getPointcut() {
				return new StaticMethodMatcherPointcut() {
					@Override
					public boolean matches(Method method, Class targetClass) {
						return method.getName().equals("testAbc");
					}
				};
			}
 
			@Override
			public Advice getAdvice() {
				return new MethodInterceptor() {
					@Override
					public Object invoke(MethodInvocation invocation) throws Throwable {
						System.out.println("before...");
						Object result = invocation.proceed();
						System.out.println("after...");
						return result;
					}
				};
			}
 
			@Override
			public boolean isPerInstance() {
				return false;
			}
		});
 
		UserInterface userService = (UserInterface) proxyFactory.getProxy();
		userService.test();

或者

		OrderService target = new OrderService();

		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.setTarget(target);
		//proxyFactory.setInterfaces(OrderInterface.class);
		proxyFactory.addAdvice(new MethodInterceptor() {
			@Override
			public Object invoke(MethodInvocation invocation) throws Throwable {
				System.out.println("before...");
				Object result = invocation.proceed();
				System.out.println("after...");
				return result;
			}
		});
		OrderInterface proxy = (OrderInterface) proxyFactory.getProxy();
		proxy.test();
		System.out.println(proxy.getClass().getName());
	}

 不管是addAdvice还是addAdvisor最后都是转换成DefaultPointcutAdvisor 

 以JdkDynamicAopProxy动态代理为例，JdkDynamicAopProxy作为InvocationHandler，代理对象在执行某个方法时，会进入到JdkDynamicAopProxy的**invoke()**方法中

org.springframework.aop.framework.JdkDynamicAopProxy#invoke

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

		// 拿到被代理对象
		TargetSource targetSource = this.advised.targetSource;
		Object target = null;

		try {
			// 如果接口中没有定义equals()方法，那么则直接调用，不走代理
			if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
				// The target does not implement the equals(Object) method itself.
				return equals(args[0]);
			}
			// 同上
			else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
				// The target does not implement the hashCode() method itself.
				return hashCode();
			}
			//没用过 留作以后再说
			else if (method.getDeclaringClass() == DecoratingProxy.class) {
				// There is only getDecoratedClass() declared -> dispatch to proxy config.
				// 得到代理对象的类型，而不是所实现的接口
				return AopProxyUtils.ultimateTargetClass(this.advised);
			}
			else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
					method.getDeclaringClass().isAssignableFrom(Advised.class)) {
				// 如果 方法所在的类是接口 并且是Advised的子类，则直接调用下面的方法，这个方法在下面分析
				// Service invocations on ProxyConfig with the proxy config...
				// 也是直接调用Advised接口中的方法，不走代理逻辑
				// 其实就是利用代理对象获取ProxyFactory中的信息
				return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
			}

			Object retVal;

			//是否对外暴露代理对象
			// 如果ProxyFactory的exposeProxy为true,则将代理对象设置到currentProxy这个ThreadLocal中去
			if (this.advised.exposeProxy) {
				// Make invocation available if necessary.
				oldProxy = AopContext.setCurrentProxy(proxy);
				setProxyContext = true;
			}

			// Get as late as possible to minimize the time we "own" the target,
			// in case it comes from a pool.
			// 被代理对象和代理类
			target = targetSource.getTarget();
			Class targetClass = (target != null ? target.getClass() : null);

			// Get the interception chain for this method.
			// 从Advised中根据方法名和目标类获取 AOP拦截器执行链 重点要分析的内容
			// 代理对象在执行某个方法时，根据方法筛选出匹配的Advisor，并适配成Interceptor
			// 代理对象在执行某个方法时，会把ProxyFactory中的Advisor拿出来和当前正在执行的方法进行匹配筛选
			// 把和方法所匹配的Advisor适配成MethodInterceptor
			List