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。

本站声明：
1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；

2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；

3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；

4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；

5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。