SSM框架学习(三)----Spring的Bean

前言

  这篇文章主要是从基础开始一步步学习SSM框架。因为这是一份学习笔记，所以会按照课程将模块分成多章节来写。这是整篇的第三章节。

系列文章传送

SSM框架学习----汇总篇

SSM框架学习(一)----认识SSM框架

SSM框架学习(二)----Spring基础

SSM框架学习(三)----Spring的Bean
…

---

Spring的Bean

1-1.什么是Spring的Bean？

  Bean的本质就是Java中的类，而Spring中的Bean其实就是对实体类的引用，来生产Java类对象，从而实现生产和管理Bean 。
  如果把Spring看做一个大型工厂，则Spring容器中的Bean就是该工厂的产品。要想使用这个工厂生产和管理Bean，就需要在配置文件中告诉它需要哪些Bean，以及需要使用何种方式将这些Bean装配到一起。

1-2.Bean的配置文件格式

  在实际开发中，最常使用的是XML文件格式的配置方式，这种配置方式是通过XML文件来注册并管理Bean之间的依赖关系。

1-3.beans元素的属性

  beans是XML配置文件的根元素，包含了多个bean子元素，每一个bean子元素定义了一个Bean，并描述了该Bean如何被装配到Spring容器中。

beans元素的常用属性

属性或子元素名称	描述
id	是一个Bean的唯一标识符，Spring容器对Bean的配置、管理都通过该属性来完成
name	Spring容器同样可以通过此属性对容器中的Bean进行配置和管理，name属性中可以未Bean指定多个名称，每个名称之间用逗号或分号隔开
class	该属性指定了Bean的具体实现类，它必须是一个完整的类名，使用类的权限定名
scope	用来设定Bean实例的作用域，其属性有singleton（单例）、prototype（原型）、request、session、global Session、application 和websocket。其默认值为singleton
constructor-arg	Bean元素的子元素，可以使用此元素传入构造参数进行实例化。该元素的index属性指定构造参数的序号（从0开始），type属性指定构造参数的类型，参数值可以通过ref属性或value属性直接指定，也可以通过ref或value子元素指定
property	Bean元素的子元素，用于调用Bean实例中的setter方法完成属性赋值，从而完成依赖注入。该元素的name属性指定Bean实例中的相应属性名，ref属性或value属性用于指定参数值
ref	property、constructor-arg 等元素的属性或子元素，可以用于指定对Bean工厂中某个Bean实例的引用
value	property、constructor-arg 等元素的属性或子元素。可以用于直接指定一个常量值
list	用于封装List或数组类型的依赖注入
set	用于封装Set类型属性的依赖注入
map	用于封装Map类型属性的依赖注入
entry	map 元素的子元素，用于设置一个键值对。其key属性指定字符串类型的键值，ref或value子元素指定其值，也可以通过value-ref或value属性指定其值

1-4.Bean的配置文件

  在配置文件中，通常一个普通的Bean只需要定义id（或name）和class 两个属性即可，定义Bean的方式如下所示：

    <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.Bean1" />
            <bean name="bean2" class="com.itheima.Bean2" />
    beans>

  如果在Bean中未指定id和name属性，则Spring会将class属性当作id使用。

（1）多个配置文件来创建Bean

  将Bean都配置在同一个xml文件中，将不利于阅读和维护。在Spring中，一般是将一个大的配置文件按模块分成多个小的配置文件来管理，在运行时再将这些配置文件加载汇总成一个配置文件。实际项目中，将Spring配置文件按模块、按组件类型分开配置，有利于团队开发和后期维护，因此程序需要根据多个配置文件来创建Spring容器。

（2）加载多个配置文件的方法

  Spring自动将多个配置文件在内存中整合成一个配置文件。
方法：

ClassPathXmlApplicationContext(java.lang.String… configLocations)

FileSystemXmlApplicationContext(java.lang.String… configLocations)

配置文件的加载方式有如下几种：

1.在XML配置文件中导入其它XML配置文件

（1）在配置文件中使用标签导入其它配置文件
（2）每个配置文件使用一个来导入。如bean.xml

（3）ApplicationContext contex=new ClassXmlApplicationContext(“bean.xml");

2.使用ApplcationContext加载多个配置文件

ApplicationContext ctx=new ClassXmlApplicationContext(
new String["bean1.xml", "bean2.xml"]);
 
BeanDefinitionRegistry a=new DefaultListableBeanFactory();
XmlBeanDefinitionReader r=new XmlBeanDefinitionReader(a);
r.loadBeanDefinitions(new ClassPathResource("bean1.xml"));
r.loadBeanDefinitions(new classPathResource("bean2.xml"));
BeanFactory bf = (BeanFactory)reg;

3.Web应用启动时加载多个配置文件

（1）在web.xml中定义contextConfigLocation参数，加载所有逗号分割的xml。如果没有这个参数，spring默认加载WEB-INF/applicationContext.xml文件。

<context-param>
   <param-name>contextConfigLocationparam-name>
<param-value>
  classpath*:conf/spring/applicationContext_core*.xml,
  classpath*:conf/spring/applicationContext_dict*.xml,    
param-value>
context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
listener-class>
listener>       利用ServletContextListener实现

2-1.Bean的实例化

  在面向对象的程序中，想要使用某个对象，就需要先实例化这个对象。同样，在Spring中，要想使用容器中的Bean，也需要实例化Bean。实例化Bean有三种方式，分别为构造器实例化、静态工厂方式实例化和实例工厂方式实例化（其中最常用的是构造器实例化）。

三个方式的目录结构（写在一个项目里）：

（1）构造器实例化

  构造器实例化是指Spring容器通过Bean对应的类中默认的构造函数来实例化Bean。方法如下：
1.创建Web项目，导入相关Jar包；

2.创建名为Bean1的Java类；

package com.itheima.instance.constructor;
public class Bean1 {
}

3.创建Spring配置文件beans1.xml，并配置Bean1实体类Bean；

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

4.创建测试类，测试程序。

public class InstanceTest1 {
       public static void main(String[] args) {
     	String xmlPath = "com/itheima/instance/constructor/beans1.xml";
               ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
			    Bean1 bean = (Bean1) applicationContext.getBean("bean1");
                System.out.println(bean);
      }
}

（2）静态工厂方式实例化

  静态工厂是实例化Bean的另一种方式。该方式要求自己创建一个静态工厂的方法来创建Bean的实例。方法如下：

1.创建名为Bean2的Java类；

package com.itheima.instance.static_factory;
public class Bean2 {
}

2.创建一个Java工厂类，在类中使用静态方法获取Bean2实例；

package com.itheima.instance.static_factory;
public class MyBean2Factory {	
	//使用自己的工厂创建Bean2实例
	public static Bean2 createBean(){
		return new Bean2();
	}
}

3.创建Spring配置文件beansxml，并配置工厂类Bean；

<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="bean2" 
            class="com.itheima.instance.static_factory.MyBean2Factory" 
		   factory-method="createBean" />
beans>

4.创建测试类，测试程序。

package com.itheima.instance.static_factory;
import org.springframework.context.ApplicationContext;
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在加载配置文件时，对Bean进行实例化
		ApplicationContext applicationContext = 
				new ClassPathXmlApplicationContext(xmlPath);
		System.out.println(applicationContext.getBean("bean2"));
	}
}

（3）实例工厂方式实例化

  采用直接创建Bean实例的方式，在配置文件中，通过factory-bean属性配置一个实例工厂，然后使用factory-method属性确定使用工厂中的哪个方法。方法如下：
1.创建名为Bean3的Java类；

package com.itheima.instance.factory;
public class Bean3 {
}

2.创建一个Java工厂类，在类中使用非静态方法获取Bean3实例；

package com.itheima.instance.factory;
public class MyBean3Factory {
	public MyBean3Factory() {
		System.out.println("bean3工厂实例化中");
	}
    //创建Bean3实例的方法
	public Bean3 createBean(){
		return new Bean3();
	}
}

3.创建Spring配置文件beans3.xml，并配置工厂类Bean；

<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="myBean3Factory" 
            class="com.itheima.instance.factory.MyBean3Factory" />
    
	<bean id="bean3" factory-bean="myBean3Factory" 
		   factory-method="createBean" />
beans>

4.创建测试类，测试程序。

package com.itheima.instance.factory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class InstanceTest3 {
	public static void main(String[] args) {
		// 指定配置文件路径
		String xmlPath = "com/itheima/instance/factory/beans3.xml";
		// ApplicationContext在加载配置文件时，对Bean进行实例化
		ApplicationContext applicationContext = 
				new ClassPathXmlApplicationContext(xmlPath);
		System.out.println(applicationContext.getBean("bean3"));
	}
} 

3-1.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的同一个实例。仅在使用portlet上下文时有效。
application	为每个ServletContext对象创建一个实例。仅在web相关的ApplicationContext中生效。
websocket	为每个websocket对象创建一个实例。仅在Web相关的ApplicationContext中生效。

singleton和prototype是最常用的两种作用域。

（1）singleton作用域

  Spring容器默认的作用域，此作用域下，Spring容器只会存在一个共享的Bean实例。对于无会话状态的Bean（如Dao 组件、Service组件）来说， singleton作用域是最理想的选择。

在Spring配置文件中，可以使用bean元素的scope属性，将Bean的作用域定义成singleton。代码如下：

<bean id="scope" class="com.itheima.scope.Scope" scope="singleton"/>

（2）prototype作用域

  对需要保持会话状态的Bean（如Struts 2的Action类）应该使用prototype作用域。在使用prototype作用域时，Spring容器会为每个对该Bean的请求都创建一个新的实例。

在Spring配置文件中，同样使用bean元素的scope属性，将Bean的作用域定义成prototype。代码如下：

<bean id="scope" class="com.itheima.scope.Scope" scope=" prototype "/>

4-1.Bean的生命周期

Spring中Bean的生命周期有何意义?
  其意义就在于，可以利用Bean在其存活期间的特定时刻完成一些相关操作。这种时刻可能有很多，但一般情况下，常会在Bean的postinitiation (初始化后) 和predestruction (销毁前) 执行一些相关操作。

Spring容器可以管理Bean部分作用域的生命周期。说明如下：

作用域	说明
singleton作用域	在此作用域下，Spring能够精确的知道该Bean何时被创建，何时初始化完成，以及何时被销毁。
prototype作用域	prototype作用域的Bean，Spring只负责创建，当容器创建了Bean实例后，Bean的实例就交给客户端代码来管理，Spring容器将不再跟踪其生命周期。

总结

  本讲对Spring的Bean进行了详细讲解，首先介绍了Bean的配置，然后通过案例讲解了Bean实例化的三种方式，最后介绍了Bean的作用域和生命周期。