锐客网

  1. 首页 > 睿知 > it技术 > >

#yyds干货盘点# Spring AOP详解

IT知识spring

弓背霞明剑照霜，秋风走马出咸阳。这篇文章主要讲述#yyds干货盘点# Spring AOP详解相关的知识，希望能为你提供帮助。
1 AOP 应用场景AOP，Aspect Oriented Programming，面向切面编程。通过预编译和运行期动态代理，实现在不修改源代码情况下，给程序动态地统一添加功能。
AOP设计追求调用者和被调用者之间的解耦，一些非业务，如：日志、事务、安全等都会写在业务代码中(也即是说，这些非业务类横切于业务类)，但这些代码往往是重复，复制粘贴式的代码，会给程序维护带来不便，AOP 就实现了把这些业务需求与系统需求分开来做。这种解决的方式也称代理机制。

2 AOP 概念1 切面（Aspect）
【#yyds干货盘点# Spring AOP详解】官方定义“ 一个关注点的模块化，这个关注点可能会横切多个对象” 。
“ 切面”可在ApplicationContext 中aop:aspect来配置（古老的 xml 配置方式）

连接点（Joinpoint）
程序执行过程中的某一行为，例如，xxxService .get 的调用或
xxxService .delete 抛出异常等行为。

通知（Advice）
“切面”对于某个“连接点”所产生的动作。其中，一个“切面”可以包含多个“Advice”。
切入点（Pointcut）
匹配连接点的断言，在AOP 中通知和一个切入点表达式关联。切面中的所有通知所关注的连接点，都由切入点表达式来决定。
目标对象（Target Object）
被一个或者多个切面所通知的对象。例如，AServcieImpl 和BServiceImpl，当然在实际运行时，Spring AOP 采用代理实现，实际AOP 操作的是TargetObject 的代理对象。
AOP 代理（AOP Proxy）
在Spring AOP 中有两种代理方式：

  • JDK 动态代理
  • CGLib 代理
默认，TargetObject 实现了接口时，则采用JDK 动态代理；反之，采用CGLib 代理。
强制使用CGLib 代理需要将aop:config的proxy-target-class 属性设为true。
通知（Advice）类型：
6、前置通知（Before Advice）
在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。ApplicationContext
中在aop:aspect里面使用aop:before元素进行声明。例如，TestAspect 中的doBefore 方法。
7、后置通知（After Advice）
当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。ApplicationContext 中在
aop:aspect里面使用aop:after元素进行声明。例如，ServiceAspect 中的returnAfter 方法，所
以Teser 中调用UserService.delete 抛出异常时，returnAfter 方法仍然执行。
8、返回后通知（After Return Advice）
在某连接点正常完成后执行的通知，不包括抛出异常的情况。ApplicationContext 中在aop:aspect
里面使用元素进行声明。
9、环绕通知（Around Advice）
包围一个连接点的通知，类似Web 中Servlet 规范中的Filter 的doFilter 方法。可以在方法的调用前
后完成自定义的行为， 也可以选择不执行。ApplicationContext 中在aop:aspect 里面使用
aop:around元素进行声明。例如，ServiceAspect 中的around 方法。

异常通知（After Throwing Advice）
在方法抛出异常退出时执行的通知。ApplicationContext 中在aop:aspect 里面使用
aop:after-throwing元素进行声明。
可将多个通知应用到一个目标对象。使用Spring AOP 可以基于两种方式：

  • 方便和强大的注解方式
  • 古老的xml配置方式
3 配置方式注解
在xml 文件中声明激活自动扫描组件功能，同时激活自动代理功能：
< ?xml version="1.0" encoding="UTF-8"?>
< beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-2.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
< context:component-scan base-package="com.gupaoedu"/>
< context:annotation-config />
< /beans>

或者基于注解的：@SpringBootApplication(scanBasePackages = "xxx")
第二步，为Aspect 切面类添加注解。

4 Spring AOP 源码分析入口
AOP 通过接入BeanPostProcessor开始的，BeanPostProcessor是个监听器，可监听容器触发的Bean生命周期事件。BeanPostProcessor向容器注册以后，容器中管理的Bean就具备了接收IOC容器事件回调的能力。
BeanPostProcessor使用非常简单，只需要提供一个实现接口BeanPostProcessor 的实现类，然后在Bean的配置文件中设置即可。

2 AbstractAu对容器生成的Bean添加后置处理器BeanPostProcessor调用发生在IoC容器完成对Bean实例的创建和属性的依赖注入完成后。
当应用程序第一次调用getBean()(lazy-init预实例化除外)向IoC容器索取指定Bean时，触发Spring IOC 容器创建Bean实例并进行依赖注入的过程， 真正实现创建Bean并依赖注入的方法是AbstractAutowireCapableBeanFactory#doCreateBean()：

// 真正创建Bean的方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException

// 实例化bean.
// 封装被创建的Bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton())
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);

if (instanceWrapper == null)
instanceWrapper = createBeanInstance(beanName, mbd, args);

final Object bean = instanceWrapper.getWrappedInstance();
// 实例化对象的类型
Class< ?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class)
mbd.resolvedTargetType = beanType;


// 调用PostProcessor
synchronized (mbd.postProcessingLock)
if (!mbd.postProcessed)
try
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

mbd.postProcessed = true;


// 向Eagerly cache singletons容器中缓存单例Bean，以防循环依赖
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() & & this.allowCircularReferences & &
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure)
// 匿名内部类，为了防止循环引用，持有Eagerly cache singletons容器中对象的引用
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));


// bean实例的初始化，依赖注入在此触发
// 这个exposedObject 在初始化完成之后返回，作为依赖注入完成后的Bean
Object exposedObject = bean;
try
//将Bean实例对象封装，并且Bean 定义中配置的属性值赋值给实例对象
populateBean(beanName, mbd, instanceWrapper);
// 初始化Bean，为Bean实例应用BeanPostProcessor
exposedObject = initializeBean(beanName, exposedObject, mbd);


if (earlySingletonExposure)
//获取指定名称的已注册的单例模式Bean 对象
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null)
//根据名称获取的已注册的Bean 和正在实例化的Bean 是同一个
if (exposedObject == bean)
//当前实例化的Bean 初始化完成
exposedObject = earlySingletonReference;

//当前Bean 依赖其他Bean，并且当发生循环引用时不允许新创建实例对象
else if (!this.allowRawInjectionDespiteWrapping & & hasDependentBean(beanName))
String[] dependentBeans = getDependentBeans(beanName);
Set< String> actualDependentBeans = new LinkedHashSet< > (dependentBeans.length);
//获取当前Bean 所依赖的其他Bean
for (String dependentBean : dependentBeans)
//对依赖Bean 进行类型检查
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean))
actualDependentBeans.add(dependentBean);






// Register bean as disposable.
// 注册完成依赖注入的Bean
try
registerDisposableBeanIfNecessary(beanName, bean, mbd);

return exposedObject;

为Bean实例添加BeanPostProcessor的入口是initializeBean()
3、initializeBean()为容器创建的Bean实例添加BeanPostProcessor ：
// 初始容器创建的Bean实例，为其添加BeanPostProcessor后置处理器
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
if (System.getSecurityManager() != null)
...

else
// 为Bean实例包装相关属性，如名称，类加载器，所属容器等信息
invokeAwareMethods(beanName, bean);


Object wrappedBean = bean;
// 对BeanPostProcessor的postProcessBeforeInitialization
// 回调方法的调用，为Bean实例初始化前做一些处理
if (mbd == null || !mbd.isSynthetic())
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

// 调用Bean实例初始化的方法，这个初始化方法是在Spring Bean 定义配置
// 文件中通过init-Method属性指定
try
invokeInitMethods(beanName, wrappedBean, mbd);

catch (Throwable ex)
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);


//对BeanPostProcessor 后置处理器的postProcessAfterInitialization
//回调方法的调用，为Bean 实例初始化之后做一些处理
if (mbd == null || !mbd.isSynthetic())
wrappedBean = applyBeanPostProcessorsAfterInitialization(

    推荐阅读


    上一篇：#yyds干货盘点#HCIE-Security Day8（3个实验理解双向NAT）

    下一篇：linux实用技巧（在虚拟机vmware16软件上安装CentOs8.2虚拟机，重置可用源和安装输入法）