Spring学习之（一）Spring的容器实例化及Bean的生命周期

Spring学习之（一）Spring的容器实例化及Bean的生命周期

容器的实例化

容器的实例化有两种方式，分别如下：

• 1.加载文件系统中的配置文件进行实例化
• 2.加载classpath下的配置文件进行实例化

// 1.加载文件系统中的配置文件
String conf = "D:\\applicationContext.xml";
ApplicationContext ac = new FileSystemXmlApplicationContext(conf);


// 2.加载classpath下的配置文件
String config = "applicationContext.xml";
ApplicationContext app = new ClassPathXmlApplicationContext(config);

Bean的实例化

Spring 容器创建Bean对象的方法有以下三种

• 用构造器来实例化
• 使用静态工厂方法实例化
• 使用实例工厂实例化

使用构造器进行Bean的实例化

• 先看一下applicationContext.xml的配置

	<!-- 1.使用构造器进行对象的实例化 -->
    <bean id="calendarByConstructor" class="java.util.GregorianCalendar"></bean>

• Java代码

   	/**
     * 使用构造器进行Bean的构造
     */
    public static void getBeanByConstructor(){
        System.out.println("=====================");
        System.out.println("使用构造器进行Bean的构造");
        String config = "applicationContext-bean.xml";
        ApplicationContext context = new ClassPathXmlApplicationContext(config);

        GregorianCalendar calendar = 					 context.getBean("calendarByConstructor",GregorianCalendar.class);
        System.out.println(calendar);
        System.out.println("=====================");
    }

使用静态工厂实例化Bean对象

• applicationContext.xml文件的配置：

<!-- 2.使用静态工厂进行对象的实例化 -->
<bean id="calendarByStaticFactoryObject" class="java.util.Calendar" factory-method="getInstance"></bean>

• Java代码如下：

    /**
     * 使用静态工厂进行bean对象的实例化
     */
    public static void getBeanByStaticFactory(){
        System.out.println("=====================");
        System.out.println("使用静态工厂进行bean对象的实例化");
        String config = "applicationContext-bean.xml";
        ApplicationContext context = new ClassPathXmlApplicationContext(config);
        GregorianCalendar calendar = context.getBean("calendarByStaticFactoryObject",GregorianCalendar.class);
        System.out.println(calendar);
        System.out.println("=====================");
        // 使用静态工厂进行bean对象的实例化，相当于如下的代码
        Calendar obj1 = Calendar.getInstance();
        System.out.println(obj1);
        // 这里说明一下，Calendar的默认实现是GregorianCalendar，格林尼治日历
        context.close();
    }

使用实例工厂实例化Bean对象

• applicationContext.xml

    <!-- 3.使用实例工厂进行对象的实例化 -->
    <bean id="calendarFactory" class="java.util.GregorianCalendar"></bean>
    <bean id="dateObject" factory-bean="calendarFactory" factory-method="getTime"></bean>

• Java代码

    /**
     * 使用实例工厂进行Bean对象的实例化
     */
    public static void getBeanByInstanceFactory(){
        System.out.println("=====================");
        System.out.println("使用实例工厂进行Bean对象的实例化");
        String config = "applicationContext-bean.xml";
        ApplicationContext context = new ClassPathXmlApplicationContext(config);
        Date date = context.getBean("dateObject", Date.class);
        System.out.println(date);
        System.out.println("=====================");
        
        // 这里相当于如下的代码：
        GregorianCalendar calendar = new GregorianCalendar();// 先将工厂实例化出来
        Date dte = calendar.getTime();// 使用工厂来生产我们要的对象
        System.out.println(dte);
    }

Bean的生命周期

单例模式的Bean

• Spring容器默认创建的对象就是单例模式的，我们使用如下的类进行演示

package com.onethreetech.lifecycle.eneity;

/**
 * 
 * @author zhang_wei
 *
 */
public class ExampleBeanLifeCycle {
	
	/**
	 * 
	 * 无参构造器
	 * 
	 */
	public ExampleBeanLifeCycle(){
		System.out.println("执行实例化方法");
	}
	
	/**
	 * 初始化方法
	 */
	public void init(){
		System.out.println("执行初始化方法");
	}
	
	/**
	 * execute方法
	 */
	public void execute(){
		System.out.println("执行execute方法");
	}
	
	/**
	 * destroy方法
	 */
	public void destroy(){
		System.out.println("执行destroy回调方法");
	}

}

• 看一下配置文件applicationContext.xml

<!-- 默认是单例模式的 -->
<bean id="exampleBeanLifeCycle" class="com.onethreetech.lifecycle.eneity.ExampleBeanLifeCycle"></bean>

• Java的测试代码

	/**
	 * 测试单例模式
	 */
	public static void testLifeCycle01() {
		String config = "applicationContext-lifecycle.xml";
		AbstractApplicationContext context = new ClassPathXmlApplicationContext(
				config);
		// 执行实例化方法 这段话只执行了一次，且这里就打印出来了
		try {
			Thread.sleep(3000);// 使我们的线程休眠3s
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		ExampleBeanLifeCycle cycleObject01 = context.getBean(
				"exampleBeanLifeCycle", ExampleBeanLifeCycle.class);
		ExampleBeanLifeCycle cycleObject02 = context.getBean(
				"exampleBeanLifeCycle", ExampleBeanLifeCycle.class);

		System.out.println(cycleObject01 == cycleObject02);// 返回的结果是true，说明只有一个对象
		context.close();

	}

原型模式的Bean

• 原型模式的Bean则需要配置Bean的scope属性为prototype
• Bean的scope为作用域，一共有5个枚举值，分别为singleton,prototype,request,session,global-session；常用的就前两个，后面三个都是跟HttpRequest有关的
• 我们看一下配置文件中的配置：

<!-- 这里可以声明为原型模式的 -->
<bean id="exampleBeanLifeCycleObject" class="com.onethreetech.lifecycle.eneity.ExampleBeanLifeCycle"
		scope="prototype"></bean>

• Java的测试代码：

	/**
	 * 测试原型模式
	 */
	public static void testLifeCycle02() {
		String config = "applicationContext-lifecycle.xml";
		AbstractApplicationContext context = new ClassPathXmlApplicationContext(
				config);
		// 执行实例化方法 这段话在这里会执行一次，表示容器会自动创建一个对象
		try {
			Thread.sleep(3000);// 使我们的线程休眠3s
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		// 这里又会将 “执行实例化方法”这句话执行两遍
		ExampleBeanLifeCycle cycleObject01 = context.getBean(
				"exampleBeanLifeCycleObject", ExampleBeanLifeCycle.class);
		ExampleBeanLifeCycle cycleObject02 = context.getBean(
				"exampleBeanLifeCycleObject", ExampleBeanLifeCycle.class);
		System.out.println(cycleObject01 == cycleObject02);// 返回的结果是false，说明有多个对象
		context.close();
	}

Bean的初始化及销毁

• 我们可以在Bean实例化的同时，指定一个初始化的方法，配置 init-method属性；destroy-method属性可以指定容器销毁时的回调方法
• applicationCont.xml的配置如下：

<bean id="destroyObject" class="com.onethreetech.lifecycle.eneity.ExampleBeanLifeCycle"
		init-method="init" destroy-method="destroy"></bean>

• Java代码如下：

	/**
	 * 测试初始化及销毁方法
	 */
	public static void testLifeCycle03() {
		String config = "applicationContext-lifecycle.xml";
		AbstractApplicationContext context = new ClassPathXmlApplicationContext(
				config);
		// 依次打印出如下的信息
		// 执行实例化方法
		// 执行初始化方法
		// 执行destroy回调方法
		ExampleBeanLifeCycle cycleObject01 = context.getBean("destroyObject",
				ExampleBeanLifeCycle.class);
		context.close();// 容器关闭时会回调我们指定的Bean的销毁的方法，这种仅对单例模式的对象起作用
	}

Bean的延迟实例化

• 在spring中，默认容器启动的时候，会对所有的单例模式的bean进行实例化，如果不需要在容器启动的时候进行实例化，则需要配置bean的 lazy-init属性，设置为true即可
• 如下xml配置：

<!-- 测试Bean的延迟初始化 -->
	<bean id="lazyInstanceObject" class="com.onethreetech.lifecycle.eneity.ExampleBeanLifeCycle" lazy-init="true"></bean>

• Java代码：

	/**
	 * 测试Bean的延迟实例化
	 */
	public static void testLifeCycleLazy() {
		String config = "applicationContext-lifecycle.xml";
		AbstractApplicationContext context = new ClassPathXmlApplicationContext(
				config);
		// 如果注释掉如下的代码，则不会打印出来 执行实例化方法
		ExampleBeanLifeCycle cycleObject01 = context.getBean("lazyInstanceObject",ExampleBeanLifeCycle.class);
		context.close();// 容器关闭时会回调我们指定的Bean的销毁的方法，这种仅对单例模式的对象起作用
	}

容器级别的初始化，销毁及延迟实例化

• 同时spring也支持在容器级别配置初始化，销毁以及延迟实例化
• 初始化：default-init-method=“init”
• 销毁：default-destroy-method=“destroy”
• 延迟初始化：default-lazy-init=“true”