《Spring攻略》 第2章 高级Spring IoC容器
1调用静态工厂方法创建Bean
问题：
你打算调用一个静态工厂方法在Spring IoC容器中创建一个Bean，静态工厂方法的目的是在静态方法中封装对象创建过程。
解决方案：
Spring支持调用一个静态工厂方法创建Bean，这个方法应该在factory-method属性中指定。
工作原理：
factory-method
public class ProductCreator {
public static Product createProduct(int productId){
if(1 == productId){
return new Product("xiaomei", 16);
}else if(2 == productId){
return new Product("xiaolang", 15);
}
throw new IllegalArgumentException("Unknown product");
}
}
<bean id="productCreator1" class="com.partner4java.spring.factorymethod.ProductCreator"
factory-method="createProduct">
<constructor-arg value="1" />
</bean>
<bean id="productCreator2" class="com.partner4java.spring.factorymethod.ProductCreator"
factory-method="createProduct">
<constructor-arg value="2" />
</bean>
@Test
public void testFactoryMethod(){
System.out.println(applicationContext.getBean("productCreator1"));
System.out.println(applicationContext.getBean("productCreator2"));
}
2调用一个实例工厂方法创建Bean
问题：
你打算调用一个实例工厂方法在Spring IoC容器中创建一个Bean，目的是在另一个对象实例的一个方法中封装对象创建过程。
请求对象的客户可以简单地调用这个方法，不需要了解创建的细节。
解决方案：
Spring支持调用实例工厂方法创建Bean。Bean实例在factory-bean属性中指定，而工厂方法应该在factory-method属性中指定。
工作原理：
factory-bean
package com.partner4java.spring.factorybean;
import java.util.Map;
import com.partner4java.spring.factorymethod.Product;
public class ProductCreator {
private Map<String, Product> products;
public void setProducts(Map<String, Product> products) {
this.products = products;
}
public Product createProduct(String productId){
Product product = products.get(productId);
if(product != null){
return product;
}
throw new IllegalArgumentException("Unknown product");
}
}
<bean id="productCreator" class="com.partner4java.spring.factorybean.ProductCreator">
<property name="products">
<map>
<entry key="gaofumei">
<bean class="com.partner4java.spring.factorymethod.Product">
<constructor-arg value="gaofumei" name="name"/>
<constructor-arg value="100" name="price"/>
</bean>
</entry>
<entry key="xiaoneinv">
<bean class="com.partner4java.spring.factorymethod.Product">
<constructor-arg value="xiaoneinv" name="name"/>
<constructor-arg value="200" name="price"/>
</bean>
</entry>
</map>
</property>
</bean>
<bean id="gaofumei" factory-bean="productCreator" factory-method="createProduct">
<constructor-arg value="gaofumei"/>
</bean>
<bean id="xiaoneinv" factory-bean="productCreator" factory-method="createProduct">
<constructor-arg value="xiaoneinv"/>
</bean>
@Test
public void testFactoryMethod(){
System.out.println(applicationContext.getBean("gaofumei"));
System.out.println(applicationContext.getBean("xiaoneinv"));
}
3从静态字段中声明bean
问题：
你打算从一个静态字段中声明Spring IoC容器中的一个Bean。在Java中，常量值往往声明为静态字段。
解决方案：
为了从静态字段中声明Bean，你可以使用内建的工厂Bean FieldRetrievingFactoryBean，或者Spring 2.X中的<util:contant>标记。
工作原理：
public class ProductConstant {
public static Product gaofumei = new Product("gaofumei", 100);
public static Product xiaoneinv = new Product("xiaoneinv", 200);
}
<util:constant id="gaofumei"
static-field="com.partner4java.spring.constant.ProductConstant.gaofumei" />
<util:constant id="xiaoneinv"
static-field="com.partner4java.spring.constant.ProductConstant.xiaoneinv" />
@Test
public void testFactoryMethod(){
System.out.println(applicationContext.getBean("gaofumei"));
System.out.println(applicationContext.getBean("xiaoneinv"));
}
4从对象属性中声明bean
问题:
你打算从一个对象属性或者嵌套的属性（也就是属性路径）中声明Spring IoC容器中的一个Bean。
解决方案：
为了从一种对象属性或者属性路径中声明Bean，可以使用内建的工厂Bean PropertyPathFactoryBean或者Spring 2.X中的<util:property-path>标记。
工作原理：
public class ProductProperty {
private Product gaofumei;
private Product xiaonennv;
public Product getGaofumei() {
return gaofumei;
}
public void setGaofumei(Product gaofumei) {
this.gaofumei = gaofumei;
}
public Product getXiaonennv() {
return xiaonennv;
}
public void setXiaonennv(Product xiaonennv) {
this.xiaonennv = xiaonennv;
}
}
<bean id="productProperty" class="com.partner4java.spring.property.ProductProperty">
<property name="gaofumei">
<bean class="com.partner4java.spring.factorymethod.Product">
<constructor-arg name="name" value="gaofumei"/>
<constructor-arg name="price" value="100.1"/>
</bean>
</property>
<property name="xiaonennv">
<bean class="com.partner4java.spring.factorymethod.Product">
<constructor-arg name="name" value="xiaonennv"/>
<constructor-arg name="price" value="200.2"/>
</bean>
</property>
</bean>
<util:property-path id="gaofumei" path="productProperty.gaofumei"/>
<util:property-path id="xiaonennv" path="productProperty.xiaonennv"/>
5使用Spring表达式语言
问题：
你希望动态的评估一些条件或者属性，并且将其作为IoC容器中的配置值使用。
你也可能因为自定义范围的情况，必须将某些估值从设计时延迟到运行时。
或者你只是需要一种行为自己的应用添加强大的表达式语言。
解决方案：
使用Spring 3.0的Spring表达式语言（SpEL），这种语言提供了与JSF和JSP中的Unified EL或者对象图形导航语言（OGNL）相似的功能。
SpEL提供了易用的基础架构，可以在Spring容器之外使用。
工作原理：
6设置Bean作用域
问题：
当你在配置文件中声明Bean时，实际上定义了Bean创建的一个模板，而不是实际的Bean实例。
当getBean()方法或者其他的Bean的一个引用请求Bean时，Spring将根据Bean作用域（Scope）确定应该返回的Bean实例。
有时候，你必须为Bean设置正确的作用域而不是默认的作用域。( By default, a bean will be a singleton)
解决方案：
作用域 描述
singleton
在每个Spring IoC容器中一个bean定义对应一个对象实例。
prototype
一个bean定义对应多个对象实例。
request
在一次HTTP请求中，一个bean定义对应一个实例；即每次HTTP请求将会有各自的bean实例， 它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。
session
在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
global session
在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。
7自定义Bean初始化和析构
问题 ：
许多现实世界中的组件在使用之前必须进行某种初始化任务。
在组件的声明周期结束时，也必须要执行相应的任务。
解决方案：
除了注册Bean之外，Spring IoC容器还负责管理Bean的声明周期，允许你在他们的生命期特定时点执行自定义任务。
你的任务应该封装在回调方法中，由Spring IoC容器在核实的时候调用。
Spring IoC容器管理Bean周期的步骤：
1、构造程序或者工厂方法创建Bean实例。
2、向Bean属性设置值和Bean引用。
3、调用初始化回调方法。
4、Bean就绪。
5、容器关闭时，调用析构回调方法。
工作原理：
方法一：实现约定接口
public class Work implements InitializingBean,DisposableBean {
@Override
public void destroy() throws Exception {
System.out.println("离职");
}
public void vork(){
System.out.println("working");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("入职");
}
}
<bean id="work" class="com.partner4java.spring.initdes.Work"
scope="prototype" />
方法二：配置文件声明
public class Work1 {
public void destroy() throws Exception {
System.out.println("离职");
}
public void vork(){
System.out.println("working");
}
public void afterPropertiesSet() throws Exception {
System.out.println("入职");
}
}
<bean id="work1" class="com.partner4java.spring.initdes.Work1"
init-method="afterPropertiesSet" destroy-method="destroy" scope="prototype" />
方法三：注解声明
public class Work2 {
@PreDestroy
public void destroy() throws Exception {
System.out.println("离职");
}
public void vork(){
System.out.println("working");
}
@PostConstruct
public void afterPropertiesSet() throws Exception {
System.out.println("入职");
}
}
<context:annotation-config/>
<bean id="work2" class="com.partner4java.spring.initdes.Work2"
scope="prototype" />
8用Java Config简化XML配置
问题：
你欣赏DI容器的能力，但是希望覆盖一些配置，或者只是希望将更多的配置从XML格式中转移到Java中，可以更好的从重构和类型安全性中获益。
解决方案：
你可以使用Java Config。
工作原理：
Java Config支持强大的，代表了与其他通过XML或者注解的配置选项完全不同的工作方式。
重要的是，Java Config可以与现有方式混合使用。
启用Java配置的最简单方法是使用简单的XML配置文件。
@Configuration标记类：Spring将在类中寻找@Bean定义，指定这个标记@Bean的方法为一个Bean。（也就是指定某个方法返回为一个Bean）
@Lazy：将Bean的构造推迟到必须满足依赖或者应用上下文中显示的访问时。
@DependsOn：指定一个Bean的创建必须在其他Bean创建之后。
@Primary：指定相同接口的多个Bean。
@Import、@Value...
9使Bean感知容器
问题：
一个精心设计的组件应该没有对容器的直接依赖。
但是，有时候Bean有必要了解容器的资源。
解决方案：
Spring将通过一些接口定义的设置方法将对应资源注入到你的Bean中。
Spring中的常见感知接口
感知接口 目标资源
BeanNameAware IoC容器中配置的实例的Bean名称
BeanFactoryAware 当前的Bean工厂，通过它你可以调用容器的服务。
ApplicationContextAware* 当前应用上下文，通过他你可以调用容器的服务。
MessageSourceAware 消息资源，通过他可以解析文本消息。
ApplicationEventPublisherAware 应用事件发布者，通过他你可以发布应用事件。
ResourceLoaderAware 资源装载器，通过他可以加载外部资源。
你可以实现这些接口，然后试试看你都能获得什么。
工作原理：
public class HelloBeanNameAware implements BeanNameAware {
private String name;
@Override
public void setBeanName(String name) {
this.name = name;
}
@Override
public String toString() {
return "HelloBeanNameAware [name=" + name + "]";
}
}
public class HelloBeanFactoryAware implements BeanFactoryAware {
private BeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
@Override
public String toString() {
return "HelloBeanFactoryAware [beanFactory=" + beanFactory.getClass().getSimpleName() + "]";
}
}
public class HelloApplicationContextAware implements ApplicationContextAware {
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
this.applicationContext = applicationContext;
}
@Override
public String toString() {
return "HelloApplicationContextAware [applicationContext="
+ applicationContext.getClass().getSimpleName() + "]";
}
}
<bean id="helloBeanNameAware" class="com.partner4java.spring.aware.HelloBeanNameAware" />
<bean id="helloBeanFactoryAware" class="com.partner4java.spring.aware.HelloBeanFactoryAware" />
<bean id="helloApplicationContextAware" class="com.partner4java.spring.aware.HelloApplicationContextAware" />
@Test
public void testAware() throws InterruptedException{
System.out.println(applicationContext.getBean("helloBeanNameAware"));
System.out.println(applicationContext.getBean("helloBeanFactoryAware"));
System.out.println(applicationContext.getBean("helloApplicationContextAware"));
// 后台打印：
// HelloBeanNameAware [name=helloBeanNameAware]
// HelloBeanFactoryAware [beanFactory=DefaultListableBeanFactory]
// HelloApplicationContextAware
// [applicationContext=ClassPathXmlApplicationContext]
}
10加载外部资源
问题：
有时候，你的应用可能需要从不同位置（例如文件系统、classpath或者URL）读取外部资源（例如文本文件、XML文件、属性文件或者图像文件）。
通常，你必须处理用于从不同位置加载资源的不同API。
解决方案：
Spring的资源装载器提供统一的getResoure()方法，按照资源路径读取外部资源。你可以为路径指定不同的前缀从不同位置加载资源。
为了从文件系统加载资源，使用file前缀。
从classpath加载资源则使用classpath前缀。
你还可以在资源路径中指定一个URL。
Resource是Spring中代表外部资源的通用接口。Spring提供Resource接口的多个实现。
资源装载器的getResource()方法根据资源路径决定实例化哪一个Resource实现。
工作原理：
方式一：实现接口ResourceLoaderAware（感知接口）
public class HelloResourceLoader implements ResourceLoaderAware {
private ResourceLoader resourceLoader;
@Override
public void setResourceLoader(ResourceLoader resourceLoader) {
this.resourceLoader = resourceLoader;
}
public void showResource() throws IOException {
Resource resource = resourceLoader.getResource("file:D:/cc.txt");
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(resource.getInputStream()));
String s = null;
while((s = bufferedReader.readLine()) != null){
System.out.println(s);
}
}
}
<bean id="helloResourceLoader" class="com.partner4java.spring.resource.HelloResourceLoader"
init-method="showResource" />
获取bean，会注入感知接口的资源，并执行初始化方法。
方式二：
简单的指定这个Resource属性的资源路径，Spring将使用预先注册属性编辑器ResourceEditor将这个属性转换为一个Resource对象，然后注入你的Bean中。
public class HelloSimpleResourceLoader {
private Resource resource;
public void setResource(Resource resource) {
this.resource = resource;
}
public void showResource() throws IOException {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(resource.getInputStream()));
String s = null;
while((s = bufferedReader.readLine()) != null){
System.out.println(s);
}
}
}
<bean id="helloSimpleResourceLoader"
class="com.partner4java.spring.resource.HelloSimpleResourceLoader"
init-method="showResource">
<property name="resource">
<value>classpath:com/partner4java/spring/App.class</value>
</property>
</bean>
11创建Bean后处理器
问题：
你希望在Spring IoC容器中注册自己的插件，在构造期间处理Bean实例。
解决方案：
Bean后处理器允许在初始化回调方法前后进行附加的Bean处理。
Bean后处理器的主要特性是逐个处理IoC容器中的所有Bean实例，而不是单个Bean实例。
一般，Bean后处理器用于检查Bean属性有效性，或者根据特殊条件修改Bean属性。
Bean后处理器的基本要求是实现BeanPostProcessor接口。
你可以实现postProcessBeforeInitialization()和postProcessAfterInitialization()方法，在初始化回调方法前后处理所有Bean。
然后，Spring将在调用初始化回调方法前后向这两个方法传递每个Bean实例。
步骤如下：
1、构造程序或者工厂方法创建Bean实例。
2、为Bean属性设置值和Bean引用。
3、调用感知接口中定义的设置方法。
4、将Bean实例传递给每个Bean前置处理器中的postProcessBeforeInitialization方法。
5、调用初始化回调方法。
6、讲Bean实例传递给每个Bean后处理器中的postProcessAfterInitialization方法。
7、Bean准备就绪，可以使用。
8、容器关闭时，调用析构回调方法。
使用Bean工厂为IoC容器时，Bean后处理器只能编程注册，更准确的讲是通过addBeanPostProcessor()方法注册。
但是，如果你使用一个应用上下文，注册将很简单，只要在Bean配置文件中声明处理器实例，他就会自动注册。
工作原理：
public class LogBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
System.out.println(beanName + " say hello world!");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println(beanName + " say good buy!");
return bean;
}
}
<!-- 要在应用上线文中注册一个Bean后处理器，只要在Bean配置文件中声明他的一个实例就可以了。 应用上下文能够自动检测谁实现了BeanPostProcessor接口，并且注册他一处理容器中的所有其他Bean实例 -->
<bean class="com.partner4java.spring.postprocess.LogBeanPostProcessor" />
<bean id="helloResourceLoader" class="com.partner4java.spring.resource.HelloResourceLoader"
init-method="showResource" />
如果以配置文件的格式设置init-method，对BeanPostProcesser的执行没有什么威胁，BeanPostProcesser还是会先执行。
但是如果，以@PreDestroy和@PostConstruct的形式，BeanPostProcesser讲不能正常工作，因为BeanPostProcesser的默认优先级低于CommonAnnotationBeanPostProcesser。
不过可以同时实现PriorityOrdered接口来指定执行顺序。
12外部化Bean配置
问题：
在配置文件中配置Bean时，你必须记住，讲部署细节如文件路径、服务器地址、用户名和密码与Bean配置混在一起是不好的做法。
通常，Bean配置由应用开发人员编写，而部署细节则是部署人员或者系统管理员的事情。
解决方案：
Spring有一个名为PropertyPlaceholderConfigurer的Bean工厂后处理器，
用来将部分Bean配置外部化为一个属性文件。你可以在Bean配置文件中使用${var}形式的变量，
PropertyPlaceholderConfigurer讲从属性文件中加载属性并且用他们替代变量。
Bea工厂后处理器与Bean后处理器之间的不同在他的目标是IoC容器--Bean工厂或者应用上下文，而不是Bean实例。
Bean工厂后处理器将在IoC容器加载Bean配置之后、Bean实例创建之前生效，他的典型作用是在Bean实例化之前修改Bean配置。
Spring有多个Bean工厂后处理器供你使用。在实战中，你很少与必要编写自己的Bean工厂后处理器。
工作原理：
方式一：
具体指定外部Bean配置类
DBConfig.properties:
DB.name=test
public class DBConfig {
private String name;
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "DBConfig [name=" + name + "]";
}
}
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location">
<value>classpath:DBConfig.properties</value>
</property>
</bean>
<bean id="dbConfig" class="com.partner4java.spring.config.DBConfig">
<property name="name" value="${DB.name}"/>
</bean>
第二种：
简单的方式
<context:property-placeholder location="classpath:DBConfig.properties"/>
13解析文本消息
问题：
对于支持国际化的应用来说，为不同地区解析文本消息的能力是必要的。
解决方案：
Spring应用上下文能够按照关键字为目标地区解析文本消息。一般来说，一个地区的消息应该存储在一个独立的属性文件中，这个属性文件称作资源包（Resource bundle）。
MessageSource是定义多种消息解析方法的接口。ApplicationContext接口扩展了这个接口，使用所有应用上下文能够解析文本消息。
应用上下文将消息解析委派给名为messageSource的Bean。ResourceBundleMessageSource最常见的MessageSource实现，他从资源包中解析不同地区的消息。
工作原理：
方式一：
message_en_US.properties：
shopping.wife=gaofumei beatu
shopping.age={0} oh
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basename">
<value>message</value>
</property>
</bean>
@Test
public void testAware() throws InterruptedException{
System.out.println(applicationContext.getMessage("shopping.wife", null, Locale.US));
System.out.println(applicationContext.getMessage("shopping.age", new Object[]{18}, Locale.US));
}
后台打印：
gaofumei beatu
18 oh
14使用应用事件进行通信
问题：
在组件之间的典型通信模式中，发送者必须定位接受者，以便调用接受者之上的方法。
在这种情况下，发送者组件必须了解接收者组件。这种通信直接而简单，但是发送者和接受者组件紧密耦合。
使用IoC容器时，你的组件可以通过接口而不是实现进行通信。这种通信模式有助于减少耦合。
但是，只有在发送者组件必须与一个接受者通信时有效。当发送者必须与多个接受者通信时，必须逐个调用接收者。
解决方案：
Spring的应用上下文支持基于事件的Bean间通信。
在基于事件的通信模式中，发送者组件只要发布一个事件而不需要知道接收者。
实际上，可以有多于一个接收者组件。
而且，接收者不需要知道是谁发布了事件，可以同时监听不同发送者的多个事件。
这样，发送者和接收者组件是低耦合的。
在Spring中，所有事件类都必须扩展ApplicationEvent类。这样，任何Bean都可以调用应用时间发布者的publishEvent()方法，发布一个事件 。
对于监听某些事件的Bean来说，必须实现ApplicationListener接口，并在onApplicationEvent()方法中处理事件。
实际上，Spring将通知所有事件的监听者，这样你必须自己过滤事件。但是，如果使用类属，Spring将只分发匹配类属参数的消息。
工作原理：
（jdk里面的观察者模式也挺成熟的）
15在Spring中注册属性编辑器
问题：
属性编辑器是JavaBeans API的一项功能，用于属性值与文本值互相转换。
每个属性编辑器仅用于某一类属性。你可以希望采用属性编辑器来简化Bean配置。
解决方案：
Spring IoC容器支持使用属性编辑器帮助Bean配置。
例如，使用java.net.URL类型的属性编辑器，可以指定用于URL类型属性的URL字符串。
Spring会自动的将这个URL字符串转换为一个URL对象，注入你的属性中。
Spring自带多种用于转换常见类型Bean属性的属性编辑器。
一般来说，你应该在Spring IoC容器中注册属性编辑器，然后才能使用它。
CustomEditorConfigurer是作为Bean工厂后处理器来实现的，用于在任何Bean实例化之前注册你的自定义属性编辑器。
工作原理：
就是先写一个编辑器，然后注册，然后自动使用。
除了CustomDateEditor之外，Spring自带多个转换常见数据类型的属性编辑器，
例如CustomNumberEditor、ClassEditor、FileEditor、LocaleEditor、StringArrayPropertyEditor和URLEditor。
可查看包：org.springframework.beans.propertyeditors
public class User {
private String username;
private Date birthday;
...
<bean id="dateEditor"
class="org.springframework.beans.propertyeditors.CustomDateEditor">
<!-- DateFormat对象作为其第一个构造程序参数 -->
<constructor-arg>
<bean class="java.text.SimpleDateFormat">
<constructor-arg value="yyyy-MM-dd" />
</bean>
</constructor-arg>
<!-- 表示该编辑器是否允许空值 -->
<constructor-arg value="true"/>
</bean>
<!-- 必须进行注册 -->
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
<property name="customEditors">
<map>
<entry key="java.util.Date">
<ref local="dateEditor"/>
</entry>
</map>
</property>
</bean>
<bean id="user" class="com.partner4java.spring.editor.User">
<property name="username" value="gaofumei"/>
<property name="birthday" value="2012-10-10"/>
</bean>
16创建自定义属性编辑器
问题：
除了注册内建的属性编辑器之外，你可能希望编写自定义的属性编辑器，转换你自定义数据类型。
解决方案：
你可以实现java.beans.PropertyEditor实例或者扩展便利的支持类java.beans.PropertyEditorSupport，编写自定义的属性编辑器。
工作原理：
首先实现自己的编辑器，然后注册编辑器
public class UserEditor extends PropertyEditorSupport {
@Override
public String getAsText() {
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
User user = (User) getValue();
return user.getClass().getName() + "," + user.getUsername() + ","
+ dateFormat.format(user.getBirthday());
}
@Override
public void setAsText(String text) throws IllegalArgumentException {
String[] parts = text.split(",");
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
try {
User user = (User)Class.forName(parts[0]).newInstance();
user.setUsername(parts[1]);
user.setBirthday(dateFormat.parse(parts[2]));
setValue(user);
} catch (Exception e) {
e.printStackTrace();
}
}
}
<!-- 必须进行注册 -->
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
<property name="customEditors">
<map>
<entry key="com.partner4java.spring.editor.User">
<bean class="com.partner4java.spring.editor.UserEditor"/>
</entry>
</map>
</property>
</bean>
<bean id="userChild" class="com.partner4java.spring.editor.UserChild">
<property name="user">
<value>com.partner4java.spring.editor.User,gaofumei,2012-01-02</value>
</property>
</bean>
@Test
public void testAware() throws InterruptedException{
System.out.println(applicationContext.getBean("userChild"));
}