三个实体类
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
}
}