Full @Configuration和lite @Bean mode 是 Spring Java Config 中兩個非常有意思的概念。

先來看一下官方文件關於這兩者的相關內容：

The @Bean methods in a regular Spring component are processed differently than their counterparts inside a Spring @Configuration class. The difference is that @Component classes are not enhanced with CGLIB to intercept the invocation of methods and fields. CGLIB proxying is the means by which invoking methods or fields within @Bean methods in @Configuration classes creates bean metadata references to collaborating objects. Such methods are not invoked with normal Java semantics but rather go through the container in order to provide the usual lifecycle management and proxying of Spring beans, even when referring to other beans through programmatic calls to @Bean methods. In contrast, invoking a method or field in a @Bean method within a plain @Component class has standard Java semantics, with no special CGLIB processing or other constraints applying.

機器翻譯結果：常規Spring元件中的@Bean方法與Spring @Configuration類中的對應方法處理方式不同。不同之處在於，@Component類沒有使用CGLIB增強來攔截方法和欄位的呼叫。CGLIB代理是通過呼叫@Configuration類中的@Bean方法中的方法或欄位來建立對協作物件的bean元資料引用的方法。這些方法不是用普通的Java語義呼叫的，而是通過容器來提供Spring bean通常的生命週期管理和代理，即使在通過對@Bean方法的程式設計呼叫引用其他bean時也是如此。相反，在普通@Component類中呼叫@Bean方法中的方法或欄位具有標準的Java語義，不需要使用特殊的CGLIB處理或其他約束。

When @Bean methods are declared within classes that are not annotated with @Configuration, they are referred to as being processed in a “lite” mode. Bean methods declared in a @Component or even in a plain old class are considered to be “lite”, with a different primary purpose of the containing class and a @Bean method being a sort of bonus there. For example, service components may expose management views to the container through an additional @Bean method on each applicable component class. In such scenarios, @Bean methods are a general-purpose factory method mechanism. Unlike full @Configuration, lite @Bean methods cannot declare inter-bean dependencies. Instead, they operate on their containing component’s internal state and, optionally, on arguments that they may declare. Such a @Bean method should therefore not invoke other @Bean methods. Each such method is literally only a factory method for a particular bean reference, without any special runtime semantics. The positive side-effect here is that no CGLIB subclassing has to be applied at runtime, so there are no limitations in terms of class design (that is, the containing class may be final and so forth). In common scenarios, @Bean methods are to be declared within @Configuration classes, ensuring that “full” mode is always used and that cross-method references therefore get redirected to the container’s lifecycle management. This prevents the same @Bean method from accidentally being invoked through a regular Java call, which helps to reduce subtle bugs that can be hard to track down when operating in “lite” mode.

機器翻譯：當@Bean方法在沒有使用@Configuration註釋的類中宣告時，它們被稱為在“lite”模式下處理。在@Component中宣告的Bean方法，甚至在普通的舊類中宣告的Bean方法，都被認為是“lite”，包含類的主要目的不同，而@Bean方法在這裡是一種附加功能。例如，服務元件可以通過每個適用元件類上的附加@Bean方法向容器公開管理檢視。在這種情況下，@Bean方法是一種通用的工廠方法機制。與完整的@Configuration不同，lite @Bean方法不能宣告bean之間的依賴關係。相反，它們對包含它們的元件的內部狀態進行操作，並可選地對它們可能宣告的引數進行操作。因此，這樣的@Bean方法不應該呼叫其他@Bean方法。每個這樣的方法實際上只是一個特定bean引用的工廠方法，沒有任何特殊的執行時語義。這裡的積極副作用是在執行時不需要應用CGLIB子類，所以在類設計方面沒有限制(也就是說，包含的類可能是final類，等等)。在常見的場景中，@Bean方法將在@Configuration類中宣告，以確保始終使用“full”模式，並因此將交叉方法引用重定向到容器的生命週期管理。這可以防止通過常規Java呼叫意外呼叫相同的@Bean方法，這有助於減少在“lite”模式下操作時難以跟蹤的細微bug。

---

相關定義

• lite @Bean mode ：當@Bean方法在沒有使用@Configuration註解的類中宣告時稱之為lite @Bean mode
• Full @Configuration：如果@Bean方法在使用@Configuration註解的類中宣告時稱之為Full @Configuration

有何區別

總結一句話，Full @Configuration中的@Bean方法會被CGLIB所代理，而 lite @Bean mode中的@Bean方法不會被CGLIB代理。

舉個例子

有一普通Java類，現在分別使用Full @Configuration和 lite @Bean mode這兩種模式註冊到Spring容器中。

public class User {
    public User() {
        System.out.println("user create... hashCode :" + this.hashCode());
    }
}

Full @Configuration

配置類：

@Configuration
public class AppConfig {

    @Bean
    public User user() {
        return new User();
    }

    @Bean
    public String name(User user) {
        System.out.println(user.hashCode());
        System.out.println(user().hashCode());
        return "123";
    }
}

主程式：

public class FullMain {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        User user = context.getBean(User.class);
        System.out.println(user.hashCode());
        context.close();
    }
}

執行結果：

user create... hashCode :1709537756
1709537756
1709537756
1709537756

分析：@Bean是在使用了@Configuration註解的類上被宣告的，屬於Full @Configuration。@Configuration類中的@Bean地方會被CGLIB進行代理。Spring會攔截該方法的執行，在預設單例情況下，容器中只有一個Bean，所以我們多次呼叫user()方法，獲取的都是同一個物件。

注意：被CGLIB的方法是不能被宣告為private和final，因為CGLIB是通過生成子類來實現代理的，private和final方法是不能被子類Override的，也就是說，Full @Configuration模式下，@Bean的方法是不能不能被宣告為private和final，不然在啟動時Spring會直接報錯。

lite @Bean mode

配置類：

@Component
public class LiteAppConfig {

    @Bean
    public User user() {
        System.out.println("user() 方法執行");
        return new User();
    }

    @Bean
    public String name(User user) {
        System.out.println("name(User user) 方法執行");
        System.out.println(user.hashCode());
        System.out.println("再次呼叫user()方法: " + user().hashCode());
        return "123";
    }
}

主程式：

public class LiteMain {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LiteAppConfig.class);
        User user = context.getBean(User.class);
        System.out.println(user.hashCode());
        context.close();
    }
}

執行結果：

user() 方法執行
user create... hashCode :254413710
name(User user) 方法執行
254413710
user() 方法執行
user create... hashCode :1793329556
再次呼叫user()方法: 1793329556
254413710

分析：在lite @Bean mode模式下， @Bean方法不會被CGLIB代理，所以多次呼叫user()會生成多個user物件。

使用建議

為了防止出現一些奇怪的問題，建議都使用Full @Configuration。

---

歡迎關注個人公眾號：

相關推薦