爱上源码，重学SpringAOP深入

　　AOP （Aspect Orient Programming）：直译过来就是 面向切面编程。AOP 是一种编程思想
　　用途：Transactions （事务调用方法前开启事务， 调用方法后提交关闭事务 ）、日志、性能（监控方法运行时间）、权限控制等
　　也就是对业务方法做了增强1.1 Spring AOP环境介绍
　　**目标：**认识AOP基础环境，后面讲使用这个基础环境进行源码讲解tips：
　　沿用ioC的工厂1）引入起步依赖    compile(project(＂:spring-aop＂))     compile(project(＂:spring-context＂))     compile ＂org.aspectj:aspectjweaver:1.9.2＂ 复制代码2）新建接口和实现public interface Slaver { 	void work(); }  复制代码import org.springframework.stereotype.Service;  @Service public class SlaverImpl implements Slaver { 	public void work() { 		System.out.println(＂进入实现类 work.....＂); 		try { 			Thread.sleep(1000); 		} catch (InterruptedException e) { 			e.printStackTrace(); 		}  	}  } 复制代码3）新建切面类package com.spring.test.aop.aop;  import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component;  import java.util.Arrays;  //将这个类声明为一个切面，需要将其放入IOC容器中 @Aspect//声明这是一个切面 @Component//声明这是一个组件 /**  * 执行顺序  * @Around进入环绕通知...  * @Before进入前置通知:[]  * 进入实现类 work.....  * @Around方法执行耗时>>>>>: 1001  * @After进入后置通知...  * @AfterReturning进入最终通知...End!  */ public class SlaverAspect {  	//环绕通知（连接到切入点开始执行，下一步进入前置通知，在下一步才是执行操作方法） 	@Around(value = ＂pointCut()＂) 	public void around(ProceedingJoinPoint joinPoint) throws Throwable { 		System.out.println(＂@Around进入环绕通知...＂); 		long startTime = System.currentTimeMillis(); 		joinPoint.proceed(); 		long endTime = System.currentTimeMillis(); 		System.out.println(String.format(＂@Around方法执行耗时>>>>>: %s＂, endTime - startTime)); 	}  	//前置通知（进入环绕后执行，下一步执行方法） 	@Before(value = ＂pointCut()＂) 	public void before(JoinPoint joinPoint) { 		System.out.println(＂@Before进入前置通知:＂ + Arrays.toString(joinPoint.getArgs())); 	}  	//异常通知（出错时执行） 	@AfterThrowing(value = ＂pointCut()＂, throwing = ＂ex＂) 	public void afterThrowing(JoinPoint joinPoint, Throwable ex) { 		System.out.println(＂@AfterThrowing进入异常通知＂ + Arrays.toString(joinPoint.getArgs())); 		System.out.println(＂@AfterThrowing异常信息：＂ + ex); 	}  	//后置通知(返回之前执行) 	@After(value = ＂pointCut()＂) 	public void after() {  		System.out.println(＂@After进入后置通知...＂); 	}  	//最终通知（正常返回通知，最后执行） 	@AfterReturning(value = ＂pointCut()＂) 	public void afterReturning() { 		System.out.println(＂@AfterReturning进入最终通知...End!＂); 	}  	//定义一个切入点 后面的通知直接引入切入点方法pointCut即可 //	@Pointcut(＂execution(public * com.spring.test.aop.impl.SlaverImpl.work())＂) 	@Pointcut(value = ＂execution(* com.spring.test.aop.impl.SlaverImpl.*(..))＂) 	public void pointCut() { 	}  }  复制代码
　　AspectJ 支持 5 种类型的通知注解: @Before: 前置通知, 在方法执行之前执行 @After: 后置通知, 在方法执行之后执行 @AfterRunning: 返回通知, 在方法返回结果之后执行 @AfterThrowing: 异常通知, 在方法抛出异常之后 @Around: 环绕通知, 围绕着方法执行
　　execution：用于匹配方法执行的连接点；4）新建配置文件
　　resources/application-aop.xml<?xml version=＂1.0＂ encoding=＂UTF-8＂?>  	 	 	 	  复制代码
　　常见错误
　　配置文件缺乏xsd的引用
　　5）新建入口类public class Main {  	public static void main(String[] args) { 		ApplicationContext context = 				new ClassPathXmlApplicationContext(＂classpath*:application-aop.xml＂); 		Slaver slaver=(Slaver)context.getBean(＂slaverImpl＂); 		slaver.work(); 	}  } 复制代码6）运行效果
　　1.2 SpringAOP和AspectJ联系tips：
　　十个人有九 个人弄不懂的关系
　　Spring AOP:
　　Spring AOP旨在通过Spring IoC提供一个简单的AOP实现，以解决编码人员面临的最常出现的问题。这并不是完整的AOP解决方案，它只能用于Spring容器管理的beans。
　　AspectJ：
　　AspectJ是最原始的AOP实现技术，提供了完整的AOP解决方案。AspectJ更为健壮，相对于Spring AOP也显得更为复杂
　　总结AOP是面向切面的一个思想 他有两种实现 1、Spring AOP 2、Aspectj Spring AOP的实现没有AspectJ强大 所以，Spring把Aspectj给集成（如果用，还需要单独引jar）进来了 但是；spring aop已能满足我们的需求 在进行开发时候，这两个框架是完全兼容的  说白了，就是两个框架能一起使用，就看你项目需求用到的哪种程度了 简单的；spirng aop够用了，但是spring aop借助了aspectj的注解功能， 在高级点，比如切面很多，上万个，这是就要用到aspectj的高级功能了  复制代码
　　区别：AspectJ使用的是编译期和类加载时进行织入，Spring AOP利用的是运行时织入
　　**依赖：**如果使用@Aspect注解，在xml里加上。但是这需要额外的jar包（ aspectjweaver.jar）
　　因为spring直接使用AspectJ的注解功能，注意只是使用了它 的注解功能而已。并不是核心功能 ！
　　运行效果如下：
　　1.3 找到处理AOP的源头
　　1、Spring处理AOP源头在哪里(织入)
　　AspectJ编译期和类加载时进行织入、Spring AOP利用的是运行时织入猜想： 1. 在容器启动时创建？  2.在getBean时创建？  复制代码
　　容器启动
　　2、代理对象到底长什么样？
　　将断点打在getBean的返回对象上，发现这并不是一个我们定义的对象本身，而是一个Proxy
　　接下来，我们会找到$Proxy生成的始末
　　3、我的接口是怎么被A0P管理上的 ？
　　com.spring.test.aop.aop.SlaverAspect#pointCut//定义一个切入点 后面的通知直接引入切入点方法pointCut即可 	//参数： 	//第一个＂*＂符号;表示返回值的类型任意 	//.*(..)表示任何方法名，括号表示参数，两个点表示任何参数类型 	@Pointcut(value = ＂execution(* com.spring.test.aop.impl.SlaverImpl.*(..))＂) 	public void pointCut() { 		System.out.println(＂@进入切点...＂); 	} 复制代码tips：
　　当然是execution声明，改成 SlaverImpl.aaaa*(..) ， 再来看getBean的对象，不再是proxy
　　断点一下……1.4 代理对象是怎么生成的1、AOP其实就是用的动态代理模式，创建代理
　　2、AOP织入源头在哪里
　　**目标：**通过源头找代理对象是如何生成的
　　找到生成代理的地方Proxy.newProxyInstance0）回顾助学
　　简单回顾一下，注意，这里不仅仅是学习代理模式，还必须搞懂它的实现方式，尤其是动态代理。开始之前，我们先必须搞懂一件事情：
　　那就是：代理模式
　　设计模式【静态代理】 【动态代理】 回顾 （见第2小节）1）从源头找代理对象生成
　　记住目标：
　　spring aop使用的就是代理模式，那我们的目标就明确了：找到生成代理的地方Proxy.newProxyInstance
　　先来张流程图：
　　下面我们沿着图中的调用链，找到aop 代理诞生的地方
　　tips：从后置处理器开始
　　为什么要从后置处理器入手？
　　很容易理解，没初始化好没法用，等你初始化好了功能齐备了，我再下手，代替你
　　找到后置处理器
　　重点关注postProcessAfterInitialization此处最好使用断点表达式，否则要循环很多次
　　因为在refresh方法中的invokeBeanFactoryPostProcessors方法也会调用到这个地方
　　断点表达式：
　　关注点：tips：
　　在BeanPostProcessor循环中，观察AnnotationAwareAspectJAutoProxyCreator
　　这货就是切面的后置处理器
　　AbstractAutowireCapableBeanFactory**#**applyBeanPostProcessorsAfterInitialization	//目标：循环所有的后置处理器进行调用 	//注意： 	//AOP调试，此处最好使用断点表达式，否则要循环很多次 	//因为在refresh方法中的invokeBeanFactoryPostProcessors方法也会调用到这个地方 	@Override 	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) 			throws BeansException {  		Object result = existingBean; 		//aop 		//此处getBeanPostProcessors()有8个内置后置处理器；生成代理会调用里面的 AnnotationAwareAspectJAutoProxyCreator 		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { 			//Aop调用AbstractAutoProxyCreator#postProcessAfterInitialization, 			Object current = beanProcessor.postProcessAfterInitialization(result, beanName); 			if (current == null) { 				return result; 			} 			result = current; 		} 		return result; 	} 复制代码如上所见
　　也就是说AOP模块是通过实现BeanPostProcessor集成进来的2）进入后置处理器tips:
　　aop这是spring内置的一个后置处理器，生效在postProcessAfterInitialization方法
　　AbstractAutoProxyCreator#postProcessAfterInitialization
　　重点关注wrapIfNecessary	//如果当前的bean适合被代理，则需要包装指定的bean 	@Override 	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException { 		if (bean != null) { 			// 根据给定的bean的class和name构建一个key 			Object cacheKey = getCacheKey(bean.getClass(), beanName); 			if (!this.earlyProxyReferences.contains(cacheKey)) {  				// 如果当前的bean适合被代理，则需要包装指定的bean 				return wrapIfNecessary(bean, beanName, cacheKey); 			} 		} 		return bean; 	} 复制代码
　　经历wrapIfNecessary方法，重点关注点有两个：
　　1是：getAdvicesAndAdvisorsForBean，找到哪些切面会作用在当前bean上，满足条件的抓出来！
　　2是：createProxy，生成代理，替代slaverImpl去做事	//目标 	//1、判断当前bean是否已经生成过代理对象，或者是否是应该被略过的对象，是则直接返回，否则进行下一步 	//2、拿到切面类中的所有增强方法（拦截器：环绕、前置、后置等） 	//3、生成代理对象 	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { 		// 判断是否为空 		// 判断当前bean是否在TargetSource缓存中存在，如果存在，则直接返回当前bean 		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { 			return bean; 		} 		// 这里advisedBeans缓存了不需要代理的bean（为false的），如果缓存中存在，则可以直接返回 		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { 			return bean; 		} 		//Infrastructure基础设施 		// 用于判断当前bean是否为Spring系统自带的bean，自带的bean是 		// 不用进行代理的；shouldSkip()则用于判断当前bean是否应该被略过 		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { 			// 对当前bean进行缓存 			this.advisedBeans.put(cacheKey, Boolean.FALSE); 			return bean; 		}                          		//AOP:【关键点1】反射来过滤，看看哪些aspect的execution能匹配上当前bean 		// ===【【【【注意！这货要分两步调试讲解，修改切面表达式做对比】】】】==== 		// 将SlaverAspect的 execution改成 SlaverImpl.aaa*(..)  试试，你将得到一个空数组！！！ 		// 匹配上的话列出前后和置换的方法（拦截器：环绕、前置、后置等） 		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);            		//如果拿到的增强方法不为空 		if (specificInterceptors != DO_NOT_PROXY) { 			// 对当前bean的代理状态进行缓存 			this.advisedBeans.put(cacheKey, Boolean.TRUE);                      			// 开始创建AOP代理       //  ===【关键点2】=== 			Object proxy = createProxy( 					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));                             			// 缓存生成的代理bean的类型，并且返回生成的代理bean 			this.proxyTypes.put(cacheKey, proxy.getClass()); 			//此处返回的代理和在Main函数中返回的是一样的 			//说明此处代理成功创建 			return proxy; 		} 		//如果拿到的增强方法为空,缓存起来(使用false标记不需要代理) 		this.advisedBeans.put(cacheKey, Boolean.FALSE); 		return bean; 	} 复制代码3）开始创建代理对象
　　重点关注最下面的关键点：proxyFactory.getProxy(getProxyClassLoader())	//beanClass：目标对象class 	//beanaName 	//specificInterceptors：拦截器里面的拦截方法 	//targetSource:目标资源 	//目标：开始为bean创建代理 	protected Object createProxy(Class<?> beanClass, @Nullable String beanName, 								 @Nullable Object[] specificInterceptors, TargetSource targetSource) { 		//为true，DefaultListableBeanFactory 		if (this.beanFactory instanceof ConfigurableListableBeanFactory) { 			//给当前的bd设置属性setAttribute(＂originalTargetClass＂,bean的class),进入 			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass); 		} 		//创建一个默认的代理工厂DefaultAopProxyFactory，父类无参构造器 		ProxyFactory proxyFactory = new ProxyFactory();   		//proxyFactory通过复制配置进行初始化 		//this为AbstractAutoProxyCreator对象，说明AbstractAutoProxyCreator继承参数实际类型 		proxyFactory.copyFrom(this); 		/** 		 * isProxyTargetClass()，默认false 		 * true 		 *目标对象没有接口(只有实现类) – 使用CGLIB代理机制 		 * false 		 * 目标对象实现了接口 – 使用JDK代理机制(代理所有实现了的接口) 		 */ 		if (!proxyFactory.isProxyTargetClass()) { 			//来判断@EnableAspectJAutoProxy注解或者XML的proxyTargetClass参数(true或者false) 			//看看用户有没有指定什么方式生成代理 			// 如果没配置就为空，此处返回false 			if (shouldProxyTargetClass(beanClass, beanName)) { 				proxyFactory.setProxyTargetClass(true); 			} else { 				//评估接口的合理性，一些内部回调接口，比如InitializingBean等，不会被实现jdk代理 				evaluateProxyInterfaces(beanClass, proxyFactory); 			} 		} 		// 把advice(增强)类型的增强包装成advisor类型(强制类型转换) 		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); 		//加入到代理工厂 		proxyFactory.addAdvisors(advisors); 		//设置要代理的类(目标类) 		proxyFactory.setTargetSource(targetSource); 		//子类实现， 定制代理 		customizeProxyFactory(proxyFactory); 		//用来控制代理工厂被设置后是否还允许修改通知，缺省值为false 		proxyFactory.setFrozen(this.freezeProxy); 		//明明是false?? 此处注意,他是在子类AbstractAdvisorAutoProxyCreator重写了advisorsPreFiltered方法 		if (advisorsPreFiltered()) { 			//设置预过滤 			proxyFactory.setPreFiltered(true); 		}  		//【关键点】通过类加载期获取代理;getProxyClassLoader为默认的类加载器 		return proxyFactory.getProxy(getProxyClassLoader()); 	} 复制代码
　　进入getProxy//通过类加载期获取代理 public Object getProxy(@Nullable ClassLoader classLoader) {    //分别进入createAopProxy 和getProxy    return createAopProxy().getProxy(classLoader); } 复制代码
　　先看createAopProxy
　　查看返回jdk代理还是cglib代理public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { 		// isOptimize:是否对代理进行优化 		// isProxyTargetClass:值为true，使用CGLIB代理，默认false 		// hasNoUserSuppliedProxyInterfaces: 		//1、如果长度为0；也就是接口为空，返回false 		//or(或的关系) 		//2、如果接口类型不是SpringProxy类型的；返回flase  		//如果条件不满足；直接走JDK动态代理(return) 		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.＂); 			} 			// 如果targetClass是接口类，使用JDK来生成Proxy 			//Tips 			//如果目标对象实现了接口，默认情况下会采用JDK动态代理， 			// 但也可以通过配置（proxy-target-class=true）强制使用CGLIB。 			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) { 				//jdk 				return new JdkDynamicAopProxy(config); 			} 			//cglib 			return new ObjenesisCglibAopProxy(config); 		} else { 			//jdk 			return new JdkDynamicAopProxy(config); 		} 	} 复制代码
　　再看getProxy	//获取最终的代理对象（由JDK生成；运行时织入） 	@Override 	public Object getProxy(@Nullable ClassLoader classLoader) { 		if (logger.isDebugEnabled()) { 			logger.debug(＂Creating JDK dynamic proxy: target source is ＂ + this.advised.getTargetSource()); 		} 		//获取代理对象需要实现的接口（业务接口和内置接口） 		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true); 		//判断接口中是否重写了equals和hashCode方法 		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);  		/** 		 * 第一个参数是类加载器（目标类） 		 * 第二个参数是代理类需要实现的接口，即目标类实现的接口（含系统接口）（数组） 		 * 第三个是InvocationHandler，本类实现了此接口 		 */ 		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); 	} 复制代码
　　找到了！代理对象在bean初始化阶段装配进了spring4）代理对象验证tips：
　　前面创建完成了代理对象，下面我们看下它调用的时候，是不是走了代理
　　这是我们一开始的结果，下面我们来再debug到work方法时，点击debug into试试，发现调到哪里去了？？？
　　结论：
　　没错！代理对象精准的调用了JdkDynamicAopProxy里面的invoke方法
　　这说明jdk动态代理生效，但是它生成的proxy字节码在jvm里，我们是看不到的，怎么破？
　　arthas上！2）Arthas代理类验证
　　arthas，阿里神器，主页：arthas.aliyun.com/zh-cn/
　　获取之前，我们需要做点小事情，打出我们的 slaver的类路径，让arthas能找到它！
　　源码：package com.aoptest;  import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;  public class Main {  	public static void main(String[] args) throws InterruptedException { 		ApplicationContext context = 				new ClassPathXmlApplicationContext(＂classpath*:application-aop.xml＂); 		Slaver slaver=(Slaver)context.getBean(＂slaverImpl＂); 		slaver.work(); 		System.out.printf(slaver.getClass().getName());  //打印当前对象的类名称：com.sun.proxy.$Proxy17 		Thread.sleep(Integer.MAX_VALUE); // 必须停留在这里，debug是不行的，arthas会连不上 	}  } 复制代码
　　开启arthas：很简单， java -jar arthas-boot.jar启动后，在arthas里执行：jad com.sun.proxy.$Proxy17 反编译我们的代理类
　　注意，jad后面的，换成你上一步控制台打印出来的
　　见证奇迹的时刻……
　　找到里面的work方法，结果它长这样……
　　那么，this.h呢？
　　杀死进程，回到debug模式，看看
　　没错，就是我们的jdk动态代理类！
　　现在调用关系明确了，接下来，我们就来分析下这个invoke1.5 代理对象如何调用1）先看张图
　　代理对象调用链如下图 (责任链，先有个印象，很长，很长……)
　　2）理解责任链
　　代码中给大家准备了一个责任链小demo，它就是我们spring aop切面调用链的缩影
　　spring-aop-test 项目下的 com.spring.test.aop.chain 包。
　　执行里面的main方法
　　生活中的例子，类似于：全公司站成一队，从队首开始签名如果先签完再交给下一个，你就是前置拦截。（签名 = 执行切面任务）如果先交给下一个，等传回来的时候再签，你就实现了后置，回来的时候再补一个个传到底后，到达队尾，老板盖章（真正的业务逻辑得到执行）然后一个个往回传（return），前面没签的那些家伙补上（后置切面任务得到执行）3）invoke方法源码分析
　　通过上小节我们知道，代理模式下执行的是以下invoke
　　org.springframework.aop.framework.JdkDynamicAopProxy#invoke
　　代码重点关注// 2.从ProxyFactory（this.advised）中构建拦截器链，包含了目标方法的所有切面方法 List