Spring5中lite@Bean方法的行为

Question

来自Spring 5文档

当@bean方法在未使用@configuration注释的类中声明时，它们被称为以'lite'模式处理。在@组件中，甚至在普通的旧类中声明的Bean方法将被视为“lite”，包含类的主要目的不同，而@Bean方法只是一种额外的好处。例如，服务组件可能通过每个适用的组件类上的附加@bean方法向容器公开管理视图。在这样的场景中，@bean方法是一种简单的通用工厂方法机制。

与full@configuration不同，lite@bean方法不能声明bean间依赖关系。相反，它们对包含组件的内部状态进行操作，并可选地对它们可能声明的参数进行操作。因此,这样的@bean方法不应该调用其他@bean方法；每个这样的方法实际上只是一个特定bean引用的工厂方法，没有任何特殊的运行时语义。这里的积极副作用是在运行时不需要应用CGLIB子类，因此在类设计方面没有限制（即包含类可能是最终类等）。

常规Spring组件中的@bean方法的处理方式不同于Spring@Configuration类中的对应方法。不同的是，@Component类没有用CGLIB增强以拦截方法和字段的调用。CGLIB代理是调用@configuration类中@bean方法中的方法或字段来创建对协作对象的bean元数据引用的手段；这样的方法不是用正常的Java语义调用的，而是通过容器来提供Spring bean的通常生命周期管理和代理，甚至在通过编程调用@bean方法引用其他bean时也是如此。相反，在普通@Component类中调用@Bean方法中的方法或字段具有标准的Java语义，不应用特殊的CGLIB处理或其他约束。

我希望下面的代码抛出的异常/bean1.bean2为null，并且不会执行init方法。但是，下面的代码运行良好并打印：

Should never be invoked
Expected null but is ch.litebeans.Bean2@402bba4f

所以对我来说，lite bean的行为与由@Configuration注释类构造的bean的行为是一样的。有人能指出在哪种情况下不是这样吗？

.

package ch.litebeans;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ApplicationConfig.class);
        Bean1 bean1 = ctx.getBean(Bean1.class);
        System.out.println("Expected null but is " + bean1.getBean2());
    }
}

package ch.litebeans;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = {"ch.litebeans"})
public class ApplicationConfig {}

package ch.litebeans;

import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class Factory1 {
    @Bean
    public Bean1 getBean1(Bean2 bean2){
        return new Bean1(bean2);
    }
}

package ch.litebeans;

import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class Factory2 {
    @Bean(initMethod = "init")
    public Bean2 getBean2(){
        return new Bean2();
    }
}

package ch.litebeans;

public class Bean1 {
    private Bean2 bean2;
    public Bean1(Bean2 bean2){
        this.bean2 = bean2;
    }
    public Bean2 getBean2(){
        return bean2;
    }
}

package ch.litebeans;

public class Bean2 {
    public void init(){
        System.out.println("Should never be invoked");
    }
}

编辑：

public class BeanLiteRunner {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext acac = new AnnotationConfigApplicationContext(MyComponent.class,
                MyConfiguration.class);
        MyComponent.MyComponentBean1 componentBean1 = acac.getBean(MyComponent.MyComponentBean1.class);
        MyComponent.MyComponentBean1 componentBean2 = acac.getBean(MyComponent.MyComponentBean1.class);

        MyConfiguration.MyConfigurationBean1 configurationBean1 = acac.getBean(MyConfiguration
                .MyConfigurationBean1.class);
        MyConfiguration.MyConfigurationBean1 configurationBean2 = acac.getBean(MyConfiguration
                .MyConfigurationBean1.class);
    }
}

@Component
public class MyComponent {

    @Bean
    public MyComponent.MyComponentBean1 getMyComponentBean1(){
        return new MyComponent.MyComponentBean1(getMyComponentBean2());
    }

    @Bean
    public MyComponent.MyComponentBean2 getMyComponentBean2(){
        return new MyComponent.MyComponentBean2();
    }


    public static class MyComponentBean1{
        public MyComponentBean1(MyComponent.MyComponentBean2 myComponentBean2){

        }
    }

    public static class MyComponentBean2{
        public MyComponentBean2(){
            System.out.println("Creating MyComponentBean2");
        }
    }
}

@Configuration
public class MyConfiguration {
    @Bean
    public MyConfigurationBean1 getMyConfigurationBean1(){
       return new MyConfigurationBean1(getMyConfigrationBean2());
    }

    @Bean
    public MyConfigurationBean2 getMyConfigrationBean2(){
        return new MyConfigurationBean2();
    }


    public static class MyConfigurationBean1{
        public MyConfigurationBean1(MyConfigurationBean2 myConfigurationBean2){}
    }

    public static class MyConfigurationBean2{
        public MyConfigurationBean2(){
            System.out.println("Creating MyConfigrationBean2");
        }
    }
}

> Creating MyComponentBean2 
> Creating MyComponentBean2 
> Creating MyConfigrationBean2

Answer 1

这不是窃听器。Spring的lite bean定义会在组件扫描期间自动添加到上下文中。使用工厂方法的Bean定义（即，所有@Bean定义的Bean）将自动尝试使用当前上下文自动连接参数。有关更多详细信息，请参阅ConstructorResolver#InstantiateUsingFactoryMethod。

所引用的文档可能并不完全清楚。“lite”和“full”bean配置之间的主要区别严格地说是在“full”(@configuration)模式下完成的代理。例如，如果我们在@configuration类中定义bean会发生什么：

@Configuration
public MyConfiguration {

    @Bean
    public Bean1 bean1() {
        return new Bean1(bean2());
    }

    @Bean
    public Bean2 bean2() {
        return new Bean2();
    }
}

从bean1()内调用bean2()实际上将从上下文引用单个bean2实例，而不是直接调用已实现的bean2()方法。实际上，从该配置类中进行多少bean2()方法调用并不重要--真正的bean2方法将只执行一次。

“lite”模式不代理这些方法，这意味着每个bean2()方法调用实际上将直接引用方法实现，而不会html" target="_blank">返回上下文中的bean。相反，它将创建一个不被上下文跟踪的新的单独实例（这是默认的Java行为）。