Spring注解驱动开发–AOP底层原理

21. AOP-AOP功能测试

AOP：【动态代理】
指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；
1、导入aop模块：Spring AOP，(Spring-aspects)
2、定义一个业务逻辑类(MathCalculator)：在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常、xxx）
3、定义一个日志切面类(LogAspects)；切面类里面的方法需要动态感知MathCalculator，div运行到哪里然后哪里就执行。
通知方法：
前置通知(@Before)：logStart：在目标方法(div)运行之前运行
后置通知(@After)：logENd：在目标方法(div)运行结束之后运行
返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
异常通知(@AfterThrowing):logException：在目标方法(div)出现异常以后运行
环绕通知(@Around)：动态代理：手动推进目标方法运行(joinPoint.procces())
4、给切面类的目标方法标注何时何地地运行(通知注释)
5、将切面类和业务逻辑类(目标方法所在类)都加入到容器中
6、必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)
【7】、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】
在Spring中很多的 @EnableXXX;
三步：
1)、将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类(@Aspect)
2)、在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行(切入点表达式)
3)、开启基于注解的aop模式：@EnableAspectJAutoProxy

第一步、导入aop模块

org.springframeworkspring-aspects4.3.12.RELEASE

第二步、定义一个业务逻辑类(MathCalculator)

public class MathCalculator {public int div(int i,int j){System.out.println("MathCalculator...div...");return i/j;}}

第三步、定义一个日志切面类(LogAspects)

/*** 切面类** @Aspect：告诉Spring当前类是一个切面类*/
@Aspect  //告诉Spring当前类是一个切面类
public class LogAspects {//抽取公共的切入点表达式//1.本类引用//2.其他的切面引用@Pointcut("execution(public int com.xjz.aop.MathCalculator.*(..))")public void pointCut(){};//@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）@Before("pointCut()")public void logStart(JoinPoint joinPoint){Object[] args = joinPoint.getArgs();System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+ Arrays.asList(args) +"}");}@After("com.xjz.aop.LogAspects.pointCut()")public void logEnd(JoinPoint joinPoint){System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");}//JoinPoint一定要出现在参数表的第一位@AfterReturning(value = "pointCut()",returning = "result")public void logReturn(JoinPoint joinPoint,Object result){System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");}@AfterThrowing(value = "pointCut()",throwing = "exception")public void logException(JoinPoint joinPoint,Exception exception){System.out.println(""+joinPoint.getSignature().getName()+"异常。。。@AfterThrowing:异常信息：{"+exception+"}");}
}

第四步、将切面类和业务逻辑类(目标方法所在类)都加入到容器中

@EnableAspectJAutoProxy  //开启基于注解的aop模式
@Configuration
public class MyConfigOfAOP {//业务逻辑类加入到容器中@Beanpublic MathCalculator calculator(){return new MathCalculator();}//切面类加入到容器中@Beanpublic LogAspects logAspects(){return new LogAspects();}}

第五步、测试

public class IOCTest_AOP {@Testpublic void test01(){AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfigOfAOP.class);//1.不要自己创建对象
//        MathCalculator mathCalculator = new MathCalculator();
//        mathCalculator.div(1,1);MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);mathCalculator.div(1,1);applicationContext.close();}
}

第六步、运行结果

• 正常返回

• 异常报错

22. AOP原理

AOP：【动态代理】指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；
1、导入aop模块：Spring AOP，(Spring-aspects)
2、定义一个业务逻辑类(MathCalculator)：在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常、xxx）
3、定义一个日志切面类(LogAspects)；切面类里面的方法需要动态感知MathCalculator，div运行到哪里然后哪里就执行。通知方法：前置通知(@Before)：logStart：在目标方法(div)运行之前运行后置通知(@After)：logENd：在目标方法(div)运行结束之后运行返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行异常通知(@AfterThrowing):logException：在目标方法(div)出现异常以后运行环绕通知(@Around)：动态代理：手动推进目标方法运行(joinPoint.procces())
4、给切面类的目标方法标注何时何地地运行(通知注释)
5、将切面类和业务逻辑类(目标方法所在类)都加入到容器中
6、必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)
【7】、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】在Spring中很多的 @EnableXXX;
三步：1)、将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类(@Aspect)2)、在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行(切入点表达式)3)、开启基于注解的aop模式：@EnableAspectJAutoProxy
AOP原理：【看给容器中注册了什么组件，这个组件什么时候工作，这个组件的功能是什么？】@EnableAspectJAutoProxj；1、@EnableAspectJAutoProxj是什么？@Import(AspectJAutoProxyRegistrar.class)：给容器中导入AspectJAutoProxyRegistrar利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetioninternalAutoProxyCreator = AnnotationAwareAspectJAutoProxyCreator；给容器中注册一个AnnotationAwareAspectJAutoProxyCreator；2、AnnotationAwareAspectJAutoProxyCreatorAnnotationAwareAspectJAutoProxyCreator->AspectJAwareAdvisorAutoProxyCreator->AbstractAdvisorAutoProxyCreator->AbstractAutoProxyCreatorimplements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware关注后置处理器(在bean初始化完成前后做事情)、自动装配BeanFactoryAwareAbstractAutoProxyCreator.setBeanFactory()AbstractAutoProxyCreator.有后置处理器的逻辑；AbstractAdvisorAutoProxyCreator.setBeanFactory()-->initBeanFactory()AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()流程：1)、传入配置类，创建ioc容器2)、注册配置类，调用refresh()刷新容器；3)、registerBeanPostProcessors(beanFactory)；注册bean的后置处理器来方便拦截bean的创建；1)、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor2)、给容器中加别的BeanPostProcessor3)、优先注册实现了呢PriorityOrdered接口的BeanPostProcessor；4)、再给容器中注册实现了Ordered接口和BeanPostProcessor；5)、注册没实现优先级接口的BeanPostProcessor6)、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxy】1)、创建Bean的实例；2)、populateBean：给bean的各种属性赋值3)、initializeBean：初始化bean；1)、invokeAwareMethods()：处理Aware接口的方法回调2)、applyBeanPostProcessorBeforeInitialization()：应用后置处理器的postProcessBefore3)、invokeInitMethods()：执行自定义的初始化方法4)、applyBeanPostProcessorAfterInitialization()：执行后置处理器的postProcessAfterIn4)、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功：--》aspectJAdvis7)、把BeanPostProcessor注册到BeanFactory中：beanFactory.addBeanPostProcessor(postProcessor);
========以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程===========AnnotationAwareAspectJAutoProxyCreator =》 InstantiationAwareBeanPostProcessor4)、finishBeanFactoryInitialization(beanFactory)；完成BeanFactory初始化工作；创建剩下的单实例Bean1)、遍历获取容器中所有的Bean，依次创建对象getBean(beanName)；getBean->doGetBean()->getSingleton()->2)、创建bean【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostP1)、先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；只要创建好的Bean都会被缓存起来2)、createBean()；创建bean；AnnotationAwareAspectJAutoProxyCreator会在任何bean创建之前先尝试返回bean的实例【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】1)、resolveBeforeInstantiation(beanName,mbdToUse)；解析BeforeInstantiation希望后置处理器在此前能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续1)、后置处理器先尝试返回对象：bean = applyBeanPostProcessorsBeforeInstantiation()；拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor；就执行postProcessBeforeInstantiationif (bean != null) {bean = applyBeanPostProcessorsBeforeInstantiation(bean,beanName)}2)、doCreateBean(beanName, mbdToUse, args)；真正的去创建一个bean实例；和3.6流程一样3)、AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】的使用：1)、每一个bean创建之前，调用postProcessBeforeInstantiation();关心MathCalculator和LogAspect的创建1)、判断当前bean是否在advisedBeans中(保存了所有需要增强bean)2)、判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AOPInfrastructureBean.或者是否是切面(@Aspect)3)、是否需要跳过1)、获取候选的增强器(切面里面的通知方法)【List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvi1)、List