Spring AOP 切面增强

背景

背景：我们在开发过程中，经常需要做些周边功能： 性能统计、日志、事物管理。我们需要考虑如何解耦这些周边功能开发和核心业务开发区分开达到提升代码质量目的。

---

定义

在AOP思想里面定义

1. 周边功能定义是（性能统计、日志、事务管理），被定义成切面。

2. 核心功能和切面功能单独开发。

3. 然后把核心功能和切面功能编织在一起。

核心概念

在AOP概念里，所有的方法称为连接点。

被AOP应用拦截到的方法称为切点。

我们在切点前后添加一段逻辑代码比如方法前、方法后、方法前后。称为增强/通知。

切面是切点和增强/通知总成

织入： 把切面加入对象，并创建代理对象过程叫做织入。 这个工作是由spring完成的。

切点

每个方法都可以称为连接点。

定义增强/通知代码

@Before 目标方法调用前通知

@AfterReturning 目标方法成功返回后通知

@After 目标方法调用之后通知

@AfterThrowing 目标方法抛出异常后通知

@Around 环绕执行

aop简单示例

定义业务Service

public interface AnswerService {
    
    void answerQuestion();
}
@Service
@Slf4j
public class AnswerServiceImpl implements AnswerService {
    @Override
    public void answerQuestion() {
        Answer answer = new Answer();
        answer.setId(1L)
        .setAuthor("jiguansheng")
        .setContent("笨笨是好宝宝");
      log.info(answer.toString());
    }
}

定义切面

@Component
    @Aspect
    @Slf4j
    public class SpringLearnAop  {

        @Pointcut("execution(* com.example.springcorelearn.answer..*(..))")
        public void definitionPointCut() {

        }

        @AfterReturning("definitionPointCut()")
        public void afterProcess() {
            log.info("结束了。。。。");
        }


        @Before("definitionPointCut()")
        public void beforeProcess() {
            log.info("想到我了");
        }

    }

输出

想到我了
Answer(id=1, content=笨笨是好宝宝, author=jiguansheng)
结束了。。。。

熟悉Spring AOP之前一定要熟悉Spring ApplicationContext启动流程和bean生命周期。

Spring 工作流程

分析

postProcessBeforeInstantiation 实例化前处理

创建AnswerService 前置处理。遍历容器所有的类，查找并遍历所有的切面信息。然后将切面信息保存到缓存中。比如案例中的SpringLearnAop。

postProcessAfterInitializaiton 初始化后处理

1. 获得AnswerService 切面信息： 首先从缓存中拿到切面信息和AnswerService 方法。然后找到所有需要进行AOP的方法。

2. 创建AOP代理对象：视AnswerService是否是接口。是接口采用sdk代理。若不是采用cglib代理。

代码入口

refresh

源码

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();

                // 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) {
               
            }

            finally {
               
            }
        }
    }

    @Override
    public void preInstantiateSingletons() throws BeansException {
        if (logger.isTraceEnabled()) {
            logger.trace("Pre-instantiating singletons in " + this);
        }

        // Iterate over a copy to allow for init methods which in turn register new bean definitions.
        // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
        List beanNames = new ArrayList<>(this.beanDefinitionNames);

        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        FactoryBean factory = (FactoryBean) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged(
                                    (PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
                        .tag("beanName", beanName);
                SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction