Spring的aop源码分析

        在之前的文章中我已经详细的说明了关于Spring的aop的使用，大家有兴趣的可以翻一下之前的文章【spring】Spring的aop的使用详解

        今天，我就带着大家一起来走进aop源码，看看其内部具体是如何实现的。

一、环境准备

1.1、引入依赖

 
        UTF-8
        UTF-8
        1.8
        1.8
        1.8
        5.1.6.RELEASE
        4.12
        1.7.35
        1.8.9
        1.2.27
    

    
        
            org.springframework
            spring-context
            ${spring.version}
        
        
            org.springframework
            spring-test
            ${spring.version}
        
        
            junit
            junit
            ${junit.version}
            test
        
        
            org.slf4j
            slf4j-log4j12
            ${slf4j.version}
        
        
            org.aspectj
            aspectjweaver
            ${aspectjweaver.version}
        
        
            com.alibaba
            fastjson
            ${json.version}
        
    

1.2、编写接口和实现类

package com.sxx.controller.service;

public interface UserService {

    void work();
}

package com.sxx.controller.service.impl;

import com.sxx.controller.service.UserService;

public class UserServiceImpl implements UserService {
    @Override
    public void work() {
        System.out.println("UserServiceImpl执行了");
    }
}

1.3、编写切面

package com.sxx.controller.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
@Aspect
public class UserServiceAspect {

    @Pointcut(value = "execution(* com.sxx.controller.service.impl.*.* (..))")
    public void pointCut() {
        System.out.println("@进入切点...");
    }

    //环绕通知（连接到切入点开始执行，下一步进入前置通知，在下一步才是执行操作方法）
    @Around(value = "pointCut()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("@Around进入环绕通知...");
        long startTime = System.currentTimeMillis();
//		调用了下一个拦截器，递归调用ReflectiveMethodInvocation#proceed
        joinPoint.proceed();  // ===>  debug into，环绕round的下一个链
        long endTime = System.currentTimeMillis();
        System.out.printf("@Around方法执行耗时>>>>>: %s%n", endTime - startTime);
    }

    //前置通知（进入环绕后执行，下一步执行方法）
    @Before(value = "pointCut()")
    public void before(JoinPoint joinPoint) {
        System.out.println("@Before进入前置通知:" + Arrays.toString(joinPoint.getArgs()));
    }

    //异常通知（出错时执行）
    @AfterThrowing(value = "pointCut()", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Throwable ex) {
        System.out.println("@AfterThrowing进入异常通知" + Arrays.toString(joinPoint.getArgs()));

    }

    //后置通知(返回之前执行)
    @After(value = "pointCut()")
    public void after() {
        System.out.println("@After进入后置通知...");
    }

    //最终通知（正常返回通知，最后执行，出现异常）
    @AfterReturning(value = "pointCut()")
    public void afterReturning() {
        System.out.println("@AfterReturning进入最终通知...End!");
    }
}

1.4、编写xml文件

1.5、编写测试类

package com.sxx.controller;

import com.sxx.controller.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserController {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/application.xml");

        UserService userService = (UserService) applicationContext.getBean("userService");

        System.out.println(userService.getClass().getName());

        userService.work();
    }

}

1.6、结果

com.sun.proxy.$Proxy16
@Around进入环绕通知...
@Before进入前置通知:[]
UserServiceImpl执行了
@Around方法执行耗时>>>>>: 0
@After进入后置通知...
@AfterReturning进入最终通知...End!

二、aop源码解析 

        通过上面的执行结果我们可以看出，在打印userService.getClass().getName()打印出来的是com.sun.proxy.$Proxy16，我们知道proxy是代理类，我们在getBean的时候获取的应该是UserServiceImpl对象，怎么会被代理了呢？Spring又是在哪一步对UserServiceImpl做了代理动作呢？或许我们可以从源码中了解一二。

先放张aop的流程图：

        

2.1、Spring Bean是什么时候被代理的

        我们知道Spring在初始化Bean的时候有自己的一套流程，aop在代理bean这一过程肯定是发生在Spring初始化，那么具体是在初始化哪一步呢？如果大家对Spring Bean的生命周期还不太清楚，可以看下我之前的文章：

【Spring】Spring中bean的生命周期

        我们知道，如果想要代理一个事物，首先这个事物应该是已经存在(我们应当是可以进行描述)，只有这样我们才能知道被替代的事物有哪些功能和属性等信息，然后才能创建一个新的代理去代替他。所以，代理类的创建肯定是在被代理类的bean已经创建好的阶段发生的，而Spring创建好bean后最后一步调用的是BeanPostProcessor，因此我们可以猜测，Spring创建代理类的是在BeanPostProcessor中。

2.2、BeanPostProcessor中做了些什么

2.2.1、initializeBean

      创建代理的入口是在initializeBean中，具体的可以查看org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean()，源码如下：

    protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction