AOP原理和切面应用_aop切面-CSDN博客

本文链接：https://blog.csdn.net/xdpcxq/article/details/136997738

本文深入探讨了Spring AOP的原理，包括面向切面编程的概念、匹配符合条件的方法及增强处理。通过案例分析展示了Spring AOP的使用，如事务管理的注解配置。文章还详细介绍了BeanFactoryPostProcessor和BeanPostProcessor接口在AOP中的作用，以及Spring如何通过NameSpaceHandler解析XML配置。同时，解析了AOP的实现机制，包括JDK代理和CGLIB代理，并分析了@Aspect注解类的处理流程，最后探讨了AOP代理的创建过程。

摘要由CSDN通过智能技术生成

1 概述

我们所说的Aop（即面向切面编程），即面向接口，也面向方法，在基于IOC的基础上实现。
Aop最大的特点是对指定的方法进行拦截并增强，这种增强的方式不需要业务代码进行调整，无需侵入到业务代码中，使业务与非业务处理逻辑分离。
以Spring举例，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
aop的实现主要包括了两个部分：

匹配符合条件的方法(Pointcut)
对匹配的方法增强(JDK代理、cglib代理)
spring针对xml配置和配置自动代理的Advisor有很大的处理差别，在IOC中主要是基于XML配置分析的，在AOP的源码解读中，则主要从自动代理的方式解析，分析完注解的方式，再分析基于xml的方式。

2 案例分析

下面是spring aop的用法也是用于源码分析的案例
切面类：TracesRecordAdvisor

@Aspect
@Component
public class TracesRecordAdvisor {
    
    @Pointcut("execution(* spring.action.expend.aop.services.*.*(..))")
    public void expression() {
    }

    @Before("expression()")
    public void beforePrint()
    {
        System.out.println("进入服务，在服务执行之前,记录日志....");
    }

    @AfterReturning("expression()")
    public void afterPrint()
    {
        System.out.println("退出服务，在服务执行结束之后,记录日志.....");
    }
}

xml配置: aop的注解启用只需要在xml中配置这段代码即可，这个是作为入口

<aop:aspectj-autoproxy/>

服务类：PayServiceImpl 使用jdk代理所以要有一个接口

@Service
public class PayServiceImpl implements PayService {
    public void payMoneyMenthod() {
        System.out.println("正在执行付款...");
    }
}

测试方法：

    @Test
    public void springAopTestService() {
        ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring-aop.xml");
        PayService payService= (PayService) applicationContext.getBean("payServiceImpl");
        payService.payMoneyMenthod();
    }

执行结果：

进入服务，在服务执行之前,记录日志....
正在执行付款...
退出服务，在服务执行结束之后,记录日志.....

从上面的执行结果看，payMoneyMenthod 方法的确是被增强了。

3 BeanFactoryPostProcessor

读spring源码的时候，可以首先看下BeanFactoryPostProcessor和BeanPostProcess,这两个接口都是在spring通过配置文件或者xml获取bean声明，生成BeanDefinition后，允许我们再对生成的BeanDefinition，进行入口包装和增强。
我们看看BeanFactoryPostProcessor的定义

public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)；
}

方法postProcessBeanFactory的参数为ConfigurableListableBeanFactory，我们之前讨论过beanFactory用来获取bean的，而ConfigurableListableBeanFactory继承接口SingletonBeanRegistry和BeanFactroy，所以可以访问到已经生成过的BeanDefinitions集合，如果某个类实现该接口，spring会注册这个类，然后执行这个类的postProcessBeanFactory方法，以便我们对BeanDefinition进行扩展。
接下来的代码表示Spring是如何注册BeanFactoryPostProcessor并执行postProcessBeanFactory的。

    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            prepareRefresh();
            //核心方法1
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            prepareBeanFactory(beanFactory);
            try {
                postProcessBeanFactory(beanFactory);
                //核心方法2 执行BeanFactoryPostProcessor
                invokeBeanFactoryPostProcessors(beanFactory);
                //核心方法 3 注册BeanPostProcessor
                registerBeanPostProcessors(beanFactory);
                // Initialize message source for this context.
                initMessageSource();
                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();
                // Initialize other special beans in specific context subclasses.
                onRefresh();
                // Check for listener beans and register them.
                registerListeners();
                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);
                // Last step: publish corresponding event.
                finishRefresh();
            }
            catch (BeansException ex) {
                 ............
                throw ex;
            }
            finally {
                 ............
                resetCommonCaches();
            }
        }
    }

核心方法1obtainFreshBeanFactory就是前两篇所说的生成BeanDefinition的入口，invokeBeanFactoryPostProcessors核心方法2就是执行BeanFactoryPostProcessor接口的方法。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
}

通过方法getBeanFactoryPostProcessors获取注册BeanFactoryPostProcessor，然后来看看如何添加一个处理器

@Override
public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor beanFactoryPostProcessor) {
   this.beanFactoryPostProcessors.add(beanFactoryPostProcessor);
}

对于方法invokeBeanFactoryPostProcessors不再往下看了，里面的方法大致先对BeanFactoryPostProcessor进行排序，排序的标准是是否实现了PriorityOrdered，然后根据设置的order大小指定执行顺序，生成一个排序集合和一个普通的集合，最后执行invokeBeanFactoryPostProcessors

private static void invokeBeanFactoryPostProcessors(
  Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
  for (BeanFactoryPostProcessor postProcessor : postProcessors) {
    //执行到自定义的BeanFactoryPostProcessor
 postProcessor.postProcessBeanFactory(beanFactory);
   }
}

这个方法就会循环先前注册的BeanFactoryPostProcessor集合，然后执行postProcessBeanFactory。

4 BeanPostProcess 解读

与BeanFactoryPostProcessor相比，BeanPostProcess就重要得多了，因为Spring的注解、AOP等都是通过这个接口的方法拦截执行的，它贯穿了Bean创建过程的整个生命周期，在IOC阶段，Spring只注册BeanPostProcess，执行则放到了Bean的实例化创建阶段。
首先看下BeanPostProcessor的接口定义

public interface BeanPostProcessor {
        //在bean创建 属性赋值之后  Aware接口执行之后执行
        Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
        //在init-method afterPropertiesSet 执行之后执行
        Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
    }

在bean的声明周期中，下面的序列是bean创建后要执行的接口和方法顺序：

实例化（autowireConstructor或者instantiateBean)
属性初始化(populateBean)
Aware接口（如果你的 bean 有进行实现)
BeanPostProcess.postProcessBeforeInitialization
PostConstructInitializingBean.afterPropertiesSet
BeanPostProcess.postProcessAfterInitialization

其中通过注解引入依赖的方式就是在AutowiredAnnotationBeanPostProcessor这个类中实现的，而接下来要分析的Spring Aop也是从这里开始的，这个类叫AnnotationAwareAspectJAutoProxyCreator,

5 NameSpaceHanlder 解读

在Spring中，任何的技术都是在IOC的基础上进行的，Aop也不例外，程序会首先读取xml配置文件，然后对读取到的标签先查找命名空间，然后找对应的NameSpaceHandler，最终调用parse方法解析标签。
aop标签的解析，使用纯注解的方式aop:aspectj-autoproxy和使用aop:config的配置解析不太一样，具体表现在生成PointCut和生成Before、After、Around等切面类时，使用aop:config的方式会为这些注解生成一个BeanDefinition，而这个BeanDefinition的构造函数是由3个BeanDefinition组成，表明这个类是合成类，即synthetic这个属性为true。然后跟解析普通的bean一样，生成这些实例对象