Spring AOP实现原理

最新推荐文章于 2025-08-04 21:50:32 发布

原创最新推荐文章于 2025-08-04 21:50:32 发布 · 304 阅读

0 ·

CC 4.0 BY-SA版权

Spring框架学习专栏收录该内容

4 篇文章

订阅专栏

本文介绍了Spring AOP的实现原理，主要依赖于动态代理。对于实现了接口的目标对象，Spring采用JDK动态代理；而对于未实现接口的对象，使用CGLIB库。详细讲解了JdkDynamicAopProxy类中的invoke方法，它是AOP代理的核心，负责调用拦截器链并执行目标方法。此外，还简单提及了CGLIB代理的工作方式。

AOP是在面向对象编程OOP下引入公共行为，导致一系列相同代码，如日志，安全检测等下产生的一种横向切面方法。

那么Spring中的aop关键是如何实现的？

Spring主要对添加了@Aspect注解的类进行切面实现，根据以下方法

通过反射对注解类的进行缓存加载

存储在map中，通过判断是否存在value。

主要通过代理进行切面：

生成响应的代理创建。

如果目标对象实现了接口，默认会以Jdk动态代理实现AOP（可强制使用为Cglib）

如果目标没有实现接口，则必须使用Cglib库

JDK动态代理：案例

新建一个接口

package com.spring.aspect;

public interface TestService {

   void test();

}

实现方法：

package com.spring.aspect;

public class TestServiceImpl implements TestService {

   @Override
   public void test() {
       System.out.println("test");

}

}
代理：

package com.spring.aspect;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class TestInvocationHandler implements InvocationHandler{

   //目标对象
   private Object target;

   //构造方法
   public TestInvocationHandler(Object target) {
       super();
       this.target = target;

   }


   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       // TODO Auto-generated method stub

       System.out.println("before test");

       method.invoke(target,args);

       System.out.println("after test");
       return null;
   }

}
测试代理类实现：

package com.spring.aspect;

import java.lang.reflect.Proxy;

public class ProxyTest {

   public static void main(String[] args) {
// 需要代理的对象
       TestService tmp =    new TestServiceImpl();

       //代理的处理器
       TestInvocationHandler t = new TestInvocationHandler(tmp);
       //通过Proxy的newProxyInstance方法创建代理对象，
       TestService res = (TestService) Proxy.newProxyInstance(tmp.getClass().getClassLoader(), tmp.getClass().getInterfaces(), t);

       res.test();
   }

}

测试结果：

通过动态代理实现了AOP的基本方法。

从Spring的动态代理类的源码中如下：

package org.springframework.aop.framework;

import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;

import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.aop.AopInvocationException;
import org.springframework.aop.RawTargetAccess;
import org.springframework.aop.TargetSource;
import org.springframework.aop.support.AopUtils;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;

/**
* JDK-based {@link AopProxy} implementation for the Spring AOP framework,
* based on JDK {@link java.lang.reflect.Proxy dynamic proxies}.
*
* Creates a dynamic proxy, implementing the interfaces exposed by
* the AopProxy. Dynamic proxies cannot be used to proxy methods
* defined in classes, rather than interfaces.
*
* Objects of this type should be obtained through proxy factories,
* configured by an {@link AdvisedSupport} class. This class is internal
* to Spring's AOP framework and need not be used directly by client code.
*
* Proxies created using this class will be thread-safe if the
* underlying (target) class is thread-safe.
*
* Proxies are serializable so long as all Advisors (including Advices
* and Pointcuts) and the TargetSource are serializable.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @author Rob Harrop
* @author Dave Syer
* @see java.lang.reflect.Proxy
* @see AdvisedSupport
* @see ProxyFactory
*/
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

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

   /*
   * NOTE: We could avoid the code duplication between this class and the CGLIB
   * proxies by refactoring "invoke" into a template method. However, this approach
   * adds at least 10% performance overhead versus a copy-paste solution, so we sacrifice
   * elegance for performance. (We have a good test suite to ensure that the different
   * proxies behave the same :-)
   * This way, we can also more easily take advantage of minor optimizations in each class.
   */

/** We use a static Log to avoid serialization issues */
private static final Log logger = LogFactory.getLog(JdkDynamicAopProxy.class);

/** Config used to configure this proxy */
private final AdvisedSupport advised;

   /**
   * Is the {@link #equals} method defined on the proxied interfaces?
   */
   private boolean equalsDefined;

   /**
   * Is the {@link #hashCode} method defined on the proxied interfaces?
   */
   private boolean hashCodeDefined;

   /**
   * 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;
   }

@Override
public Object getProxy() {

//通过Proxy的newProxyInstance方法创建代理对象，即该方法进行了实现
return getProxy(ClassUtils.getDefaultClassLoader());
}

@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);
}

/**
 * Finds any {@link #equals} or {@link #hashCode} method that may be defined
 * on the supplied set of interfaces.
 * @param proxiedInterfaces the interfaces to introspect
 */
 private void findDefinedEqualsAndHashCodeMethods(Class<?>[] proxiedInterfaces) {
 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;
 }
 }
 }
 }

/**
 * Implementation of {@code InvocationHandler.invoke}.
 * Callers will see exactly the exception thrown by the target,
 * unless a hook method throws an exception.
 */
 @Override
 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;

           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();
           }

// Get the interception chain for this method.
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.
               retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
           }
           else {
               // We need to create a method invocation...
               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.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);
 }
 }
 }

/**
 * Equality means interfaces, advisors and TargetSource are equal.
 * The compared object may be a JdkDynamicAopProxy instance itself
 * or a dynamic proxy wrapping a JdkDynamicAopProxy instance.
 */
 @Override
 public boolean equals(Object other) {
 if (other == this) {
 return true;
 }
 if (other == null) {
 return false;
 }

       JdkDynamicAopProxy otherProxy;
       if (other instanceof JdkDynamicAopProxy) {
           otherProxy = (JdkDynamicAopProxy) other;
       }
       else if (Proxy.isProxyClass(other.getClass())) {
           InvocationHandler ih = Proxy.getInvocationHandler(other);
           if (!(ih instanceof JdkDynamicAopProxy)) {
               return false;
           }
           otherProxy = (JdkDynamicAopProxy) ih;
       }
       else {
           // Not a valid comparison...
           return false;
       }

       // If we get here, otherProxy is the other AopProxy.
       return AopProxyUtils.equalsInProxy(this.advised, otherProxy.advised);
   }

   /**
   * Proxy uses the hash code of the TargetSource.
   */
   @Override
   public int hashCode() {
       return JdkDynamicAopProxy.class.hashCode() * 13 + this.advised.getTargetSource().hashCode();
   }

}

可以推断出SpringJDK动态代理的原理：首先找到有@Aspect注释的切面类，其次找到需要进行切面的类方法，将该方法装换成AdvisedSupport对象，生成JdkDynamicAopProxy动态代理类，修改invoke方法,对其进行切面处理，通过getProxy方法生成代理对象，然后执行代理对象的方法。

那么JdkDynamicAopProxy里的invoke函数实现过程如何？

   @Override
   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;

// method.getDeclaringClass().isAssignableFrom(Advised.class)如果调用method类与参数Advised的类相同则返回true
           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;

// Get the interception chain for this method.获取当前方法的拦截器
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.
               retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
           }
           else {
               // We need to create a method invocation...生成拦截器封装成ReflectiveMethodInvocation
               invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
               // Proceed to the joinpoint through the interceptor chain.执行拦截器，创建出了拦截链后逐一执行
               retVal = invocation.proceed();
           }

   @Override
   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;
           if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
               return dm.interceptor.invoke(this);//对其进行执行invoke方法实现aop
           }
           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);
       }
   }

Cglib代理：

什么是CGLIB？

CGLIB是一个强大的高性能的代码生成包。它广泛的被许多AOP的框架使用，例如Spring AOP为他们提供

方法的interception（拦截）。

java实现案列：

创建一个无接口的实现类：

package com.spring.aspect;

import org.springframework.cglib.proxy.Enhancer;

public class EnhanceDemo {

   public void test() {
       System.out.println("测试");
   }

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       Enhancer tmp = new Enhancer();
       tmp.setSuperclass(EnhanceDemo.class);
       tmp.setCallback(new MethodInterceptorImpl());

       EnhanceDemo demo = (EnhanceDemo) tmp.create();
       demo.test();
   }

}
创建对应的代理：

package com.spring.aspect;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class MethodInterceptorImpl implements MethodInterceptor {

   @Override
   public Object intercept(Object obj, Method method, Object[] aobj, MethodProxy methodproxy) throws Throwable {
       // TODO Auto-generated method stub
       System.out.println("before");
       methodproxy.invokeSuper(obj, aobj);
       System.out.println("after");
       return null;
   }

}

最终生成结果如下：