小菜鸟 SSM框架之 Spring复习-02（Bean的实例化）

Bean 的实例化

Bean的实例化有三种方式：构造器实例化、静态工厂实例化、实例工厂方式实例化

构造器实例化

实例化构造方法 是指Spring容器通过Bean对应类中默认的无参构造方法来实例化。

创建Bean1类：

package com.itheima.instance.constructor;

public class Bean1 {
    
}

创建Spring的配置文件：

<?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 id = "bean1" class = "com.itheima.instance.constructor.Bean1"></bean>
        
</beans>

​ 在配置文件中配置一个id 为bean1的 Bean ，并通过class属性指定其对应的实现类。

创建测试类：

package com.itheima.instance.constructor;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InstanceTest1 {
	public static void main(String[] args) {
		//定义配置文件的路径
		String xmlPath = "com/itheima/instance/constructor/beans1.xml";
		//加载配置文件，并对Bean进行实例化
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		Bean1 bean = (Bean1) applicationContext.getBean("bean1"); //强制类型转换
		System.out.print(bean);
		((AbstractApplicationContext)applicationContext).close();
	}
}

运行结果：

bean1 已被执行，执行结果在不同的电脑有不同的结果！！！

静态工厂方式实例化

该方式要求开发者创建一个静态工厂的方法来创建 Bean 的实例。其中Bean的class属性不再是Bean实例的实现类，而是静态工厂类，同时还需要使用 factory-method 的属性来制定所创建的静态工厂方法。

创建Bean2类：

package com.itheima.instance.static_factory;

public class Bean2 {

}

创建工厂类，并在工厂类中创建一个静态工厂方法：

package com.itheima.instance.static_factory;

//工厂类
public class MyBean2Factory {
	//工厂类中的静态方法
	public static Bean2 createBean() {
		return new Bean2();
	}
}

使用静态工厂实例化时，工厂类中的静态方法必须有返回值，且返回值的类型和实例化的Bean2 的类型相同。

配置Spring的配置文件：

<?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 id = "bean2" class = "com.itheima.instance.static_factory.MyBean2Factory" 
    		factory-method = "createBean"/>
</beans>

class属性指向 静态方法的所属的工厂类；factory-method指向 实例化Bean的静态方法。

测试类：

package com.itheima.instance.static_factory;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InstanceTest2 {
	public static void main(String[] args) {
		//定义配置文件的路径
		String xmlPath = "com/itheima/instance/static_factory/beans2.xml";
		//加载配置文件
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		//实例化Bean2对象
		Bean2 bean2 = (Bean2) applicationContext.getBean("bean2");
		System.out.println(bean2);
		((AbstractApplicationContext)applicationContext).close();
	}
}

运行结果：

实例工厂方式实例化

此种方式不再使用静态方法创建 Bean 实例，而是采用直接创建 Bean 实例的方式。

在配置文件中，需要实例化的 Bean 也不是通过class 属性直接指向的实例化类，而是通过 factory-bean 属性指向配置的实例工厂，然后使用 factory-method 属性确定使用工厂中的那个方法。

创建Bean3 类：

package com.itheima.instance.factory;

public class Bean3 {

}

创建实例工厂类：

package com.itheima.instance.factory;

public class MyBean3Factory {
	//无参构造方法
	public MyBean3Factory() {
		System.out.println("bean3 工厂实例化中 。。。。");
	}
	
	//创建bean3实例化方法
	public Bean3 createBean() {
		return new Bean3();
	}
}

创建Spring配置文件：

<?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  id = "MyBean3Factory"  class = "com.itheima.instance.factory.MyBean3Factory"/>
       	<!-- factory-method配置工厂中使用哪一个方法      factory-bean指向配置的实例工厂-->
       	<bean id = "bean3" factory-bean = "MyBean3Factory"  factory-method = "createBean"></bean>
        
</beans> 

创建测试类：

package com.itheima.instance.factory;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InstanceTest3 {
	public static void main(String[] args) {
		//指定配置文件的路经
		String xmlPath = "com/itheima/instance/factory/beans3.xml";
		//加载配置文件
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		//实例化Bean3对象
		Bean3 bean = (Bean3) applicationContext.getBean("bean3");
		System.out.println(bean);
		
		((AbstractApplicationContext)applicationContext).close();
		
	}
}

运行结果：

构造器实例化、静态工厂方式实例化、实例工厂方式实例化三者的复杂程度依次增加。

静态工厂方式实例化和实例工厂方式实例化两者批量实例化的Bean比较方便。

---

》 附加一点Bean的作用域的知识，这一点比较简单。

Bean 的作用域

作用域的种类

作用域	说明
singleton（单例）	使用singleton定义的Bean 在Spring容器中只有一个实例，即：无论有多少个Bean引用它，都始终指向同一个对象。是Spring默认的作用域
prototype（原型）	每次通过Spring 获取 prototype定义的 Bean时，容器都将创建一个新的Bean实例对象
request	在一次HTTP请求中，容器会返回该Bean的同一个实例，对于不同的HTTP请求，会产生不同的Bean实例，而且该Bean仅在当前的HTTP Request 内有效
session	在一次HTTP Session 请求中，容器会返回该Bean的同一个实例，对于不同的HTTP请求，会产生不同的Bean实例，而且该Bean仅在当前的HTTP Session 内有
globalSession	在一个全局的HTTP Session 中容器会返回该Bean的同一个实例。仅在使用porlet 上下文时有效
application	为每个ServeletContext 对象创建一个实例。仅在WEB相关的ApplicationContext中生效
websocket	为每一个Websocket 对象创建一个实例。仅在web相关的ApplicationContext中生效

singleton和prototype是最常用的

在Spring的配置文件中，Bean的作用域是通过元素的scope属性来指定的，该属性值可以设置为：singleton、prototype、request、session、globalSession、application、websocket

配置文件中的格式：

<bean id = "XXXX" class = "XXXXX"  scope = "singleton/prototype/request/session/globalSession/application/websocket">

Bean 生命周期

Spring 容器可以管理singleton 作用域的 Bean的生命周期。在此作用域下，Spring容器能够准确地知道该Bean 是何时被创建的、何时初始化完成、何时被销毁的

对于prototype作用域的Bean ，Spring容器只负责创建，当容器创建了Bean实例后，Bean的实例就交给客户端的代码来管理了，Spring容器并不会来管理这些Bean的生命周期

---

		在校学习生，不定时更新。还请各位看官谅解。
（参考书籍：JAVA EE 企业级应用开发教程（Spring+SpringMVC+MyBatis））