@configuration与@component类中的自调用行为

Question

我的问题是关于内部方法调用情况下的AOP Spring行为。

@Service
class Service {
    @Transactional
    public void method1() {
        method1();
    }

    @Transactional
    public void method2() {}
}

@Configuration
class MyConfiguration{
    @Bean
    public Object1 bean1() {
        return new Object1();
    }

    @Bean
    public Object1 bean2() { 
        Object1 b1 = bean1();
        return new Object2(b1);
    }
}

首先，您能从技术上解释一下为什么代理对象不拦截内部调用吗？其次，检查一下我对第二个示例的理解是否正确。

Answer 1

关于普通Spring(AOP)代理或动态代理（JDK,CGLIB）的一般工作原理的解释,请参阅我的另一个答案和示例代码。首先阅读这篇文章，您就会理解为什么不能通过Spring AOP拦截这些类型的代理的自调用。

至于@configuration类，它们的工作方式不同。为了避免已经创建的Spring bean仅仅因为它们的@bean工厂方法在外部或内部被再次调用而被再次创建，Spring为它们创建了特殊的CGLIB代理。

我的一个配置类如下所示：

java prettyprint-override">package spring.aop;

import org.springframework.context.annotation.*;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class ApplicationConfig {
  @Bean(name = "myInterfaceWDM")
  public MyInterfaceWithDefaultMethod myInterfaceWithDefaultMethod() {
    MyClassImplementingInterfaceWithDefaultMethod myBean = new MyClassImplementingInterfaceWithDefaultMethod();
    System.out.println("Creating bean: " + myBean);
    return myBean;
  }

  @Bean(name = "myTestBean")
  public Object myTestBean() {
    System.out.println(this);
    myInterfaceWithDefaultMethod();
    myInterfaceWithDefaultMethod();
    return myInterfaceWithDefaultMethod();
  }
}

package spring.aop;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext appContext = SpringApplication.run(DemoApplication.class, args);
        MyInterfaceWithDefaultMethod myInterfaceWithDefaultMethod =
          (MyInterfaceWithDefaultMethod) appContext.getBean("myInterfaceWDM");
        System.out.println(appContext.getBean("myTestBean"));
    }
}

此打印（编辑以删除我们不想看到的内容）：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.2.RELEASE)

2019-07-07 08:37:55.750  INFO 22656 --- [           main] spring.aop.DemoApplication               : Starting DemoApplication on (...)
(...)
Creating bean: spring.aop.MyClassImplementingInterfaceWithDefaultMethod@7173ae5b
spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a@72456279

运行应用程序时，方法MyInterfaceWithDefaultMethod()不会被多次调用，即使在MyTestBean()中有多次调用。为什么？

如果在MyTestBean()中的一个MyInterfaceWithDefaultMethod（）调用上放置一个断点，并让调试器停止，则可以了解更多信息。然后您可以通过评估代码来检查情况：

System.out.println(this);

spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a@72456279

因此config类实际上是一个CGLIB代理。但是它有什么方法呢？

for (Method method: this.getClass().getDeclaredMethods()) {
  System.out.println(method);
}

public final java.lang.Object spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.myTestBean()
public final spring.aop.MyInterfaceWithDefaultMethod spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.myInterfaceWithDefaultMethod()
public final void spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.setBeanFactory(org.springframework.beans.factory.BeanFactory) throws org.springframework.beans.BeansException
final spring.aop.MyInterfaceWithDefaultMethod spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.CGLIB$myInterfaceWithDefaultMethod$1()
public static void spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.CGLIB$SET_THREAD_CALLBACKS(org.springframework.cglib.proxy.Callback[])
public static void spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.CGLIB$SET_STATIC_CALLBACKS(org.springframework.cglib.proxy.Callback[])
public static org.springframework.cglib.proxy.MethodProxy spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.CGLIB$findMethodProxy(org.springframework.cglib.core.Signature)
final void spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.CGLIB$setBeanFactory$6(org.springframework.beans.factory.BeanFactory) throws org.springframework.beans.BeansException
static void spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.CGLIB$STATICHOOK4()
private static final void spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.CGLIB$BIND_CALLBACKS(java.lang.Object)
final java.lang.Object spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.CGLIB$myTestBean$0()
static void spring.aop.ApplicationConfig$$EnhancerBySpringCGLIB$$8b4ed8a.CGLIB$STATICHOOK3()

这看起来有点乱，让我们只打印方法名：

for (Method method: this.getClass().getDeclaredMethods()) {
  System.out.println(method.name);
}

myTestBean
myInterfaceWithDefaultMethod
setBeanFactory
CGLIB$myInterfaceWithDefaultMethod$1
CGLIB$SET_THREAD_CALLBACKS
CGLIB$SET_STATIC_CALLBACKS
CGLIB$findMethodProxy
CGLIB$setBeanFactory$6
CGLIB$STATICHOOK4
CGLIB$BIND_CALLBACKS
CGLIB$myTestBean$0
CGLIB$STATICHOOK3

代理实现任何接口吗？

for (Class<?> implementedInterface : this.getClass().getInterfaces()) {
  System.out.println(implementedInterface);
}

interface org.springframework.context.annotation.ConfigurationClassEnhancer$EnhancedConfiguration

好吧，有意思。让我们读一些Javadoc。实际上类ConfigurationClassEnhancer是包范围的，因此我们必须读取源代码内部的Javadoc：

通过生成一个CGLIB子类来增强配置类，该子类与Spring容器交互，以尊重@bean方法的bean作用域语义。每个这样的@bean方法都将在生成的子类中被重写，只有在容器实际请求构造新实例时才委托给实际的@bean方法实现。否则，对这种@bean方法的调用将作为返回容器的引用，通过名称获得相应的bean。

内部接口enhancedconfiguration实际上是公共的，但Javadoc仍然只在源代码中：

要由所有@Configuration CGLIB子类实现的标记接口。通过检查候选类是否已经可分配给它，例如已经被增强，来促进增强的幂等行为。还扩展了BeanFactoryAware,因为所有增强的@Configuration类都需要访问创建它们的BeanFactory。

请注意，该接口仅用于框架内部使用，但必须保持公共，以便允许访问从其他包（即用户代码）生成的子类。

现在，如果我们进入MyInterfaceWithDefaultMethod（）调用，我们会看到什么？生成的代理方法调用方法ConfigurationClassEnhancer.BeanMethodInterceptor.Intercept(..)，该方法的Javadoc表示：

增强@bean方法以检查提供的BeanFactory是否存在此bean对象。

在那里你可以看到其他的神奇的发生，但是描述真的会超出这个已经很长的答案的范围。