关于spring:Spring源码核心剖析-京东云技术团队

SpringAOP 作为 Spring 最外围的能力之一，其重要性显而易见。而后须要晓得的是 AOP 并不只是 Spring 特有的性能，而是一种思维，一种通用的性能。而 SpringAOP 只是在 AOP 的根底上将能力集成到 SpringIOC 中，使其作为 bean 的一种，从而咱们可能很不便的进行应用。

当咱们在日常业务开发中，例如有些功能模块是通用的（日志、权限等），或者咱们须要在某些性能前后去做一些加强，例如在某些办法执行后发送一条 mq 音讯等。

如果咱们将这些通用模块代码与业务代码放在一块，那么每个业务代码都要写这些通用模块，保护老本与耦合状况都非常重大。

因而，咱们能够将此模块形象进去，就有了”切面“的概念。

AOP 的应用形式绝对比较简单，首先咱们须要实现业务代码

@Service
public class AopDemo implements AopInterface{public Student start(String name) {System.out.println("执行业务逻辑代码.....");
        return new Student(name);
    }

}

业务逻辑比较简单，接管一个 name 参数。

接下来咱们须要创立其对应的切面

// 将该切面退出 spring 容器
@Service
// 申明该类为一个切面
@Aspect
class AopAspect {

    // 申明要进行代理的办法
    @Pointcut("execution(* com.example.demo.aop.AopInterface.start(..))")
    public void startAspect() {}

    // 在办法执行之前的逻辑
    @Before(value = "startAspect()")
    public void beforeAspect() {System.out.println("业务逻辑前代码.....");
    }

    // 在办法执行之后的逻辑
    @After(value = "startAspect()")
    public void afterAspect() {System.out.println("业务逻辑后代码.....");
    }

    // 围绕办法前后的逻辑
    @Around("startAspect()")
    public Object aroundAspect(ProceedingJoinPoint point) throws Throwable {Object[] requestParams = point.getArgs();
        String name = requestParams[0].toString();
        System.out.println("传入参数:" + name);
        requestParams[0] = "bob";
        return point.proceed(requestParams);
    }

}

能够看到，首先须要咱们指明要代理的对象及办法，而后依据须要抉择不同的注解即可实现代理对象。

传入参数:tom
业务逻辑前代码.....
执行业务逻辑代码.....
业务逻辑后代码.....

依据下面的应用状况，咱们晓得只须要申明对应的注解即可，不须要其余额定的配置，而后咱们取得的 bean 对象就曾经是被代理的了，那么咱们能够推断代理对象的过程肯定是产生在 bean 创立的过程的。

咱们回顾一下创立 bean 的流程

实例化 bean
拆卸属性
初始化 bean

只有第三步初始化 bean 的时候才会有机会进行代理。

找到对应的代码地位：

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      // 前置处理器
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }
     //...
   try {
      // 对象的初始化办法
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      // 后置处理器，AOP 开始的中央
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

后置处理器会执行那些实现了后置处理器接口的代码：

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   // 获取所有的后置处理器
   for (BeanPostProcessor processor : getBeanPostProcessors()) {
      // 实现其要执行的办法
      Object current = processor.postProcessAfterInitialization(result, beanName);
      if (current == null) {return result;}
      result = current;
   }
   return result;
}

而 AOP 的后置处理器就是其中的一个：AbstractAutoProxyCreator

其对应的办法为（以下代码不为同一个类，而是对应的执行程序）：

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {if (bean != null) {Object cacheKey = getCacheKey(bean.getClass(), beanName);
      if (this.earlyProxyReferences.remove(cacheKey) != bean) {
         // 执行到上面办法
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        // Create proxy if we have advice.
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {this.advisedBeans.put(cacheKey, Boolean.TRUE);
      // 创立代理对象
            Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
}

protected Object createProxy(Class beanClass, @Nullable String beanName,
            @Nullable Object[] specificInterceptors, TargetSource targetSource) {

        // 获取 advisors
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        proxyFactory.addAdvisors(advisors);
        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {proxyFactory.setPreFiltered(true);
        }

        // Use original ClassLoader if bean class not locally loaded in overriding class loader
        ClassLoader classLoader = getProxyClassLoader();
        if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();}
    // 通过代理工厂创立代理对象
        return proxyFactory.getProxy(classLoader);
}

public Object getProxy(@Nullable ClassLoader classLoader) {
    // 首先获取对应的代理
        return createAopProxy().getProxy(classLoader);
}

// 该办法依据要被代理的类抉择应用 jdk 代理还是 cglib 代理
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {if (!NativeDetector.inNativeImage() &&
                (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {Class targetClass = config.getTargetClass();
      // 如果被代理的类是一个接口则应用 jdk 代理
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass) || ClassUtils.isLambdaClass(targetClass))             {return new JdkDynamicAopProxy(config);
            }
      // 否则应用 cglib 代理
            return new ObjenesisCglibAopProxy(config);
        }
        else {
      // 依据配置抉择强制应用 jdk 代理
            return new JdkDynamicAopProxy(config);
        }
}

咱们晓得，代理形式有 jdk 动静代理与 cglib 动静代理两种形式，而咱们一个 bean 应用那种代理形式则由上述的办法决定。

至此，咱们曾经确定了应用那种 代理形式 获取代理对象。

从上文中，咱们曾经确定了选用何种形式构建代理对象。接下来就是通过不同的形式是如何获取代理对象的。

看懂本章须要实现理解 jdk 动静代理或者 cglib 动静代理的形式。

首先在获取代理对象时抉择 JdkDynamicAopProxy

public Object getProxy(@Nullable ClassLoader classLoader) {if (logger.isTraceEnabled()) {logger.trace("Creating JDK dynamic proxy:" + this.advised.getTargetSource());
   }
   // 这里通过反射创立代理对象
   return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
}

当被代理 对象执行被代理的办法 时，会进入到此办法。（jdk 动静代理的概念）

JDK 通过反射创建对象，效率上来说绝对低一些。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        try {
            // 获取被代理对象的所有切入点
            List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            // 如果调用链路为空阐明没有须要执行的切入点，间接执行对应的办法即可
            if (chain.isEmpty()) {
                // We can skip creating a MethodInvocation: just invoke the target directly
                // Note that the final invoker must be an InvokerInterceptor so we know it does
                // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // 如果有切入点的话则依照切入点程序开始执行
                MethodInvocation invocation =
                        new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                // Proceed to the joinpoint through the interceptor chain.
                retVal = invocation.proceed();}
            
            return retVal;
        }
}

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) {
      InterceptorAndDynamicMethodMatcher dm =
            (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
      Class targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
      if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {return dm.interceptor.invoke(this);
      }
      else {
         // 继续执行
         return proceed();}
   }
   else {// 如果调用链路还继续的话，下一个办法仍会调用 proceed()
      return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
   }
}

public Object getProxy(@Nullable ClassLoader classLoader) {

   try {
      // 配置 CGLIB Enhancer...
      Enhancer enhancer = createEnhancer();
      if (classLoader != null) {enhancer.setClassLoader(classLoader);
         if (classLoader instanceof SmartClassLoader &&
               ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {enhancer.setUseCache(false);
         }
      }
      enhancer.setSuperclass(proxySuperClass);
      enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
      enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
      enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));

      //1. 获取回调函数, 对于代理类上所有办法的调用，都会调用 CallBack，而 Callback 则须要实现 intercept()办法
      Callback[] callbacks = getCallbacks(rootClass);
      Class[] types = new Class[callbacks.length];
      for (int x = 0; x < types.length; x++) {types[x] = callbacks[x].getClass();}
      // fixedInterceptorMap only populated at this point, after getCallbacks call above
      enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
      enhancer.setCallbackTypes(types);

      //2. 创立代理对象
      return createProxyClassAndInstance(enhancer, callbacks);
   }
   catch (CodeGenerationException | IllegalArgumentException ex) {throw new AopConfigException("Could not generate CGLIB subclass of" + this.advised.getTargetClass() +
            ": Common causes of this problem include using a final class or a non-visible class",
            ex);
   }
   catch (Throwable ex) {// TargetSource.getTarget() failed
      throw new AopConfigException("Unexpected AOP exception", ex);
   }
}

能够看到咱们在创立代理对象前会先获取代理对象的所有回调函数：

首先能够看到咱们一共有 7 个回调办法，其中第一个为 AOP 相干的办法，其余的为 spring 相干。

在第一个对调对象中持有的 advised 对象中有 advisors 属性，就是对应咱们的代理类中四个切片，@Before 等等。

而后咱们看一下 createProxyClassAndInstance()都做了什么。

//CglibAopProxy 类的创立代理对象办法
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {enhancer.setInterceptDuringConstruction(false);
   enhancer.setCallbacks(callbacks);
   return (this.constructorArgs != null && this.constructorArgTypes != null ?
         enhancer.create(this.constructorArgTypes, this.constructorArgs) :
         enhancer.create());
}

//ObjenesisCglibAopProxy 继承了 CglibAopProxy 类，并覆写了其办法
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {Class proxyClass = enhancer.createClass();
        Object proxyInstance = null;

    //1. 尝试应用 objenesis 创建对象
        if (objenesis.isWorthTrying()) {
            try {proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
            }
            catch (Throwable ex) {
                logger.debug("Unable to instantiate proxy using Objenesis," +
                        "falling back to regular proxy construction", ex);
            }
        }

    //2. 依据 commit 的提交记录发现，objenesis 有可能创建对象失败，如果失败的话则选用喷射的形式创建对象
        if (proxyInstance == null) {
            // Regular instantiation via default constructor...
            try {
                Constructor ctor = (this.constructorArgs != null ?
                        proxyClass.getDeclaredConstructor(this.constructorArgTypes) :
                        proxyClass.getDeclaredConstructor());
                ReflectionUtils.makeAccessible(ctor);
                proxyInstance = (this.constructorArgs != null ?
                        ctor.newInstance(this.constructorArgs) : ctor.newInstance());
            }
            catch (Throwable ex) {
                throw new AopConfigException("Unable to instantiate proxy using Objenesis," +
                        "and regular proxy instantiation via default constructor fails as well", ex);
            }
        }

    //
        ((Factory) proxyInstance).setCallbacks(callbacks);
        return proxyInstance;
    }

此处有个遇到的问题，当我在 debug 的时候，发现怎么都进不去 createProxyClassAndInstance()，百思不得其解，而后看到 IDEA 旁边有一个向下的箭头，代表该办法可能其子类被覆写了。而后在其子类处打断点果然发现是其子类的实现。

此处在 2.2 中也可看到：

能够看到返回的是其子类的对象，而不是 CglibAopProxy 自身的对象。

作者：京东科技韩国凯

起源：京东云开发者社区

关于spring:Spring源码核心剖析-京东云技术团队

前言

一、SpringAOP 的应用形式

1.1 应用场景

1.2 罕用形式

二、SpringAOP 源码解析

2.1 被代理对象的开始 initializeBean

2.2 后置处理器 applyBeanPostProcessorsAfterInitialization

2.3 获取代理对象

2.3.1 JDK 代理

2.3.2 cglib 代理

2.3.3 cglib