Spring进阶运用

1.配置Bean的属性和依赖关系

组件与组件之间的耦合采用依赖注入管理；但对普通的JavaBean属性值，则直接在代码中设置。

1.1Bean的配置

<beans>
<bean id="唯一标识符" name="别名1,别名2" class="实现类的全限定类名"/>
</beans>

1.2设置普通属性值

<property name=" " value=" "/>

1.3配置合作者Bean

<bean id="u" class=" "/>
<bean id="user" class=" ">
<property name="userDao">
<ref bean="u"/>
</property>
<constructor-arg>
<ref bean="u">
</constructor-arg>
</bean>

!!被注入的类型只需要与注入目标中定义的类型兼容就可。

1.4注入集合值

//Set<String>
<property name="sets">
<set>
<value>1</value>
<value>2</value>
</set>
</property>
//List<String>
<property name="lists">
<list>
<value>1</value>
<value>2</value>
</list>
</property>
//Map<String,String> <entry>中key值只能是String
<property name="maps">
<map>
<entry key="1" value="1"></entry>
<entry key="2" value="2"></entry>
</map>
</property>
<property name="maps">
<map>
<entry>
<key>
<value>1</value>
</key>
<value>1</value>
<key>
<value>2</value>
</key>
<value>2</value>
</entry>
</map>
</property>

2.管理Bean的生命周期



Spring可以管理singleton作用域Bean的生命周期，可以精确的知道该Bean何时被创建，何时初始化完成，何

时被销毁。

Spring仅负责创建prototype作用域的Bean,创建完后完全交给客户端代码管理。

两个重要生命周期时刻：postinitiation（初始化后）和predestruction（销毁前）。

2.1Spring容器中Bean的作用域

Spring3.0中支持的5种作用域：

（1）Singleton:单例模式,在容器中只有一个实例，无论多少Bean引用他，都只有一个对象；

（2）Prototype:原型模式，每次通过容器获取Bean时，都会创建一个新的实例；

（3）Request:针对每次HTTP请求都会产生一个新的Bean,仅在当前HTTP request内有效；

（4）Session:针对每次HTTP请求都会产生一个新的Bean,仅在当前HTTP session内有效；

（5）Global session:类似标准HTTP Session作用域，但仅仅在基于portlet的web应用中有效。

//scope默认为singleton
<bean id=" " class=" " scope="singleton|prototype|request|session|global session"/>

如果Bean使用了有限的资源，如数据库、网络连接等，则多个实例的创建会浪费有限的资源，此时应将Bean设置为
singleton。

2.2Bean的实例化

当一个Bean实例化时，往往需要执行一些初始化工作；不再使用时，需要从容器中删除他。

（1）指定初始化方法

<bean id="bean1" class="com.bean.simpleBean" init-method="init"
<property name="name" value="xiaoming"/>
</bean>

Spring完成依赖注入后，自动调用init()方法。

（2）实现InitializingBean接口（侵入式设计，不推荐使用）

一旦某个Bean实现了InitializingBean接口，那么这个Bean的代码就与Spring耦合到一起了。该接口只定义

了一个afterPropertiesSet方法。

凡是继承了InitializingBean接口的类，初始化Bean时都会执行其afterPropertiesSet方法。

!!可以和指定初始化方法 同时使用，此时先执行afterPropertiesSet（）方法，再执行init-method属性指定

方法。

Spring容器可以自动检测Bean中是否实现了特定生命周期接口，若实现某个生命周期接口，则需执行相应

的生命周期方法。

2.3Bean的销毁

Spring提供了两种方法在Bean实例销毁之前执行指定的动作：使用destroy-method属性和实现

DisposableBean接口。

（1）使用关闭钩子（shutdown hook）

只需要调用在AbstractApplicationContext中提供的registerShutdownHook()方法

public static void main(String[] args){
AbstractApplicationContext ctx = new
ClassPathXmlApplicationContext("beans.xml");
ctx.getBean(" ");
//为Spring容器注册关闭钩子
ctx.registerShutdownHook();
}

程序会在退出JVM之前关闭Spring ApplicationContext容器，并在关闭之前调用singleton作用域中Bean的
析构回调方法。

（2）Bean销毁时执行析构方法

可以在Bean中定义一个普通的析构方法，然后在XML配置文件中通过destroy-method属性指定其方法

名。Spring会在销毁单例前调用此方法执行一些清理和释放工作。

<bean id="bean1" class="com.bean.simpleBean" destroy-method="close"
<property name="name" value="xiaoming"/>
</bean>
//Spring会在销毁bean1实例前自动调用simpleBean类中的close()方法。

（3）实现DisposableBean接口（侵入式设计）

该接口只有一个方法：void destroy() throws Exception，Bean实例被销毁前执行的方法。

2.4使用方法注入

singleton Bean依赖的一直是最开始（初始化时）的Bean实例。

lookup方法注入利用了Spring容器重写Bean中抽象方法或具体方法的能力，从而返回指定名字的Bean实

例，常用来获取一个non-singleton对象。

！！Spring方法注入需要用到CGLIB的动态代理功能，需要将CGLIB库的JAR包导入到项目中。

public abstract MyHelper getMyHelper();
@Override
public MyHelper getHelper(){
return getMyHelper();
}

<bean id="helper" class="com.deciphering.bean.MyHelper" scope="prototype">
</bean>
<bean id="abstractLookupBean" class="com.deciphering.bean.AbstractLookupDemo">
<lookup-method name="getMyHelper" bean="helper"/>
</bean>

3.让Bean可以感知Spring容器

3.1使用BeanNameAware接口

该接口仅有一个方法：setBeanName(String name),name参数为Bean的id.Bean属性设置完后，初始化回调方法之前，setBeanName回调方法会先被调用。

public class SimpleBean implements InitializingBean, BeanNameAware{
private String beanName;
...
@Override
public void setBeanName(String beanName) {
this.beanName = beanName;
System.out.println("回调setBeanName方法获得BeanName "+ beanName);
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println(beanName+"初始化，调用afterPropertiesSet()...");
}
}
//先调用setBeanName(String beanName)，再调用afterPropertiesSet()

3.2使用BeanFactoryAware接口、ApplicationContextAware接口

BeanFactoryAware接口只有一个方法：setBeanFactory(BeanFactory beanFactory);

实现该接口让Bean拥有了直接访问容器的能力，导致代码和Spring接口耦合在一起

public class SimpleBean implements InitializingBean, BeanFactoryAware{
private BeanFactory Factory;
...
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.Factory = beanFactory;
System.out.println("获得容器： "+Factory);
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("初始化完成，调用afterPropertiesSet()...");
}
}
//先调用setBeanFactory(BeanFactory beanFactory)，再调用afterPropertiesSet()

!!Spring容器完成依赖关系注入之后会回调setBeanFactory()方法，此时应用程序可获得创建该Bean的BeanFactory引用，程序可以保存该引用并利用其做一些处理。
另外，类似，还有ApplicationContextAware接口，可获得ApplicationContext容器的引用。

4.Spring国际化支持

getMessage()的重载方法：

getMessage(String,Object[],Locale);

getMessage(String,Object[],String Locale);

getMessage(MessageSourceResolvable,Locale)

public class SimpleBean {
public static void main(String[] args){
//实例化ApplicationContext
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
String [] a = {"读者"};
//使用getMessage方法获得本地化信息。
//返回计算机环境默认的Locale
String hello = ctx.getMessage("hello", a, Locale.getDefault());
Object[] b = { new Date() };
String now = ctx.getMessage("now", b, Locale.getDefault());
//将两条本地化信息打印出来
System.out.println(hello);
System.out.println(now);

//认为设置成英文环境
hello = ctx.getMessage("hello", a, Locale.US);
now = ctx.getMessage("now", b, Locale.US);
//将两条英文信息打印出来
System.out.println(hello);
System.out.println(now);

//认为设置成中文环境
hello = ctx.getMessage("hello", a, Locale.CHINA);
now = ctx.getMessage("now", b, Locale.CHINA);
//将两条中文信息打印出来
System.out.println(hello);
System.out.println(now);
}
}
//即使在英文环境下，“读者”也不能变成英文，因为是写在代码中而不是从资源文件中获取的。

<!-- id="messageSource"不变 -->
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames" >
<list>
<value>message</value>
<!--
如果有多个资源文件，全部列举在此
-->
</list>
</property>
</bean>