Spring课件

spring in action

一、开始 spring 之旅

理解反向控制 (IOC)

依赖注入：比 IOC 更好的名字。获得依赖对象的

方式反转了。

IOC 应用

理解 AOP

二、装配 Bean

2.1 容纳你的 bean

bean 工厂 : 最简单的容器，提供了基础的依赖

注入支持。创建各种类型的 Bean.

应用上下文 : 建立在 bean 工厂基础之上，提供系

统架构服务。

二、装配 Bean

2.1.1 bean 工厂介绍

工厂设计模式，创建分发各种 bean 。配置好它们之

间的写作关系，参与 bean 的生命周期。

BeanFactory factory = new XmlBeanFactory(

new FileInputStream(“beans.xml”));

bean 工厂只把 bean 的定义信息载进来，用到的时候

才实例化。

factory.getBean(“mybean”); 就可得到一个

bean 。

二、装配 Bean

2.1.2 使用应用上下文

ApplicationCotext,spring 更加高级的容器。功能

强大：

1. 提供文本信息解析工具，包括对国际化支持。

2. 提供载入文件资源的通用方法，如图片。

3. 可以向注册为监听器的 bean 发送事件。

在很少的情况下，使用 BeanFactory ，如在移动设

备。

二、装配 Bean

2.1.2 使用应用上下文 ( 续 )

三种经常用到的实现：

1.ClassPathXmlApplicationContext: 从类路径中加载。

2.FileSystemXmlApplicationContext: 从文件系统加载。

3.XmlWebApplicationContext: 从 web 系统中加载。

二、装配 Bean

ApplicationContext context =

new FileSystemXmlApplicationContext(“

c:foo.xml”);

ApplicationContext context =

new ClassPathXmlApplicationContext(“

foo.xml”);

二、装配 Bean

除了应用上下文提供的附加功能外，应用上下文

与 bean 工厂的另一个重要区别是关于单例 bean

如何被加载。

bean 工厂延迟加载所有 bean ，直到 getBean()

方法被调用。

应用上下文会在启动后预载入所有单例 bean. 这样可确

保应用不需要等待他们被创建。

二、装配 Bean

2.1.3 bean 的生命周期

bean 被载入到容器中时，他的生命周期就开始

了。 bean 工厂在一个 bean 可以使用前完成很多

工作：

1. 容器寻找 bean 的定义信息并实例化。

2. 使用依赖注入， spring 按 bean 定义信息配置 bean 的所有属性。

3. 若 bean 实现了 BeanNameAware 接口，工厂调用 Bean 的 setBeanName

（）方法传递 bean 的 ID 。

4. 若 bean 实现了 BeanFactoryAware 接口，工厂调用 setBeanFactory （）

方法传入工厂自身。

5. 若 BeanPostProcessor 和 bean 关联，则它们的

postProcessBeforeInitialization() 方法被调用。

6. 若 bean 指定了 ini-method 方法、，它将被调用。

7. 最后，若有 BeanPostProcessor 和 bean 关联，则它们的

postProcessAfterInitialization() 方法被调用、。

二、装配 Bean

2.1.3 bean 的生命周期 ( 续 )

将 bean 从工厂中删掉有两种方法：

1. 若 bean 实现了 DisposableBean 接口，

distroy() 方法被调用。

2. 如果指定了定制的销毁方法，就调用这个方法。

bean 在应用上下文中的生命周期和在 bean 工厂

的生命周期唯一不同的是：若 bean 实现了

ApplicationContextAware() 接口，

setApplicationContext() 方法会被调用。

二、装配 Bean

实例化设置属性值调用 BeanNameAware 的 setBeanName() 方法调用 BeanFactoryAware 的 setBeanFactory() 方法调用 BeanPostProcessor 的预初始化方法调用 InitializingBean 的 afterPropertiesSet() 方法调用调用定制的初始化方法调用 BeanPostProcessor 的后初始化方法 Bean 可以使用了容器关闭调用 DisposableBean 的 destory() 方法调用定制的销毁方法 Bean 在 Spring Bean 工厂中的生命周期

二、装配 Bean

实例化设置属性值调用 BeanNameAware 的 setBeanName() 方法调用 BeanFactoryAware 的 setBeanFactory() 方法调用 BeanPostProcessor 的预初始化方法调用 InitializingBean 的 afterPropertiesSet() 方法调用调用定制的初始化方法调用 BeanPostProcessor 的后初始化方法 Bean 可以使用了容器关闭调用 DisposableBean 的 destory() 方法调用定制的销毁方法 Bean 在 Spring Bean 应用上下文中的生命周期调用 ApplicationContextAware 方法 setApplicationContext() 方法

二、装配 Bean

2.2 基本装配

在 spring 容器内拼凑 bean 叫做装配。装

配 bean 的时候，需要告诉容器哪些 bean

以及容器如何使用依赖注入将它们配合在

一起。

二、装配 Bean

2.2 基本装配

2.2.1 使用 XML 装配

xml 是最常见的 spring 应用系统配置源。

几种 spring 容器都支持使用 xml 装配 bean ，包括：

1.XmlBeanFactory: 调用 InputStream 载入上下文

定义文件。

2.ClassPathXmlApplicationContext: 从类路径载

入上下文定义文件。

3.XmlWenApplicationContext: 从 web 应用上下文

中载入定义文件。

二、装配 Bean

2.2 基本装配

2.2.1 使用 XML 装配 ( 续 )

上下文定义文件的根元素是 <beans>.<beans> 有多

个 <bean> 子元素。每个 <bean> 元素定义了一个

bean 如何被装配到 spring 容器中。

<beans>

<bean id=“foo” class=“...Foo”/>

<bean id=“bar” class=“...Bar”/>

</beans>

二、装配 Bean

2.2 基本装配

2.2.2 添加一个 bean

对 bean 的最基本的配置包括 bean 的 ID 和他的

全称类名。

<bean id=“foo” class=“...Foo”/>

bean 的 id 是 foo 。

二、装配 Bean

2.2 基本装配

2.2.2 添加一个 bean( 续 )

原型与单实例

spring 中的 bean 缺省情况下是单例模式。始终返

回一个实例。若想返回不同的实例的话需要定义

成原型模式。

bean 的 singleton 属性告诉上下文该 bean 是否为

单例的。缺省为 true 。若为 false 的话，为原型

bean 。

<bean id=“foo” class=“...Foo”

singleton=“false”/>

二、装配 Bean

2.2 基本装配

使用原型 bean 会对性能产生影响，尽量不要把 singleton 设置为 false, 除非有必要。

二、装配 Bean

2.2 基本装配

实例化与销毁

spring 实例化 bean 或销毁 bean 时，有时需要作一些处理工作，因此 spring 可以在创建和拆卸 bean 的时候调用 bean 的两个生命周期方法。

init-method=“setup”

destory-method=“teardown”/>

二、装配 Bean

2.2 基本装配

spring 也提供了两个接口来实现相同的功能：

InitializingBean 和 DisposableBean.

InitializingBean 接口提供了一个 afterPropertiesSet() 方法。

DisposableBean 接口提供了 destroy().

不推荐使用该接口，它将你的 bean 和 springAPI 邦定在一起。

二、装配 Bean

2.2 基本装配

2.2.3 通过 set 方法注入依赖

<bean> 元素的 < property > 子元素指明了使用它们的 set 方法来注入。可以注入任何东西，从基本类型到集合类，甚至是应用系统的 bean 。

二、装配 Bean

2.2 基本装配

2.2.3 通过 set 方法注入依赖 ( 续 )

简单 bean 配置

配置 bean 的简单属性，基本数据类型和 string 。

<bean id=“foo” class=“...Foo”>

<property name=“name”>

<value>tom</value>

</property>

</bean>

二、装配 Bean

2.2 基本装配

引用其它 bean

<property name=“name”>

<ref bean=“bar”>

</property>

</bean>

<bean id=“bar” class=“...Bar”>

</bean>

二、装配 Bean

2.2 基本装配

内部 bean

<property name=“bar”>

<bean class=“...Bar”>

</property>

</bean>

这种方式的缺点是你无法在其它地方重用这个 bar 实

例，原因是它是专门为 foo 而用。

二、装配 Bean

2.2 基本装配

装配集合

若 bean 的属性是集合类型，按如下处理：

装配 List 和数组：

<property name=“barlist”>

<list>

<value>bar1</value>

<ref bean=“bar2”/>

</list>

</property>

二、装配 Bean

2.2 基本装配

装配集合

装配 set ：

<set>

<value>bar1</value>

</set>

</property>

set 使用方法和 list 一样，不同的是对象被装配到 set

中，而 list 是装配到 List 或数组中装配。

二、装配 Bean

2.2 基本装配

装配 map ：

<map>

<entry key=“key1”>

<value>bar1</value>

</entry>

<entry key=“key2”>

<ref bean=“bar2”>

</entry>

</map>

</property>

map 中的 <entry> 的数值和 <list> 以及 <set> 的一样，可以使任何有效

的属性元素，需要注意的是 key 值必须是 string 的。

二、装配 Bean

2.2 基本装配

装配 Properties ：

<props>

<prop key=“key1”>bar1</prop>

<prop key=“key2”>bar2</prop>

</props>

</property>

二、装配 Bean

2.2 基本装配

若 bean 的属性是集合类型，按如下处理：

设置 null ：

<null/>

</property>

二、装配 Bean

2.2 基本装配

Set 注入的替代：

set 注入是一种直接方式，缺点是它假设了所

有的可变属性都可以通过 set 方法访问到。例如有些属性在创建时设置一次，以后不再改变。

替代方式是通过构造函数设置一些属性值。

二、装配 Bean

2.2 基本装配

2.2.4 通过构造函数注入依赖

<constructor-arg>

<value>42</value>

</constructor>

</bean>

<constructor-arg>

<ref bean=“bar”>

</constructor>

</bean>

set 注入的缺点是无法清晰表达哪些属性是必须的，哪些是可选

的，构造注入的优势是通过构造强制依赖关系，不可能实例化不

完全的或无法使用的 bean 。

二、装配 Bean

2.2 基本装配

2.2.4 通过构造函数注入依赖 ( 续 )

解决构造函数参数不确定性

构造函数多或参数类型大都相同该如何处理？

spring 并不是按照参数的顺序来配置参数的。

有两种方法来解决构造参数的不确定性：序号和类型。

<constructor-arg> 有一个可选的 index 属性，可用来指定参数的顺序。

二、装配 Bean

2.2 基本装配

通过参数的顺序：

<constructor-arg index=0>

<value>http://www.tom.com</value>

</construcotr-arg>

<value>bar1</value>

</construcotr-arg>

二、装配 Bean

2.2 基本装配

通过参数的类型：

<constructor-arg type=“java.lang.String”>

<value>http://www.tom.com</value>

</construcotr-arg>

<constructor-arg java.lang.URL>

<value>bar1</value>

</construcotr-arg>

二、装配 Bean

2.3 自动装配

autowire=“autowire type”>

有四种自动装配类型：

1.byName: 寻找和属性名相同的 bean ，若找

不到，则装不上。

2.byType: 寻找和属性类型相同的 bean ，若找

不到，则装不上，找到多个，抛异常。

3.constructor: 查找和 bean 的构造参数一致的一个或

多个 bean ，若找不到或找到多个，抛异常。按照参数的类型装配，与 (2)

相似 .

4.autodetect: 首先尝试用 (3) 来装配，然后使用 (2) 方式。不确定

性的处理与 (3) 和 (2) 一致。

<bean id=“bar” class=“...Bar” autowire=“byName”/>

二、装配 Bean

2.3 自动装配

2.3.1 处理自动装配的不确定性

使用 byType 和 constructor 自动装配时，若找到多个符合条件的 bean ，会报异常，因此最好的方式是不用自动组装。

二、装配 Bean

2.3 自动装配

2.3.2 混合使用手动和自动组装

<bean id=“bar” class=“...Bar”

autowire=“byName”>

<property name=“cousedao”>

<ref bean=“somebean” />

</property>

</bean>

二、装配 Bean

2.3 自动装配

2.3.3 缺省自动组装

默认不是自动组装。

通过 < beans default-

autowire=“byName”>

可将 bean 设置为自动组装。

二、装配 Bean

2.4 使用 spring 的特殊 bean

让 spring 特殊对待这些 bean 。使它们可以：

1. 通过配置后加工 bean ，涉及到 Bean 和 Bean 工厂生命

周期。

2. 改变依赖注入，将字符串转换成其它类型。

3. 从属性文本装载信息，包括信息国际化。

4. 监听并处理其它 bean 及 spring 发布的系统消息。

5. 知道自己在 spring 中的唯一表识。

二、装配 Bean

2.4.1 对 bean 进行后处理

BeanPostProcessor 接口提供机会来修改 bean 。

public interface BeanPostProcessor{

//Bean 初始化 ( 调用 afterPropertiesSet() 以及 Bean 的指

// 定 initmethod 方法 ) 之前被调用。

Object postProcessorBeforeInitialation(…);

// 在初始化之后马上调用

Object postProcessorAfterInitialization(…);

}

二、装配 Bean

2.4.1 对 bean 进行后处理 ( 续 )

注册后处理 Bean

如果使用的是 Bean 工厂 , 需要调用工厂的 addBeanPostProcessor() 来注册 .

factory.addBeanPostProcessor(…);

如果使用的是上下文同其他 Bean 一样 :

<bean id=“” class=“……” />

二、装配 Bean

2.4.2 对 bean 工厂进行后处理

　 BeanPostProcessor 在 bean 载入后，对 bean 进行一些后处理工作。而 BeanFactoryPostProcessor 在 bean 工厂载入所有 bean 的定义后，实例化 bean 之前，对 Bean 工厂做一些后处理工作。

　 public interface BeanFactoryPostProcessor{

public void postProcessorBeanFactory(…);

}

如果使用的是应用上下文不需要将他注册为 Bean 工厂后处理器。上下文会自动注册它。按照正常的 Bean 声明即可。

二、装配 Bean

2.4.3 分散配置

将配置文件分成几个分散的配置文件是很有益的。如数据源。

<bean id=“propertyConfigurer”

class=“...PropertyPlaceholderConfigurer”>

<property name=“locations”>

<list>

<value>jdbc.properties</value>

<value>securtiy.properties</value>

<value>application.properties</value>

</list>

</property>

</bean>

二、装配 Bean

2.4.3 分散配置 ( 续 )

jdbc.properties

database.url=

database.driver=

datebase.username=

datebase.password=

二、装配 Bean

2.4.3 分散配置 ( 续 )

使用占位符变量代替 bean 装配文件中的硬编码配置。占位符采

${variable} 形式。

<bean id=“datasource”

　　　 class=“org.springframework.jdbc.datasource

　　　　　　　　　　 .DriverManagerDataSource”>

<property name=“url”>

<value>${database.url}</value>

</property>

......

</bean>

二、装配 Bean

2.4.4 定制属性编辑器

public contact{

private PhoneNumber phone;

void setPhoneNumber(){

}

......

}

二、装配 Bean

2.4.4 定制属性编辑器 ( 续 )

public PhoneNumber{

private String areacode ;

private String prefix ;

private String number ;

......

public PhoneNumber(arg0,arg1,arg2){

......

}

}

二、装配 Bean

<bean id=“infoPhone”

class=“PhoneNumber”>

<value>888</value>

</constructor-arg>

<value>555</value>

</constructor-arg>

<value>1212</value>

</constructor-arg>

</bean>

<bean id=“contact” class=“Contact”>

<property name=“phoneNumber”>

<ref bean=“infoPhone”/>

</property>

</bean>

二、装配 Bean

编写一个自定义的 PhoneEditor

class PhoneEditor extends

java.beans.PropertyEditorSupport {

void setAsText(String textvalue){

......

p=new PhoneNumber(......);

setValue(p);

}

}

二、装配 Bean

<bean id=“customerEditorConfigurer”

class=“...config.CustomEditorConfigurer”>

<property name=“customEditors”>

<map>

<entry key=“Phone”>

<bean id=“phoneEditor”

class=“PhoneEditor”>

</bean>

</entry>

</map>

</property>

</bean>

<bean id=“contact” class=“Contact”>

<property name=phoneNumber>

<value>888-555-1212</value>

</property>

</bean>

二、装配 Bean

2.4.5 解析文本信息

有些信息经常发生改变或提供国际化功能。用本地语言显示文本。

trainingtext.properties

trainingtext_en_US.properties

trainingtext_es_MX.properties

trainingtext_de_DE.properties

spring 提供了一个现成的 messageSource 接口的实现类。 ResourceBundleMessageSource.

Bean 的名字必须是 messageSource,

context.getMessage(……);

二、装配 Bean

2.4.5 解析文本信息 ( 续 )

<bean id=“messageSource”

class=“org.springframework.

context.support.

ResouceBundleMessageSource”>

<property name=“basename”>

<value>trainingtext</value>

</property>

</bean>

context.getMessage(...);

<spring:message ...>

二、装配 Bean

2.4.6 监听事件

应用上下文会发布很多事件，告诉感兴趣的监听器都

发生了什么事件，这些事件都是抽象类

org.sf.contxt.ApplicationEvent 的子类。

系统事件有：

1.ContextCloseEvent 上下文关闭时发布

2.ContextRefreshedEvent 上下文初始化或刷新

3.RequestHandledEvent web 上下文中请求被处理

后发布。

二、装配 Bean

2.4.6 监听事件 ( 续 )

若需要 bean 对系统事件进行响应需要实现接口 org.sf.ctxt.ApplicationListener. 该接口需要实现 onApplicationEvent(...) 方法。

注册监听器：

<bean id=“refreshListener”

class=“foo.RefreshListener”/>

二、装配 Bean

2.4.7 发布事件

Bean 可以很容易的处理容器发布的事件 , 同时

也可以发布自己的事件 .

首先要定义自己的事件 :

pubic class MyEvent extends ApplicationEvent{

......

}

// 发布事件

context.publish(new MyEvent());

二、装配 Bean

2.4.8 感知其他 bean

运行在 spring 容器中的 bean 不知道自己的注册名，运行在哪里。实现以下三个接口：

BeanNameAware: 知道自己的名字。

BeanFactoryAware ：所处的 bean 工厂。

ApplicationContextAware ：所在上下文

二、装配 Bean

2.4.8 感知其他 bean( 续 )

知道你是谁

实现 BeanNameAware 接口。无需为该接口的 setBeanName() 方法作任何处理， bean 被载入时，容器会自动调用该方法，为其设置 id 或 name 的值。

二、装配 Bean

2.4.8 感知其他 bean( 续 )

知道你在哪里

实现 BeanFactoryAware( 感知 ) 或 ApplicationContextAware 接口。分别定义了 setBeanFactory() 和 setApplicationContext() 方法。

三、创建切面

3.1 AOP 介绍

CourseService CourseService CourseService 安全事务其他

三、创建切面

3.1 AOP 介绍

3.1.1 定义 AOP 术语

1. 切面 (aspect): 要实现的交叉功能，是系统模块化的一个切面或领域。如日志记录。

2. 连接点 : 应用程序执行过程中插入切面的地点，可以是方法调用，异常抛出，或者要修改的

字段。

3. 通知 : 切面的实际实现，他通知系统新的行为。如在日志通知包含了实

现日志功能的代码，如向日志文件写日志。通知在连接点插入到应用系统中。

4. 切入点 : 定义了通知应该应用在哪些连接点，通知可以应用到 AOP 框架支持的任何连接点。

5. 引入 : 为类添加新方法和属性。

6. 目标对象 : 被通知的对象。既可以是你编写的类也可以是第三方类。

7. 代理 : 将通知应用到目标对象后创建的对象，应用系统的其他部分不用为了支持代理对象而

改变。

8. 织入 : 将切面应用到目标对象从而创建一个新代理对象的过程。织入发生在目标

对象生命周期的多个点上：

编译期：切面在目标对象编译时织入 . 这需要一个特殊的编译器 .

类装载期：切面在目标对象被载入 JVM 时织入 . 这需要一个特殊的类载入器 .

运行期：切面在应用系统运行时织入 .

通知程序执行切入连接点

三、创建切面

3.1 AOP 介绍

3.1.2 SpringAOP 实现

用 java 编写 spring 通知

在 spring 中所有的通知都是以 java 类的形式编写的。切入点定义在配置文件中编写，所以切面代码和配置文件对我们来说都很熟悉。

对于其他框架 (Aspectj) ，需要特定的语法编写，如果使用的话，还需学习新的语言。

三、创建切面

3.1 AOP 介绍

3.1.2 SpringAOP 实现 ( 续 )

spring 的运行时通知对象

spring 在运行期创建代理 , 不需要特殊的编译器 .

spring 有两种代理方式：

1. 若目标对象实现了若干接口， spring 使用 JDK 的

java.lang.reflect.Proxy 类代理。该类让 spring 动态产生

一个新类，它实现了所需的接口，织入了通知，并且代理对

目标对象的所有请求。

2. 若目标对象没有实现任何接口， spring 使用

CGLIB 库生成目标对象的子类。使用该方式时需要注意 :

1. 对接口创建代理优于对类创建代理，因为会产生更加松耦合的系统。

对类代理是让遗留系统或无法实现接口的第三方类库同样可以得到通知，

这种方式应该是备用方案。

2. 标记为 final 的方法不能够被通知。 spring 是为目标类产生子类。任何需要

被通知的方法都被复写，将通知织入。 final 方法是不允许重写的。

spring 实现了 aop 联盟接口。

spring 只支持方法连接点：不提供属性接入点， spring 的观点是属性拦截破坏了

封装。面向对象的概念是对象自己处理工作，其他对象只能通过方法调用的得到的

结果。

三、创建切面

3.2 创建通知

当目标方法抛出异常时调用在目标方法调用后调用在目标方法调用前调用拦截对目标方法调用描述 Org.springframework.aop. ThrowsAdvice Org.springframework.aop. AfterReturningAdvice Org.springframework.aop. BeforeAdvice Org.springframework.aop. MethodInterceptor 接口 Around Before After Throws 通知类型

三、创建切面

3.2 创建通知

3.2.1 前置通知

public interface MethodBeforeAdvice{

void before(Method m,Object[]

os ,Object target){

}

}

该接口提供了获得目标方法、参数和目标对象的机会。不能够改变运行时参数，即不能替换参数对象和目标对象。

注意在方法结束后不返回任何值东西。原因是该接口返回后，目标方法将会被调用，应该返回目标对象的返回值。该接口唯一能

阻止目标方法被调用的途径是抛出异常或 (System.exit()) 。

三、创建切面

3.2 创建通知

3.2.1 前置通知 ( 续 )

public class WelcomeAdvice implements MethodBeforeAdvice{ public void before(Method m,Object[] os,Object target){ Customer c = (Customer)arg[0]; System.out.println(c.getName()); } } --------------------------------------------- // 创建目标代理对象 <bean id=“kwikEMartTarget” class=“…ApuKwikEMart” /> <bean id=“welcomeAdvice” class=“…WelcomeAdvice” /> <bean id=“kwikEMart” class=“……ProxyFactoryBean”> <property name=“proxyInterfaces”><value>……KwikEMart</value></property> <property name=“interceptorNames”> <list><value>welcomeAdvice</value></list> </property> <property name=“target”><ref bean=“kwikEMartTarget” /></property> </bean>

三、创建切面

3.2 创建通知

3.2.1 前置通知 ( 续 )

ProxyFactoryBean 是一个在 BeanFactory 中显式创建代理对象的中心类，可以给它一个

要实现的接口、一个要代理的目标对象、一个

要织入的通知，并且他将创建一个崭新的代理

对象。

三、创建切面

3.2 创建通知

3.2.2 后置通知

同前置通知类似。

public interface AfterReturningAdvice{

public void afterReturning(Object returnValue,Method

m,Object[] os,Object target);

}

三、创建切面

3.2 创建通知

3.2.3 环绕通知

public interface MethodInterceptor extends Interceptor{

Object invoke(MethodInvocation invocation);

}

该接口同前两种通知有两个重要区别 :1. 该通知能够控制目标方法

是否真的被调用。通过 invocation.proceed() 方法来调用。

2. 该通知可以控制返回的对象。可以返回一个与 proceed() 方法返回对象完全不同的对象。但要谨慎使用。

三、创建切面

3.2 创建通知

3.2.4 异常通知

public interface ThrowsAdvice{

}

该接口为标识性接口，没有任何方法，但实现该接口的类必须要有如下形

式的方法：

void afterThrowing(Throwable throwable);

void afterThrowing(Method m,Object[] os,Object

target,Throwable throwable);

第一个方法只接受一个参数：需要抛出的异常。

第二个方法接受异常、被调用的方法、参数以及目标对象。

三、创建切面

3.2 创建通知

3.2.5 引入通知

以前定义的通知类型是在目标对象的方法被调用

的周围织入。引入通知给目标对象添加新的方法

和属性。

三、创建切面

3.3 定义切入点

如果不能表达在应用系统的什么地方应用

通知的话，通知将毫无用处，这就是切入点的用处。切入点决定了一个特定的类的特定方法是否满足一定的规则。若符合，通知就应用到该方法上。

三、创建切面

3.3 定义切入点

3.3.1 在 spring 中定义切入点

public interface Pointcut{

ClassFilter getClassFilter();

MethodMatcher getMethodMatcher();

}

切入点根据方法和类决定何处织入通知。 ClassFilter 接口决定了一个类

是否符合通知的要求：

public interface ClassFilter{

boolean matches(Class clazz);

}

实现该接口的类决定了以参数传递进来的类是否应该被通知。实现该接

口的类一般根据类名决定，但不一定必须如此。该接口总是包含了一个

三、创建切面

3.3 定义切入点

3.3.1 在 spring 中定义切入点 ( 续 )

简单的 ClassFilter 接口实现 -ClassFilter.TRUTE 。它是规范的适合任何

类的 ClassFilter 实例，适合用于只根据方法决定时候符合要求的切入。

ClassFilter 通过类过滤切面， MethodMatcher 通过方法过滤切面。

public interface MethodMatcher{

boolean matches(Method m,Class targetClass); 1.

boolean isRuntime(); 2.

boolean matchers(Method m,Class target,Object[] args); 3.

}

1. 根据目标类和方法决定方法是否被通知。因为可以静态的判断，所以

可以在 AOP 代理被创建时候调用一次这个方法。该方法的结果最终决

定了通知是否被织入。

三、创建切面

3.3 定义切入点

如果 1. 返回 true, 2. 被调用来决定 MethodMatcher 的类型。有两种类型：静态和动态。静态切入点的意思是通知总是被执行。如果一个切入点是静态的，该方法返回 false. 动态切入点根据运行时方法的参数值决定通知是否需要执行。如果切入点是动态的，该方法返回 true 。和 1. 方法类似，该方法也是在代理创建时运行一次。

三、创建切面

3.3 定义切入点

如果切入点是静态的， 3. 永远不会执行，对于动态切入点，需要根据运行时的参数决定方法是否被通知，所以会增加系统的负担，尽量使用静态切入点。

三、创建切面

3.3 定义切入点

3.3.2 理解 Advisor

大多数切面是由定义切面行为的通知和定义切面在什么地方执行的切入点组合而成的。 spring 认识到了这一点，提供了 Advisor 类。他把通知和切入点组合到一个对象中。更确切地说 PointcutAdvisor 提供了这些功能。

public interface PointcutAdvisor{

Pointcut getPointcut();

Advice getAdvice();

}

这样方便在一个地方定义切入点和通知。

三、创建切面

3.3 定义切入点

3.3.3 使用 spring 的静态切入点

静态切入点只在代理创建的时候执行一次而不

是在运行期间每次方法调用都执行，所以性能

比动态切入点好，是首选的切入点方式。 spring 为创建静态切入点提供了方便的父类。

staticMethodMatherPointcut.

三、创建切面

3.3 定义切入点

3.3.3 使用 spring 的静态切入点

NameMatchMethodPointcut:

public void setMappedName(String);

public void setMappedNames(String);

当调用的方法名字与给出的映射名字匹配时，

切点才匹配。也可在名字的开始和结束使用通配符。

三、创建切面

3.3 定义切入点

3.3.3 使用 spring 的静态切入点 ( 续 )

<bean id=“xxxTarget” class=“xxxServiceImpl”/> <bean id=“xxxAdvice” class=“”/> <bean id=“xxxAdvisor” class=“…NameMatchMethodPointcutAdvisor”> <property name=“mappedName”> <value>order*<value> </property> <property name=“advice”> <ref bean=“xxxAdvice” /> </property> </bean> <bean id=“xxxService” class=“…ProxyFactoryBean”> <property name=“proxyInterfaces”> <value>……xxxService</value> </property> <property name=“interceptorNames”> <list><value>xxxAdvisor</value></list> </property> <property name=“target”><ref bean=“xxxTarget” /></property> </bean>

三、创建切面

3.3 定义切入点

正则表达式切入点

RegexpMethodPointcut

setFoo setFoo setFoo setFooBar 不匹配 bar.setFoo setFoo setFooB, setFooBar setFooBar setFooB setFooB 匹配 .setFoo. setFoo.* setFoo.+ setFoo. 示例匹配任何正则表达式符号匹配前一个字符 0 次或多次匹配前一个字符一次或多次匹配任何单个字符描述 . + * 符号

三、创建切面

3.3 定义切入点

<bean id=“xxxTarget” class=“xxxServiceImpl”/> <bean id=“xxxAdvice” class=“”/> <bean id=“xxxAdvisor” class=“…RegExpPointcutAdvisor”> <property name=“pattern”> <value>.*get.+bar.+<value> </property> <property name=“advice”> <ref bean=“xxxAdvice” /> </property> </bean> <bean id=“xxxService” class=“…ProxyFactoryBean”> <property name=“proxyInterfaces”> <value>……xxxService</value> </property> <property name=“interceptorNames”> <list><value>xxxAdvisor</value></list> </property> <property name=“target”><ref bean=“xxxTarget” /></property> </bean> 该规则表示任何类的以 get 开头，后面至少有一个字符，然后跟着 by, 后面至少有一个字符的方法

三、创建切面

3.3 定义切入点

3.3.4 使用动态切入点

动态切入点需要判断运行时属性的值。 spring

提供了一种内置的动态切入点 :ControlFlowPointcut. 该切入点根据线程

调用堆栈的信息来匹配方法。也就是说只有当

指定的方法或类能在当前线程执行堆栈中找到时，返回 true.

三、创建切面

3.3 定义切入点

3.3.4 使用动态切入点 ( 续 )

<bean id=“xxxTarget” class=“xxxServiceImpl”/> <bean id=“xxxAdvice” class=“”/> <bean id=“xxxPointcut” class=“…ControlFlowPointcut”> <contructor-arg”> <value>javax.servlet.http.HttpServlet</value> </contructor-arg> </bean> <bean id=“xxxAdvisor” class=“…DefaultPointcutAdvisor”> <property name=“advice”> <ref bean=“xxxAdvice” /> </property> <property name=“pointcut”> <ref bean=“xxxPointcut”> </property> </bean> <bean id=“xxxService” class=“……ProxyFactoryBean”> …… </bean>

三、创建切面

3.4 创建引入

引入是为需要方法的类添加属性和方法。可以用一个已存在的类让他实现另外的接口，维持另外的状态 ( 这也叫混合 ) 。引入

能够动态的建立复合对象，提供了多态继承的好处。

三、创建切面

3.4 创建引入

class AuditableIntroductionInterceptor extends DelegatingIntroductionInceptor{ private Date lastModifiedDate ; public Date getLastModifiedDate(){} public void setLastModifiedDate(Date date){} } 如果你的混合体要改变任何目标对象方法的行为的话，你就需要实现 invoke() 方法。 public Object invoke(MethodInvcation mi) throws Throwable{ String name = mi.getMethod().getName(); if(name.indexof(“set”) == 0){ throw new IllegalModificationException(); } return super.invoke(mi); } 我们复写了 invoke 方法，所以他拦截所有的方法的调用。注意我们调用的 super.invoke() 而不是 mi.proceed(). 这样做是因为父类 DelegatingIntroductionInterceptorkeyijiang 可以决定哪个类负责处理这个方法调用。这一点需要注意，当需要复写 invoke 方法时，你需要调用 super.invoke 方法来确保调用正确的方法。

三、创建切面 <bean id=“xxxTarget” class=“xxxServiceImpl” /> <bean id=“myDelegatingIntroductionInterceptor” class=“xxxMyDelegatingIntr..” /> <bean id=“xxxAdvisor” class=“DefaultIntroductionAdvisor” singleton=“false”> <constructor-arg> <ref bean=“myDelegatingIntroductionInterceptro” /> </constructor-arg> </bean> <bean id=“xxx” class=“…ProxyFatoryBean”> <property name=“proxyTargetClass”> <value>true</value> </property> <property name=“singleton”> <value>false</value> </property> <property name=“proxyInterfaces”> <value>xxxService</value> </property> <property name=“interceptorNames”> <list> <value>xxxAdvisor</value> </list> </property> <property name=“target”><ref bean=“xxxTarget”/></property> </bean>

三、创建切面

3.4 创建引入

谨慎使用引入通知

spring 通知是在运行时织入，而不象其他的 AOP 框架将通知织入到类的字节码当中。这意味着，从其他方法创建或得道的对象不会被引入通知。例如直接实例化或返序列化的对象。

三、创建切面

3.5 使用 proxyFactoryBean

目标对象是否需要得到当前代理。是用的 ProxyFactoryBean 实现。 spring 有两种实现： jdk 动态代理和 CGLIB 。通常不需要使用该属性。是否返回同一个实例。需要应用到目标对象上的通知的名字。可以是拦截器、 Advisor 或其他通知类型的名字。这个属性必须按照 beanFactory 中的使用顺序设置。代理应该实现的接口列表代理的目标对象使用 target proxyInterfaces interceptorNames singleton exposeProxy aopProxyFactory 属性

三、创建切面

3.5 使用 proxyFactoryBean( 续 )

是否对创建的代理进行优化 ( 只适用于 CGLIB) 。这会带来性能的提升，不过要慎用。 optimize 是否代理目标对象，而不是接口。只能在使用 CGLIB ( 即部署了 cglib 包 ) 时使用。 ProxyTargetClass 一旦工厂被创建，是否可以修改代理的通知。当为 true 时，运行时就不能修改 ProxyFactoryBean 了。通常不需要使用这个属性。 frozen 使用属性

三、创建切面

3.6 自动代理

有许多类需要通知时，显式的创建每个代理就会

显得很笨拙。 spring 有一个自动代理机制，它

可以让容器为我们产生代理。

BeanNameAutoProxyCreator

DefaultAdvisorAutoProxyCreator

三、创建切面

3.6 自动代理

3.6.1 BeanNameAutoProxyCreator

该类为匹配一系列名字的 Bean 自动创建代理。这种名字匹配和前面讲到的 NameMethodMatherPointcut 类似，他也允许在名字的两端进行通配符。通常为符合相同命名规则的 bean 应用一个或一组切面。

三、创建切面

3.6 自动代理

3.6.1 BeanNameAutoProxyCreator( 续 )

public class PerformancethreshodInterceptor implements MethodInterceptor{ private final long thresholdInMillis ; … public Object invoke(MehtodInvocation mi){ long t = System.currentTimeMillis(); Object o = mi.proceed(); t = System.currenttimeMillis – t ; if(t > thresholdInMillis ){ …… . } return o ; } }

三、创建切面

3.6 自动代理

3.6.1 BeanNameAutoProxyCreator( 续 )

<bean id=“performanceThresholdInterceptor” class=“…” > <constructor-arg> <value>5000</value> </constructor-arg> </bean> <bean id=“performanceThresholdProxyCreator” class=“…BeanNmaeAutoProxyCreator”> <property name=“beanNames”> <list> <values>*Service</values> </list> </property> <property name=“interceptorNames”> <value>performanceThresholdInterceptor<value> </property> </bean>

三、创建切面

3.6 自动代理

3.6.2 DefaultAdvisorAutoProxyCreator( 续 )

该类实现了 BeanPostProcessor 接口。当应用上下文

读入所有的 Bean 的配置信息后，该类将扫描上下文，

寻找所有的 Advisor 。他将这些 Advisor 应用到所有符

合切入点的 Bean 中。很重要的一点是这个代理创建器

只能与 Advisor 配合使用。该类需要 Advisor 来知道哪些 Bean 需要通知。

三、创建切面

3.6 自动代理

3.6.2 DefaultAdvisorAutoProxyCreator( 续 )

<bean id=“xxxInterceptor” class=“” /> <bean id=“advisor” class=“…RegexpMethodPointcutAdvisor”> <property name=“advice”> <ref beam=“xxxInterceptor” /> <property> <property name=“pattern”> <value>.+Service..+</value> </property> </bean> <bean id=“autoProxyCreator” class=“…DefaultAdvisorAutoProxyCreatro” />

四、征服数据库

4.1 学习 dao 的理念

DAO: 数据访问对象 (data access object)

服务对象数据访问接口数据访问实现

4.1 学习 dao 的理念

从 jdni 的数据源

<bean id=“dataSource”

class=“org…JndiObjectFactoryBean”>

<property name=“jndiName”>

<value>java:comp/env/jdbc/myDatasource</value>

<property>

</bean>

创建一个 DataSource 连接池

<bean id=“dataSource”

class=“org.apache.commons.dbcp.BasicDataSource”>

<property name=“driver”>

<value>${database.driver}</value>

</property>

<property name=“url”>

……

</bean>

4.2 在 Spring 中使用 JDBC

4.2.2 使用 Jdbc Template(JdbcTemplate 模板类 )

JdbcTemplate t = new JdbcTemplate(datasource);

class StudentDao implements StudentDao{

JdbcTemplate jdbcTemplate;

……

}

4.2 在 Spring 中使用 JDBC

将 jdbc template 连接到 daobean 中

<bean id=“jdbcTemplate”

class=“org……JdbcTemplate”/>

<property name=“datasource”>

<ref bean=“datasource”>

</property>

<bean id=“studentdao”

class=“StudentDao”>

<property name=“jdbctemplate”>

<ref bean=“jdbctemplate”>

</property>

</bean>

……

在 Spring 中使用 JDBC

将 jdbc template 连接到 daobean 中

ProparedStatmentCreator

template.update(sql,params,types);

使用 BatchPreparedStatmentCreator 插入多个对象

template.batchUpdate(sql,setter);

读数据 :

使用 RowCallBackHandler 执行查询

Temp.query(sql,params,new RowCallBackHandler());

使用 RowMapper 查询

Template.query(sql,params,new RowMapperResultReader(new PersonRowMapper()));

调用存储过程

CallableStatmentCallback cb=new

CallableStatementCallback(){

public Object doInCallableStatement(CallableStatement cs){

cs.execute();

return null;

}

};

jdbctemplate.execute(“{ARCHIVE_STUDENTS}”,cb);

4.4 介绍 orm 框架支持

4.4.2 管理 hibernate 资源

<bean id=“dataSource” class=“org.springframework.jndi.JndiObjectFactoryBean”> <property name=“jndiName”> <value>java:comp/env/jdbc/trainingDatasource</value> </property> </bean> <bean id=“sessionFactory” class=“org.springframework.orm.hibernate .LocalSessionFactoryBean”/> <property name=“dataSource”> <ref bean=“dataSoure”/> </property> </bean>

4.4.2 管理 hibernate 资源 ( 续 )

将 hibernate.properties 里的信息设定在 LocalSessionFactoryBean 中

<bean id=“sessioinFactory”

class=“ort.springframework.orm.hibernate.LocalsessionFactoryBean”>

<property name=“hibernateProperties”>

<props>

<prop key=“hibernate.dialect”>net.sf.hibernate.dialect.MySQLDialect<prop>

……

</props>

</property>

<property name=“mappingResources”>

<list>

<value>student.hbm.xml</value>

<value>Course.hbm.xml</value>

</list>

</property>

</bean>

将 hibernate.properties 里的信息设定在 LocalSessionFactoryBean 中

<bean id=“sessioinFactory”

class=“ort.springframework.orm.hibernate.LocalsessionFactoryBean”>

<property name=“hibernateProperties”>

<props>

<prop key=“hibernate.dialect”>net.sf.hibernate.dialect.MySQLDialect<prop>

……

</props>

</property>

<property name=“ mappingDirectoryLocations ”>

<list>

<value>classpath:/com/spring/persistence</value>

……

<value>Course.hbm.xml</value>

</list>

</property>

<bean id=“hibernateTemplate”

class=“org.springframework.orm.hibernate.HIbernateTemplate”>

<property name=“sessionFactory”>

<ref bean=“sessionFactory” />

</property>

</bean>

4.4 介绍 orm 框架支持 ( 续 )

<bean id=“studentdao” class=“StudentDaoImpl”>

<property name=“hibernateTemplate”>

<ref bean=“hibernateTemplate”/>

</property>

</bean>

<bean id=“coursedao” class=“CourseDaoImpl”>

<property name=“hibernateTemplate”>

<ref bean=“hibernateTemplate”/>

</property>

</bean>

用 hibernate 模板访问 hibernate

public Student getStudent(final Integer id){

return (Student)hibernateTemplate.execute(

new HibernateCallback(){

public Object doInHibernate(Session session) throws

HibernateException{

return session.load(Student.class,id);

}

} );

}

hibernateTemplate 可以隐含创建 hibernateCallback 类。

public Student getStudent(Integer id){

return (Student)hibernateTemplate.load(Student.class,id);

}

public void updateStudent(Student s){

hibernateTemplate.update(s);

}

HibernateDaoSupport 子类

class StudentDaoHibernate extends HibernateDaoSupport{

void updateStudent(Student s){

getHibernateTemplate().update(s);

}

……

}

spring 和 JDO( 略 )

配置 JDO

用 JdoTemplate 访问数据库

征服数据库

spring 和 iBatis( 略 )

五、事务管理

5.1 理解事务

5.1.1 仅用四个词解释事务

atomic: 要么都发生，要么都不发生。

consistent: 数据应该不被破坏。

Isolate: 用户间操作不相混淆

Durable: 永久保存

五、事务管理

5.1 理解事务

5.1.3 介绍 spring 的事务管理器

spring 没有直接管理事务，而是将管理事务的责任委

托给某个特定平台的事务实现。

当 apache 的 ojb 用作持久化机制时，用它来管理事务。使用一个 JTA 实现来管理事务。在一个事务跨越多个数据源时使用当持久化机制是 Jdo 时，用它来管理事务。当持久化机制是 hibernate 时，用它来管理事务在单一的 JDBC Datasource 中的管理事务目标 org.springframework.jdbc.datasource.DataSourceTransactionManager org.springframework.orm.hibernate.HibernateTransactionManager org.springframework.jdo.JdoTransactionManager org.springframework.transaction.jta.JtaTransactionManager org.springframework.orm.ojb.PersistenceBrokerTransactionManager 事务管理器实现

五、事务管理

5.1 理解事务

5.1.3 spring 的事务管理器 ( 续 )

platformTransactionmanager datasource Transaction manager hibernate Transaction manager jdo Transaction manager persistence Broker Transaction manager JTA Transaction manager jdbc hibernate JDO OJB JTA 每种事务管理器都充当了对特定平台的事务实现的代理。这样我们就只需要和 spring 中的事务打交道，而不用关系实际上事务实现是什么样的。要使用一个事务管理器，你得再上下文中声明他。程序控制事务管理能让你在代码中精确定义事务边界，声明式事务帮助把一个操作从事务规则中分离出来。

五、事务管理

5.1 理解事务

5.13 spring 的事务管理器

JDBC 事务：

<bean id=“transaction” class=“…DataSourceTransactoinManager”> <property name=“dataSource”> <ref bean=“dataSource”> </property> </bean> 在幕后， DataSourceTransactionManager 通过调用从 DataSource 得到的 Connection 对象来管理事务。如： conn.rollback() conn.commit()

五、事务管理

5.1 理解事务

5.13 spring 的事务管理器

Hibernate 事务： <bean id=“transactionManager” class=“…HibernateTransactionManager”> <property name=“sessionFactory”> <ref bean=“sessionFactory” /> </property> </bean> 其中 sessionFactory 属性必须和一个 Hibernate 的 SessionFactory 绑定 HibernateTransactionManager 把事务管理委托给一个从 Hibernate session 中取得的 net….Transaction 对象。当一个事务成功完成时， HibernateTransactionManager 将调用 Transaction 对象的 commit() 方法。类似的，当一个事务失败时， Transaction 对象的 rollback() 方法将被调用。

五、事务管理

5.1 理解事务

5.1.3 spring 的事务管理器

JDO 事务 ( 略 )

OJB 事务 ( 略 )

五、事务管理

5.2 在 spring 中编写事务

public void enrollStudentIncourse(){ transactionTemplate.execute(){ new TransactionCallback(){ public Object doInTransaction(TransactionStatus ts){ try{ //do stuffr } catch(Exception e){ ts.setRollbackOnly(); } return null; } } }; }

五、事务管理

5.2 在 spring 中编写事务 ( 续 )

注入事务模板： <bean id=“transactionTemplate” class=“…TransactionTemplate”> <property name=“transactionManager”> <ref bean=“transactionManager” /> </property> </bean> <bean id=“courseService” class=“…CourseServiceImpl” > <property name=“transactionTemplate”> <ref bean=“transactionTemplate” /> </property> </bean>

五、事务管理

5.2 在 spring 中编写事务

在代码中添加事务的一种方法是使用 spring 的

TransactionTemplate 类。该类采用了一套回调机制。

public void enrollStudentInCourse(){ transactionTemplate.execute( new TransactionCallback(){ public Object doInTransaction(TransactionStatus ts){ try{ //do stuff } catch(Exception e){ ts.setRollbackOnly(); } return null; } } ); }

五、事务管理

5.2 在 spring 中编写事务 ( 续 )

五、事务管理

5.3 声明式事务

spring 对声明式的事务管理的支持是通过它的

AOP 框架实现的。事务是一个切面，“包裹着”

方法。要在 spring 应用中使用声明式事务，需要使用 TransactionProxyFactoryBean. 这个代理工厂对象类似于 ProxyFactoryBean 处理事务，只不过它的目的是将方法包装在事务的上下文中。

五、事务管理

5.3 声明式事务 ( 续 )

<bean id=“courseService” class=“org.springframework.transaction.interceptor.TransactionProxyFactoryBean”> <property name=“proxyInterfaces”> <list> <value>CourseService</value> 代理所实现的接口 </list> </property> <property name=“target”> <ref bean=“courseServiceTarget” /> 被代理的对象 </property> <propety name=“transactionManager”> <ref bean=“transactionManager” /> 事务管理器 </property> <property name=“transactionAttributeSource”> <ref bean=“attributeSource” /> 事务的属性源 </property> </bean>

五、事务管理

5.3 声明式事务

5.3.1 理解事务属性

传播行为 :

表示该方法不应在事务中运行。如果一个现有的事务正在运行，他将在该方法的运行期间被挂起。如果使用 jta 的事务管理器，需要访问 jtatansactionmanager. 当前的方法不应该运行在一个事务上下文中。如果当前存在一个事务，则会抛出一个异常。若当前已经存在一个事务，则该方法应当运行在一个嵌套的事务中。被嵌套的事务可以从当前事务中单独的提交或回滚。若当前事务不存在，则看起来就和 PROPAGATION_REQUIRED 没有两样。该方法必须运行在一个事务中。如果当前事务不存在，将抛出一个异常。意义 PROPAGATION_MANDATORY PROPAGATION_NESTED PROPAGATION_NEVER PROPAGATION_NOT_SUPPORTED 传播行为

五、事务管理

5.3 声明式事务

5.3.1 理解事务属性

传播行为 ( 续 )

传播规则回答了一个问题，就是新的事务是否要被启动或是挂起，或者方法是否要在事务环境中运行。当前方法不需要事务处理环境，但如果有一个事务已经在运行的话，这个方法也可以在这个事务里运行。 PROPAGATION_SUPPORTS 表示当前方法必须运行在它自己的事务里。他将启动一个新的事务。如果一个现有事务在运行的话，将在这个方法运行期间被挂起。若使用 jtaTransactionManager ，则需要访问 transactionManager 表示当前方法必须运行在一个事务中。若一个现有的事务正在进行中，该方法将会运行在这个事务中。否则的话，就要开一个新的事务。意义 PROPAGATION_REQUIRES_NEW PROPAGATION_REQUIRED 传播行为

五、事务管理

5.3 声明式事务

5.3.1 理解事务属性 ( 续 )

隔离级别

脏读 : 一个事务读取了另一个事务改写但还未

提交的数据，如果这些数据被回滚，则

读到的数据是无效的。

不可重复读 : 一个事务执行相同的查询两次或两次以

上，但每次查询结果都不同。

幻读 : 一个事务读取了几行记录后，另一个事务插入一

些记录，幻读就发生了。再后来的查询中，第一

个事务就会发现有些原来没有的记录。

五、事务管理

5.3 声明式事务

5.3.1 理解事务属性 ( 续 )

隔离级别

完全服从 ACID 的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，幻读仍可能发生。允许在并发事务已经提交后读取。可防止脏读，但幻读和不可重复读仍可发生。允许你读取还未提交后数据。可能导致脏、幻、不可重服使用后端数据库默认的隔离级别含义 ISOlATION_DEFAULT ISOLATION_READ_UNCOMMITED ISOLATION_READ_COMMITTED ISOLATION_REPEATABLE_READ ISOLATION_SERIALABLE 隔离级别

五、事务管理

5.3 声明式事务

理解事务属性 ( 续 )

只读

若对数据库只进行读操作，可设置事务只读的属性，使用某些优化措施。数据库会进行优化处理。若使用 hibernate 作为持久化机制，声明一个只读事务会使 hibernate 的 flush 模式设置为 FLUSH_NEVER 。避免不必要的数据同步，将所有更新延迟到事务的结束。

五、事务管理

5.3 声明式事务

5.3.1 理解事务属性 ( 续 )

事务超时

若事务在长时间的运行，会不必要的占用数据库资源。设置超时后，会在指定的时间片回滚。将那些具有可能启动新事务的传播行为的方法的事务设置超时才有意义 (PROPAGATION_REQUIRED,PROPAGATION_REQUIRES_NEW,PROPAGATION_NESTED) 。

五、事务管理

5.3 声明式事务

5.3.2 声明一个简单的事务策略 TransactionProxyFactoryBean 从 TransactoinAttributeSource 获得一个方法的事务属性。

public interface TransactionAttributeSource{ public TransactionAttribute getTransactionAttribute(Method ,tartgetClass); } 总是匹配事务属性源： <bean id=“transactionAttributeSource” class=“org…..MatchAlwaysTransactionAttributeSource”> …… </bean>

五、事务管理

5.3 声明式事务

5.3.2 声明一个简单的事务策略 ( 续 )

MatchAlwaysTransactionAttributeSource 可能是最简单的事务属性源的实现。每一次他的 getTransactionAttribute() 方法被调用时，他总是简单的返回相同的 TransactionAttribute ，而不管这个事务中包装了哪个方法 ( 默认是 PROPAGATION_REQUIRED 和 ISOLATION_DEFAULT). 那就是 MatchAlwaysTransactionAttributeSource 的“永远匹配 (match always)” 部分在起作用。

五、事务管理

5.3 声明式事务

改变默认的事务属性如果希望改变 MatchAlwaysTransactionAttributeSource 的返回的默认的 TransactionAttribute ，可以在 TransactionAttribute 属性中置入另一个事务属性。如返回一个带 PROPAGATION_REQUIRES_NEW 和 ISOLATION_REPEATED_READ 策略的 TransactionAttribute.

<bean id=“myTransactionAttribute” class=“org……DefaultTransactionAttribute”> <property name=“propagationBehaviorName”> <value>PROPAGATION_REQUIRES_NEW</value> </property> <property name=“isolationLevelName”> <value>ISOLATION_REPEATABLE_READ</value> </property> </bean>

五、事务管理

5.3 声明式事务

改变默认的事务属性

<bean id=“transaction” class=“org…MatchAlwaysTransactionAttributeSource”> <property name=“transactionAttribute”> <ref bean=“myTransactionAttribute” /> </property> </bean> --------------------------------------------------------------------------------- 虽然可以改变事务属性参数，但总是返回相同的事务属性，而不关心参与交易的是哪个方法。如果对不同的方法应用不同的事务策略时，使用 NameMatchTransactionAttributeSource 类。

五、事务管理

5.4 通过方法名声明事务

5.4.1 使用 NameMatchTransactionAttributeSource.

该事务属性源可以在方法名的基础上声明事务。如为了在 enrollStudentInCourse() 方法具有的” requires new” 的传播行为。需要替换 transactionAttributeSource 对象的声明。

<bean id=“transactionAttributeSource” class=“org……NameMatchTransactionAttributeSource”> <property name=“properties”> <props> <prop key=“enrollStudentIncourse”> PROPAGATION_REQUIRES_NEW </prop> </props> </property> </bean>

五、事务管理

5.4.1 使用 NameMatchTransactionAttributeSource.

该事务属性源的 properties 属性把方法名映射到事务属性描述器上。事务属性描述器有以下几种形式：

PROPAGATION,ISOLATION,readonly,-Exception,+Exception 传播行为隔离级别 ( 可选 ) 是否只读 ( 可选 ) 回滚规则 ( 可选 ) <bean id=“transactionAttributeSource” class=“org……NameMatchTransactionAttributeSource”> <property name=“properties”> <props> <prop key=“enrollStudentIncourse”> PROPAGATION_REQUIRES_NEW,ISOLATION_REPEATABLE_READ </prop> </props> </property> </bean>

五、事务管理

5.4.1 使用 NameMatchTransactionAttributeSource( 续 )

使用只读事务

<bean id=“transactionAttributeSource” class=“org……NameMatchTransactionAttributeSource”> <property name=“properties”> <props> <prop key=“enrollStudentIncourse”> PROPAGATION_REQUIRES_NEW,ISOLATION_REPEATABLE_READ, readOnly </prop> </props> </property> </bean>

五、事务管理

指定回滚规则

<bean id=“transactionAttributeSource” class=“org……NameMatchTransactionAttributeSource”> <property name=“properties”> <props> <prop key=“enrollStudentIncourse”> PROPAGATION_REQUIRES_NEW,ISOLATION_REPEATABLE_READ, -CourseException </prop> </props> </property> </bean> --------------------------------------------------------------------------------------------------- 负号异常抛出时，触发回滚，正号异常抛出时，事务仍可提交。

五、事务管理

使用通配符匹配

<bean id=“transactionAttributeSource” class=“org……NameMatchTransactionAttributeSource”> <property name=“properties”> <props> <prop key=“get*”> PROPAGATION_REQUIRES_NEW,ISOLATION_REPEATABLE_READ, -CourseException </prop> </props> </property> </bean> --------------------------------------------------------------------------------------------------- 负号异常抛出时，触发回滚，正号异常抛出时，事务仍可提交。

五、事务管理

5.4.2 名称匹配事务的捷径

TransactionProxyFactoryBean 也有一个 TransactionAttibutes 属性。与其把 NameMatchTransactionAttributeSource 对象置入该属性，不如直接把事务属性邦定到该属性上。如下所示：

<bean id=“transactionAttributeSource” class=“org……TransactionProxyFactoryBean”> … <property name=“transactionProperties”> <props> <prop key=“enrollStudentInCourses”> PROPAGATION_REQUIRES_NEW,ISOLATION_REPEATABLE_READ, -CourseException </prop> </props> </property> </bean> 将事务属性设置到 transactionProperties 属性中和把 NameMatchTransactionAttributeSource 置入到 transactionAttributeSource 中的功能是一样的。

五、事务管理

5.5 用元数据声明事务

5.5.1 用元数据书写事务属性

五、事务管理

5.5.2 用 Commons Attributes 声明事务

声明一个属性的实现

<bean id=“attributeImpl”

class=“org……CommonsAttributes”>

…

</bean>

五、事务管理

5.5.2 用 Commons Attributes 声明事务 ( 续 )

给事务方法加标签

/**

*attribute-name(“arg1”,property=“arg2”)

*/

五、事务管理

5.6 修建事务声明

5.6.1 从父 TransactionProxyFactoryBean 继承

事务管理

修建事务声明

自动代理事务

远程调用

spring 远程调用概览

访问 webservices Jax-rpc 访问对 ejb 实现的遗留的 j2ee 系统考虑网络限制时，访问基于 spring 的服务考虑网络限制，通过 http 访问基于 java 的服务不考虑网络限制（防火墙），访问公开基于 java 的服务使用场景 RMI Hession 或 burlap http invoker Ejb RPC 模式

远程调用

服务接口代理服务接口客户端服务将远程方法调用序列化和反序列化

远程调用

服务接口服务 bean RemoteExporter 客户端将远程方法调用序列化和反序列化

远程调用

与 RMI 一起工作

连接 RMI 服务

<bean id=“paymentService” class=“org.sf.remoting.rmi.RmiProxyFactoryBean”> <property name=“serviceUrl”> <value>rmi://${paymenthost}/PayService</value> </property> <property name=“serviceInterface”> <value>com…..PaymentService</value> </property> </bean>

远程调用

与 RMI 一起工作

输出 RMI 服务

<bean id=“paymentService” class=“org.sf.remoting.rmi.RmiProxyFactoryBean”> <property name=“serviceUrl”> <value>rmi://${paymenthost}/PayService</value> </property> <property name=“serviceInterface”> <value>com…..PaymentService</value> </property> </bean> -------------------------------------------------------------------------------------------------------- <bean id=“org………remoting.rmi.RmiServiceExporter”> <property name=“service”> <ref bean=“paymentService”> </property> <property name=“service”> <ref bean=“paymentService”> </property> <property name=“service”> <ref bean=“paymentService”> </property> </bean>

<bean id=“paymentService” class=“org.sf.remoting.rmi.RmiProxyFactoryBean”> <property name=“serviceUrl”> <value>rmi://${paymenthost}/PayService</value> </property> <property name=“serviceInterface”> <value>com…..PaymentService</value> </property> </bean> ------------------------------------------------------------------------------------ <bean id=“org………remoting.rmi.RmiServiceExporter”> <property name=“service”> <ref bean=“paymentService”> </property> <property name=“serviceName”> <value>Payment</value> </property> <property name=“serviceInterface”> <value>……PaymentService</value> </property> </bean>

远程调用

使用 http invoker

通过 http 访问服务

<bean id=“paymentService” class=“org……HttpInvokerProxyFactoryBean”> <property name=“serviceUrl”> <value>http://${servername}/${contextpath}/pay.service</value> </property> <property name=“serviceInterface”> <value>com……PaymentService</value> </property> </bean>

远程调用

使用 http invoker

把 Bean 作为 HTTP 服务公开

<bean id=“httpPaymentService” class=“org……HttpInvokerServiceExporter”> <property name=“service”> <ref bean=“paymentService” /> </property> <property name=“serviceInterface”> <value>com……PaymentService</value> </property> </bean>

访问企业级服务

发送电子邮件

<bean id=“mailSender” class=“…..JavaMailSenderImpl”> <property name=“host”> <value>mail.springinaction.com</value> </property> </bean> host: 邮件服务器主机名。默认端口 25 。可通过 <proerty name=“port”> 修改 -------------------------------------------------------- 消息模版 <bean id=“mailMessage” class=“…..SimpleMailMessage”> <property name=“to”> <value>dd@dd.com</value> </property> <property name=“from”> <value>dd@dd.com</value> </property> <property name=“subject”> <value>sss</value> </property> </bean>

访问企业级服务 class XXX extends TimerTask{ public void run(){ …… } } ------------------------------------- 调度定时器任务 <bean id=“schedualTask” class=“org……ScheduleTimerTask”> <property name=“timerTask”> <ref bean=“myTimerTask” /></property> <property name=“period”><86400000</value></property> <property name=“delay”>3600000</property> </bean>

调度任务

使用 java Timer

按任意周期运行。继承 java.util.TimerTask

class XXX extends TimerTask{ public void run(){ …… } } ------------------------------------- 调度定时器任务 <bean id=“schedualTask” class=“org……ScheduleTimerTask”> <property name=“timerTask”> <ref bean=“myTimerTask” /></property> <property name=“period”><86400000</value></property> <property name=“delay”>3600000</property> </bean> 启动任务： <bean class=“TimerFactoryBean”> <period 86400000(24 小时 ) <delay 3600000>

调度任务

使用 java Timer

按任意周期运行。继承 java.util.TimerTask( 续 )

timerTask: 运行哪个任务。

period: 频度。 24 小时运行一次。

delay: 首次等待多久后启动。

调度任务

使用 Quartz 调度器

可以每隔多少毫秒启动任务，还允许在某个特定的时间运行。

1. 创建一个工作

class EmailReportJob extends QuartzJobBean{…}

<bean id=“reportJob” class=“……JobDetailBean”>

<propety name=“jobClass”>EmailReportJob

</propety>

<property name=“jobDataAsMap”>

<map></map>

</property>

调度任务

2. 调度工作

<bean id=“simple” class=“……SimpleTriggerBean”>

<propety name=“jobDetail”>

<ref bean=“reportJob”/>

</propety>

startDelay:

repeartInterval:

调度任务

3. 调度 cron 工作

<bean id=“xxx” class=“……CronTriggerBean”>

<propety name=“jobDetail”>

<ref bean=“reportJob”/>

</propety>

cronExpression:006**?

一个 cron 表达式有 >=6 个有空格分隔的时间元素。从左至右依次为：

1. 秒 0 - 59

2. 分钟 0-59

3. 小时 0-23

4. 月份中的日期 1-31

5. 月份 1-12

6. 星期几 1-7

7. 年份 1970-2099

启动工作

<bean id=“ ” class=“…SchedulerFactoryBean”>

<property name=“triggers”>

<list>

<ref bean=“”/>

</list>

</property>

</bean>

调度任务

按调度计划调用方法

class XXX extends TimerTask{ public void run(){ …… } } ------------------------------------- 调度定时器任务 <bean id=“schedualTask” class=“org……ScheduleTimerTask”> <property name=“timerTask”> <ref bean=“myTimerTask” /></property> <property name=“period”><86400000</value></property> <property name=“delay”>3600000</property> </bean>

第八章建立 web 层

8.1 开始 springMVC 之旅

DispatcherServlet HandlerMapping Controller ViewResolver View ModelAndView

8.1.2 配置 DispatcherServlet

<servlet> <servlet-name>action</servlet-name> <servlet-value>……DispatcherServer</servlet-value> </servlet> <servlet-mapping> <servlet-name>action</servlet-name> <url-pattern>*.htm</url-pattern> </servlet-mapping>

8.1.2 配置 DispatcherServlet( 续 )

分解应用上下文 <listener> <listener-class>……ContextLoaderListener</listener-class> </listener> -------------------- 或 <servlet> <servlet-name>context</servlet-name> <servlet-class>……ContextLoaderServlet</servlet-class> <servlet> 不管使用哪种上下文载入器，都需要告诉它配置文件的位置。如果没有指定，将默认需寻找 /WEB-INF/application-Context.xml 。但还可以通过设定 contextConigLocation 参数来指定多个配置文件。 <context-parm> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/xxx.xml,xxxxx.xml</param-value> </context-parm>

8.1.3 spring MVC 概述

1. 编写控制器类

2. 在 DispatcherServlet 上下文配置文件配控制器

　 3. 配置视图解析器将控制器与 jsp 结合起来

4. 编写将主页呈现给用户的 JSP 文件。

创建控制器：

class HomeController implements Controller{

ModelAndView handleRequest(){

return new ModelAndView(“index”);

}

}

配置控制器

<bean name=“/home” class=“…HomeController”>

<property name=“…”></property>

<property name=“…”></property>

</bean>

8.1.3 spring MVC 概述 ( 续 )

声明视图解析器

<bean id=“viewResolver”

class=“…InternalResourceViewResolver”>

<property name=“prefix”>/jsps/</property>

<property name=“suffix”>.jsp</property>

</bean>

ModelAndView 将 prifix + url + suffix 。

合并起来

1. 中央控制器接受 /home.htm 样式的请求

2. 询问 BeanNameUrlHandlerMapping( 默认 ) ，找到处理器。

3. 业务控制器处理

4. 返回 ModelAndView 对象。带有逻辑试图名。

5. 中央控制器通过试图解析器返回 jsp 文件路径。

6. 导向 jsp 页面，展现给用户。

8.2 将请求映射到控制器

1.BeanNameUrlHandlerMapping

2.SimpleUrlHandlerMapping

3.CommonsPathMapHandlerMapping

8.2.1 将 URL 映射到 Bean 名称

8.2.2 使用 SimpleUrlHandlerMapping

<bean id=“” class=“ SimpleUrlHandlerMapping ”> <property name=“mappings”> <props> <prop key=“/xxx.service”>xxxController</prop> <prop key=“/xxx.service”>xxxController</prop> … </props> </property> </bean>

8.2.4 使用多映射处理器

8.3 用控制器处理请求

复杂多页面的输入表单 AbstractWizardFormController 向导显示输入表单，处理表单数据携带参数，邦定到对象，相当于 actionForm 有多个动作处理相似或相关逻辑简单请求处理方式控制器非常简单，功能和 servlet 差不多适用于 AbstractFormController SimpleFormController BaseCommandController AbstractCommandController MultiActionController ThrowawayController Contoller AbstractController 类简单一次性多动作命令表单控制类型

8.3.1 编写一个简单的控制器

class xxx extends AbstractController{ ModelAndView hanleRequest(){ Set courses = courseService.getAllCourses(); return new ModelAndView(“courseList”,”courses”,courses); } } 参数一：控制器输出表单视图组件的逻辑名。参数二：传递给视图组件的数据对象名。参数三：传递给视图组件的数据对象。 ----------------------------------------- <bean id=“coursesCtroller” class=“xxx.CourseController”> <property name=“courseService”> <ref bean=“” /> </property> </bean>

8.3.2 处理命令

对于 web 请求需要若干个参数来帮助确定返回结果。 public calss xxxController extends AbstractCommandController(){ public xxxController(){ setCommandClass(xxxCommand.class); } public ModelAndView handle(request,response,command,errors){ xxxComand xxxcommand = (XxxCommand)command ; return new ModelAndView(“”,””,); } } 标准 javabean: class XxxCommand(){ int I ; int name ; … }

8.3.2 处理表单提交

public calss xxxController extends SimpleFormController (){ public xxxController(){ setCommandClass(xxxCommand.class); } public void doSubmitAction(){ … } } doSubmitAction() 方法没有返回任何东西，用户将看到什么页面也不是很清楚， Simple FormController 类被设计成尽量将视图详细信息放在控制器代码之外。不是将 ModelAnd View 对象硬编码进来，而是像下面这样在上下文配置文件中配置控制器。

8.3.2 处理表单提交 ( 续 )

<bean id=“xxxController” class=“xxxFormController”> <property name=“xxxService”> <ref bean=“xxxService” /> </property> <property name=“formView”> <value>newStudentForm</value> </property> <property name=“successView”> <value>studentWelcome</value> </property> </bean> formView 属性是控制器接收到 get 请求或有任何错误发生时需要显示的视图的逻辑名。同样， successView 属性是提交的表单成功处理后要显示的视图的逻辑名。视图解析器将使用这些值来定位相应的视图对象。 doSubmitAction() 方法的限制是无法往视图发送任何数据。如果需要给视图传递数据，需要复写 onSubmit() 方法而不是 doSubmitAction() 方法。 protected ModelAndView onSubmit(command,errors){ return new ModelAndView( getSuccessView() ,”student”,student); }

8.3.2 处理表单提交 ( 续 )

验证表单输入：当控制器调用命令进行数据操作时，确保命令中的数据有效性，… Validator 接口为 spring MVC 提供了验证功能。定义如下： public interface Validator{ void validate(Object obj,Errors errors); boolean supports(Class clazz); } 这个接口的实现必须验证传递给 validate() 方法的对象的字段，用 errors 对象驳回任何非法数据。 supports() 方法用于帮助 spring 判断验证器是否可以用于指定类。 StudentValidator 是一个用于验证 Student 对象的 Validator 实现。

8.3.2 处理表单提交 ( 续 )

使用验证器：

public class StudentValidator implements Validator{ public boolean supports(Class clazz){ return clazz.equals(student.class); } public void validate(command,errors){ Student s = (Student)command; ValidationUtils.rejectIfEmpty(errors,”login”,”required.login”,”login is required”); …… } } 最后要让控制器使用校验器。我们可以将校验器装配到控制器上。 <bean id=“xxxController” class=“”> <property name=“validator”> <bean class=“xxxValidator” /> </propety> </bean>

8.3.2 用向导处理复杂表单

对于较多的表单信息，放在一个页面上会难于使用而且也会造成

用户的反感。幸运的是 spring 提供了 AbstractWizardFormController

控制器。

创建基本的向导控制器 public class xxxController extends AbstractWizardFormController{ public xxxController(){ setCommandClass(xxxCommand.class); } public ModelAndView processFinish(request,response,command,errors){ … } } 和命令控制器一样，向导表单控制器必须使用 command 。向导表单的唯一一个必须实现的方法是 processFinish （）。在用户完成表单后，这个方法被调用，完成整个表单。注意该向导控制器没有任何地方告诉你有关组成表单的页面是哪些以及页面是按什么顺序显示的。这是因为向导表单控制器负责处理大部分的工作，包括隐藏在向导下面的工作流程。他是如何知道的呢？

8.3.2 用向导处理复杂表单 ( 续 )

<bean id=“xxxController” class=“…”> <property name=“xxxService”> <ref bean=“xxxService” /> </property> <property name=“pages”> <list> <value>general</value> <value>instructor</value> <value>course</value> <value>facilities</value> </list> </property> </bean>

分步显示表单页面 :

向导控制器显示的第一个页面都是 pages 属性中的第一个页面。为了判断接下来显示哪个页面，控制器询问他的 getTargetPage() 方法。该方法返回一个整数，它是 pages 属性中设置的页面列表的索引值 ( 以 0 为基址 ).getTargetPage() 方法的缺省实现是根据请求中的一个参数来决定下一步是哪个页面，这个参数以” _target” 开头，以数字结尾。该方法去掉这个参数的” _target” 前缀，得到剩下的数字，以它作为页面列表的索引。知道了 getTargetPage() 方法的工作原理，有助于我们构造“上一步”、“下一步”按钮。我们要做的就是创建提交按钮。名字以” _target” 开始。 <form method=“” action=“”> … <input type=“submit” name=“_target1” value=“Back”/> <input type=“submit” name=“_target3” value=“Next” /> </form> getTargetPage() 方法的缺省实现对于大多数项目已经够用，如果愿意可以复写该方法。

完成向导 :

上面介绍了如何在向导表单中返回和前进。但如何告诉控制器你已经完成，应该调用 processFinish() 方法呢？还有一个特殊的请求参数叫” _finish” ，他告诉控制器用户已经完成了表单的填写，要提交需要处理的信息。和” _targetX” 参数一样，” _finish” 可以被用于在页面上创建一个结束按钮： <form method=“post” action=“”> …… <input type=“submit” value=“Finish” name=“_finish” /> </form> 当控制器看到请求中的“ _finish” 参数时，他会将控制权交给 processFinish() 方法，让他对表单进行最后的处理。

取消向导 :

类同： <form method=“post” action=“”> …… <input type=“submit” value=“cancel” name=“_cancel” /> </form> 当控制器看到请求中的“ _cancel” 参数时，他会将控制权交给 processCancel() 方法。缺省情况下，该方法会抛出一个异常，表示取消操作是不被支持的。所以需要复写个方法。

每次验证一个向导表单 :

向导控制器在每个页面验证一次命令对象，不是只验证一次。这是通过每次页面跳转时调用 validatePage() 方法实现的。该方法的缺省实现是空的，但可以复写该方法。 protectd void validatePage(command,errors,int){ FeedbackSurvey feedback = (FeedbackSurvey)command; FeedbackValidator validator = (FeedbackValidator)getValidator(); if(page == 0){ validator.validateEmail(feedback.getEmail(),errors); } } <bean id=“xxxController” class=“xxx”> <property name=“pages”> <list><value>xxx</value></list> </property> </bean> <property name=“validator” > <bean class=“……Validator”> </property>

8.3.2 在一个控制器中处理多个动作

MultiActionController 是一个特殊类型的控制器，它可以实现多个动作，每个动作分派给不同的方法。 public class ListCourseController extends MultiActionController{ public ModelAndView courseUnsorted(request,response){} public ModelAndView courseSortedByDate(request,response){} public ModelAndView courseSortedByName(request,response){} } 缺省情况下，方法的选择是根据 URL 中的文件名部分决定的。例如，如果 ListCourseContro ~ller 映射到 URL 样式“ /course*.html” 的话，那么 1 。 http://.../courseUnsorted.htm 将被 coursesUnsorted 处理。 2 。 http://.../coursesSortByDate.html 将被 coursesSortByDate 处理。 3 。 http://.../coursesSortByName.htm 将被 courseSortByName 处理。尽管这样很直接、简单，但是并不是最佳方式。或许我们不希望将方法名和 URL 直接绑定一起。

8.3.2 在一个控制器中处理多个动作

解析方法名：

多动作控制器使用自己的方法名解析器解析器方法名。默认的解析器是 InternalPathMethodNameResovler, 他根据 URL 样式解析方法名，就像前面一样。但 spring 带有两种其他类型的方法名解析器。 1.ParameterMethodNameResovler- 根据参数解析方法名 2.PropertiesMethodNameResovler- 根据查询一个 key/value 列表解析执行方法名。无论哪种，都需要装配到控制器上。 <bean id=“xxxController” class=“”> <property name=“methodNameResovler”> <ref bean=“methodNameResolver” /> </property> </bean> <bean id=“methodNameResolver” class=“ParameterMethodNameResolver”> <property name=“paramName”> <value>action</value> </property> </bean> 使用方式： http://.../listCourses.htm?action=courseUnsorted

8.3.2 在一个控制器中处理多个动作 ( 续 )

解析方法名：

<bean id=“methodNameResovler” class=“…PropertiesMethodNameResolver”> <property name=“mappings”> <props> <prop key=“/courseList.html”>coursesUnsorted</prop> <prop key=“/courseByDate.html”>coursesSortedByDate</prop> <prop key=“/courseByName.html”>coursesSortByName</prop> </props> </property> </bean>

使用一次性控制器

一次性控制器自己作为自己的命令对象，而不是通过 request 或命令对象获得参数。

public class XxxController extends ThrowawayController{ private Integer id ; public ModelAndView exceute() throws Exception{ return new ModelAndView(); } } 在该控制器处理请求之前，将会先调用相应的 setXxx （）方法，传递请求参数的 id 值。同其他控制器一样，在结束执行方法之后会返回一个模型和视图对象。 <bean =“xxxController” class=“” singleton=“false”> <property name=“xxxService”> <ref bean=“xxxService” /> </property> </bean> singleton 属性告诉 spring 在控制器在使用完后就将其销毁，为每次请求实例化一个新的实例。

使用一次性控制器 ( 续 )

因为该控制器和其他控制器不处于同一个继承层次，所以必须告诉分发器使用一种不同的处理适配器。 <bean id=“throwawayHandler” class=“……ThrowawayControllerHanderAdapter” /> 因为有可能在同一个应用系统中同时使用一次性控制器和常规控制器，所以还要告诉分发器使用常规控制器。 <bean =“simpleHandlerAdapter” class=“…..SimpleControllerHandlerAdapter” /> 声明了两种处理适配器后，你可以在同一个应用系统中混合使用两种控制器。

8.4 视图解析

在 spring 的 MVC 中，一个视图就是将一个结果渲染给用户的

Bean 。如何完成渲染取决于你使用的视图类型。通常是 jsp 。

这里，关键的问题是附给 ModelAndView 对象的逻辑视图对象

是如何被解析成一个用于将结果渲染给用户的视图 bean 的。

这就是视图解析器的作用。该对象是一个实现了… ViewResolver

接口的 bean 。

spring 有四种视图解析器：

1.InternalResourceViewResolver- 将逻辑视图名解析成一个用模板文件

( 如 jsp 和 Velocity 模板 ) 渲染的视图对象。

2.BeanNameViewResolver- 将逻辑视图名解析为一个

DispatcherServlet 应用上下文的视图 bean 。

3.ResourceBundleViewResolover- 将逻辑视图名解析为

ResourceBundle 中的视图对象。

4.XmlViewResovler- 从一个 XML 文件中解析视图 bean ，这个文件是从

DispatcherServler 应用上下文中分离出来的。

8.4 视图解析

使用视图模板

如果使用 jsp 文件显示课程信息。

<%@ page contentType=“text/html;charset=UTF-8” %> <%taglib uri=“ http:// java.sun.com/jsp/jstl/core ” prefix=“c” %> <%taglib uri=“http://java.sun.com/jsp/jstl/fmt” prefix=“f”%> <html> <head> <title>course:${course.id}/${course.name}</title> </head> <body> </body> </html>

8.4 视图解析

8.4.1 使用模板视图 ( 续 )

告诉控制器象下面这样结尾：

return new ModelAndView(“index”,”course”,course);

InternalResourceViewResolver 将一个逻辑视图名解析成一个将渲染任务委

托给位于 web 应用中的模板文件的视图对象。通过从 ModelAndView 对象中获

得逻辑视图名。加上前缀和后缀达到位于模板。

<bean =“internaResourceViewResolver” class=“InternalResource..”>

<property name=“prefix”></property>

<property name=“sufix”></property>

</bean>

/WEB-INF/jsp/courseDetail.jsp 前缀后缀视图逻辑名

8.4 视图解析

8.4.1 使用模板视图 ( 续 )

缺省视图对象是 InternalResourceView, 他只是简单的将请求分发给 jsp 来完成实际的渲染工作。但由于使用了 JSTL 标签，应该选择 JstlView 替换 InternalResourceView 。

<bean id=“viewResolver” class=“…InternalResourceViewResolver”>

<property name=“viewClass”>

<value>…..JstlView</value>

</property>

<property name=“suffix”></property>

</bean>

8.4 视图解析

8.4.2 解析视图 Bean

如果我们不使用 JSP 来渲染 html 页面而是使用 PDF 文件该如何处理？

这里假设已经编写了 AbstractPdfView 的子类。这里我们要使用其他的

视图解析器来替换内部资源视图解析器。 BeanNameViewResolver

是将一个逻辑视图名与应用上下文中的 Bean 匹配的视图解析器。

<bean id=“viewResolver” class=“.BeanNameViewResolver”/>

现在当控制器返回一个以“ courseList” 为逻辑名的 ModelAndView 对象

的话， beanNameViewResolver 将会寻找一个叫改名的 bean 。

<bean id=“courseList” class=“..CourseList”>

8.4 视图解析

8.4.2 解析视图 Bean( 续 )

在一个独立的 XML 文件中声明视图对象

另一种使用 Bean 名解析视图对象的方法是使用 XmlFileViewResolver.

XmlFileViewResolver 与 BeanNameViewResolver 相似，只是不是在应用上下文中寻找试图 bean ，而是在一个独立的 xml 文件中查找。

<bean id=“xmlViewResolver” class=“XmlFileViewResolver”>

<property name=“location”>

<value>/WEB-INF/xxx.xml</value>

</property>

</bean>

缺省情况下，该解析器寻找 /WEB-INF/views.xml 文件，我们可以替换调它。

8.4 视图解析

从资源包中解析视图

ResourceBundleViewResolver 在 properties 文件而不是 xml 文件中管理视图定

义。该解析器在国际化方面比较有优势。

<bean id=“bundleViewResolver”

class=“…ResourceBundleViewResolver”>

<property name=“basename”>

<value>views</value>

<property>

</bean>

views.properties

views_en_US.properties

views_fr_FR.properties

views_de_DE.properties

8.4 视图解析

views.properties 内容：

courseList.class=……CourseListPdfView

-------------------------------------------------

views_de_DE.properties 内容：

courseList.class=……JstlView

courseList.url=/WEB-INF/jsp/courseList.jsp

8.4 视图解析

8.4.3 选择视图解析器

使用多视图解析器

<bean id=“viewResolver” class=“…InternalResourceViewResolver”>

<property name=“suffix”></property>

<property name=“order”>1</property>

</bean>

<bean id=“xmlviewResolver”

class=“…InternalResourceViewResolver”>

<property name=“location”></property>

<property name=“order”>2</property>

</bean>

8.5 使用 spring 的绑定标签

为了在页面中显示模型数据， spring 提供了完成这些功能的标签库。为了使用这些

标签库，首先需要将他注册到应用系统中。将 spring.tld 文件放到 /WEB-INF/ 目录

下，然后在 web.xml 文件中注册标签库。

<taglib>

<taglib-uri>/spring</taglib>

<taglib-location>/WEB-INF/spring.tld</taglib-location>

<taglib>

用 <spring:bind> 标签可以得到命令对象以及与其有关的任何信息。该标签只有一个

path 属性，指定使用的 bean 或 bean 属性。在 JSP 页面中你可以使用该对象的三个属

性：

expression- 获得属性值的表达式。

value- 属性字符串值

errorMessages- 有关这个属性的一组错误信息。

8.5 使用 spring 的绑定标签 ( 续 )

使用 spring-bind 组装表单

<%@ taglib uri=“jstl/core.tld” prefix=“x” %> <%@ taglib uri=“spring” prefix=“spring“ %> <spring:bind path=“student.firstName”> <input type=“text” name=“<c:out value=“${status.expression}”>” value=“<c:out value=“${status.value}”>”> </spring:bind>

8.5 使用 spring 的绑定标签 ( 续 )

使用 spring-bind 显示错误信息

<%@ taglib uri=“jstl/core.tld” prefix=“x” %> <%@ taglib uri=“spring” prefix=“spring“ %> <spring:bind path=“student”> <c:forEach items=“${status.errorMessages}” var=“errorMessage”> <c:out value=“${errorMessage}”> </c:forEach> </spring:bind>

第九章其他视图技术

9.1 使用 Velocity 模板

9.1.1 定义 Velocity 视图

courseList.vm:

<html> … . #foreach($course in $courses) <tr><td>… <a href=“/…?id=${course.id}” >${course.id}</a> ${course.name} ${course.instructor.lastName} </td></tr> #end </html> 该文件中没有使用任何模板标签，因为 velocity 不是基于与 jsp 类似的标签的，而是采用了自己的语言，称为 velocity 模板语言。用于流程控制和其他指令。

第十章使用其他 web 框架

9.1 使用 struts

spring 提供了两种与 Struts 集成的方式

1. 从一个知晓 Spring 的基类中派生 strutsAction bean 。 2. 将请求委托给作为 springBean 管理的 StrutsAction 来处理。

10.1 使用 struts

10.1.1 注册 spring 插件

<plug-in class=“…ContextLoaderPlugIn”> <set-property name=“contextConfigLocation value=“/WEB-INF/training-servlet.xml,…”/> </plug-in> ContextLoaderPlugIn 负责装载一个 spring 应用上下文，该应用上下文使用该类指定的属性列举的上下文配置文件。

10.1 使用 struts

10.1.2 实现知晓 spring 的 struts action

从一个公共的能够访问的 spring 上下文的基类中派生所有的 struts action ， spring 已经作了对该方法的支持。 ActionSupport 类。 public class xxxAction extends ActionSupport{ public ActionForward execute(…){ ctxt = getWebApplicationContext(); ctxt.getBean(“xxx”); } } 该方式好处在于同 struts 集成较直观。除了需要从 actionSupport 派生，以及需要从上下文中获取 Bean 之外，其他方面都和 struts 相似。不利的一面是与 spring 结合紧密。

10.1 使用 struts

10.1.3 委托 Action

编写一个 Struts action, 但它只不过是一个包含在 spring 应用上下文中真正的 Struts action 的代理。该代理 action 从 ContextLoaderPlugIn 中获取应用上下文。然后将处理交给该 action 。 public class xxxAction extends ActionSupport{ public ActionForward execute(…){ … . } private XxxService xxxService ; private getXXX() setXXX();// 注入依赖 } 我们注册不是 strutsAction 而是代理 action 。 spring 中提供了这个类 DelegatingActionProxy. <action path=“/…” type=“…DelegatingActionProxy”/>

10.1 使用 struts

10.1.3 委托 Action( 续 )

作为 spring Bean 编写 Struts Action <bean name=“/xxx” class=“….xxxServiceAction”> <property name=“xxxService”> <ref bean =“xxxService” /> </property> </bean>