一、學習指引

Spring中的@Lazy注解真的可以實現Bean的延遲創建嗎？

平時工作過程中，不知道大家有沒有遇到過這樣一種場景：應用程序可能會在啟動的時候創建大量的對象，加載大量的配置文件來進行初始化工作。但是在程序運行的過程中，這些對象或者配置文件使用的頻率并不是很頻繁，甚至是只有個別很少使用的功能在使用這些配置文件。

此時，為了優化應用的啟動性能，我們就可以對這些對象的創建和配置文件的加載進行延遲處理。也就是說，在應用啟動的時候不去創建這些對象和加載配置文件，而是到觸發某些功能操作時，再去創建這些對象和加載配置文件，這就是一種延遲處理的操作。

在設計模式的單例模式中，會分為懶漢模式和餓漢模式，其中，懶漢模式就是一種延遲創建對象的模式。

二、注解說明

關于@Lazy注解的一點點說明~~

對于單例Bean來說，如果不想在IOC容器啟動的時候就創建Bean對象，而是在第一次使用時創建Bean對象，就可以使用@Lazy注解進行處理。

2.1 注解源碼

@Lazy注解可以標注到類、方法、構造方法、參數和屬性字段上，能夠實現在啟動IOC容器時，不創建單例Bean，而是在第一次使用時創建單例Bean對象。源碼詳見：org.springframework.context.annotation.Lazy。

/**
 * @author Chris Beams
 * @author Juergen Hoeller
 * @since 3.0
 */
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Lazy {
 boolean value() default true;
}

從源碼可以看出，@Lazy注解是從Spring3.0版本開始提供的注解，其中，只提供了一個boolean類型的value屬性，具體含義如下所示。

• value：boolean類型的屬性，表示是否延遲創建單例Bean，默認值為true。

true：表示延遲創建單例Bean，此時在IOC啟動時不會創建Bean對象，而是在第一次使用時創建單例Bean對象。

false：表示不延遲創建單例Bean對象，IOC容器啟動時，就會創建單例Bean對象。

注意：使用@Lazy直接延遲創建單例Bean，不是延遲加載思想，因為不是每次使用時都創建，只是改變了第一次創建單例Bean的時機。

2.2 使用場景

在實際開發過程中，如果使用Spring創建的Bean是單例對象時，有時并不是每個單例Bean對象都需要在IOC容器啟動時就創建，有些單例Bean可以在使用的時候再創建。此時，就可以使用@Lazy注解實現這樣的場景。

注意：@Lazy注解只對單例Bean對象起作用，如果使用@Scope注解指定為多例Bean對象，則@Lazy注解將不起作用。

三、使用案例

@Lazy的實現案例，我們一起實現吧~~

本節，就使用@Lazy注解實現延遲創建Bean的案例。本節主要從創建單例Bean、添加@Lazy注解和獲取單例Bean三個方面實現案例程序。

3.1 創建單例Bean

本小節，完成創建單例Bean的案例部分，具體步驟如下所示。

（1）新增LazyBean類

LazyBean類的源碼詳見：spring-annotation-chapter-09工程下的io.binghe.spring.annotation.chapter09.bean.LazyBean。

public class LazyBean {
    public LazyBean(){
        System.out.println("執行LazyBean類的構造方法...");
    }
}

可以看到，LazyBean類就是一個普通的實體類對象，在LazyBean類的構造方法中，打印了執行LazyBean類的構造方法...的日志。

（2）新增LazyConfig類

LazyConfig類的源碼詳見：spring-annotation-chapter-09工程下的io.binghe.spring.annotation.chapter09.config.LazyConfig。

@Configuration
public class LazyConfig {
    @Bean
    public LazyBean lazyBean(){
        return new LazyBean();
    }
}

可以看到，LazyConfig類是Spring中的配置類，在LazyConfig類中使用@Bean注解創建了LazyBean類的單例Bean對象，同時在lazyBean()方法上并沒有標注@Lazy注解。

（3）新增LazyTest類

LazyTest類的源碼詳見：spring-annotation-chapter-09工程下的io.binghe.spring.annotation.chapter09.LazyTest。

public class LazyTest {
    public static void main(String[] args) {
        System.out.println("創建IOC容器開始...");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LazyConfig.class);
        System.out.println("創建IOC容器結束");
    }
}

可以看到，LazyTest類主要是測試案例程序，在main()方法中，創建了IOC容器，并在創建IOC容器前后打印了相關的日志信息。

（4）運行LazyTest類

運行LazyTest類中的main()方法，輸出的結果信息如下所示。

創建IOC容器開始...
執行LazyBean類的構造方法...
創建IOC容器結束...

從輸出的結果信息可以看出，打印了LazyBean類的構造方法中輸出的日志信息。

說明：Spring會在IOC容器啟動時，創建單例Bean。

3.2 添加@Lazy注解

本小節在3.1小節的基礎上，完成案例添加@Lazy注解的部分，具體實現步驟如下所示。

（1）修改LazyConfig類

在LazyConfig類的lazyBean()方法上添加@Lazy注解，如下所示。

@Bean
@Lazy
public LazyBean lazyBean(){
    return new LazyBean();
}

（2）運行LazyTest類

運行LazyTest類中的main()方法，輸出的結果信息如下所示。

創建IOC容器開始...
創建IOC容器結束...

可以看到，輸出的結果信息中并沒有打印LazyBean類的構造方法中輸出的日志信息。

說明：在創建單實例Bean的方法上添加@Lazy注解時，當IOC容器啟動時，并不會創建單例Bean。

3.3 獲取單例Bean

本小節在3.2小節的基礎上，完成案例獲取單例Bean的部分，具體實現步驟如下所示。

（1）修改LazyTest類

在LazyTest類的main()方法中，創建完IOC容器，從IOC容器中多次獲取LazyBean類的Bean對象，如下所示。

public class LazyTest {
    public static void main(String[] args) {
        System.out.println("創建IOC容器開始...");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LazyConfig.class);
        System.out.println("創建IOC容器結束...");
        System.out.println("從IOC容器中獲取Bean開始...");
        LazyBean lazyBean1 = context.getBean(LazyBean.class);
        LazyBean lazyBean2 = context.getBean(LazyBean.class);
        System.out.println("(lazyBean1 是否等于 lazyBean2) ===>>> " + (lazyBean1 == lazyBean2));
        System.out.println("從IOC容器中獲取Bean結束...");
    }
}

可以看到，在LazyTest類的構造方法中，創建完IOC容器中，從IOC容器中連續獲取兩次LazyBean類的Bean對象，并打印兩次獲取的Bean對象是否相等。

（2）運行LazyTest類

運行LazyTest類中的main()方法，輸出的結果信息如下所示。

創建IOC容器開始...
創建IOC容器結束...
從IOC容器中獲取Bean開始...
執行LazyBean類的構造方法...
(lazyBean1 是否等于 lazyBean2) ===>>> true
從IOC容器中獲取Bean結束...

從輸出的結果信息可以看出，從第一次從IOC容器中獲取Bean對象時，打印了LazyBean類的構造方法中輸出的日志信息，并且兩次從IOC容器中獲取到的Bean對象相同。

說明：當在創建單例Bean的方法上標注@Lazy注解時，啟動IOC容器并不會創建對應的單例Bean對象，而是在第一次獲取Bean對象時才會創建，同時，由于Spring創建的是單例Bean對象，所以，無論從IOC容器中獲取多少次對象，每次獲取到的Bean對象都是相同的。

四、源碼時序圖

結合時序圖理解源碼會事半功倍，你覺得呢？

本節，就以源碼時序圖的方式，直觀的感受下@Lazy注解在Spring源碼層面的執行流程。本節，主要從注冊Bean、調用Bean工廠后置處理器和創建單例Bean三個方面分析源碼時序圖。

4.1 注冊Bean的源碼時序圖

@Lazy注解涉及到的注冊Bean的源碼時序圖如圖9-1所示。

由圖9-1可以看出，@Lazy注解在注冊Bean的流程中涉及到LazyTest類、AnnotationConfigApplicationContext類、AnnotatedBeanDefinitionReader類、AnnotationConfigUtils類、BeanDefinitionReaderUtils類和DefaultListableBeanFactory類。具體的源碼執行細節參見源碼解析部分。

4.2 調用Bean后置處理器的源碼時序圖

@Lazy注解涉及到的調用Bean工廠后置處理器的源碼時序圖如圖9-2~9-4所示。

由圖9-2~9-4可以看出，@Lazy注解涉及到的調用Bean工廠后置處理器的流程涉及到LazyTest類、AnnotationConfigApplicationContext類、AbstractApplicationContext類、PostProcessorRegistrationDelegate類、ConfigurationClassPostProcessor類、ConfigurationClassParser類、ComponentScanAnnotationParser類、ClassPathBeanDefinitionScanner類、AnnotationConfigUtils類、BeanDefinitionReaderUtils類和DefaultListableBeanFactory類。具體的源碼執行細節參見源碼解析部分。

4.3  創建單例Bean的源碼時序圖

@Lazy注解涉及到的創建Bean的源碼時序圖如圖9-5所示。

由圖9-5可以看出，@Lazy注解涉及到的創建Bean的流程涉及到LazyTest類、AnnotationConfigApplicationContext類、AbstractApplicationContext類、DefaultListableBeanFactory類和AbstractBeanFactory類。具體的源碼執行細節參見源碼解析部分。

五、源碼解析

源碼時序圖整清楚了，那就整源碼解析唄！

本節，主要分析@Lazy注解在Spring源碼層面的執行流程，結合源碼執行的時序圖，會理解的更加深刻。本節，同樣會從注冊Bean、調用Bean工廠后置處理器和創建單例Bean三個方面分析源碼的執行流程。

5.1 注冊Bean的源碼流程

@Lazy注解在Spring源碼層面注冊Bean的執行流程，結合源碼執行的時序圖，會理解的更加深刻，本節的源碼執行流程可以結合圖9-1進行理解。

@Lazy注解涉及到的注冊Bean的源碼流程與第7章5.1小節@DependsOn注解涉及到的注冊Bean的源碼流程大體相同，只是在解析AnnotatedBeanDefinitionReader類的doRegisterBean()方法時，略有不同。本小節，就從AnnotatedBeanDefinitionReader類的doRegisterBean()方法開始解析。

（1）解析AnnotatedBeanDefinitionReader類的doRegisterBean()方法

源碼詳見：org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean(ClassbeanClass, String name, Class<? extends Annotation>[] qualifiers, Suppliersupplier, BeanDefinitionCustomizer[] customizers)。重點關注如下代碼片段。

private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier, @Nullable BeanDefinitionCustomizer[] customizers) {
 /***********省略其他代碼************/
    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    if (qualifiers != null) {
        for (Class<? extends Annotation> qualifier : qualifiers) {
            if (Primary.class == qualifier) {
                abd.setPrimary(true);
            }
            else if (Lazy.class == qualifier) {
                abd.setLazyInit(true);
            }
            else {
                abd.addQualifier(new AutowireCandidateQualifier(qualifier));
            }
        }
    }
    /**********省略其他代碼************/
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

可以看到，在AnnotatedBeanDefinitionReader類的doRegisterBean()方法中，調用了AnnotationConfigUtils類的processCommonDefinitionAnnotations()方法。

（2）解析AnnotationConfigUtils類的processCommonDefinitionAnnotations()方法

源碼詳見：org.springframework.context.annotation.AnnotationConfigUtils#processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd)。

public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
    processCommonDefinitionAnnotations(abd, abd.getMetadata());
}

可以看到，在AnnotationConfigUtils類的processCommonDefinitionAnnotations()方法中，直接調用了另一個重載的processCommonDefinitionAnnotations()方法。

（3）解析AnnotationConfigUtils類的processCommonDefinitionAnnotations()方法

源碼詳見：org.springframework.context.annotation.AnnotationConfigUtils#processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata)。

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
    AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
    if (lazy != null) {
        abd.setLazyInit(lazy.getBoolean("value"));
    }
    else if (abd.getMetadata() != metadata) {
        lazy = attributesFor(abd.getMetadata(), Lazy.class);
        if (lazy != null) {
            abd.setLazyInit(lazy.getBoolean("value"));
        }
    }
 /**********省略其他代碼***********/
}

可以看到，在AnnotationConfigUtils類的processCommonDefinitionAnnotations()方法中，會解析@Lazy注解中的value屬性，并將屬性值存入abd對象的lazyInit字段中。

（4）回到AnnotatedBeanDefinitionReader類的doRegisterBean()方法。

可以看到，在方法中遍歷qualifiers數組，如果Lazy.class的值與遍歷出的qualifier對象相等，就會將abd對象的lazyInit字段設置為true。如果abd對象的lazyInit字段為true，則后續在啟動IOC容器的過程中，就不會創建單例Bean對象。

后續的執行流程就與第7章5.1小節的執行流程相同，不再贅述。

至此，@Lazy注解涉及到的注冊Bean的源碼流程分析完畢。

5.2 調用Bean后置處理器的源碼流程

@Lazy注解在Spring源碼層面調用Bean工廠后置處理器的執行流程，結合源碼執行的時序圖，會理解的更加深刻，本節的源碼執行流程可以結合圖9-2~9-4進行理解。

@Lazy注解涉及到的調用Bean后置處理器的源碼流程，與第7章5.2小節@DependsOn注解涉及到的調用Bean后置處理器的源碼流程大體相同，只是在解析ComponentScanAnnotationParser類的parse()方法和AnnotationConfigUtils類的processCommonDefinitionAnnotations()方法時，略有不同。

（1）解析ComponentScanAnnotationParser類的parse()方法

源碼詳見：org.springframework.context.annotation.ComponentScanAnnotationParser#parse(AnnotationAttributes componentScan, String declaringClass)。重點關注如下代碼片段。

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, String declaringClass) {
    /**********省略其他代碼**********/
    boolean lazyInit = componentScan.getBoolean("lazyInit");
    if (lazyInit) {
        scanner.getBeanDefinitionDefaults().setLazyInit(true);
    }
 /**********省略其他代碼**********/
    return scanner.doScan(StringUtils.toStringArray(basePackages));
}

可以看到，在ComponentScanAnnotationParser類的parse()方法中，會獲取componentScan中的lazyInit屬性，如果屬性的值為true，會將scanner對象中beanDefinitionDefaults對象的lazyInit屬性設置為true。

（2）解析AnnotationConfigUtils類的processCommonDefinitionAnnotations()方法

此時，與本章5.1節注冊Bean的源碼流程中解析AnnotationConfigUtils類的processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata)方法的流程相同。不再贅述。

后續源碼的解析流程與第7章5.2小節解析源碼的流程相同，這里不再贅述。

至此，@Lazy注解涉及到的調用Bean后置處理器的源碼流程分析完畢。

5.3 創建單例Bean的源碼流程

@Lazy注解在Spring源碼層面創建單例Bean的執行流程，結合源碼執行的時序圖，會理解的更加深刻，本節的源碼執行流程可以結合圖9-5進行理解。

本節@Lazy注解創建單例Bean的源碼流程，與第7章中5.3小節中@DependsOn注解創建單例Bean的源碼流程大體相同，只是在DefaultListableBeanFactory類的preInstantiateSingletons()方法中略有差異。

DefaultListableBeanFactory類的preInstantiateSingletons()方法的源碼詳見：org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons()。重點關注如下代碼片段。

@Override
public void preInstantiateSingletons() throws BeansException {
    /************省略其他代碼**************/
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof SmartFactoryBean<?> smartFactoryBean && smartFactoryBean.isEagerInit()) {
                    getBean(beanName);
                }
            }
            else {
                getBean(beanName);
            }
        }
    }
 /************省略其他代碼**************/
}

可以看到，在preInstantiateSingletons()方法中，會循環遍歷解析出的Bean名稱，在循環中，會根據遍歷出的Bean名稱獲取RootBeanDefinition對象。接下來會進行如下判斷。

if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    /*************省略其他代碼*************/
}

可以看到，在preInstantiateSingletons()方法中，會判斷每次遍歷獲取出的RootBeanDefinition對象中如果標記的不是抽象類，并且是單實例對象，并且沒有設置延遲創建Bean。同時滿足這些條件后，參會調用getbean()方法創建對應的Bean對象，并注入到IOC容器中。

所以，使用@Lazy注解指定延遲創建對象后，啟動IOC容器時并不會創建對應的單例Bean，而是在第一次使用對應的Bean對象時，才會創建對應的單例Bean對象。

后續的源碼執行流程與第7章5.3小節的源碼執行流程相同，這里不再贅述。

至此，@Lazy注解在Spring源碼層面創建單例Bean的執行流程分析完畢。

六、總結

@Lazy注解介紹完了，我們一起總結下吧！

本章，首先介紹了@Lazy注解的源碼和使用場景，隨后介紹了@Lazy的使用案例。接下來，詳細介紹了@Lazy在Spring中執行的源碼時序圖和源碼流程。

七、思考

既然學完了，就開始思考幾個問題吧？

關于@Lazy注解，通常會有如下幾個經典面試題：

• @Lazy注解的作用是什么？
• @Lazy注解有哪些使用場景？
• @Lazy注解延遲創建Bean是如何實現的？
• @Lazy注解在Spring內部的執行流程？
• 你在平時工作中，會在哪些場景下使用@Lazy注解？
• 你從@Lazy注解的設計中得到了哪些啟發？