夯实spring(十二):bean延迟初始化

港控/mmm° 2024-03-23 23:22 89阅读 0赞

bean初始化时有两种方式：

*  实时初始化
 *  延迟初始化

#### 1，实时初始化 ####

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

**案例**

public class Car {
        
        private String name;
        private Double price;
    
    
        public Car() {
        
            System.out.println("我是实时初始化的Car!");
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public Double getPrice() {
        
            return price;
        }
    
        public void setPrice(Double price) {
        
            this.price = price;
        }
    
        @Override
        public String toString() {
        
            return "Car{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    }

**bean.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="car1" class="com.chen.Car"/>
    </beans>

**测试输出**

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

> 可以看出car1这个bean是在容器启动过程中被创建好的。

#### 2，延迟初始化 ####

实时初始化的bean都会在容器启动过程中创建好，如果程序中定义的bean非常多，并且有些bean创建的过程中比较耗时的时候，会导致系统消耗的资源比较多，并且会让整个启动时间比较长，使用spring开发的系统比较大的时候，整个系统启动耗时是比较长的，基本上多数时间都是在创建和组装bean。  
spring对这些问题也提供了解决方案：bean延迟初始化

> 延迟初始化，就是和实时初始化刚好相反，延迟初始化的bean在容器启动过程中不会创建，而是需要使用的时候才会去创建

**bean什么时候会被使用？**

*  被其他bean作为依赖进行注入的时候，比如通过property元素的ref属性进行引用，通过构造器注入、通过set注入、通过自动注入，这些都会导致被依赖bean的创建。
 *  自己写代码向容器中查找bean的时候，如调用容器的getBean方法获取bean。

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

**案例1**  
把上面的bean.xml修改成:

**测试输出**

public class Main {
        
        public static void main(String[] args) {
        
            System.out.println("容器启动中...");
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean.xml"); //启动spring容器
            System.out.println("容器启动完毕...");
            System.out.println("从容器中开始查找car1");
            Car car = context.getBean(Car.class);
            System.out.println("car1Bean:" + car);
        }
    }

容器启动中...
    容器启动完毕...
    从容器中开始查找car1
    我是延时初始化的Car!
    car1Bean:Car{
        name='null', price=null}}

> 可以看出来，car1在容器启动过程中并没有创建，当我们调用context.getBean方法的时候，car1才被创建的。

**案例2**  
案例1这种方式是我们主动从容器中获取bean的时候，延迟初始化的bean才被容器创建的，下面来看一下当延迟初始化的bean被其他实时初始化的bean依赖的时候，是什么时候创建的。

public class Garage {
        
        private String addr;
        private String name;
    
        public Garage() {
        
            System.out.println("我是被依赖的车库");
        }
    
    
    }

public class Car {
        
        private String name;
        private Double price;
     	private Garage garage;
    
        public Car() {
        
            System.out.println("我是实时时初始化的Car!");
        }
    
        public Garage getGarage() {
        
            return garage;
        }
    
        public void setGarage(Garage garage) {
        
            System.out.println("Car.setGarage()");
            this.garage = garage;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public Double getPrice() {
        
            return price;
        }
    
        public void setPrice(Double price) {
        
            this.price = price;
        }
    
        @Override
        public String toString() {
        
            return "Car{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    }

**bean.xml**

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

**测试输出**

容器启动中...
    我是实时时初始化的Car!
    我是被依赖的车库
    Car.setGarage()
    容器启动完毕...

> 可以看到，xml中定义的2个bean都在容器启动过程中被创建好了。 garage的lazy-init为true，也在容器启动过程中被创建了,是因为car1为实时初始化的bean，而这个bean在创建过程中需要用到garage，此时容器会去查找garage这个bean，然后会进行初始化，所以这2个bean都在容器启动过程中被创建的。

**总结**

> 延迟初始化的bean无法在程序启动过程中迅速发现bean定义的问题，第一次获取的时候可能耗时会比较长。