Spring Bean的实例化，作用域，初始化以及销毁

一，Bean的实例化。

1.说明。

Bean的实例化有如下三种方式：
（1）构造方法实例化。
（2）静态工厂实例化。
（3）实例工厂实例化。

2.Bean的实例化测试代码。

（1）依赖文件：spring四个核心模块jar包以及spring框架需要依赖的jar包。spring-beans-xxx.jar，spring-core-xxx.jar，spring-context-xxx.jar，spring-expression-xxx.jar,commons-logging-xxx.jar。（xxx为版本号）
（2）代码。
创建以下3个类：

package instance;

public class BeanClass {
    public String message;
    public BeanClass() {
        message="使用构造方法实例化Bean";
    }

    public BeanClass(String message) {
        this.message = message;
    }
}

package instance;

public class BeanInstanceFactory {
    public BeanClass createBeanClassInstance(){
        return new BeanClass("调用实例工厂方法实例化Bean");
    }
}

package instance;

public class BeanStaticFactory {
    public static BeanClass beanClassInstance = new BeanClass("调用静态工厂方法实例化Bean");

    public static BeanClass createInstance(){
        return beanClassInstance;
    }

}

编写appcationContext.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.xsd">
	<!-- 构造方法实例化Bean -->
	<bean id="constructorInstance" class="instance.BeanClass"/>

	<!-- 静态工厂方法实例化Bean，createInstance为静态工厂类BeanStaticFactory中的静态方法-->
	<bean id="staticFactoryInstance" class="instance.BeanStaticFactory" factory-method="createInstance"/>

	<!-- 配置工厂 -->
    <bean id="myFactory" class="instance.BeanInstanceFactory"/>

	<!-- 使用factory-bean属性指定配置工厂，使用factory-method属性指定使用工厂中哪个方法实例化Bean-->
    <bean id="instanceFactoryInstance" factory-bean="myFactory" factory-method="createBeanClassInstance"/>
</beans>

创建测试类Test：

package Test;

import instance.BeanClass;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext appcon = new ClassPathXmlApplicationContext("config/applicationContext.xml");

        BeanClass bean1 = (BeanClass) appcon.getBean("constructorInstance");
        System.out.println(bean1+bean1.message);

        BeanClass bean2 = (BeanClass) appcon.getBean("staticFactoryInstance");
        System.out.println(bean2+bean2.message);

        BeanClass bean3 = (BeanClass) appcon.getBean("instanceFactoryInstance");
        System.out.println(bean3+bean3.message);

    }
}

运行结果如下图所示：

二，Bean的作用域。

1.说明。

Bean的作用域通过属性scope来设置。

2.Bean的作用域测试代码。

这里只测试singleton和prototype。

创建类BeanClass：

package instance;

public class BeanClass {
    public String message;
    public BeanClass() {
        message="使用构造方法实例化Bean";
    }

    public BeanClass(String message) {
        this.message = message;
    }
}

编写配置文件applicationContext.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.xsd">
        
	<!-- 默认的作用域，使用singleton的bean在Spring容器中只有一个bean实例-->
    <bean id="scope1" class="instance.BeanClass" scope="singleton"/>

	<!-- spring容器每次获取prototype的bean，容器都会创建一个新的bean实例-->
    <bean id="scope2" class="instance.BeanClass" scope="prototype"/>
</beans>

编写测试Test类：

package Test;

import instance.BeanClass;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext appcon = new ClassPathXmlApplicationContext("config/applicationContext.xml");

        BeanClass singletonBean1 = (BeanClass) appcon.getBean("scope1");
        System.out.println(singletonBean1+singletonBean1.message);

        BeanClass singletonBean2 = (BeanClass) appcon.getBean("scope1");
        System.out.println(singletonBean2+singletonBean2.message);

        BeanClass prototypeBean1 = (BeanClass) appcon.getBean("scope2");
        System.out.println(prototypeBean1+prototypeBean1.message);

        BeanClass prototypeBean2 = (BeanClass) appcon.getBean("scope2");
        System.out.println(prototypeBean2+prototypeBean2.message);

    }
}

测试结果如下图所示：

可以看到，作用域为singleton的Bean实例只有一个，而作用域为prototype的Bean实例有多个。

三，Bean的初始化和销毁。

1.说明。

Spring为Bean的生命周期操作提供了支持，在配置文件appcationContext.xml文件定义Bean时，可以使用init-method和destroy-method属性对Bean进行初始化和销毁。

2.Bean的初始化和销毁测试代码。

创建Service类：

package service;
public class MyService {
	public MyService() {
		System.out.println("执行构造方法");
	}
	public void initService() {
		System.out.println("执行初始化方法");
	}
	public void destroyService() {
		System.out.println("执行销毁方法");
	}
}

编写配置文件applicationContext.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.xsd">
	
	<!-- bean的初始化和销毁 -->
    <!-- 配置bean，使用init-method属性指定初始化方法，使用 destroy-method属性指定销毁方法-->
	<bean id="beanLife" class="service.MyService" init-method="initService" destroy-method="destroyService"/>
	
</beans>

编写测试类Test：

package Test;

import instance.BeanClass;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.MyService;

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext appcon = new ClassPathXmlApplicationContext("config/applicationContext.xml");
        
        System.out.println("获得Bean对象前");
        MyService beanLife =(MyService) appcon.getBean("beanLife");
        System.out.println("获得Bean对象后"+beanLife);

        appcon.close();//关闭容器，销毁Bean对象。
    }
}

运行结果如下图所示：