7.4 使用 Spring 容器
Spring 有两个核心接口：BeanFactory 和 ApplicationContext，其中ApplicationContext 是 BeanFactory 的子接口。它们都可代表 Spring 容器，Spring 容器是生成 Bean 实例的工厂，并管理容器中的Bean。
Java 程序面向接口编程，无须关心 Bean 实例的实现类；但 Spring 容器负责创建 Bean 实例，因此必须精确知道每个 Bean 实例的实现类，故Spring 配置文件必须指定 Bean 实例的实现类。
7.4.1 Spring 容器
Spring 容器最基本的接口就是BeanFactory。BeanFactory 负责配置、创建、管理Bean，它有一个子接口：ApplicationContext，因此也被称为Spring上下文。Spring 容器还负责管理Bean 与 Bean 之间的依赖关系。
BeanFactory 接口包含如下几个基本方法。
boolean containsBean(String name)：判断Spring容器是否包含id为name 的Bean 实例。
<T> T getBean(Class<T> requiredType)：获取Spring容器中属于requiredType类型的、唯一的Bean实例。
Object getBean(String name)：返回容器id为name的Bean实例。
<T> T getBean(String name,Class requiredType)：返回容器中id为name，并且类型为requiredType的Bean。
Class<?> getType(String name)：返回容器中id为name的Bean实例的类型。
BeanFactory 常用的实现类是DefaultListableBeanFactory。
ApplicationContext 常用的实现类是FileSystemXmlApplicationContext、ClassPathXmlApplicationContext 和 AnnotationConfigApplicationContext。
如果在Web应用中使用Spring容器，则通常有XmlWebApplicationContext、AnnotationConfigWebApplicationContext两个实现类。
创建BeanFactory实例时，应该提供XML配置文件作为参数，XML配置文件通常使用Resource对象传入。
Resource接口是Spring提供的资源访问接口，通过使用该接口，Spring能以简单、透明的方式访问磁盘、类路径以及网络上的资源。
大部分Java EE应用，可在启动Web应用时自动加载ApplicationContext实例，接收Spring管理的Bean无须知道ApplicationContext的存在，一样可以利用ApplicationContext的管理。
对于独立的应用程序，可通过如下方法实例化BeanFactory。
// 搜索类加载路径下的beans.xml 文件创建Resource对象
Resource isr = new ClassPathResource("beans.xml");
// 创建默认的BeanFactory容器
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 让默认的BeanFactory容器加载isr对应的XML配置文件
new XmlBeanDefinitionReader(beanFactory).loadBeanDefinitions(isr);
或者采用如下代码来创建BeanFactory：
// 搜索文件系统的当前路径下的beans.xml 文件创建Resource对象
Resource isr = new FileSystemResource("beans.xml");
// 创建默认的BeanFactory容器
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 让默认的BeanFactory容器加载isr对应的XML配置文件。
new XmlBeanDefinitionReader(beanFactory).loadBeanDefinitions(isr);
如果应用需要加载多个配置文件来创建Spring容器，则应该采用BeanFactory的子接口ApplicationContext来创建BeanFactory的实例。
ApplicationContext接口包含FileSystemXmlApplicationContext和ClassPathXmlApplicationContext两个常用的实现类。
如果需要同时加载多个XML配置文件来创建Spring容器，则可以采用如下方式：
// 以类加载路径下的Beans.xml、service.xml文件创建ApplicationContext
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml","service.xml");
当然也可支持从文件系统的相对路径或绝对路径来搜索配置文件，只要使用FileSystemXmlApplicationContext即可。
// 以类加载路径下的Beans.xml、service.xml文件创建ApplicationContext
ApplicationContext ctx = new FileSystemXmlApplicationContext("beans.xml","service.xml");
7.4.2 使用ApplicationContext
大部分时候使用ApplicationContext实例作为容器，因此也把Spring容器称为Spring上下文。ApplicationContext是BeanFactory接口的子接口，它增强了BeanFactory的功能。
ApplicationContext允许以声明式方式操作容器，无须手动创建它。可利用ContextLoader的支持类，在Web应用启动时自动创建ApplicationContext。当然也可采用编程方式创建ApplicationContext。
除了提供BeanFactory所支持的全部功能外，ApplicationContext还有如下额外的功能。
ApplicationContext默认会预初始化所有singleton Bean，也可通过配置取消预初始化。
ApplicationContext继承MessageSource接口，因此提供国际化支持。
资源访问，比如访问URL文件。
事件机制。
同时加载多个配置文件。
以声明式方式启动并创建Spring容器。
配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring 配置文件的根元素，使用Spring-beans-4.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd"> <!-- 如果不加任何特殊的配置，该Bean默认是singleton行为的 -->
<bean id="chinese" class="edu.pri.lime._7_4_2.bean.Person">
<property name="test" value="孙悟空"/>
</bean> </beans>
Class： Person
package edu.pri.lime._7_4_2.bean;
public class Person {
public Person(){
System.out.println("==正在执行Person无参数的构造器==");
}
public void setTest(String name){
System.out.println("正在调用setTest()方法，传入参数为：" + name);
}
}
Class： TestBean
package edu.pri.lime._7_4_2.test; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestBean { public static void main(String[] args){
ApplicationContext ctx = new ClassPathXmlApplicationContext("app_7_4_2.xml");
}
}
Console：
==正在执行Person无参数的构造器==
正在调用setTest()方法，传入参数为：孙悟空
配置文件<bean.../>如果没有任何特殊配置，该Bean就是singleton Bean，ApplicationContext会在容器初始化完成后，自动调用Person类的构造器创建chinese Bean，并以“孙悟空”作为参数去调用chinese Bean的setTest()方法。
如果使用BeanFactory作为容器，BeanFactory不会预初始化容器中的Bean。
为了阻止Spring容器预初始化容器中的singleton Bean，可以为<bean.../>元素指定lazy-init="true"，该属性用于阻止容器预初始化该Bean。
<!-- 阻止容器预初始化Bean -->
<bean id="chinese" class="edu.pri.lime._7_4_2.bean.Person" lazy-init="true">
<property name="test" value="孙悟空"/>
</bean>
7.4.3 ApplicationContext 的国际化支持
ApplicationContext接口继承了MessageSource接口，因此具有国际化功能。
MessageSource接口中定义的两个用于国际化的方法：
String getMessage(String code,Object[] args,Locale loc)
String getMessage(String code,Object[] args,String default,Locale loc)
ApplicationContext 正是通过这两个方法来完成国际化的，当程序创建ApplicationContext容器时，Spring自动查找配置文件中名为messageSource的Bean实例，一旦找到这个Bean实例，上述两个方法的调用就被委托给该messageSource Bean。如果没有该Bean，ApplicationContext会查找其父容器中的messageSource Bean；如果找到，它将被作为messageSource Bean 使用。如果无法找到messageSource Bean，系统将会创建一个空的StaticMessageSource Bean ，该Bean能就收上述两个方法的调用。
在Spring中配置messageSource Bean是通常使用ResourceBundleMessageSource类。
message_zh_CN.properties：
hello=\u6B22\u8FCE\u4F60,{0}
now=\u73B0\u5728\u65F6\u95F4\u662F\uFF1A{0}
message_en_US.properties：
hello=welcome,{0}
now=now is:{0}
app_7_4_3.xml：
<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring 配置文件的根元素，使用Spring-beans-4.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd"> <bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<!-- 驱动Spring调用messageSource Bean的setBasenames()方法，
该方法需要一个数组参数，使用list元素配置多个数组元素 -->
<property name="basenames">
<list>
<value>message</value>
<!-- 如果有多个资源文件，全部列在此处 -->
</list>
</property>
</bean>
</beans>
SpringTest：
package edu.pri.lime._7_4_3.main; import java.util.Date;
import java.util.Locale; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; public class SpringTest { public static void main(String[] args){
// 实例化ApplicationContext
ApplicationContext ctx = new ClassPathXmlApplicationContext("app_7_4_3.xml");
// 使用getMessage()方法获取本地化消息。
// Locale的getDefault()方法获取本地化消息
// Gets the current value of the default locale for the specified Category for this instance of the Java Virtual Machine.
// Category used to represent the default locale for formatting dates, numbers, and/or currencies.
String hello = ctx.getMessage("hello", new String[]{"孙悟空"},Locale.getDefault(Locale.Category.FORMAT));
String now = ctx.getMessage("now", new Object[]{new Date()},Locale.getDefault(Locale.Category.FORMAT));
// 打印出两条本地化信息
System.out.println(hello);
System.out.println(now); System.out.println("----------------------------");
Locale enUs = new Locale("en", "US");
String hello_ = ctx.getMessage("hello", new String[]{"lime"}, enUs);
String now_ = ctx.getMessage("now", new Object[]{new Date()}, enUs);
System.out.println(hello_);
System.out.println(now_);
}
}
Spring 的国际化支持，其实是简历在Java程序国际化的基础之上的。其核心思路都是将程序中需要实现国际化的信息写入资源文件，而代码中仅仅使用相应的各信息的Key。
7.4.4 ApplicationContext 的事件机制
ApplicationContext的事件机制是观察者设计模式的实现，通过ApplicationEvent类和ApplicationListener接口，可以实现ApplicationContext的事件处理。
如果容器中有一个ApplicationListener Bean，每当ApplicationContext发布ApplicationEvent时，ApplicationListener Bean将自动被触发。
Spring的事件框架有如下两个重要成员：
ApplicationEvent：容器事件，必须由ApplicationContext发布。
ApplicationListener：监听器，可由容器中的任何监听器Bean担任。
Spring的事件机制与所有的事件机制有基本相似，它们都需要由事件源、事件和事件监听器组成。只是此处的事件源是ApplicationContext，且事件必须由Java程序显式触发。
Class：EmailEvent
package edu.pri.lime._7_4_4.bean; import org.springframework.context.ApplicationEvent; //只要一个Java类继承了ApplicationEvent基类，那该对象就可作为Spring容器的容器事件(观察者模式：主题）
public class EmailEvent extends ApplicationEvent { private static final long serialVersionUID = 1L; private String address;
private String text; public EmailEvent(Object source) {
super(source);
// TODO Auto-generated constructor stub
} // 初始化全部成员变量的构造器
public EmailEvent(Object source, String address, String text) {
super(source);
this.address = address;
this.text = text;
} public String getAddress() {
return address;
} public void setAddress(String address) {
this.address = address;
} public String getText() {
return text;
} public void setText(String text) {
this.text = text;
}
}
Class ： MyOtherEvent
package edu.pri.lime._7_4_4.bean;
import org.springframework.context.ApplicationEvent;
public class MyOtherEvent extends ApplicationEvent {
private static final long serialVersionUID = -2196975742599078369L;
public MyOtherEvent(Object source) {
super(source);
// TODO Auto-generated constructor stub
}
}
Class ： EmailNotifier
package edu.pri.lime._7_4_4.bean; import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener; //容器事件的监听器类必须实现ApplicationListener接口（观察者模式：观察者）
public class EmailNotifier implements ApplicationListener { // 该方法会在容器发生任何事件时都会自动触发
public void onApplicationEvent(ApplicationEvent event) {
// 只处理EmailEvent，模拟发送email通知
if(event instanceof EmailEvent){
EmailEvent emailEvent = (EmailEvent) event;
System.out.println("EmailEvent " + event);
System.out.println("需要发送邮件的接收地址 " + emailEvent.getAddress());
System.out.println("需要发送邮件的邮件正文 " + emailEvent.getText());
}else{
// 其他事件不作任何处理
System.out.println("其他事件 ：" + event);
}
} }
XML ：app_7_4_4.xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring 配置文件的根元素，使用Spring-beans-4.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
<!-- 配置监听器 -->
<!-- 只要在Spring中配置一个实现了ApplicationListener接口的Bean，Spring容器就会把这个Bean当成容器事件的事件监听器 -->
<bean class="edu.pri.lime._7_4_4.bean.EmailNotifier" />
</beans>
Class ： SpringTest
package edu.pri.lime._7_4_4.main; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import edu.pri.lime._7_4_4.bean.EmailEvent;
import edu.pri.lime._7_4_4.bean.MyOtherEvent; public class SpringTest { public static void main(String[] args){
// 当系统创建Spring容器、加载Spring容器时会自动触发容器事件，容器时间监听器可以监听到这些事件。
ApplicationContext ctx = new ClassPathXmlApplicationContext("app_7_4_4.xml");
// 创建一个ApplicationEvent对象
EmailEvent emailEvent = new EmailEvent("test","zzulime@outlook.com","this is a test");
// 调用ApplicationContext的pulishEvent()方法来主动触发容器事件。
ctx.publishEvent(emailEvent); System.out.println("---------------"); MyOtherEvent myOtherEvent = new MyOtherEvent("myOtherEvent");
ctx.publishEvent(myOtherEvent);
}
}
Console ：
十二月 31, 2016 11:58:05 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@56cbfb61: startup date [Sat Dec 31 23:58:05 CST 2016]; root of context hierarchy
十二月 31, 2016 11:58:06 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [app_7_4_4.xml]
其他事件 ：org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.context.support.ClassPathXmlApplicationContext@56cbfb61: startup date [Sat Dec 31 23:58:05 CST 2016]; root of context hierarchy]
EmailEvent edu.pri.lime._7_4_4.bean.EmailEvent[source=test]
需要发送邮件的接收地址 zzulime@outlook.com
需要发送邮件的邮件正文 this is a test
---------------
其他事件 ：edu.pri.lime._7_4_4.bean.MyOtherEvent[source=myOtherEvent]
监听器不仅监听到程序所触发的事件，也监听到容器内置的事件。实际上，如果开发者需要在Spring容器初始化、销毁时回调自定义方法，就可以通过上面的事件监听器来实现。
如果Bean希望发布容器事件，则该Bean必须先获得对Spring容器的引用。为了让Bean获得对Spring容器的引用，可让Bean类实现ApplicationContextAware或BeanFactoryAware接口。
Spring 提供了如下几个内置事件：
⊙ ContextRefreshedEvent ： ApplicationContext容器初始化或刷新触发该事件，此处的初始化是指，所有的Bean被成功加载，后处理的Bean被检测并激活，所有的singleton Bean 被预实例化，ApplicationContext容器已就绪可用。
⊙ ContextStartedEvent ： 当使用ConfigurableApplicationContext （ApplicationContext的子接口）接口的start()方法启动ApplicationContext容器时触发该事件。容器管理生命周期的Bean实例将获得一个指定的启动信号，这在经常需要停止后重新启动的场合比较常见。
⊙ ContextClosedEvent ： 当使用ConfigurableApplicationContext（ApplicationContext的子接口）接口的close()方法关闭ApplicationContext容器时触发该事件。
⊙ ContextStoppedEvent ： 当使用ConfigurableApplicationContext（ApplicationContext的子接口）接口的stop()方法使ApplicationContext停止时触发该事件。此处的“停止”意味着容器管理生命周期的Bean实例将获得一个指定的停止信号，被停止的Spring容器可再次调用start()方法重新启动。
⊙ RequestHandledEvent ： Web相关的事件，只能应用于使用DispatcherServlet的Web应用中。在使用Spring作为前端的MVC控制器时，当Spring处理用户请求结束后，系统会自动触发该事件。
⊙ SessionConnectedEvent ： 用于WebSocket功能服务
⊙ SessionConnectEvent ：用于WebSocket功能服务
⊙ SessionDisconnectEvent ：用于WebSocket功能服务
7.4.5 让Bean获取Spring容器
在Web应用中，Spring容器通常采用声明式方式配置产生：开发者只要在web.xml文件中配置一个Listener，该Listener将会负责初始化Spring容器，前端MVC框架可以直接调用Spring容器中的Bean，无须访问Spring容器本身。在这种情况下，容器中的Bean处于容器管理下，无须主动访问容器，只需接收容器的依赖注入即可。
在某些特殊的情况下，Bean需要实现某个功能（比如该Bean需要输出国际化消息，或者giantBean需要想Spirng容器发布事件......），但该功能必须借助于Spring容器才能实现，此时就必须让该Bean先获取Spring容器，然后借助于Spring容器来实现该功能。
为了让Bean获取它所在的Spring容器，可以让该Bean实现BeanFactoryAware接口，并覆写唯一的方法setBeanFacotry(BeanFactory beanFactory)。
setBeanFactory(BeanFactory beanFactory) ： beanFactory参数指向创建它的BeanFactory。
该方法将由Spring调用，Spring调用该方法时会将Spring容器作为参数传入该方法。
与BeanFactoryAware接口类似的有ApplicationContextAware接口，实现该接口的Bean需要实现setApplicationContext(ApplicationContext applicationContext)方法，该方法有Spring来调用，当Spring容器调用该方法时，它会把自身作为参数传入该方法。
Class ： Person
package edu.pri.lime._7_4_5.bean; import java.util.Date;
import java.util.Locale; import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware; /* 国际化功能需要借助于Spring容器来实现，因此程序就需要让Person类实现ApplicationContextAware接口。
*/
public class Person implements ApplicationContextAware { // 将BeanFactory容器以成员变量保存
private ApplicationContext ctx;
// Spring 容器会检测容器中所有的Bean,如果发现某个Bean实现了ApplicationContextAware接口，
// Spring容器会在创建该Bean后，自动调用该方法，调用该方法时，会将容器本身最为参数传给该方法
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.ctx = applicationContext;
} // 借助ApplicationContext容器的getMessage方法获取国际化消息
public void sayHi(String name){
System.out.println(ctx.getMessage("hello", new String[]{name}, Locale.getDefault(Locale.Category.FORMAT)));
}
}
property ：message_zh_CN.properties
hello=\u6B22\u8FCE\u4F60,{0}
now=\u73B0\u5728\u65F6\u95F4\u662F\uFF1A{0}
property ：message_en_US.properties
hello=welcome,{0}
now=now is:{0}
XML ： app_7_4_5.xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring 配置文件的根元素，使用Spring-beans-4.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd"> <!-- 加载容器国际化所需要的语言资源文件 -->
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>message</value>
</list>
</property>
</bean>
<!-- Spring容器会检测容器中所有的Bean，如果发现某个Bean实现了ApplicationContextAware接口，
Spring容器会在创建该Bean之后，自动调用该Bean的setApplicationContext()方法，
并将容器本身最为参数传给该方法。 -->
<bean id="person" class="edu.pri.lime._7_4_5.bean.Person" /> </beans>
Class ： SpringTest
package edu.pri.lime._7_4_5.main; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import edu.pri.lime._7_4_5.bean.Person; public class SpringTest { public static void main(String[] args){
ApplicationContext ctx = new ClassPathXmlApplicationContext("app_7_4_5.xml");
Person per = ctx.getBean("person",Person.class);
per.sayHi("lime");
}
}
7.5 Spring容器中的Bean
7.5.1 Bean的基本定义和Bean别名
<beans.../>元素是Spring配置文件的根元素，该元素可以指定如下属性：
default-lazy-init ： 指定该<beans.../> 元素下配置的所有Bean默认的延迟初始化行为。
default-merge ： 指定该<beans.../> 元素下配置的所有Bean默认的merge行为。
default-autowire ： 指定该<beans.../> 元素下配置的所有Bean 默认的自动装配行为。
default-autowire-candidates： ： 指定该<beans.../> 元素下配置的所有Bean 默认是否作为自动装配的候选Bean。
default-init-method ： 指定该<beans.../> 元素下配置的所有Bean 默认的初始化方法。
default-destroy-method ： 指定该<beans.../> 元素下配置的所有Bean 默认的回收方法。
<beans.../>元素下所能指定的属性都可以在每个<bean.../>子元素中指定----将属性名去掉default即可。区别是：为<bean.../>指定的这些属性，只对特定Bean起作用；如果在<beans.../>元素下指定这些属性，这些属性将会对<beans.../>包含的所有Bean都起作用。当二者所指定的属性不一致时，<bean.../>下指定的属性会覆盖<beans.../>下指定的属性。
<bean.../>元素的id属性具有唯一性，而且是一个真正的XML ID 属性，因此其他XML元素在引用id时，可以利用XML解析器的验证功能。
指定别名有两种方式：
⊙ 定义<bean.../>元素时通过name属性指定别名；如果需要为Bean实例指定多个别名，则可以在name属性中使用逗号、冒号或者空格来分隔多个别名，后面通过任一别名即可访问该Bean实例。
⊙ 通过<alias.../>元素为已有的Bean指定别名。
<alias name="" alias=""/> name:指定一个Bean实例的标识名，表明将为该Bean实例指定别名；alias：指定一个别名。
<bean id="person" class="edu.pri.lime._7_4_5.bean.Person" name="chinese,lime,oracle"/>
<alias name="person" alias="jackson"/>
<alias name="person" alias="tomcat"/>
啦啦啦