Spring Bean方法反射调用行为不一致问题分析

public Object getProxy(ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
    	logger.debug("Creating CGLIB proxy: target source is " + 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 UndeclaredThrowableStrategy(UndeclaredThrowableException.class));
        
        //获取方法调用时的拦截
    	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);
    }

private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
    // Parameters used for optimisation choices...
    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组成元素
    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 optimisations 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<String, Integer>(methods.length);

    	// TODO: small memory optimisation 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;
}

public int accept(Method method) {
	if (AopUtils.isFinalizeMethod(method)) {
		logger.debug("Found finalize() method - using NO_OVERRIDE");
		return NO_OVERRIDE;
	}
	if (!this.advised.isOpaque() && method.getDeclaringClass().isInterface() &&
			method.getDeclaringClass().isAssignableFrom(Advised.class)) {
		if (logger.isDebugEnabled()) {
			logger.debug("Method is declared on Advised interface: " + method);
		}
		return DISPATCH_ADVISED;
	}
	// We must always proxy equals, to direct calls to this.
	if (AopUtils.isEqualsMethod(method)) {
		logger.debug("Found 'equals' method: " + method);
		return INVOKE_EQUALS;
	}
	// We must always calculate hashCode based on the proxy.
	if (AopUtils.isHashCodeMethod(method)) {
		logger.debug("Found 'hashCode' method: " + method);
		return INVOKE_HASHCODE;
	}
	Class<?> targetClass = this.advised.getTargetClass();
	// Proxy is not yet available, but that shouldn't matter.
	List<?> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
	boolean haveAdvice = !chain.isEmpty();
	boolean exposeProxy = this.advised.isExposeProxy();
	boolean isStatic = this.advised.getTargetSource().isStatic();
	boolean isFrozen = this.advised.isFrozen();
	if (haveAdvice || !isFrozen) {
		// If exposing the proxy, then AOP_PROXY must be used.
		if (exposeProxy) {
			if (logger.isDebugEnabled()) {
				logger.debug("Must expose proxy on advised method: " + method);
			}
			return AOP_PROXY;
		}
		String key = method.toString();
		// Check to see if we have fixed interceptor to serve this method.
		// Else use the AOP_PROXY.
		if (isStatic && isFrozen && this.fixedInterceptorMap.containsKey(key)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Method has advice and optimisations are enabled: " + method);
			}
			// We know that we are optimising so we can use the
			// FixedStaticChainInterceptors.
			int index = this.fixedInterceptorMap.get(key);
			return (index + this.fixedInterceptorOffset);
		}
		else {
			if (logger.isDebugEnabled()) {
				logger.debug("Unable to apply any optimisations to advised method: " + method);
			}
			return AOP_PROXY;
		}
	}
	else {
		// See if the return type of the method is outside the class hierarchy
		// of the target type. If so we know it never needs to have return type
		// massage and can use a dispatcher.
		// If the proxy is being exposed, then must use the interceptor the
		// correct one is already configured. If the target is not static, then
		// cannot use a dispatcher because the target cannot be released.
		if (exposeProxy || !isStatic) {
			return INVOKE_TARGET;
		}
		Class<?> returnType = method.getReturnType();
		if (targetClass == returnType) {
			if (logger.isDebugEnabled()) {
				logger.debug("Method " + method +
						"has return type same as target type (may return this) - using INVOKE_TARGET");
			}
			return INVOKE_TARGET;
		}
		else if (returnType.isPrimitive() || !returnType.isAssignableFrom(targetClass)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Method " + method +
						" has return type that ensures this cannot be returned- using DISPATCH_TARGET");
			}
			return DISPATCH_TARGET;
		}
		else {
			if (logger.isDebugEnabled()) {
				logger.debug("Method " + method +
						"has return type that is assignable from the target type (may return this) - " +
						"using INVOKE_TARGET");
			}
			return INVOKE_TARGET;
		}
	}
}

public class VideoAccessServiceImpl$$EnhancerBySpringCGLIB$$4d078710
  extends VideoAccessServiceImpl
  implements SpringProxy, Advised, Factory{
    public final boolean saveVideo(String paramString)
    {
      try
      {
        MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
        if (tmp4_1 == null)
        {
          tmp4_1;
          CGLIB$BIND_CALLBACKS(this);
        }
        MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
        if (tmp17_14 != null)
        {
          Object tmp41_36 = tmp17_14.intercept(this, CGLIB$saveVideo$0$Method, new     Object[] { paramString }, CGLIB$saveVideo$0$Proxy);
          tmp41_36;
          return tmp41_36 == null ? false : ((Boolean)tmp41_36).booleanValue();
        }
        return super.saveVideo(paramString);
      }
      catch (RuntimeException|Error localRuntimeException)
      {
        throw localRuntimeException;
      }
      catch (Throwable localThrowable)
      {
        throw new UndeclaredThrowableException(localThrowable);
      }
    }
  }