spring学习笔记第三章

3.1 Bean基本原理

BeanFactory 负责读取Bean的定义文件：管理对象的加载,生成,维护,与对象之间的依赖关系。提供的功能比较简单。

ApplicationContext 提供一些特色以及高级的容器功能。大概有3个实现类：

l FileSystemXmlApplicationContext

l ClassPathXmlApplicationContext

l XmlWebApplicationContext

当需要多个Bean定义文件，Spring建议使用ApplicationContext的方法读取，好处

Bean定义文件之间嗜独立的。

u 一个替代的方式是使用<import>标签，如：

……

</beans>

u 另外的方法如下：

ApplicationContext context = new ClassPathXmlApplicationContext(

new String[]{“beans-config.xml”, ”beans2-config.xml”});

使用file:/,classpath:甚至http://等url前致，或者classpath*: 表示

classpath前致路径都匹配。

ApplicationContext context =

new ClassPathXmlApplicationContext(“classpath*:beans-config.xml”);

制定*字符,以下的例子可读取ClassPath下所有以”beans”开头的xml配置文件，但耀注意的是此方法只在实际的文件系统中有用，如果是.jar文件，以下的指定无效：

ApplicationContext context = new ClassPathXmlApplicationContext(“beans*.xml”);

XmlWebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(this.getServletConfig().getServletContext());

l Bean的实例化

1) 最简单的最基本的,也就是没有参数的构造方法。

2) 有构造方法的,代码如下：

public class HelloBean {

private String name;

private String helloWorld;

public HelloBean(){}

public HelloBean(String name, String helloWorld) {

this.name = name;

this.helloWorld = helloWorld;

}

public String getName() { return name; }

public void setName(String name) { this.name = name; }

public String getHelloWorld() { return helloWorld; }

public void setHelloWorld(String hel) { this.helloWorld = hel; }

public static void main(String args[]) {

AbstractApplicationContext context =

new ClassPathXmlApplicationContext("beans.xml");

HelloBean hello = (HelloBean)context.getBean("hellBean");

System.out.println(hello.getHelloWorld()+","+hello.getName());

}

<constructor-arg index="0">

</constructor-arg>

<constructor-arg index="1">

<value>Hello</value>

</constructor-arg>

</bean>

3) 通过静态构造方法来取得某个对象，好处是调用静态工厂方法的对象不用了解对象建立的细节，例子如下：

interface IMusicBox {public void play();}

class MusicBoxFactory {

public static IMusicBox createMusicBox() {

return new IMusicBox() {

public void play() {

System.out.println("弹奏吉他的声音...");

}

};

}

public static void main(String args[]) {

AbstractApplicationContext context =

new ClassPathXmlApplicationContext("beans.xml");

IMusicBox box = (IMusicBox)context.getBean("musicbox");

Box.play();

}

<bean id="musicbox" class="com.spring.ch3.MusicBoxFactory"

factory-method="createMusicBox" />

或者

问题

为什么不行

l Bean的scope

Spring中取得的实例默认为Singleton,也就是默认每一个Bean名称只维持一个实例。也就是说getBean(“xxx”)的时候实际上都是同一个对象。使用Singleton模式产生的单一实例，对单线程的程序来说不会有什么问题，单对于多线程的程序，必须注意Thread-safe的问题，防止多个线程同时存取公用资源所引发的问题，通常Singleton的Bean都是无状态的(Stateless)。可以通过设置，每次从BeanFactory或者ApplicationContext中制定别名取得Bean都产生一个新的实例，如:

...

</bean>

在Spring中，”scope”属性预设为”singleton”,通过将其设置为”prototype”,使得每次制定名称来取得Bean时,都会产生一个新的实例; 也可以设置<bean>的”singleton”属性为”true”或”false”,来设置是否Singleton的方式来产生实例，不过这个主要是为了和前面的版本兼容而保留的。在Spring中，”Scope”除了可以设置为”singleton”和”prototype”,

针对Web应用程序,还可以设置”request”,”session”,”GlobalSession”,分别表示请求阶段,会话阶段,和基于Protlet的Web应用程序会话阶段.

l Bean的生命周期

一个Bean从建立到销毁，会经历几个执行阶段，如果使用BeanFactoyr来生成，管理Bean，会尽量支持以下的生命周期。

1) Bean的建立

由BeanFactory读取定义Bean定义文件，并生成各个Bean实例。

2) 属性注入

执行相关的Bean属性依赖注入。

3) BeanNameAware的setBeanName()

如果Bean类有实现BeanNameAware接口，则执行它的setBeanName()。

4) BeanFactoryAware的setBeanFactory()

如果Bean类有实现BeanFactoryAware接口，则执行它的setBeanFactory()。

5) BeanPostProcessors的processBeforeInitialization()。

如果有任何的BeanPostProcessors实例与Bean实例关联，则执行BeanPostProcessors实例的processBeforeInitialization()方法。

6) InitializingBean的afterPropertiesSet()

如果Bean有实现InitializingBean，则执行他的afterPropertiesSet()方法。

7) Bean定义文件中的init-method

可以在Bean定义文件中使用”init-method”属性设置方法名称，如：

...

...

8) BeanPostProcessors的processaAfterInitialization()

如果有任何的BeanPostProcessors实例与Bean实例关联，则执行BeanPostProcessors实例的processaAfterInitialization()方法。

9) DisposableBean的destroy()

在容器关闭的时候，如果Bean类有实现DisposableBean接口，则执行他的destroy()方法。

10) Bean定义文件中定义的destroy-method

在容器关闭时，可以在Bean定义文件使用”destroy-method”属性设置方法名称，如：

...

...

如果有以上的设置，当代码运行到这个阶段的时候，就会执行的destroyBean方法。

定义<bean>的”init-method”属性，其实与实现InitializingBean的afterPropertiesSet()意义是相同的。采用前者，可以定义Bean的初始化方法而不用耦合至Spring的API。定义<bean>的”destroy-method”属性，与实现DisposableBean接口的destroy()方法的意义也是相同的。

11) 另外

可以在<beans>上定义”default-init-method”和”default-destroy-method”属性，Spring会自动执行每个Bean上所定义的init()和destroy()方法，例如：

...

</beans>

如果使用BeanFactory，只用在使用getBean()取得Bean时，才会做实例化的动作。如果使用ApplicationContext,则会预先针对Bean定义文件的内容，将所有的Bean实例化。在<bean>上设置”lazy-int”属性为”true”，ApplicationContext 就不会在启动针对该Bean做实例化动作，例如:

...

</bean>

l Bean的生命周期

如果Bean定义文件的内容不断的增加，而你发现有些Bean的定义其实有所重复。如，有好几个Bean定义都有”name”和”age”等属性，而大部分设置都是相同的值，只有几个Bean会有不同的设置，则可以考虑继承某个Bean定义，这样可以省去许多设置的功夫。

class SomeBean {

private String name;

private int age;

public String getName() { return name; }

public void setName(String name) { this.name = name; }

public int getAge() { return age; }

public void setAge(int age) { this.age = age; }

public static void main(String args[]) {

AbstractApplicationContext context =

new ClassPathXmlApplicationContext("beans.xml");

SomeBean bean = (SomeBean)context.getBean("some");

System.out.println("SomeBean->"+bean.getName());

System.out.println("SomeBean->"+bean.getAge());

}

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

</bean>

</bean>

运行结果为：

SomeBean->测试人员

SomeBean->18

3.2 Bean的依赖设置

当构造方法上的参数个数相同时，Spring会自动解析构造方法上的参数类型及所设置的依赖注入，用来决定要使用哪个构造方法，例如：

public class HelloBean {

private String name;

private Date date;

public HelloBean(Date date) { this.date = date; }

public HelloBean(String name) { this.name = name; }

public HelloBean(String name, Date date) {

this.name = name;

this.date = date;

}

public String getName() { return name; }

public void setName(String name) { this.name = name; }

public Date getDate() { return date; }

public void setDate(Date date) { this.date = date; }

public static void main(String args[]) {

AbstractApplicationContext context =

new ClassPathXmlApplicationContext("beans.xml");

HelloBean bean = (HelloBean)context.getBean("helloBean");

System.out.println("SomeBean->"+bean.getName());

System.out.println("SomeBean->"+bean.getDate().toString());

}

<constructor-arg><ref bean="date"/></constructor-arg>

</bean>

运行结果为：

SomeBean->null

SomeBean->Thu Aug 21 11:33:12 CST 2008

可以设置”type”属性来明确制定要使用哪个类型，如：

<constructor-arg type=”java.util.Date”><ref bean="date"/></constructor-arg>

</bean>

l 依赖的值设置与参考

1) 设置例子1：

<constructor-arg><value>大家好</value></constructor-arg>

</bean>

注意: <property name="date"><value></value></property>是把属性设置为空字符串,而不是设这为null

2) 设置例子2：

<constructor-arg value=”大家好”></constructor-arg>

</bean>

3) 如果Bean定义文件中已经有一个定义的Bean实例，则可以直接让某个属性参考这个实例，例如：

<constructor-arg><ref bean=”date”/></constructor-arg>

</bean>

另一个比较简介的写法，使用”ref”属性来制定，例如：

<constructor-arg ref=”date”/>

</bean>

4) 如果希望使用<ref>参考其他Bean实例时，所定义的Bean必须是同一个设置文件中，且可以指定”local”属性，例如：

</bean>

5) 如果某个Bean实例只被某个属性参考过一次，之后在定义文件中再也不被参考，则可以直接在属性定义的时候使用<Bean>标签，并且需要指定其”class”属性即可，例如：

</bean>

6) 在取得某个Bean之前，如果它依赖于另一个Bean，Spring就会先去实例化被依赖的Bean并进行依赖注入。如果某个Bean在生成之前要求另一个Bean必须先实例化，则可以指定”depends-on”属性来设置，如果有2个以上的Bean要设置在”depends-on”中，则以都好隔开，例如：

l 自动绑定

除了在Bean定义文件中使用<value>指定字符串以及基本类型值，使用<ref>直接指定参考其他Bean的实例，或是使用<bean>标签指定”class”属性，用来指定依赖对象外，Spring也支持隐式的自动绑定。可以通过(byType)或者名称（byName），将某个Bean实例绑定到其他Bean对应的属性上，例如：

public class HelloBean {

private String name;

private Date date;

public HelloBean() {}

public HelloBean(Date date) { this.date = date; }

public HelloBean(String name) { this.name = name; }

public HelloBean(String name, Date date) {

this.name = name;

this.date = date;

}

public String getName() { return name; }

public void setName(String name) { this.name = name; }

public Date getDate() { return date; }

public void setDate(Date date) { this.date = date; }

public static void main(String args[]) {

AbstractApplicationContext context =

new ClassPathXmlApplicationContext("beans.xml");

HelloBean bean = (HelloBean)context.getBean("helloBean");

System.out.println("SomeBean->"+bean.getName());

System.out.println("SomeBean->"+bean.getDate().toString());

}

</bean>

运行结果为：

SomeBean->哈哈呵呵

SomeBean->Thu Aug 21 13:30:15 CST 2008

在定义文件中，并没有指定”helloBean”的”date”属性，而是通过自动绑定，在”autowire”属性上指定了”byType”,所以会根据”helloBean”的setDate()方法所接受的类型来判断在Bean定义文件中是否定义了累世的类型对象，并将之设置给”helloBean”的setDate()。使用自动绑定时，如果”byType”无法完成绑定，则丢出异常。

可以通过指定”byName”来绑定，则Spring会判断Bean定义时的”id”属性上指定的别名与Setter名称是否一致来进行自动绑定。如果使用”byName”无法完成绑定,则对应的Setter仅保持未绑定的状态。

也可以在使用Type3 Dependency Injection时套用自动绑定，也就是在构造方法上也可以尝试自动绑定，实质上是根据byType来绑定，例如：

</bean>

如果还想再偷懒，可以设置未”autodetect”，一切都让spring来判断。当”autowire”被设置未”autodected”来处理依赖关系的时候，Spring会先尝试”construtor”，如果没有能建立依赖关系，则在尝试”byType”的方式来建立依赖关系。

在以上介绍的隐式自动绑定中，由于没有办法从定义文件中清楚看到是否每个属性都完成了设置，为了确定某些依赖关系确实建立，可以建立依赖检查，在<bean>标签使用设置”dependency-check”,可以有4种依赖检查方式：”simple”, “objects”, “all”, “none”。

”simple”只检查简单的属性是否完成依赖关系，像是原生(primitive)数据类型或字符串对象；”objects”则检查对象类型的属性是否完成依赖关系；”all”检查全部的属性是否完成依赖关系；”none”是默认值，表示不检查依赖性。例如：

<!—如果该属性没有设置的话，则会有异常 -->

</bean>

l 集合对象

对于数组,List, Set, Map等集合对象，在注入前必须填充入一些对象到集合中，然后再将集对象注入

所需要的Bean,也可以由Spring的Ioc容器来自动维护或者生成结合对象，并完成依赖注入。

这里直接举个完成的应用程序做示范，例如有个SomeBean类定义，如下所示:

public class SomeBean {

private String[] someStrArr;

private Some[] someObjArr;

private List<Object> someList;

private Set<Object> someSet;

private Map<Object, Object> someMap;

private Properties properties;

public Properties getProperties() { return properties; }

public void setProperties(Properties properties) { this.properties = properties; }

public String[] getSomeStrArr() { return someStrArr; }

public void setSomeStrArr(String[] someStrArr) { this.someStrArr = someStrArr; }

public Some[] getSomeObjArr() { return someObjArr; }

public void setSomeObjArr(Some[] someObjArr) { this.someObjArr = someObjArr; }

public List<Object> getSomeList() { return someList; }

public void setSomeList(List<Object> someList) { this.someList = someList; }

public Map<Object, Object> getSomeMap() { return someMap; }

public void setSomeMap(Map<Object, Object> someMap) { this.someMap = someMap; }

public Set<Object> getSomeSet() { return someSet; }

public void setSomeSet(Set<Object> someSet) { this.someSet = someSet; }

public static void main(String args[]) {

AbstractApplicationContext context =

new ClassPathXmlApplicationContext("beans.xml");

SomeBean bean = (SomeBean)context.getBean("someBean");

System.out.println(bean.getSomeList().getClass());

System.out.println(bean.getSomeObjArr()[0].getName());

System.out.println(bean.getSomeMap().get("some2"));

Iterator<Object> iter = bean.getSomeSet().iterator();

while (iter.hasNext()) {

System.out.println(iter.next());

}

System.out.println(bean.getProperties().get("key1"));

}

</bean>

</bean>

<list>

<value>Hello</value>

<value>Welcome</value>

</list>

</property>

<list>

</list>

</property>

<list>

<value>ListTest</value>

</list>

</property>

<map>

</entry>

<entry>

</entry>

</map>

</property>

<set>

<value>a set element</value>

</set>

</property>

<props>

<prop key="key1">keyValue1</prop>

<prop key="key2">keyValue2</prop>

</props>

</property>

</bean>

如果集合对象不只注入一个对象，则要考虑为集合对象设置”id”名称，例子如下：

Ø 如果是List对象

<list>

<value>[email protected]</value>

</list>

</property>

</bean>

Ø 如果是Map对象

<map>

</map>

</property>

</bean>

Ø 如果是Set对象

<set>

<value>[email protected]</value>

</set>

</property>

</bean>

Ø 如果是Properties对象

<props>

<prop key="a">[email protected]</prop>

<prop key="b">[email protected]</prop>

</props>

</property>

</bean>

Ø 使用"location"属性，指定.properties文件的位置，从中读取Properties资料

</bean>

Ø Spring2.0中，还支持集合对象的合并，和Bean的继承类似

<props>

<prop key="key1">keyValue1</prop>

<prop key="key2">keyValue2</prop>

</props>

</property>

</bean>

<prop key="key3">keyValue3</prop>

<prop key="key4">keyValue4</prop>

</props>

</property>

</bean>

l Spring中的<util>标签

在Spring2.0中如果使用基于XML Schema的XML定义文件进行设置，则可以加入新增的<util>标签扩充。

<util>标签在设置Bean定义时更为方便，对于XML配置文件的简化很有帮助，要使用<util>标签，必须在XML中加入util 名称空间(namespace):

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:util="http://www.springframework.org/schema/util"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/util

http://www.springframework.org/schema/util/spring-util-2.5.xsd "

default-init-method="init" default-destroy-method="destroy">

例如上面的SomeBean的例子可以定义为：

</bean>

</bean>

<util:list id="strArr">

</util:list>

<util:list id="objArr">

</util:list>

<util:list id="list" list-class="java.util.ArrayList">

<value>ListTest</value>

</util:list>

<util:map id="map" map-class="java.util.HashMap">

</util:map>

<util:properties id="property">

<prop key="a">[email protected]</prop>

<prop key="b">[email protected]</prop>

</util:properties>

<util:set id="set" set-class="java.util.HashSet">

</util:set>

</bean>

除了这里介绍的<util>标签之外，还有<util:constant>可用来把Bean的某个成员设置成为其他类的静态变量/常量,而免于设置FieldRetrievingFactoryBean,如(把ERROR_MESSAGE给testStaticSet赋值)：

<util:constant static-field="javax.swing.JOptionPane.ERROR_MESSAGE"/>

</property>

还可以用<util:property-path>标签为某个Bean的属性成员设置”id”名称(也就是说把某个bean的成员拿出来当作单独的bean以供调用),免于设置PropertyPathFactoryBean,例如：

<util:property-path id="testStaticSet" path="someBean2.testStaticSet"/>

调用如下:

System.out.println(">>>"+context.getBean("testStaticSet"));

l Lookup Method Injection

假设现在要设计一个Singleton的MessageManager,当调用display()方法时，会取得一个系统新建立的Message对象并显示，例如:

public abstract class MessageManager {

public void display() {

Message message = createMessage();

System.out.println(message); }

protected abstract Message createMessage();

public static void main(String args[]) {

AbstractApplicationContext context =

new ClassPathXmlApplicationContext("beans.xml");

MessageManager manger = (MessageManager)context.getBean("messageManager");

manger.display(); }

}class Message {

private String sysMessage;

public Message() { sysMessage = "系统信息: " + new Date().toString(); }

public String toString() { return sysMessage; }

}

<lookup-method name="createMessage" bean="sysMessage"/>

</bean>

执行结果：

系统信息: Fri Aug 22 11:38:36 CST 2008

3.3 Bean高级管理

l 非XML定义文件的配置方式(忽略)

l Aware相关接口

Spring中提供一些Aware相关接口，实现这些Aware接口的Bean类在被初始之后，可以取得一些Spring所提供的资源或使用某些功能。如：

Ø org.springframework.beans.factory.BeanNameAware

如果实现了BeanNameAware接口的Bean类，在设置依赖关系之后、初始化方法之前(如InitializingBean的afterPropertiesSet()方法或者自定义的init方法),会将Bean在定义文件中的名称通过setBeanName()方法设置给Bean。

Ø org.springframework.beans.factory.BeanFactoryAware

如果实现了BeanFactoryAware接口的Bean类，在设置依赖关系后、初始化方法之前，Spring容器将会注入BeanFactory的实例。

Ø org.springframework.context.ApplicationContextAware

如果实现了ApplicationContextAware接口的Bean类，在Bean类被初始后，将会被注入ApplicationContext的实例。

Ø org.springframework.context.ResourceLoaderAware

如果实现了该接口，可以让Bean取得ResourceLoader实例，并进一步取得相关的资源文件。

像这样用来取得Spring资源的Bean，设计上应该说是Spring框架的一部分，是应用程序与Spring框架的桥梁。

l BeanPostProcessor

在Bean的依赖关系由Spring容器建立并设置之后，还有机会定义一些Bean的修正动作来修正相关的属性，方法是让Bean类实现org.springframework.beans.factory.config.BeanPostProcessor接口。(注意:该类会对定义文件中所有的Bean都进行该接口中的方法调用,使用时请小心)

该接口定义了如下的2个方法：

Ø postProcessBeforeInitialization()

该方法会在Bean类被初始化之前(如InitializingBean的afterPropertiesSet()方法或者自定义的init方法)被执行。

Ø postProcessAfterInitialization()

该方法会在Bean类被初始化之后被执行。

class BeanPostProcessorHelloBean {

private String helloWord;

public String getHelloWord() { return helloWord; }

public void setHelloWord(String helloWord) { this.helloWord = helloWord; }

}

public class BeanPostProcessorExample implements BeanPostProcessor {

public Object postProcessAfterInitialization(Object bean, String name)

throws BeansException {

Field[] fields = bean.getClass().getDeclaredFields();

for (int i = 0; i < fields.length; i++) {

Field f = fields[i];

if (f.getType().equals(String.class)) {

try {

f.setAccessible(true);

String orginal = (String)f.get(bean);

f.set(bean, "(" + orginal.toUpperCase()+"->AfterInit)");

} catch(Exception e) { System.out.println(e.getMessage()); }

}

return bean;

}

public Object postProcessBeforeInitialization(Object bean, String name)

throws BeansException {

Field[] fields = bean.getClass().getDeclaredFields();

for (Field f : fields) {

if (f.getType().equals(String.class)) {

f.setAccessible(true);

try {

String orginal = (String)f.get(bean);

System.out.println("-->"+orginal);

} catch(Exception e) {}

}

return bean;

}

public static void main(String args[]) {

AbstractApplicationContext context =

new ClassPathXmlApplicationContext("beans.xml");

BeanPostProcessorHelloBean bean = (BeanPostProcessorHelloBean)context.getBean("beanPostProcessorHello");

System.out.println("->"+bean.getHelloWord());

}

</bean>

</bean>

l BeanFactoryPostProcessor

在BeanFactory载入Bean定义文件的所有内容，但还没有正式产生Bean实例前，可以对该BeanFactory进行一些处理，方式是让Bean类实现org.springframework.beans.factory.config.BeanFactoryPostProcessor接口。接口定义的方法如下:

Ø postProcessBeanFactory()

如果有类SomeBean实现了BeanFactoryPostProcessor接口，则可以在Bean定义文件中定义它，在使用ApplicationContext时，ApplicationContext会自动使用这些类的实例。

在Spring中提供有几个BeanFactoryPostProcessor接口的实现类，像

org.springframework.beans.factory.config.PropertyPlaceholderConfigurer

org.springframework.beans.factory.config.PropertyOverrideConfigurer

org.springframework.beans.factory.config.CustomEditorConfigurer

l PropertyPlaceholderConfigurer

通过这个类，可以将一些配置设置信息移出到一个或者多个.property文件中。可以让XML定义文件负责系统的相关设置，而.properties文件可以让客户根据实际应用的需求，自定义一些相关数据(也就是可以在Bean定义文件中直接引用.properties文件中的定义值)。

</bean>

</bean>

如果有多个.properties文件，则可以通过“locations”属性来设置，例如：

<list>

<value>classpath:com/spring/config.properties</value>

</list>

</property>

</bean>

l CustomEditorConfigurer

这个类实现了接口BeanFactoryPostProcessor。这个类可以读取实现java.beans.PropertyEditor接口的类，并按其中的实现，将字符串值转换为指定类型的对象。

举个例子来说，假设现在设计了两个类：User类和HelloBean类。

</bean>

<bean id="configBean"

class="org.springframework.beans.factory.config.CustomEditorConfigurer">

<map>

</entry>

</map>

</property>

</bean>

class User {

private String name;

private int number;

public String getName() { return name; }

public void setName(String name) { this.name = name; }

public int getNumber() { return number; }

public void setNumber(int number) { this.number = number; }

}

class UserHelloBean {

private String helloWord;

private User user;

public String getHelloWord() { return helloWord; }

public void setHelloWord(String helloWord) { this.helloWord = helloWord; }

public User getUser() { return user; }

public void setUser(User user) { this.user = user; }

}

class UserEditor extends PropertyEditorSupport {

public void setAsText(String text) {

String[] strs = text.split(",");

int number = Integer.parseInt(strs[1]);

User user = new User();

user.setName(strs[0]+"@-@");

user.setNumber(number);

setValue(user);

}

public static void main(String args[]) {

AbstractApplicationContext context =

new ClassPathXmlApplicationContext("beans.xml");

UserHelloBean hello = (UserHelloBean)context.getBean("userHelloBean");

System.out.println(hello.getHelloWord());

System.out.println("名字: "+hello.getUser().getName());

System.out.println("数字: "+hello.getUser().getNumber());

}

运行结果：

你好!

名字: 张怡宁@-@

数字: 8888

3.4 资源、消息、事件

l 资源的获得

Spring提供了对资源文件的泛型存取，ApplicationContext继承了org.springframework.core.io.ResourceLoader接口，你可以使用getResource()方法并制定资源文件的URL来取得一个实现Resource接口的实例，例如：

Resource resource = context.getResource(“classpath:admin.properties”);

也可以制定标准的URL,像”file:”或者”http:”,例如：

Context.getResource(“file:/workspace/springtest/conf/admin.properties”);

这会回传一个org.springframework.core.io.FileSystemResource的实例，或者你可以按如下来指定回传一个ServletContextResource：

Context.getResource(“WEB-INF/conf/admin.properties”);

l 解析文字消息

ApplicationContext继承org.springframework.context.MessageSource接口，你可以使用getMessage的方法来取得文件消息的资源文件，从而实现国际化的目的。

Object[] ags = new Object[] {"张怡宁", Calendar.getInstance().getTime()};

System.out.println(context.getMessage("userLogin", ags, Locale.TAIWAN));

System.out.println(context.getMessage("userLogin", ags, Locale.US));

<bean id="messageSource"

class="org.springframework.context.support.ResourceBundleMessageSource">

</bean>

其中：

message_en_US.properties

userLogin =User {0} login at {1}

message_zh_TW.properties

userLogin =\u7528\u6237 {0} \u4E8E {1} \u767B\u 5F 55

运行结果:

用户张怡宁于 2008/8/24 下午 10:56 登录

User 张怡宁 login at 8/24/08 10:56 PM

l 监听事件

在Spring程序执行期间，ApplicationContext本省就会发布一连串的事件，所有发布的事件的抽象类org.springframework.context.ApplicationEvent的子类，例如：

Ø ContextClosedEvent

在ApplicationContext关闭时发布事件。

Ø ContextRefreshedEvent

在ApplicationContext初始或者Refresh时发布事件。

Ø RequestHandledEvent

在Web程序中，当请求被处理时，ApplicationContext会发布此事件。如果你对这些事件有兴趣，则可以实现org.springframework.context.ApplicationContext接口，并在定义文件中定义实现该接口的一个Bean实例：

public interface ApplicationListener extends EventListener {

void onApplicationEvent(ApplicationEvent event);

}

l 事件传播

如果打算发布事件通知ApplicationListener的实例（例如在程序中定义发布事件），可以使用ApplicationContext的publishEvent()方法，如：

class SomeEvent extends ApplicationEvent {

public SomeEvent(Object source) {

super(source);

}

class SomeListener implements ApplicationListener {

public void onApplicationEvent(ApplicationEvent event) {

if (event instanceof SomeEvent) {

System.out.println(event.getClass());

}

</bean>

context.publishEvent(new SomeEvent(context));

运行结果：

class com.spring.ch3.SomeEvent

</script>

spring学习笔记 第三章

你可能感兴趣的:(spring学习笔记 第三章)

spring学习笔记第三章

你可能感兴趣的:(spring学习笔记第三章)