devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring AOP详细介绍

作者：weixin_40725706 | 2024-06-28 17:19:14

赞

踩

spring aop

什么是AOP

        AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

       而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

一 AOP的基本概念

  • (1)Aspect(切面):通常是一个类，里面可以定义切入点和通知
  • (2)JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用
  • (3)Advice(通知):AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,afterThrowing,around
  • (4)Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式
  • (5)AOP代理：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

通知方法:

  1. 前置通知:在我们执行目标方法之前运行(@Before)
  2. 后置通知:在我们目标方法运行结束之后 ,不管有没有异常(@After)
  3. 返回通知:在我们的目标方法正常返回值后运行(@AfterReturning)
  4. 异常通知:在我们的目标方法出现异常后运行(@AfterThrowing)
  5. 环绕通知:动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知, 执行之后就相当于我们后置通知(@Around)

二 Spring AOP

       Spring中的AOP代理还是离不开Spring的IOC容器，代理的生成，管理及其依赖关系都是由IOC容器负责，Spring默认使用JDK动态代理，在需要代理类而不是代理接口的时候，Spring会自动切换为使用CGLIB代理，不过现在的项目都是面向接口编程，所以JDK动态代理相对来说用的还是多一些。

三 基于注解的AOP配置方式

切面类：

  1. package com.enjoy.cap10.aop;
  2.  
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.AfterReturning;
  6. import org.aspectj.lang.annotation.AfterThrowing;
  7. import org.aspectj.lang.annotation.Before;
  8. import org.aspectj.lang.annotation.Pointcut;
  9. import org.aspectj.lang.annotation.Around;
  10. import org.aspectj.lang.annotation.Aspect;
  11.  
  12. //日志切面类
  13. @Aspect
  14. public class LogAspects {
  15. 	@Pointcut("execution(public int com.enjoy.cap10.aop.Calculator.*(..))")
  16. 	public void pointCut(){};
  17. 	
  18. 	//@before代表在目标方法执行前切入, 并指定在哪个方法前切入
  19. 	@Before("pointCut()")
  20. 	public void logStart(){
  21. 		System.out.println("除法运行....参数列表是:{}");
  22. 	}
  23. 	@After("pointCut()")
  24. 	public void logEnd(){
  25. 		System.out.println("除法结束......");
  26. 	}
  27. 	@AfterReturning("pointCut()")
  28. 	public void logReturn(){
  29. 		System.out.println("除法正常返回......运行结果是:{}");
  30. 	}
  31. 	@AfterThrowing("pointCut()")
  32. 	public void logException(){
  33. 		System.out.println("运行异常......异常信息是:{}");
  34. 	}
  35. 	@Around("pointCut()")
  36. 	public Object Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
  37. 		System.out.println("@Arount:执行目标方法之前...");
  38. 		Object obj = proceedingJoinPoint.proceed();//相当于开始调div地
  39. 		System.out.println("@Arount:执行目标方法之后...");
  40. 		return obj;
  41. 	}
  42. }

目标方法：

  1. package com.enjoy.cap10.aop;
  2.  
  3. public class Calculator {
  4. 	//业务逻辑方法
  5. 	public int div(int i, int j){
  6. 		System.out.println("--------");
  7. 		return i/j;
  8. 	}
  9. }

配置类：

  1. package com.enjoy.cap10.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.EnableAspectJAutoProxy;
  6.  
  7. import com.enjoy.cap10.aop.Calculator;
  8. import com.enjoy.cap10.aop.LogAspects;
  9.  
  10. @Configuration
  11. @EnableAspectJAutoProxy
  12. public class Cap10MainConfig {
  13. 	@Bean
  14. 	public Calculator calculator(){
  15. 		return new Calculator();
  16. 	}
  17.  
  18. 	@Bean
  19. 	public LogAspects logAspects(){
  20. 		return new LogAspects();
  21. 	}
  22. }

测试类：

  1. public class Cap10Test {
  2. 	@Test
  3. 	public void test01(){
  4. 		AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap10MainConfig.class);	
  5. 		Calculator c = app.getBean(Calculator.class);
  6. 		int result = c.div(4, 3);
  7. 		System.out.println(result);
  8. 		app.close();
  9.  
  10. 	}
  11. }

结果：

  1. @Arount:执行目标方法之前...
  2. 除法运行....参数列表是:{}
  3. --------
  4. @Arount:执行目标方法之后...
  5. 除法结束......
  6. 除法正常返回......运行结果是:{}
  7. 1

AOP源码赏析

在这个注解比较流行的年代里,当我们想要使用spring 的某些功能时只需要加上一行代码就可以了,比如:

  • @EnableAspectJAutoProxy开启AOP
  • @EnableTransactionManagement开启spring事务管理,
  • @EnableCaching开启spring缓存
  • @EnableWebMvc 开启webMvc

        对于我们使用者而言十分简单便利,然而,其背后所做的事,却远远比一个注解复杂的多了,本篇只是简略的介绍一下@EnableAspectJAutoProxy背后所发生的那些事,了解其工作原理,才能更好的运用,并从中领略大师的智慧.

废话不多说,先来看一下源码:

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Import(AspectJAutoProxyRegistrar.class)
  5. public @interface EnableAspectJAutoProxy {
  6.  
  7.     /**
  8.      * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
  9.      * to standard Java interface-based proxies. The default is {@code false}.
  10.      */
  11.     boolean proxyTargetClass() default false;
  12.  
  13.     /**
  14.      * Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
  15.      * for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
  16.      * Off by default, i.e. no guarantees that {@code AopContext} access will work.
  17.      * @since 4.3.1
  18.      */
  19.     boolean exposeProxy() default false;
  20.  
  21. }

       英文注解已经很详细了,这里简单介绍一下两个参数,一个是控制aop的具体实现方式,为true 的话使用cglib,为false的话使用java的Proxy,默认为false,第二个参数控制代理的暴露方式,解决内部调用不能使用代理的场景，默认为false.

这里核心是@Import(AspectJAutoProxyRegistrar.class);在AspectJAutoProxyRegistrar里,核心的地方是

AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

       一个AOP的工具类,这个工具类的主要作用是把AnnotationAwareAspectJAutoProxyCreator这个类定义为BeanDefinition放到spring容器中,这是通过实现ImportBeanDefinitionRegistrar接口来装载的,具体装载过程不是本篇的重点,这里就不赘述,我们重点看AnnotationAwareAspectJAutoProxyCreator这个类.

首先看看这个类图:

        从类图是可以大致了解AnnotationAwareAspectJAutoProxyCreator这个类的功能.它实现了一系列Aware的接口,在Bean装载的时候获取BeanFactory(Bean容器),Bean的ClassLoader,还实现了order接口,继承了PorxyConfig,ProxyConfig中主要封装了代理的通用处理逻辑,比如设置目标类,设置使用cglib还是java proxy等一些基础配置.

       而能够让这个类参与到bean初始化功能,并为bean添加代理功能的还是因为它实现了BeanPostProcessor这个接口.这个接口的postProcessAfterInitialization方法会在bean初始化结束后(赋值完成)被调用。

这里先看一下最顶部的抽象类:AbstractAutoProxyCreator,这个抽象类主要抽象了实现代理的逻辑:

  1. @Override
  2. 	public Object postProcessBeforeInitialization(Object bean, String beanName) {
  3. 		return bean;
  4. 	}
  5.  
  6.     // 主要看这个方法，在bean初始化之后对生产出的bean进行包装
  7. 	@Override
  8. 	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  9. 		if (bean != null) {
  10. 			Object cacheKey = getCacheKey(bean.getClass(), beanName);
  11. 			if (!this.earlyProxyReferences.contains(cacheKey)) {
  12. 				return wrapIfNecessary(bean, beanName, cacheKey);
  13. 			}
  14. 		}
  15. 		return bean;
  16. 	}
  17.  
  18.     // wrapIfNecessary
  19. 	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
  20. 		if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
  21. 			return bean;
  22. 		}
  23. 		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
  24. 			return bean;
  25. 		}
  26. 		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
  27. 			this.advisedBeans.put(cacheKey, Boolean.FALSE);
  28. 			return bean;
  29. 		}
  30.  
  31. 		// Create proxy if we have advice.
  32.         // 意思就是如果该类有advice则创建proxy，
  33. 		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
  34. 		if (specificInterceptors != DO_NOT_PROXY) {
  35. 			this.advisedBeans.put(cacheKey, Boolean.TRUE);
  36.             // 1.通过方法名也能简单猜测到，这个方法就是把bean包装为proxy的主要方法，
  37. 			Object proxy = createProxy(
  38. 					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
  39. 			this.proxyTypes.put(cacheKey, proxy.getClass());
  40.             
  41.             // 2.返回该proxy代替原来的bean
  42. 			return proxy;
  43. 		}
  44.  
  45. 		this.advisedBeans.put(cacheKey, Boolean.FALSE);
  46. 		return bean;
  47. 	}

 总结：

  • 1）将AnnotationAwareAspectJAutoProxyCreator注册到Spring容器中
  • 2）AnnotationAwareAspectJAutoProxyCreator类的postProcessAfterInitialization()方法将所有有advice的bean重新包装成proxy
     

创建proxy过程分析

        通过之前的代码结构分析，我们知道，所有的bean在返回给用户使用之前都需要经过AnnotationAwareAspectJAutoProxyCreator类的postProcessAfterInitialization()方法，而该方法的主要作用也就是将所有拥有advice的bean重新包装为proxy，那么我们接下来直接分析这个包装为proxy的方法即可，看一下bean如何被包装为proxy，proxy在被调用方法时，是具体如何执行的

 以下是AbstractAutoProxyCreator.wrapIfNecessary(Object bean, String beanName, Object cacheKey)中的createProxy()代码片段分析

  1. protected Object createProxy(
  2. 			Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
  3.  
  4. 		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
  5. 			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
  6. 		}
  7.  
  8.         // 1.创建proxyFactory，proxy的生产主要就是在proxyFactory做的
  9. 		ProxyFactory proxyFactory = new ProxyFactory();
  10. 		proxyFactory.copyFrom(this);
  11.  
  12. 		if (!proxyFactory.isProxyTargetClass()) {
  13. 			if (shouldProxyTargetClass(beanClass, beanName)) {
  14. 				proxyFactory.setProxyTargetClass(true);
  15. 			}
  16. 			else {
  17. 				evaluateProxyInterfaces(beanClass, proxyFactory);
  18. 			}
  19. 		}
  20.  
  21.         // 2.将当前bean适合的advice，重新封装下，封装为Advisor类，然后添加到ProxyFactory中
  22. 		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
  23. 		for (Advisor advisor : advisors) {
  24. 			proxyFactory.addAdvisor(advisor);
  25. 		}
  26.  
  27. 		proxyFactory.setTargetSource(targetSource);
  28. 		customizeProxyFactory(proxyFactory);
  29.  
  30. 		proxyFactory.setFrozen(this.freezeProxy);
  31. 		if (advisorsPreFiltered()) {
  32. 			proxyFactory.setPreFiltered(true);
  33. 		}
  34.  
  35.         // 3.调用getProxy获取bean对应的proxy
  36. 		return proxyFactory.getProxy(getProxyClassLoader());
  37. 	}

        TargetSource中存放被代理的对象,这段代码主要是为了构建ProxyFactory,将配置信息(是否使用java proxy,是否threadlocal等),目标类,切面,传入ProxyFactory中

1）创建何种类型的Proxy？JDKProxy还是CGLIBProxy？

  1. // getProxy()方法
  2. 	public Object getProxy(ClassLoader classLoader) {
  3. 		return createAopProxy().getProxy(classLoader);
  4. 	}
  5.  
  6.     
  7.     // createAopProxy()方法就是决定究竟创建何种类型的proxy
  8. 	protected final synchronized AopProxy createAopProxy() {
  9. 		if (!this.active) {
  10. 			activate();
  11. 		}
  12.         // 关键方法createAopProxy()
  13. 		return getAopProxyFactory().createAopProxy(this);
  14. 	}
  15.  
  16.     // createAopProxy()
  17. 	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
  18.         // 1.config.isOptimize()是否使用优化的代理策略，目前使用与CGLIB
  19.         // config.isProxyTargetClass() 是否目标类本身被代理而不是目标类的接口
  20.         // hasNoUserSuppliedProxyInterfaces()是否存在代理接口
  21. 		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
  22. 			Class<?> targetClass = config.getTargetClass();
  23. 			if (targetClass == null) {
  24. 				throw new AopConfigException("TargetSource cannot determine target class: " +
  25. 						"Either an interface or a target is required for proxy creation.");
  26. 			}
  27.             
  28.             // 2.如果目标类是接口或者是代理类，则直接使用JDKproxy
  29. 			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
  30. 				return new JdkDynamicAopProxy(config);
  31. 			}
  32.             
  33.             // 3.其他情况则使用CGLIBproxy
  34. 			return new ObjenesisCglibAopProxy(config);
  35. 		}
  36. 		else {
  37. 			return new JdkDynamicAopProxy(config);
  38. 		}
  39. 	}

2）getProxy()方法

由1）可知，通过createAopProxy()方法来确定具体使用何种类型的Proxy，针对于该示例，我们具体使用的为JdkDynamicAopProxy，下面来看下JdkDynamicAopProxy.getProxy()方法

  1. final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable// JdkDynamicAopProxy类结构，由此可知，其实现了InvocationHandler，则必定有invoke方法，来被调用，也就是用户调用bean相关方法时，此invoke()被真正调用
  2.     // getProxy()
  3.     public Object getProxy(ClassLoader classLoader) {
  4. 		if (logger.isDebugEnabled()) {
  5. 			logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
  6. 		}
  7. 		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
  8. 		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
  9.         
  10.         // JDK proxy 动态代理的标准用法
  11. 		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
  12. 	}

3）invoke()方法

    以上的代码模式可以很明确的看出来，使用了JDK动态代理模式，真正的方法执行在invoke()方法里，下面我们来看下该方法，来看下bean方法如何被代理执行的

  1. 	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  2. 		MethodInvocation invocation;
  3. 		Object oldProxy = null;
  4. 		boolean setProxyContext = false;
  5.  
  6. 		TargetSource targetSource = this.advised.targetSource;
  7. 		Class<?> targetClass = null;
  8. 		Object target = null;
  9.  
  10. 		try {
  11.             // 1.以下的几个判断，主要是为了判断method是否为equals、hashCode等Object的方法
  12. 			if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
  13. 				// The target does not implement the equals(Object) method itself.
  14. 				return equals(args[0]);
  15. 			}
  16. 			else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
  17. 				// The target does not implement the hashCode() method itself.
  18. 				return hashCode();
  19. 			}
  20. 			else if (method.getDeclaringClass() == DecoratingProxy.class) {
  21. 				// There is only getDecoratedClass() declared -> dispatch to proxy config.
  22. 				return AopProxyUtils.ultimateTargetClass(this.advised);
  23. 			}
  24. 			else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
  25. 					method.getDeclaringClass().isAssignableFrom(Advised.class)) {
  26. 				// Service invocations on ProxyConfig with the proxy config...
  27. 				return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
  28. 			}
  29.  
  30. 			Object retVal;
  31.  
  32. 			if (this.advised.exposeProxy) {
  33. 				// Make invocation available if necessary.
  34. 				oldProxy = AopContext.setCurrentProxy(proxy);
  35. 				setProxyContext = true;
  36. 			}
  37.  
  38. 			// May be null. Get as late as possible to minimize the time we "own" the target,
  39. 			// in case it comes from a pool.
  40. 			target = targetSource.getTarget();
  41. 			if (target != null) {
  42. 				targetClass = target.getClass();
  43. 			}
  44.  
  45. 			// 2.获取当前bean被拦截方法链表
  46. 			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
  47.  
  48. 			// 3.如果为空，则直接调用target的method
  49. 			if (chain.isEmpty()) {
  50. 				Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
  51. 				retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
  52. 			}
  53.             // 4.不为空，则逐一调用chain中的每一个拦截方法的proceed
  54. 			else {
  55. 				// We need to create a method invocation...
  56. 				invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
  57. 				// Proceed to the joinpoint through the interceptor chain.
  58. 				retVal = invocation.proceed();
  59. 			}
  60.  
  61. 			...
  62. 			return retVal;
  63. 		}
  64. 		...
  65. 	}

4）拦截方法真正被执行调用invocation.proceed() 

  1. 	public Object proceed() throws Throwable {
  2. 		//	We start with an index of -1 and increment early.
  3. 		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
  4. 			return invokeJoinpoint();
  5. 		}
  6.  
  7. 		Object interceptorOrInterceptionAdvice =
  8. 				this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
  9. 		if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
  10. 			// Evaluate dynamic method matcher here: static part will already have
  11. 			// been evaluated and found to match.
  12. 			InterceptorAndDynamicMethodMatcher dm =
  13. 					(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
  14. 			if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
  15. 				return dm.interceptor.invoke(this);
  16. 			}
  17. 			else {
  18. 				// Dynamic matching failed.
  19. 				// Skip this interceptor and invoke the next in the chain.
  20. 				return proceed();
  21. 			}
  22. 		}
  23. 		else {
  24. 			// It's an interceptor, so we just invoke it: The pointcut will have
  25. 			// been evaluated statically before this object was constructed.
  26. 			return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
  27. 		}
  28. 	}

 总结4：依次遍历拦截器链的每个元素，然后调用其实现，将真正调用工作委托给各个增强器

总结：

    纵观以上过程可知：实际就是为bean创建一个proxy，JDKproxy或者CGLIBproxy，然后在调用bean的方法时，会通过proxy来调用bean方法

    重点过程可分为：

    1）将AnnotationAwareAspectJAutoProxyCreator注册到Spring容器中

    2）AnnotationAwareAspectJAutoProxyCreator类的postProcessAfterInitialization()方法将所有有advice的bean重新包装成proxy

    3）调用bean方法时通过proxy来调用，proxy依次调用增强器的相关方法，来实现方法切

转载：https://blog.csdn.net/qq_26323323/article/details/81012855

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号