Spring进阶（七）之懒加载（解决循环依赖）

冰魄雕狼

已于 2022-12-03 18:59:58 修改

阅读量1k

点赞数 1

分类专栏： spring 文章标签： spring java 后端

于 2022-09-29 00:30:37 首次发布

本文链接：https://blog.csdn.net/weixin_56644618/article/details/127099075

版权

spring 专栏收录该内容

23 篇文章 3 订阅

订阅专栏

bean实时初始化

延迟初始化的bean

lazy-init：bean延迟初始化。常常用于解决循环依赖问题，后面我们会有专门的一节来讲解循环依赖问题，这里先不做说明。

Spring中的bean初始化的方式有两种，实时初始化和延迟初始化

bean实时初始化

在容器启动过程中被创建组装好的bean，称为实时初始化的bean，spring中默认定义的bean都是实时初始化的bean，这些bean默认都是单例的，在容器启动过程中会被创建好，然后放在spring容器中以供使用。

实时初始化bean的一些优点

更早发下bean定义的错误：实时初始化的bean如果定义有问题，会在容器启动过程中会抛出异常，让开发者快速发现问题
查找bean更快：容器启动完毕之后，实时初始化的bean已经完全创建好了，此时被缓存在spring 容器中，当我们需要使用的时候，容器直接返回就可以了，速度是非常快的

public class ActualTimeBean {
    public ActualTimeBean() {
        System.out.println("我是实时初始化的bean!");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <bean id="actualTimeBean" class="com.javacode2018.lesson001.demo11.ActualTimeBean"/>

</beans>

public class LazyBeanTest {
    @Test
    public void actualTimeBean() {
        System.out.println("spring容器启动中...");
        String beanXml = "classpath:/com/javacode2018/lesson001/demo11/actualTimeBean.xml";
        new ClassPathXmlApplicationContext(beanXml); //启动spring容器
        System.out.println("spring容器启动完毕...");
    }
}

运行以后控制台打印：

spring容器启动中...

我是实时初始化的bean!

spring容器启动完毕...

验证了我们上面的说法：bean对象是容器启动时就创建好，并放到容器中。

延迟初始化的bean

从上面我们可以看出，实时初始化的bean都会在容器启动过程中创建好，如果程序中定义的bean非常多，并且有些bean创建的过程中比较耗时的时候，会导致系统消耗的资源比较多，并且会让整个启动时间比较长，这个我估计大家都是有感受的，使用spring开发的系统比较大的时候，整个系统启动耗时是比较长的，基本上多数时间都是在创建和组装bean。

spring对这些问题也提供了解决方案：bean延迟初始化。

所谓延迟初始化，就是和实时初始化刚好相反，延迟初始化的bean在容器启动过程中不会创建，而是需要使用的时候才会去创建，先说一下bean什么时候会被使用：

1. 被其他bean作为依赖进行注入的时候，比如通过property元素的ref属性进行引用，通过构造器注入、通过set注入、通过自动注入，这些都会导致被依赖bean的创建

2. 开发者自己写代码向容器中查找bean的时候，如调用容器的getBean方法获取bean。

上面这2中情况会导致延迟初始化的bean被创建。

<bean id="" class="" lazy-init="true"/>

案例一：

public class LazyInitBean {
    public LazyInitBean() {
        System.out.println("我是延迟初始化的bean!");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    <bean id="lazyInitBean" class="com.javacode2018.lesson001.demo11.LazyInitBean" lazy-init="true"/>
</beans>

@Test
    public void lazyInitBean() {
        System.out.println("spring容器启动中...");
        String beanXml = "classpath:/com/javacode2018/lesson001/demo11/lazyInitBean.xml";
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml); //启动spring容器
        System.out.println("spring容器启动完毕...");
        System.out.println("从容器中开始查找LazyInitBean");
        LazyInitBean lazyInitBean = context.getBean(LazyInitBean.class);
        System.out.println("LazyInitBean:" + lazyInitBean);
    }

运行后控制台打印：

spring容器启动中...

spring容器启动完毕...

从容器中开始查找LazyInitBean

我是延迟初始化的bean! LazyInitBean:com.javacode2018.lesson001.demo11.LazyInitBean@11dc3715

案例二：

public class ActualTimeDependencyLazyBean {
    public ActualTimeDependencyLazyBean() {
        System.out.println("ActualTimeDependencyLazyBean实例化!");
    }
    private LazyInitBean lazyInitBean;
    public LazyInitBean getLazyInitBean() {
        return lazyInitBean;
    }
    public void setLazyInitBean(LazyInitBean lazyInitBean) {
        this.lazyInitBean = lazyInitBean;
        System.out.println("ActualTimeDependencyLazyBean.setLazyInitBean方法!");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    <bean id="lazyInitBean" class="com.javacode2018.lesson001.demo11.LazyInitBean" lazy-init="true"/>

    <bean id="actualTimeDependencyLazyBean" class="com.javacode2018.lesson001.demo11.ActualTimeDependencyLazyBean">
        <property name="lazyInitBean" ref="lazyInitBean"/>
    </bean>
</beans>

注意上面定义了2个bean：

lazyInitBean：lazy-init为true，说明这个bean是延迟创建的 actualTimeDependencyLazyBean：通过property元素来注入lazyInitBean， actualTimeDependencyLazyBean中没有指定lazy-init，默认为false，表示是实时创建的bean，会在容器创建过程中被初始化

@Test
    public void actualTimeDependencyLazyBean() {
        System.out.println("spring容器启动中...");
        String beanXml = "classpath:/com/javacode2018/lesson001/demo11/actualTimeDependencyLazyBean.xml";
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml); //启动spring容器
        System.out.println("spring容器启动完毕...");
    }

运行以后控制台打印：

spring容器启动中...

ActualTimeDependencyLazyBean实例化!

我是延迟初始化的bean!

ActualTimeDependencyLazyBean.setLazyInitBean方法!

spring容器启动完毕...

从控制台打印的信息我们可以看，容器在启动的时候这两个bean就都已经创建好了。

有些人就会疑惑，不是说添加了lazy-init属性以后会延迟加载吗，那为什么lazyInitBean对象没有延迟加载。

是因为 actualTimeDependencyLazyBean 为实时初始化的bean，而这个bean在创建过程中需要用到 lazyInitBean ，此时容器会去查找 lazyInitBean 这个bean，然后会进行初始化，所以这2个bean都在容器启动过程中被创建的。

另外扩展两点：