一、學(xué)習(xí)指引

Spring中的@Lazy注解真的可以實現(xiàn)Bean的延遲創(chuàng)建嗎？

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

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

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

二、注解說明

關(guān)于@Lazy注解的一點點說明~~

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

2.1 注解源碼

@Lazy注解可以標(biāo)注到類、方法、構(gòu)造方法、參數(shù)和屬性字段上，能夠?qū)崿F(xiàn)在啟動IOC容器時，不創(chuàng)建單例Bean，而是在第一次使用時創(chuàng)建單例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類型的屬性，表示是否延遲創(chuàng)建單例Bean，默認(rèn)值為true。

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

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

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

2.2 使用場景

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

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

三、使用案例

@Lazy的實現(xiàn)案例，我們一起實現(xiàn)吧~~

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

3.1 創(chuàng)建單例Bean

本小節(jié)，完成創(chuàng)建單例Bean的案例部分，具體步驟如下所示。

（1）新增LazyBean類

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

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

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

（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注解創(chuàng)建了LazyBean類的單例Bean對象，同時在lazyBean()方法上并沒有標(biāo)注@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("創(chuàng)建IOC容器開始...");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LazyConfig.class);
        System.out.println("創(chuàng)建IOC容器結(jié)束");
    }
}

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

（4）運行LazyTest類

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

創(chuàng)建IOC容器開始...
執(zhí)行LazyBean類的構(gòu)造方法...
創(chuàng)建IOC容器結(jié)束...

從輸出的結(jié)果信息可以看出，打印了LazyBean類的構(gòu)造方法中輸出的日志信息。

說明：Spring會在IOC容器啟動時，創(chuàng)建單例Bean。

3.2 添加@Lazy注解

本小節(jié)在3.1小節(jié)的基礎(chǔ)上，完成案例添加@Lazy注解的部分，具體實現(xiàn)步驟如下所示。

（1）修改LazyConfig類

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

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

（2）運行LazyTest類

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

創(chuàng)建IOC容器開始...
創(chuàng)建IOC容器結(jié)束...

可以看到，輸出的結(jié)果信息中并沒有打印LazyBean類的構(gòu)造方法中輸出的日志信息。

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

3.3 獲取單例Bean

本小節(jié)在3.2小節(jié)的基礎(chǔ)上，完成案例獲取單例Bean的部分，具體實現(xiàn)步驟如下所示。

（1）修改LazyTest類

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

public class LazyTest {
    public static void main(String[] args) {
        System.out.println("創(chuàng)建IOC容器開始...");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LazyConfig.class);
        System.out.println("創(chuàng)建IOC容器結(jié)束...");
        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結(jié)束...");
    }
}

可以看到，在LazyTest類的構(gòu)造方法中，創(chuàng)建完IOC容器中，從IOC容器中連續(xù)獲取兩次LazyBean類的Bean對象，并打印兩次獲取的Bean對象是否相等。

（2）運行LazyTest類

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

創(chuàng)建IOC容器開始...
創(chuàng)建IOC容器結(jié)束...
從IOC容器中獲取Bean開始...
執(zhí)行LazyBean類的構(gòu)造方法...
(lazyBean1 是否等于 lazyBean2) ===>>> true
從IOC容器中獲取Bean結(jié)束...

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

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

四、源碼時序圖

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

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

4.1 注冊Bean的源碼時序圖

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

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

4.2 調(diào)用Bean后置處理器的源碼時序圖

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

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

4.3  創(chuàng)建單例Bean的源碼時序圖

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

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

五、源碼解析

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

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

5.1 注冊Bean的源碼流程

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

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

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

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

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()方法中，調(diào)用了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()方法中，直接調(diào)用了另一個重載的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數(shù)組，如果Lazy.class的值與遍歷出的qualifier對象相等，就會將abd對象的lazyInit字段設(shè)置為true。如果abd對象的lazyInit字段為true，則后續(xù)在啟動IOC容器的過程中，就不會創(chuàng)建單例Bean對象。

后續(xù)的執(zhí)行流程就與第7章5.1小節(jié)的執(zhí)行流程相同，不再贅述。

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

5.2 調(diào)用Bean后置處理器的源碼流程

@Lazy注解在Spring源碼層面調(diào)用Bean工廠后置處理器的執(zhí)行流程，結(jié)合源碼執(zhí)行的時序圖，會理解的更加深刻，本節(jié)的源碼執(zhí)行流程可以結(jié)合圖9-2~9-4進(jìn)行理解。

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

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

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

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屬性設(shè)置為true。

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

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

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

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

5.3 創(chuàng)建單例Bean的源碼流程

@Lazy注解在Spring源碼層面創(chuàng)建單例Bean的執(zhí)行流程，結(jié)合源碼執(zhí)行的時序圖，會理解的更加深刻，本節(jié)的源碼執(zhí)行流程可以結(jié)合圖9-5進(jìn)行理解。

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

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

@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()方法中，會循環(huán)遍歷解析出的Bean名稱，在循環(huán)中，會根據(jù)遍歷出的Bean名稱獲取RootBeanDefinition對象。接下來會進(jìn)行如下判斷。

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

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

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

后續(xù)的源碼執(zhí)行流程與第7章5.3小節(jié)的源碼執(zhí)行流程相同，這里不再贅述。

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

六、總結(jié)

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

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

七、思考

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

關(guān)于@Lazy注解，通常會有如下幾個經(jīng)典面試題：

• @Lazy注解的作用是什么？
• @Lazy注解有哪些使用場景？
• @Lazy注解延遲創(chuàng)建Bean是如何實現(xiàn)的？
• @Lazy注解在Spring內(nèi)部的執(zhí)行流程？
• 你在平時工作中，會在哪些場景下使用@Lazy注解？
• 你從@Lazy注解的設(shè)計中得到了哪些啟發(fā)？