Spring bean 加载执行顺序

三个实体类

package com.qdu.beans;

/**
 * Dog类
 * @author NIIT
 */
public class Dog {
 
    public Dog() {
        System.out.println("实例化了一只狗！");
    }
    
    public void eat(){
        // sout->tab
        System.out.println("这是一只狗，狗吃骨头！");
    }
}

package com.qdu.beans;

/**
 * Pig类 
 * @author NIIT
 */
public class Pig {

    public Pig() {
        System.out.println("实例化了一只猪~");
    }

    public void eat() {
        // sout->tab
        System.out.println("这是一只猪，猪吃饲料~");
    }
}

package com.qdu.beans;

/**
 * Sheep类
 * @author NIIT
 */
//goat
public class Sheep {

    public Sheep() {
        System.out.println("实例化了一只羊…");
    }

    public void eat() {
        // sout->tab
        System.out.println("这是一只羊，羊吃草……");
    }
}

一个配置文件

<?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.0.xsd
">
    
    <!--该文件是spring的配置文件，用于配置spring管理的各种bean及其他spring的配置
        一个bean对应一个类，就是交给Spring管理的类
            id用于指定一个bean的唯一标识符，也就是一个名字，用于区分每个bean
            class用于指定bean的全限定类名
    -->
    <!--scope: 指定bean的作用域,该属性决定了一个bean有几个实例-->
    <bean id="dog" scope="singleton" name="gou,quan,wangxingren" 
          class="com.qdu.beans.Dog" >
        
    </bean>
    
    <bean id="pig" scope="prototype" class="com.qdu.beans.Pig" >
        
    </bean>
    
    <!--lazy-init指定该bean是否使用延迟加载，也就是是否在容器启动的时候就实例化-->
    <!--该属性只适用于单例的bean，默认值是false，不使用懒加载，true表示使用延迟加载-->
    <bean id="sheep" class="com.qdu.beans.Sheep" lazy-init="true">
        
    </bean>

</beans>

一个Main Class

package com.qdu.main;

import com.qdu.beans.Dog;
import com.qdu.beans.Pig;
import com.qdu.beans.Sheep;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 练习1-熟悉bean的范围和延迟加载
 * @author NIIT
 */
public class Test6_Exercise1 {
    
    public static void main(String[] args) {
                
        //思考：
        //1. 本程序的执行导致实例化几只狗(1)几只猪(3)几只羊(1) 
        //2. 实例化分别在哪行代码执行
        //狗的实例化：1
        //猪的实例化：4,5,6
        //羊的实例化：7
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");  //1
        Dog d1 = (Dog) ctx.getBean("dog"); //2
        Dog d2 = (Dog) ctx.getBean("dog"); //3
        
        Pig p1 = (Pig) ctx.getBean("pig"); //4
        Pig p2 = (Pig) ctx.getBean("pig"); //5
        Pig p3 = (Pig) ctx.getBean("pig"); //6
        
        Sheep s1 = (Sheep) ctx.getBean("sheep"); //7
        Sheep s2 = (Sheep) ctx.getBean("sheep"); //8
        Sheep s3 = (Sheep) ctx.getBean("sheep"); //9
        Sheep s4 = (Sheep) ctx.getBean("sheep"); //10

    }
}

singleton

singleton：单例，默认的值，在容器中，始终只仅仅生成该bean的一个共享实例
        单例：会创建全局唯一的实例，存在单例缓存（Singleton session）中
        第二次创建实例的时候，因为是singleton的，所以并不会创建新的实例，
        而是从缓存中将上面创建过的从缓存中取出来  

狗的实例化在加载配置文件的时候就开始了。

prototype

prototype:原型，每次请求bean（依赖注入或者调用getBean()）,创建一个新的实例

所以猪的实例化在4、5、6阶段

lazy-init

lazy-init指定该bean是否使用延迟加载，也就是是否在容器启动的时候就实例化
lazy-init:延迟加载，默认是false,如果设置为true的话请求bean的时候才实例化，该属性只适用于单例的bean

因为这里lazy-init设置为true,所以并没有和狗一起在容器启动的时候，默认是单例，所以只实例化一次

Spring bean 加载执行顺序

package com.qdu.main;

import com.qdu.beans.Dog;
import com.qdu.beans.Pig;
import com.qdu.beans.Sheep;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 练习2-熟悉bean的范围和延迟加载
 *
 * @author admin
 */
public class Test7_Exercise2 {

    public static void main(String[] args) {

        //思考：
        //1. 本程序的执行导致实例化几只狗(3)几只猪(4)几只羊(3)
        //2. 实例化分别在哪行代码执行？
        //狗的实例化：1,2,3 ，该bean是单例，非延迟加载，一个容器里一个Dog实例
        //猪的实例化：7,8,9,10，因为是原型，所以getBean()一次，就创建一个Pig实例
        //羊的实例化：11,12,13，该bean是单例，延迟加载，14行只是为了获取11行实例化的羊
        ApplicationContext ctx1 = new ClassPathXmlApplicationContext("beans.xml");  //1
        ApplicationContext ctx2 = new ClassPathXmlApplicationContext("beans.xml");  //2
        ApplicationContext ctx3 = new ClassPathXmlApplicationContext("beans.xml");  //3

        Dog d1 = (Dog) ctx1.getBean("dog"); //4
        Dog d2 = (Dog) ctx2.getBean("dog"); //5
        Dog d3 = (Dog) ctx2.getBean("dog"); //6

        Pig p1 = (Pig) ctx1.getBean("pig"); //7
        Pig p2 = (Pig) ctx1.getBean("pig"); //8
        Pig p3 = (Pig) ctx2.getBean("pig"); //9
        Pig p4 = (Pig) ctx3.getBean("pig"); //10

        Sheep s1 = (Sheep) ctx1.getBean("sheep"); //11
        Sheep s2 = (Sheep) ctx2.getBean("sheep"); //12
        Sheep s3 = (Sheep) ctx3.getBean("sheep"); //13
        Sheep s4 = (Sheep) ctx1.getBean("sheep"); //14
    }
}