浅谈SPRING AOP

一、什么是AOP

 AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

二、AOP中的相关概念

1、这里还是先给出一个比较专业的概念定义：

1）Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

2）Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。

3）Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。

4）Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

5）Target（目标对象）：织入 Advice 的目标对象.。

6）AOP Proxy（AOP代理）： AOP框架创建的对象，包含通知。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

7）Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程。 组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

 

2、SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：

1）before advice：在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码)

2）after return advice：在一个 join point 正常返回后执行的 advice

3）around advice： 在 join point 前和 joint point 退出后都执行的 advice. 这个是最常用的 advice.

4）after throwing advice： 当一个 join point 抛出异常后执行的 advice5）introduction：introduction可以为原有的对象增加新的属性和方法。

三、Spring AOP组件

 

四、走进部分源码、流程说明

1、spring 容器启动

1.1. 每个bean的实例化之前都会先经过AbstractAutoProxyCreator类的postProcessAfterInitialization（）这个方法，然后接下来是调用wrapIfNecessary方法。

/** * Create a proxy with the configured interceptors if the bean is * identified as one to proxy by the subclass. * 如果bean被子类标识为要代理的bean，则使用配置的拦截器创建一个代理。 * @see #getAdvicesAndAdvisorsForBean */ @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean != null) { Object cacheKey = getCacheKey(bean.getClass(), beanName); if (!this.earlyProxyReferences.contains(cacheKey)) { return wrapIfNecessary(bean, beanName, cacheKey); } } return bean; }

1.2. 进入wrapIfNecessary方法后，我们直接看重点实现逻辑的方法getAdvicesAndAdvisorsForBean,这个方法会提取当前bean 的所有增强方法，然后获取到适合的当前bean 的增强方法，然后对增强方法进行排序，最后返回

/** * Wrap the given bean if necessary, i.e. if it is eligible for being proxied.   * 如有必要，包装给定的bean，即如果它有资格被代理 * @param bean the raw bean instance * @param beanName the name of the bean * @param cacheKey the cache key for metadata access * @return a proxy wrapping the bean, or the raw bean instance as-is */ protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { if (beanName != null && this.targetSourcedBeans.contains(beanName)) { return bean; } if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { return bean; } 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);------>提取当前bean 的所有增强方法 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; } this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; }

2、创建代理

获取到当前bean的增强方法后，便调用createProxy方法，先创建代理工厂proxyFactory，然后获取当前bean 的增强器advisors，把当前获取到的增强器添加到代理工厂proxyFactory，然后设置当前的代理工的代理目标对象为当前bean，最后根据配置创建JDK的动态代理工厂，或者CGLIB的动态代理工厂，然后返回proxyFactory

/** * Create an AOP proxy for the given bean. * @param beanClass the class of the bean * @param beanName the name of the bean * @param specificInterceptors the set of interceptors that is * specific to this bean (may be empty, but not null) * @param targetSource the TargetSource for the proxy, * already pre-configured to access the bean * @return the AOP proxy for the bean * @see #buildAdvisors */ protected Object createProxy( Class beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) { if (this.beanFactory instanceof ConfigurableListableBeanFactory) { AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass); } ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.copyFrom(this); if (!proxyFactory.isProxyTargetClass()) { if (shouldProxyTargetClass(beanClass, beanName)) { proxyFactory.setProxyTargetClass(true); } else { evaluateProxyInterfaces(beanClass, proxyFactory); } } Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); for (Advisor advisor : advisors) { proxyFactory.addAdvisor(advisor); } proxyFactory.setTargetSource(targetSource); customizeProxyFactory(proxyFactory); proxyFactory.setFrozen(this.freezeProxy); if (advisorsPreFiltered()) { proxyFactory.setPreFiltered(true); } return proxyFactory.getProxy(getProxyClassLoader());----->4 }

3、关于AOP的动态代理执行

有两种主要的方式JDK的动态代理和CGLIB的动态代理，接下来，我们先来看看AOP动态代理的实现选择方式，先上核心实现代码：

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { 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."); } if (targetClass.isInterface()) { return new JdkDynamicAopProxy(config); } return CglibProxyFactory.createCglibProxy(config); } else { return new JdkDynamicAopProxy(config); } }

4、spring jdk动态代理实现

4.1. 获取代理类要实现的接口：

/** * * 获取代理类要实现的接口,除了Advised对象中配置的,还会加上SpringProxy, Advised(opaque=false) * 检查上面得到的接口中有没有定义 equals或者hashcode的接口  * 调用Proxy.newProxyInstance创建代理对象  * */ 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); }

4.2. 下面的问题是，代理对象生成了，那切面是如何织入的？

我们知道InvocationHandler是JDK动态代理的核心，生成的代理对象的方法调用都会委托到InvocationHandler.invoke()方法。而通过JdkDynamicAopProxy的签名我们可以看到这个类其实也实现了InvocationHandler，下面我们就通过分析这个类中实现的invoke()方法来具体看下Spring AOP是如何织入切面的。

public Object invoke(Object proxy, Method method, Object[] args) throwsThrowable { MethodInvocation invocation = null; Object oldProxy = null; boolean setProxyContext = false; TargetSource targetSource = this.advised.targetSource; Class targetClass = null; Object target = null; try { //eqauls()方法，具目标对象未实现此方法  if (!this.equalsDefined && AopUtils.isEqualsMethod(method)){ return (equals(args[0])? Boolean.TRUE : Boolean.FALSE); } //hashCode()方法，具目标对象未实现此方法  if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)){ return newInteger(hashCode()); } //Advised接口或者其父接口中定义的方法,直接反射调用,不应用通知  if (!this.advised.opaque &&method.getDeclaringClass().isInterface() &&method.getDeclaringClass().isAssignableFrom(Advised.class)) { // Service invocations onProxyConfig with the proxy config...  return AopUtils.invokeJoinpointUsingReflection(this.advised,method, args); } Object retVal = null; if (this.advised.exposeProxy) { // Make invocation available ifnecessary.  oldProxy = AopContext.setCurrentProxy(proxy); setProxyContext = true; } //获得目标对象的类  target = targetSource.getTarget(); if (target != null) { targetClass = target.getClass(); } //获取可以应用到此方法上的Interceptor列表  List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method,targetClass);------->可查看 //如果没有可以应用到此方法的通知(Interceptor)，此直接反射调用 method.invoke(target, args)  if (chain.isEmpty()) { retVal = AopUtils.invokeJoinpointUsingReflection(target,method, args); } else { //创建MethodInvocation  invocation = newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain); retVal = invocation.proceed();----->创建MethodInvocation，调用其proceed方法，触发拦截器链的执行 } // Massage return value if necessary.  if (retVal != null && retVal == target &&method.getReturnType().isInstance(proxy) &&!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) { // Special case: it returned"this" and the return type of the method // is type-compatible. Notethat we can't help if the target sets // a reference to itself inanother returned object.  retVal = proxy; } return retVal; } finally { if (target != null && !targetSource.isStatic()) { // Must have come fromTargetSource.  targetSource.releaseTarget(target); } if (setProxyContext) { // Restore old proxy.  AopContext.setCurrentProxy(oldProxy); } } }

主流程可以简述为：获取可以应用到此方法上的通知链（Interceptor Chain）,

如果有,则应用通知,并执行joinpoint;

如果没有,则直接反射执行joinpoint。

4.3.  而这里的关键是通知链是如何获取的以及它又是如何执行的，下面逐一分析下。

/** * Determine a list of {@link org.aopalliance.intercept.MethodInterceptor} objects * for the given method, based on this configuration. * @param method the proxied method * @param targetClass the target class * @return List of MethodInterceptors (may also include InterceptorAndDynamicMethodMatchers) */ public List

可以看到实际的获取工作其实是由AdvisorChainFactory. getInterceptorsAndDynamicInterceptionAdvice()这个方法来完成的，获取到的结果会被缓存。

4.4.这个方法执行完成后，Advised中配置能够应用到连接点或者目标类的Advisor全部被转化成了MethodInterceptor.

/** * 从提供的配置实例config中获取advisor列表,遍历处理这些advisor.如果是IntroductionAdvisor, * 则判断此Advisor能否应用到目标类targetClass上.如果是PointcutAdvisor,则判断  * 此Advisor能否应用到目标方法method上.将满足条件的Advisor通过AdvisorAdaptor转化成Interceptor列表返回. */ public List getInterceptorsAndDynamicInterceptionAdvice(Advised config, Methodmethod, Class targetClass) { // This is somewhat tricky... we have to process introductions first, // but we need to preserve order in the ultimate list.  List interceptorList = new ArrayList(config.getAdvisors().length); //查看是否包含IntroductionAdvisor  boolean hasIntroductions = hasMatchingIntroductions(config,targetClass); //这里实际上注册一系列AdvisorAdapter,用于将Advisor转化成MethodInterceptor  AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance(); Advisor[] advisors = config.getAdvisors(); for (int i = 0; i

4.5. 接下来回到invoke方法中的proceed方法 ，我们再看下得到的拦截器链是怎么起作用的，也就是proceed方法的执行过程

public Object proceed() throws Throwable { // We start with an index of -1and increment early.  if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size()- 1) { //如果Interceptor执行完了，则执行joinPoint  return invokeJoinpoint(); } Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex); //如果要动态匹配joinPoint  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)) { //执行当前Intercetpor  returndm.interceptor.invoke(this); } else { //动态匹配失败时,略过当前Intercetpor,调用下一个Interceptor  return proceed(); } } else { // It's an interceptor, so we just invoke it: The pointcutwill have // been evaluated statically before this object was constructed. //执行当前Intercetpor  return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); } }

5、Spring CGLIB动态代理实现

 这两个代理的实现方式都差不多，都是创建方法调用链，不同的是jdk的动态代理创建的是

ReflectiveMethodInvocation调用链，而cglib创建的是Cglib MethodInvocation。

五、使用Spring实现Aop

1、第一种方式，通过 Spring API 实现

1.1. 首先编写我们的业务接口和实现类

业务接口	实现类
public interface UserService { public void add(); public void delete(); public void update(); public void search(); }	public class UserServiceImpl implements UserService{ @Override  public void add() { System.out.println("增加用户"); } @Override  public void delete() { System.out.println("删除用户"); } @Override  public void update() { System.out.println("更新用户"); } @Override  public void search() { System.out.println("查询用户"); } }

1.2. 然后去写我们的增强类 , 我们编写两个 , 一个前置增强 一个后置增强

前置增强	后置增强
public class Log implements MethodBeforeAdvice { //method : 要执行的目标对象的方法  //objects : 被调用的方法的参数  //Object : 目标对象  @Override  public void before(Method method, Object[] objects, Object o) throws Throwable { System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了"); } }	public class AfterLog implements AfterReturningAdvice { //returnValue 返回值  //method被调用的方法  //args 被调用的方法的对象的参数  //target 被调用的目标对象  @Override  public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { System.out.println("执行了" + target.getClass().getName() +"的"+method.getName()+"方法,"  +"返回值："+returnValue); } }

1.3. 最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .

bean.xml

2、第二种方式，自定义类来实现Aop

2.1. 目标业务类不变依旧是userServiceImpl

2.2. 写我们自己的一个切入类

切入类
public class DiyPointcut { public void before(){ System.out.println("---------方法执行前---------"); } public void after(){ System.out.println("---------方法执行后---------"); } }

2.3.去spring中配置

bean.xml

3、第三种方式，使用注解实现

3.1. 目标业务类不变依旧是userServiceImpl

3.2. 编写一个注解实现的增强类

增强类

@Aspect public class AnnotationPointcut { @Before("execution(* com.kuang.service.UserServiceImpl.*(..))") public void before(){ System.out.println("---------方法执行前---------"); } @After("execution(* com.kuang.service.UserServiceImpl.*(..))") public void after(){ System.out.println("---------方法执行后---------"); } @Around("execution(* com.kuang.service.UserServiceImpl.*(..))") public void around(ProceedingJoinPoint jp) throws Throwable { System.out.println("环绕前"); System.out.println("签名:"+jp.getSignature()); //执行目标方法proceed  Object proceed = jp.proceed(); System.out.println("环绕后"); System.out.println(proceed); } }

3.3.在Spring配置文件中，注册bean，并增加支持注解的配置

bean.xml	aop:aspectj-autoproxy：说明
bean.xml	aop:aspectj-autoproxy：说明
	通过aop命名空间的声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被隐藏起来了 有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

参考资料：

(5条消息) 狂神说Spring07：AOP就这么简单_狂神说-CSDN博客_狂神aop

(5条消息) 细说Spring——AOP详解（AOP概览）_啦啦啦的博客-CSDN博客_aop

(5条消息) Spring AOP实现原理简介_wyl6019的博客-CSDN博客

(5条消息) Spring AOP 实现原理_KevinJom的专栏-CSDN博客

【狂神说Java】通俗易懂的23种设计模式教学（动态代理）_哔哩哔哩_bilibili

Spring AOP二次封装实战, 面试阿里50W年薪岗必备技术（包含程序员职业生涯讲解）_哔哩哔哩_bilibili