Spring AOP功能源码解析

妖狐艹你老母 2022-03-15 15:50 278阅读 0赞

# **前言：** #

有关于Spring，我们最常用的两个功能就是IOC和AOP，前几篇文章从源码级别介绍了Spring容器如何为我们生成bean及bean之间的依赖关系

下面我们接着来看AOP的源码实现。

有关于AOP，我们在面试中也被无数次问到，AOP是什么？AOP有什么作用与优势？AOP在项目中是如何用到的？

这些还都是比较简单的，有些可能会问你AOP的实现是怎样的？

哪怕没有看过源码的同学也应该知道，AOP是通过动态代理实现的，动态代理又分为两个部分：[JDK][]动态代理和CGLIB动态代理

确实，Spring也就是通过这两种方式来实现AOP相关功能，下面就通过源码来简单求证下

## **1.AOP功能简单实现** ##

###  **1）引入maven依赖（笔者使用SpringBoot开发）** ###

<parent>
    
    <groupId>org.springframework.boot</groupId>
    
    <artifactId>spring-boot-starter-parent</artifactId>
    
    <version>1.5.3.RELEASE</version>
    
    </parent>
    
    <dependency>
    
    <groupId>org.springframework.boot</groupId>
    
    <artifactId>spring-boot-starter-aop</artifactId>
    
    </dependency>
    
        2）创建接口及其实现类
    
    public interface Person {
    
    void say();
    
    }
    
    public class Student implements Person{
    
    
    public void say(){
    
    System.out.println("这是一个苦逼的程序员");
    
    }
    
    }
    
        3）创建切面类
    
    @Aspect
    
    public class AspectJTest {
    
    
    @Pointcut("execution(* *.say(..))")
    
    public void test(){}
    
    
    @Before("test()")
    
    public void before(){
    
    System.out.println("before test..");
    
    }
    
    
    @After("test()")
    
    public void after(){
    
    System.out.println("after test..");
    
    }
    
    
    @Around("test()")
    
    public Object around(ProceedingJoinPoint p){
    
    System.out.println("before1");
    
    Object o = null;
    
    try {
    
    o = p.proceed();
    
    } catch (Throwable e) {
    
    e.printStackTrace();
    
    }
    
    System.out.println("after1");
    
    return o;
    
    }
    
    }

**4）创建beans.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:aop="http://www.springframework.org/schema/aop"
    
    xsi:schemaLocation="
    
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    
    <aop:aspectj-autoproxy/>
    
    <bean id="student" class="test.Student"/>
    
    <bean class="test.AspectJTest"/>
    
    </beans>
    
        5）测试类
    
    public class Test {
    
    
    public static void main(String[] args) {
    
    
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    
    Person bean2 = (Person)ac.getBean("student");
    
    bean2.say();
    
    }
    
    // 结果如下：
    
    before1
    
    before test..
    
    这是一个苦逼的程序员
    
    after1
    
    after test..

总结：AOP功能的使用还是比较简单的，把相关bean注入到Spring容器中，编写好相应的Aspect类即可

## **2.写在分析AOP功能源码之前** ##

1）在使用ApplicationContext相关实现类加载bean的时候，会针对所有单例且非懒加载的bean，在构造ApplicationContext的时候就会创建好这些bean，而不会等到使用的时候才去创建。这也就是单例bean默认非懒加载的应用

2）读者需要了解BeanPostProcessor的相关使用，所有实现BeanPostProcessor接口的类，在初始化bean的时候都会调用这些类的方法，一般用于在bean初始化前或后对bean做一些修改。而AOP的功能实现正式基于此，在bean初始化后创建针对该bean的proxy，然后返回给用户该proxy

3）结合以上两点，被代理后的bean，实际在ApplicationContext构造完成之后就已经被创建完成，getBean()的操作直接从singletonObjects中获取即可

## **3.AOP源码架构分析** ##

###  **1）寻找 <aop:aspectj-autoproxy/> 注解对应的解析器** ###

但凡注解都有对应的解析器，以用来解析该注解的行为。全局搜索之后可发现

org.springframework.aop.config.AopNamespaceHandler类中有对应的解析行为，代码如下：
    
    public class AopNamespaceHandler extends NamespaceHandlerSupport {
    
    @Override
    
    public void init() {
    
    // In 2.0 XSD as well as in 2.1 XSD.
    
    registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
    
    registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());// 就是该段代码
    
    registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
    
    
    // Only in 2.0 XSD: moved to context namespace as of 2.1
    
    registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    
    }
    
    }

###  **2）了解AspectJAutoProxyBeanDefinitionParser对应的行为** ###

class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {
    
    
    @Override
    
    public BeanDefinition parse(Element element, ParserContext parserContext) {
    
    // 1.注册proxy creator
    
    AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
    
    extendBeanDefinition(element, parserContext);
    
    return null;
    
    }
    
    ...
    
    
    // registerAspectJAnnotationAutoProxyCreatorIfNecessary()
    
    public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
    
    ParserContext parserContext, Element sourceElement) {
    
    // 注册行为主要内容
    
    BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
    
    parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    
    registerComponentIfNecessary(beanDefinition, parserContext);
    
    }
    
    
    // registerAspectJAnnotationAutoProxyCreatorIfNecessary()
    
    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
    
    // 主要就是为了注册AnnotationAwareAspectJAutoProxyCreator类
    
    return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    
    }
    
    
    // 注册类相关代码
    
    private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
    
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
    
    BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
    
    if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
    
    int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
    
    int requiredPriority = findPriorityForClass(cls);
    
    if (currentPriority < requiredPriority) {
    
    apcDefinition.setBeanClassName(cls.getName());
    
    }
    
    }
    
    return null;
    
    }
    
    
    // 类似于我们在使用BeanFactory.getBean()时候的操作，生成一个RootBeanDefinition，然后放入map中
    
    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    
    beanDefinition.setSource(source);
    
    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    
    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    
    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    
    return beanDefinition;
    
    }

**总结：通过以上的代码分析，可知，AspectJAutoProxyBeanDefinitionParser主要的功能就是将AnnotationAwareAspectJAutoProxyCreator注册到Spring容器中，把bean交给Spring去托管。**

AnnotationAwareAspectJAutoProxyCreator的功能我们大胆猜测一下：应该也就是生成对象的代理类的相关功能，这个我们接下来再看。

**问题：**

那么问题来了，我们最开始的类AopNamespaceHandler.init()方法是在什么时候被调用的呢？什么时候生效的？这个决定了我们注册到Spring的AnnotationAwareAspectJAutoProxyCreator的生效时间？读者可自行思考下。

###   **3）分析AnnotationAwareAspectJAutoProxyCreator主要行为** ###

通过查看AnnotationAwareAspectJAutoProxyCreator的类层次结构，可知，其实现了BeanPostProcessor接口，实现类为AbstractAutoProxyCreator

类层次结构如下：

### ![70][]    **4）AbstractAutoProxyCreator主要方法** ###

@Override
    
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
    
    return bean;
    
    }
    
    
    // 主要看这个方法，在bean初始化之后对生产出的bean进行包装
    
    @Override
    
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    
    if (bean != null) {
    
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    
    if (!this.earlyProxyReferences.contains(cacheKey)) {
    
    return wrapIfNecessary(bean, beanName, cacheKey);
    
    }
    
    }
    
    return bean;
    
    }
    
    
    // wrapIfNecessary
    
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    
    if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
    
    return bean;
    
    }
    
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
    
    return bean;
    
    }
    
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
    
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    
    return bean;
    
    }
    
    
    // Create proxy if we have advice.
    
    // 意思就是如果该类有advice则创建proxy，
    
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    
    if (specificInterceptors != DO_NOT_PROXY) {
    
    this.advisedBeans.put(cacheKey, Boolean.TRUE);
    
    // 1.通过方法名也能简单猜测到，这个方法就是把bean包装为proxy的主要方法，
    
    Object proxy = createProxy(
    
    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
    
    this.proxyTypes.put(cacheKey, proxy.getClass());
    
    
    // 2.返回该proxy代替原来的bean
    
    return proxy;
    
    }
    
    
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    
    return bean;
    
    }

总结：

**1）通过AspectJAutoProxyBeanDefinitionParser类将AnnotationAwareAspectJAutoProxyCreator注册到Spring容器中**

**2）AnnotationAwareAspectJAutoProxyCreator类的postProcessAfterInitialization()方法将所有有advice的bean重新包装成proxy**

## **4.创建proxy过程分析** ##

通过之前的代码结构分析，我们知道，所有的bean在返回给用户使用之前都需要经过AnnotationAwareAspectJAutoProxyCreator类的postProcessAfterInitialization()方法，而该方法的主要作用也就是将所有拥有advice的bean重新包装为proxy，那么我们接下来直接分析这个包装为proxy的方法即可，看一下bean如何被包装为proxy，proxy在被调用方法时，是具体如何执行的

**以下是AbstractAutoProxyCreator.wrapIfNecessary(Object bean, String beanName, Object cacheKey)中的createProxy()代码片段分析**

protected Object createProxy(
    
    Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
    
    
    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
    
    AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    
    }
    
    
    // 1.创建proxyFactory，proxy的生产主要就是在proxyFactory做的
    
    ProxyFactory proxyFactory = new ProxyFactory();
    
    proxyFactory.copyFrom(this);
    
    
    if (!proxyFactory.isProxyTargetClass()) {
    
    if (shouldProxyTargetClass(beanClass, beanName)) {
    
    proxyFactory.setProxyTargetClass(true);
    
    }
    
    else {
    
    evaluateProxyInterfaces(beanClass, proxyFactory);
    
    }
    
    }
    
    
    // 2.将当前bean适合的advice，重新封装下，封装为Advisor类，然后添加到ProxyFactory中
    
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    
    for (Advisor advisor : advisors) {
    
    proxyFactory.addAdvisor(advisor);
    
    }
    
    
    proxyFactory.setTargetSource(targetSource);
    
    customizeProxyFactory(proxyFactory);
    
    
    proxyFactory.setFrozen(this.freezeProxy);
    
    if (advisorsPreFiltered()) {
    
    proxyFactory.setPreFiltered(true);
    
    }
    
    
    // 3.调用getProxy获取bean对应的proxy
    
    return proxyFactory.getProxy(getProxyClassLoader());
    
    }

###  **1）创建何种类型的Proxy？JDKProxy还是CGLIBProxy？** ###

// getProxy()方法
    
    public Object getProxy(ClassLoader classLoader) {
    
    return createAopProxy().getProxy(classLoader);
    
    }
    
    
    
    // createAopProxy()方法就是决定究竟创建何种类型的proxy
    
    protected final synchronized AopProxy createAopProxy() {
    
    if (!this.active) {
    
    activate();
    
    }
    
    // 关键方法createAopProxy()
    
    return getAopProxyFactory().createAopProxy(this);
    
    }
    
    
    // createAopProxy()
    
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    
    // 1.config.isOptimize()是否使用优化的代理策略，目前使用与CGLIB
    
    // config.isProxyTargetClass() 是否目标类本身被代理而不是目标类的接口
    
    // hasNoUserSuppliedProxyInterfaces()是否存在代理接口
    
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
    
    Class<?> targetClass = config.getTargetClass();
    
    if (targetClass == null) {
    
    throw new AopConfigException("TargetSource cannot determine target class: " +
    
    "Either an interface or a target is required for proxy creation.");
    
    }
    
    
    // 2.如果目标类是接口或者是代理类，则直接使用JDKproxy
    
    if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
    
    return new JdkDynamicAopProxy(config);
    
    }
    
    
    // 3.其他情况则使用CGLIBproxy
    
    return new ObjenesisCglibAopProxy(config);
    
    }
    
    else {
    
    return new JdkDynamicAopProxy(config);
    
    }
    
    }

2）getProxy()方法

由1）可知，通过createAopProxy()方法来确定具体使用何种类型的Proxy

针对于该示例，我们具体使用的为JdkDynamicAopProxy，下面来看下JdkDynamicAopProxy.getProxy()方法

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable// JdkDynamicAopProxy类结构，由此可知，其实现了InvocationHandler，则必定有invoke方法，来被调用，也就是用户调用bean相关方法时，此invoke()被真正调用
    
    
    // getProxy()
    
    public Object getProxy(ClassLoader classLoader) {
    
    if (logger.isDebugEnabled()) {
    
    logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    
    }
    
    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    
    
    // JDK proxy 动态代理的标准用法
    
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    
    }

3）invoke()方法

以上的代码模式可以很明确的看出来，使用了JDK动态代理模式，真正的方法执行在invoke()方法里，下面我们来看下该方法，来看下bean方法如何被代理执行的

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    MethodInvocation invocation;
    
    Object oldProxy = null;
    
    boolean setProxyContext = false;
    
    
    TargetSource targetSource = this.advised.targetSource;
    
    Class<?> targetClass = null;
    
    Object target = null;
    
    
    try {
    
    // 1.以下的几个判断，主要是为了判断method是否为equals、hashCode等Object的方法
    
    if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
    
    // The target does not implement the equals(Object) method itself.
    
    return equals(args[0]);
    
    }
    
    else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
    
    // The target does not implement the hashCode() method itself.
    
    return hashCode();
    
    }
    
    else if (method.getDeclaringClass() == DecoratingProxy.class) {
    
    // There is only getDecoratedClass() declared -> dispatch to proxy config.
    
    return AopProxyUtils.ultimateTargetClass(this.advised);
    
    }
    
    else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
    
    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
    
    // Service invocations on ProxyConfig with the proxy config...
    
    return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
    
    }
    
    
    Object retVal;
    
    
    if (this.advised.exposeProxy) {
    
    // Make invocation available if necessary.
    
    oldProxy = AopContext.setCurrentProxy(proxy);
    
    setProxyContext = true;
    
    }
    
    
    // May be null. Get as late as possible to minimize the time we "own" the target,
    
    // in case it comes from a pool.
    
    target = targetSource.getTarget();
    
    if (target != null) {
    
    targetClass = target.getClass();
    
    }
    
    
    // 2.获取当前bean被拦截方法链表
    
    List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
    
    
    // 3.如果为空，则直接调用target的method
    
    if (chain.isEmpty()) {
    
    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
    
    retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
    
    }
    
    // 4.不为空，则逐一调用chain中的每一个拦截方法的proceed
    
    else {
    
    // We need to create a method invocation...
    
    invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
    
    // Proceed to the joinpoint through the interceptor chain.
    
    retVal = invocation.proceed();
    
    }
    
    
    ...
    
    return retVal;
    
    }
    
    ...
    
    }

###  **4）拦截方法真正被执行调用invocation.proceed()** ###

public Object proceed() throws Throwable {
    
    // We start with an index of -1 and increment early.
    
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
    
    return invokeJoinpoint();
    
    }
    
    
    Object interceptorOrInterceptionAdvice =
    
    this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
    
    // Evaluate dynamic method matcher here: static part will already have
    
    // been evaluated and found to match.
    
    InterceptorAndDynamicMethodMatcher dm =
    
    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
    
    if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
    
    return dm.interceptor.invoke(this);
    
    }
    
    else {
    
    // Dynamic matching failed.
    
    // Skip this interceptor and invoke the next in the chain.
    
    return proceed();
    
    }
    
    }
    
    else {
    
    // It's an interceptor, so we just invoke it: The pointcut will have
    
    // been evaluated statically before this object was constructed.
    
    return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    
    }
    
    }

总结4：依次遍历拦截器链的每个元素，然后调用其实现，将真正调用工作委托给各个增强器

**总结：**

**纵观以上过程可知：实际就是为bean创建一个proxy，JDKproxy或者CGLIBproxy，然后在调用bean的方法时，会通过proxy来调用bean方法**

**重点过程可分为：**

**1）通过AspectJAutoProxyBeanDefinitionParser类将AnnotationAwareAspectJAutoProxyCreator注册到Spring容器中**

**2）AnnotationAwareAspectJAutoProxyCreator类的postProcessAfterInitialization()方法将所有有advice的bean重新包装成proxy**

**3）调用bean方法时通过proxy来调用，proxy依次调用增强器的相关方法，来实现方法切入**

[JDK]: https://www.baidu.com/s?wd=JDK&tn=24004469_oem_dg&rsv_dl=gh_pl_sl_csd
[70]: /images/20220315/5ac6c452705c4761aa7775a2a3da5e4b.png