Spring-AOP【九】创建代理对象

引言

至此，Spring-AOP的核心逻辑已经走了一半了，获取了目标类所适应的增强器列表，下面开始分析获取代理的过程。
回到初始代码入口：AbstractAutoProxyCreator的postProcessAfterInitialization(@Nullable Object bean, String beanName)

 /**
    * 如果bean被子类标识为一个代理，则使用已配置的拦截器创建一个代理。
    *
    * @see #getAdvicesAndAdvisorsForBean
    */
   @Override
   public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
       if (bean != null) {
           //根据给定的bean的class和name 获取key,有三种可能：beanName；bean.getClass()；"&"+beanName
           Object cacheKey = getCacheKey(bean.getClass(), beanName);
           // 如果没有代理过cacheKey
           if (this.earlyProxyReferences.remove(cacheKey) != bean) {
               //如果需要，就为bean生成代理对象
               return wrapIfNecessary(bean, beanName, cacheKey);
           }
       }
       return bean;
   }
/**
    * 如果需要，包装给定的bean，例如，如果它符合代理的条件。
    *
    * @param bean     原始bean实例
    * @param beanName bean的名称
    * @param cacheKey 用于元数据访问的缓存键
    * @return 包装过的代理类或者原始bean实例
    */
   protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
       // 已经处理过的bean
       if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
           return bean;
       }
       // 不需要增强的bean
       if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
           return bean;
       }
       //基础bean不需要增强：Advice；Pointcut；Advisor；AopInfrastructureBean
       // beanName以beanClassName开头且以“.ORIGINAL”结尾的原始类不需要代理
       if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
           this.advisedBeans.put(cacheKey, Boolean.FALSE);
           return bean;
       }

       // Create proxy if we have advice.
       // 如果存在增强的方法，则创建代理类
       Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);

	// 看这里！！！！
       // DO_NOT_PROXY = 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;
       }

       // 如果没有增强的方法，则返回原始bean实例
       this.advisedBeans.put(cacheKey, Boolean.FALSE);
       return bean;
   }

通过前几天的分析，获取到了上面代码中的specificInterceptors，下面分析创建代理对象方法 createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean))。
发现在分析整个aop流程的时候，已经将创建代理的整个流程分析了一下，但是没有详细的进入：

/**
    * 为给定bean创建AOP代理。
    *
    * @param beanClass            bean class
    * @param beanName             bean名称
    * @param specificInterceptors 特定于此bean的一组拦截器(可能是空的，但不是null)
    * @param targetSource        代理的TargetSource，已经预先配置为访问bean
    * @return the AOP proxy for the bean
    * @see #buildAdvisors
    */
   protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
                                @Nullable Object[] specificInterceptors, TargetSource targetSource) {

       // 如果bean工厂为ConfigurableListableBeanFactory
       if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
           //设置BeanDefinition中的originalTargetClass属性
           AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
       }

       //获取代理工厂
       ProxyFactory proxyFactory = new ProxyFactory();
       //复制配置。
       proxyFactory.copyFrom(this);

       // 决定对给定的 bean 是否应该使用 targetClass 而不是他的接口代理，
       // 检查 proxyTargetClass 设置以及 preserveTargetClass 属性
       if (!proxyFactory.isProxyTargetClass()) {
           if (shouldProxyTargetClass(beanClass, beanName)) {
               proxyFactory.setProxyTargetClass(true);
           } else {
               // 检测 beanClass 是否实现了接口，若未实现，
               // 则将proxyFactory 的成员变量 proxyTargetClass 设为 true
               evaluateProxyInterfaces(beanClass, proxyFactory);
           }
       }

       //确定给定bean的Advisor，包括特定的拦截器和公共拦截器，所有这些都适应于Advisor接口。
       //specificInterceptors 中若包含有 Advice，此处将 Advice 转为 Advisor
       Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
       //加入增强器
       proxyFactory.addAdvisors(advisors);
       //设置要代理的类
       proxyFactory.setTargetSource(targetSource);
       //定制代理
       customizeProxyFactory(proxyFactory);
       // 用来控制代理过程被配置之后，是否还允许修改通知。
       // 默认值为 false （即在代理被配置之后，不允许修改代理的配置）
       proxyFactory.setFrozen(this.freezeProxy);

       // 是否跳过ClassFilter检查
       if (advisorsPreFiltered()) {
           proxyFactory.setPreFiltered(true);
       }
       //创建代理
       return proxyFactory.getProxy(getProxyClassLoader());
   }

流程：

1. 获取当前类中的属性。
2. 添加代理接口。
3. 封装Advisor并加入到ProxyFactory中。
4. 设置要代理的类。
5. 当然在Spring中还为子类提供了定制的函数customizeProxyFactory，子类可以在此函数中对ProxyFactory的进一步封装。
6. 进行获取代理操作

这里主要分析第6步：ProxyFactory的getProxy(@Nullable ClassLoader classLoader)获取代理。

/**
	 * 根据工厂中的设置创建一个新的代理。
	 * 可以反复调用。
     * 如果我们添加或删除了接口，效果会有所不同。
     * 可以添加和删除拦截器。
	 * 使用给定的类加载器(如果需要创建代理)。
	 * @param classLoader the class loader to create the proxy with
	 * (or {@code null} for the low-level proxy facility's default)
	 * @return the proxy object
	 */
	public Object getProxy(@Nullable ClassLoader classLoader) {
	    //首先调用父类ProxyCreatorSupport的createAopProxy()方法获取AopProxy
        //之后getProxy方法获取代理对象
		return createAopProxy().getProxy(classLoader);
	}

这个方法分为两大步骤：

1. 获取AopProxy
2. 获取代理对象
   下面分两块分析。

createAopProxy()

首先调用父类ProxyCreatorSupport的createAopProxy()：

/**
 * 子类应该调用它来获得一个新的AOP代理。 They should <b>not</b>
 * 他们不应该用这个参数创建AOP代理。
 */
protected final synchronized AopProxy createAopProxy() {
    //active在创建第一个AOP代理时设置为true。
	if (!this.active) {
	    //激活代理配置。
           //激活AdvisedSupportListener监听
		activate();
	}
	//分为两步：
       //获取AopProxyFactory，默认为DefaultAopProxyFactory
       //调用createAopProxy(AdvisedSupport config)方法返回AopProxy
	return getAopProxyFactory().createAopProxy(this);
}

在来看DefaultAopProxyFactory的createAopProxy(AdvisedSupport config)方法：

@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
	    //判断是使用JDK的动态代理还是CGLIB代理
	    //optimize：用来控制通过CGLIB创建的代理是否使用激进的优化策略。仅用于CGLIB；
        //proxyTargetClass：这个属性为 true 时，目标类本身本代理而不是目标类的接口，
        //如果这个属性值被设为 true，CGLIB 代理将被创建，
        //设置方式：<aop：aspectj-autoproxy proxy-target-class="true"/>；
        //hasNoUserSuppliedProxyInterfaces：是否存在代理接口；
		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.");
			}
			//如果目标类实现了接口，返回true
            //isProxyClass：当且仅当使用getProxyClass方法或newProxyInstance方法将指定的类动态生成为代理类时，返回true。
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
			    //使用JDK动态代理
				return new JdkDynamicAopProxy(config);
			}
			//使用CGLIB代理，ObjenesisCglibAopProxy 继承 CglibAopProxy
			return new ObjenesisCglibAopProxy(config);
		}
		//上面的条件不满足则使用JDK动态代理
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

这里有三个条件判断，详见代码注释。
贴一张AopProxy的继承关系图：

JDK动态代理JdkDynamicAopProxy

/**
	 * Construct a new JdkDynamicAopProxy for the given AOP configuration.
	 * @param config the AOP configuration as AdvisedSupport object
	 * @throws AopConfigException if the config is invalid. We try to throw an informative
	 * exception in this case, rather than let a mysterious failure happen later.
	 */
	public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
		Assert.notNull(config, "AdvisedSupport must not be null");
		if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
			throw new AopConfigException("No advisors and no TargetSource specified");
		}
		this.advised = config;
	}

CGLIB代理ObjenesisCglibAopProxy

	/**
	 * Create a new ObjenesisCglibAopProxy for the given AOP configuration.
	 * @param config the AOP configuration as AdvisedSupport object
	 */
	public ObjenesisCglibAopProxy(AdvisedSupport config) {
		super(config);
	}
/**
	 * Create a new CglibAopProxy for the given AOP configuration.
	 * @param config the AOP configuration as AdvisedSupport object
	 * @throws AopConfigException if the config is invalid. We try to throw an informative
	 * exception in this case, rather than let a mysterious failure happen later.
	 */
	public CglibAopProxy(AdvisedSupport config) throws AopConfigException {
		Assert.notNull(config, "AdvisedSupport must not be null");
		if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
			throw new AopConfigException("No advisors and no TargetSource specified");
		}
		this.advised = config;
		this.advisedDispatcher = new AdvisedDispatcher(this.advised);
	}

下面分析核心方法，获取代理对象。

getProxy(classLoader)

分为两种：JDK动态代理与CGLIB代理。

JDK动态代理

@Override
	public Object getProxy(@Nullable ClassLoader classLoader) {
		if (logger.isTraceEnabled()) {
			logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
		}
		//确定用于代理给定AOP配置的完整接口集。
		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
		//查找可能在提供的接口集上定义的任何equals或hashCode方法。
		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
		//创建代理对象
		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
	}

最后创建代理对象Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);传入的InvocationHandler是当前类自己，所以看当前类的invoke(Object proxy, Method method, Object[] args) 方法：

/**
	 * 实现{@code InvocationHandler.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]);
			}
			//hashCode方法处理
			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.
                // 只有getDecoratedClass()声明->分派到代理配置。
				return AopProxyUtils.ultimateTargetClass(this.advised);
			}
			else 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;
            // 有时候目标对象内部的自我调用将无法实施切面中的增强
            // 则需要通过属性暴露代理
			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);

			// 获取此方法的拦截链。
			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

			// Check whether we have any advice. If we don't, we can fallback on direct
			// reflective invocation of the target, and avoid creating a MethodInvocation.
			if (chain.isEmpty()) {
				// We can skip creating a MethodInvocation: just invoke the target directly
				// Note that the final invoker must be an InvokerInterceptor so we know it does
				// nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
				Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                // 如果没有发现任何拦截器那么直接调入切点方法
				retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
			}
			else {
				// We need to create a method invocation...
                // 将拦截器封装在 ReflectiveMethodInvocation
                // 以便于使用期 proceed 进行链接表用拦截器
				MethodInvocation invocation =
						new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
				// Proceed to the joinpoint through the interceptor chain.
                // 执行拦截器链
				retVal = invocation.proceed();
			}

			// 返回结果
			// Massage return value if necessary.
			Class<?> returnType = method.getReturnType();
			if (retVal != null && retVal == target &&
					returnType != Object.class && returnType.isInstance(proxy) &&
					!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
				// Special case: it returned "this" and the return type of the method
				// is type-compatible. Note that we can't help if the target sets
				// a reference to itself in another returned object.
				retVal = proxy;
			}
			else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
				throw new AopInvocationException(
						"Null return value from advice does not match primitive return type for: " + method);
			}
			return retVal;
		}
		finally {
			if (target != null && !targetSource.isStatic()) {
				// Must have come from TargetSource.
				targetSource.releaseTarget(target);
			}
			if (setProxyContext) {
				// Restore old proxy.
				AopContext.setCurrentProxy(oldProxy);
			}
		}
	}

在这分析一下ReflectiveMethodInvocation实现的Joinpoint接口中的proceed()方法：

@Override
	@Nullable
	public Object proceed() throws Throwable {
		//	We start with an index of -1 and increment early.
        //  执行完所有增强后执行切点方法
		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
			return invokeJoinpoint();
		}

		// 获取下一个要执行的拦截器
		Object interceptorOrInterceptionAdvice =
				this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
		if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
			// Evaluate dynamic method matcher here: static part will already have
			// been evaluated and found to match.
			InterceptorAndDynamicMethodMatcher dm =
					(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
			Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
			//匹配
			if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
			    // 在这一步会调用增强器，逻辑在内部实现，比如MethodBeforeAdviceInterceptor
				return dm.interceptor.invoke(this);
			}
			else {
				// Dynamic matching failed.
				// Skip this interceptor and invoke the next in the chain.
				return proceed();
			}
		}
		else {
			// It's an interceptor, so we just invoke it: The pointcut will have
			// been evaluated statically before this object was constructed.
			return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
		}
	}

proceed方法负责实现方法前置调用以及后置调用的逻辑处理，然后将工作委托给各个增强器，在增强器内部实现具体逻辑。
比如MethodBeforeAdviceInterceptor内部维护着MethodBeforeAdvice：

@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
		return mi.proceed();
	}

最终会调用到：AspectJMethodBeforeAdvice的before方法。

@Override
	public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
	    //首先，获取JoinPointMatch，在被分派到的连接点上获取当前连接点匹配。
        //之后调用advice方法。
		invokeAdviceMethod(getJoinPointMatch(), null, null);
	}
/**
	 * Invoke the advice method.
	 * @param jpMatch the JoinPointMatch that matched this execution join point
	 * @param returnValue the return value from the method execution (may be null)
	 * @param ex the exception thrown by the method execution (may be null)
	 * @return the invocation result
	 * @throws Throwable in case of invocation failure
	 */
	protected Object invokeAdviceMethod(
			@Nullable JoinPointMatch jpMatch, @Nullable Object returnValue, @Nullable Throwable ex)
			throws Throwable {

		return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));
	}
protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
		Object[] actualArgs = args;
		if (this.aspectJAdviceMethod.getParameterCount() == 0) {
			actualArgs = null;
		}
		try {
			ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
			// TODO AopUtils.invokeJoinpointUsingReflection
			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();
		}
	}

即最终会调用到Method的invoke方法，增强结束。

CGLIB代理

@Override
	public Object getProxy(@Nullable ClassLoader classLoader) {
		if (logger.isTraceEnabled()) {
			logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
		}

		try {
			Class<?> rootClass = this.advised.getTargetClass();
			Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

			Class<?> proxySuperClass = rootClass;
			if (ClassUtils.isCglibProxyClass(rootClass)) {
				proxySuperClass = rootClass.getSuperclass();
				Class<?>[] additionalInterfaces = rootClass.getInterfaces();
				for (Class<?> additionalInterface : additionalInterfaces) {
					this.advised.addInterface(additionalInterface);
				}
			}

			// Validate the class, writing log messages as necessary.
			validateClassIfNecessary(proxySuperClass, classLoader);

			// Configure CGLIB Enhancer...
			Enhancer enhancer = createEnhancer();
			if (classLoader != null) {
				enhancer.setClassLoader(classLoader);
				if (classLoader instanceof SmartClassLoader &&
						((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
					enhancer.setUseCache(false);
				}
			}
			enhancer.setSuperclass(proxySuperClass);
			enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
			enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
			enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));

			// 设置拦截器
			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.
            // 生成代理类以及创建代理，由子类ObjenesisCglibAopProxy实现
			return createProxyClassAndInstance(enhancer, callbacks);
		}
		catch (CodeGenerationException | IllegalArgumentException ex) {
			throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() +
					": Common causes of this problem include using a final class or a non-visible class",
					ex);
		}
		catch (Throwable ex) {
			// TargetSource.getTarget() failed
			throw new AopConfigException("Unexpected AOP exception", ex);
		}
	}

这里面两处重点：getCallbacks(rootClass)与createProxyClassAndInstance(enhancer, callbacks)

getCallbacks(rootClass)

private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
        // 对于 expose-proxy 属性的处理
		boolean exposeProxy = this.advised.isExposeProxy();
		boolean isFrozen = this.advised.isFrozen();
		boolean isStatic = this.advised.getTargetSource().isStatic();

		// Choose an "aop" interceptor (used for AOP calls).
		Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);

		// Choose a "straight to target" interceptor. (used for calls that are
		// unadvised but can return this). May be required to expose the proxy.
		Callback targetInterceptor;
		if (exposeProxy) {
			targetInterceptor = (isStatic ?
					new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
					new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource()));
		}
		else {
			targetInterceptor = (isStatic ?
					new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
					new DynamicUnadvisedInterceptor(this.advised.getTargetSource()));
		}

		// Choose a "direct to target" dispatcher (used for
		// unadvised calls to static targets that cannot return this).
		Callback targetDispatcher = (isStatic ?
				new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp());

		Callback[] mainCallbacks = new Callback[] {
				aopInterceptor,  // for normal advice
				targetInterceptor,  // invoke target without considering advice, if optimized
				new SerializableNoOp(),  // no override for methods mapped to this
				targetDispatcher, this.advisedDispatcher,
				new EqualsInterceptor(this.advised),
				new HashCodeInterceptor(this.advised)
		};

		Callback[] callbacks;

		// If the target is a static one and the advice chain is frozen,
		// then we can make some optimizations by sending the AOP calls
		// direct to the target using the fixed chain for that method.
		if (isStatic && isFrozen) {
			Method[] methods = rootClass.getMethods();
			Callback[] fixedCallbacks = new Callback[methods.length];
			this.fixedInterceptorMap = new HashMap<>(methods.length);

			// TODO: small memory optimization here (can skip creation for methods with no advice)
			for (int x = 0; x < methods.length; x++) {
				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(methods[x], rootClass);
				fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
						chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
				this.fixedInterceptorMap.put(methods[x].toString(), x);
			}

			// Now copy both the callbacks from mainCallbacks
			// and fixedCallbacks into the callbacks array.
			callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
			System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
			System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
			this.fixedInterceptorOffset = mainCallbacks.length;
		}
		else {
			callbacks = mainCallbacks;
		}
		return callbacks;
	}

createProxyClassAndInstance(enhancer, callbacks)

@Override
	protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
		Class<?> proxyClass = enhancer.createClass();
		Object proxyInstance = null;

		if (objenesis.isWorthTrying()) {
			try {
				proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
			}
			catch (Throwable ex) {
				logger.debug("Unable to instantiate proxy using Objenesis, " +
						"falling back to regular proxy construction", ex);
			}
		}

		if (proxyInstance == null) {
			// Regular instantiation via default constructor...
			try {
				Constructor<?> ctor = (this.constructorArgs != null ?
						proxyClass.getDeclaredConstructor(this.constructorArgTypes) :
						proxyClass.getDeclaredConstructor());
				ReflectionUtils.makeAccessible(ctor);
				proxyInstance = (this.constructorArgs != null ?
						ctor.newInstance(this.constructorArgs) : ctor.newInstance());
			}
			catch (Throwable ex) {
				throw new AopConfigException("Unable to instantiate proxy using Objenesis, " +
						"and regular proxy instantiation via default constructor fails as well", ex);
			}
		}

		((Factory) proxyInstance).setCallbacks(callbacks);
		return proxyInstance;
	}

到此就把代理的对象获取到了。