Spring系列第12篇：lazy-init：bean延迟初始化

时间  2020-05-06 标签 spring 系列 lazy init bean 延迟 初始化

bean初始化的方式2种方式

  1. 实时初始化java

  2. 延迟初始化算法

bean实时初始化

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

实时初始化bean的有一些优势

  1. 更早发下bean定义的错误：实时初始化的bean若是定义有问题，会在容器启动过程当中会抛出异常，让开发者快速发现问题数据库

  2. 查找bean更快：容器启动完毕以后，实时初始化的bean已经彻底建立好了，此时被缓存在spring容器中，当咱们须要使用的时候，容器直接返回就能够了，速度是很是快的缓存

案例

ActualTimeBean类

package com.javacode2018.lesson001.demo11;

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

一会咱们在spring中建立上面这个对象，构造函数中会输出一段话，这段话会在spring容器建立过程当中输出。并发

actualTimeBean.xml

<?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>

测试用例

package com.javacode2018.lesson001.demo11;


import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 公众号：路人甲Java，工做10年的前阿里P7分享Java、算法、数据库方面的技术干货！坚信用技术改变命运，让家人过上更体面的生活!
 * bean默认是实时初始化的，能够经过bean元素的lazy-init="true"将bean定义为延迟初始化
 */
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容器启动完毕...");
    }
}

注意上面代码，容器启动先后有输出，运行actualTimeBean输出：less

spring容器启动中...
我是实时初始化的bean!
spring容器启动完毕...

能够看出actualTimeBean这个bean是在容器启动过程当中被建立好的。ide

延迟初始化的bean

从上面咱们能够看出，实时初始化的bean都会在容器启动过程当中建立好，若是程序中定义的bean很是多，而且有些bean建立的过程当中比较耗时的时候，会致使系统消耗的资源比较多，而且会让整个启动时间比较长，这个我估计你们都是有感觉的，使用spring开发的系统比较大的时候，整个系统启动耗时是比较长的，基本上多数时间都是在建立和组装bean。函数

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

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

  1. 被其余bean做为依赖进行注入的时候，好比经过property元素的ref属性进行引用，经过构造器注入、经过set注入、经过自动注入，这些都会致使被依赖bean的建立

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

上面这2种状况会致使延迟初始化的bean被建立。

延迟bean的配置

在bean定义的时候经过lazy-init属性来配置bean是不是延迟加载，true：延迟初始化，false：实时初始化

<bean lazy-init="是不是延迟初始化" />

咱们来2个案例看一下效果。

案例1

LazyInitBean类

package com.javacode2018.lesson001.demo11;

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

lazyInitBean.xml

<?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>

注意上面的lazy-init="true"表示定义的这个bean是延迟初始化的bean。

测试用例

LazyBeanTest中加个方法

@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);
}

注意上面的输出，容器启动先后有输出，而后又从容器中查找LazyInitBean。

运行输出

执行lazyInitBean方法，输出：

spring容器启动中...
spring容器启动完毕...
从容器中开始查找LazyInitBean
我是延迟初始化的bean!
LazyInitBean:com.javacode2018.lesson001.demo11.LazyInitBean@11dc3715

代码结合输出能够看出来，LazyInitBean在容器启动过程当中并无建立，当咱们调用context.getBean方法的时候，LazyInitBean才被建立的。

案例2

上面这种方式是咱们主动从容器中获取bean的时候，延迟初始化的bean才被容器建立的，下面咱们再来看一下当延迟初始化的bean被其余实时初始化的bean依赖的时候，是何时建立的。

ActualTimeDependencyLazyBean类

package com.javacode2018.lesson001.demo11;

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方法!");
    }
}

ActualTimeDependencyLazyBean类中有个lazyInitBean属性，对应的有get和set方法，咱们将经过set方法将lazyInitBean对象注入。

actualTimeDependencyLazyBean.xml

<?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，会在容器建立过程当中被初始化

测试用例

LazyBeanTest中加个方法，以下：

@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容器启动完毕...

从容器中能够看到，xml中定义的2个bean都在容器启动过程当中被建立好了。

有些朋友比较迷茫，lazyInitBean的lazy-init为true，怎么也在容器启动过程当中被建立呢？

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

总结

延迟初始化的bean没法在程序启动过程当中迅速发现bean定义的问题，第一次获取的时候可能耗时会比较长。在实际工做中用的比较少，做为了解，之后碰到的时候会有个印象。

案例源码

连接：https://pan.baidu.com/s/1p6rcfKOeWQIVkuhVybzZmQ 
提取码：zr99

Spring系列

  1. Spring系列第1篇：为什么要学spring？

  2. Spring系列第2篇：控制反转（IoC）与依赖注入（DI）

  3. Spring系列第3篇：Spring容器基本使用及原理

  4. Spring系列第4篇：xml中bean定义详解(-)

  5. Spring系列第5篇：建立bean实例这些方式大家都知道？

  6. Spring系列第6篇：玩转bean scope，避免跳坑里！

  7. Spring系列第7篇：依赖注入之手动注入

  8. Spring系列第8篇：自动注入（autowire）详解，高手在于坚持

  9. Spring系列第9篇：depend-on究竟是干什么的？

  10. Spring系列第10篇：primary能够解决什么问题？

  11. Spring系列第11篇：bean中的autowire-candidate又是干什么的？

更多好文章

  1. Java高并发系列（共34篇）

  2. MySql高手系列（共27篇）

  3. Maven高手系列（共10篇）

  4. Mybatis系列（共12篇）

  5. 聊聊db和缓存一致性常见的实现方式

  6. 接口幂等性这么重要，它是什么？怎么实现？

  7. 泛型，有点难度，会让不少人懵逼，那是由于你没有看这篇文章！

感谢你们的阅读，也欢迎您把这篇文章分享给更多的朋友一块儿阅读！谢谢！

路人甲java

▲长按图片识别二维码关注

路人甲Java：工做10年的前阿里P7分享Java、算法、数据库方面的技术干货！坚信用技术改变命运，让家人过上更体面的生活！

联系我们 沪ICP备13005482号-10