Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。
Struts
自推出以来不断受到开发者的追捧,其最新版本
Struts2.0
亦代表了下一代
Java Web
开发的新趋势。从目前公布的
Struts2.0
的框架来看,具有一系列丰富的特性,对大型开发社区很有帮助,最关键的是从
1.0
迁移到
2.0
也不是很困难。
对于
Web
框架中的
MVC
架构,基本上
Struts
是表示层部分、
spring
是事务层部分、
hibernate
是持久层(数据层)部分。通俗点就是差不多表示层主要页面,事务层主要事务逻辑处理,持久层和数据库打交道。
对于
Struts2
与
Struts1
的对比(来源:
Struts2
开发组
),可以大致归纳如下:
Ø
Action
类
:
• Struts1
要求
Action
类继承一个抽象基类。
Struts1
的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action
类可以实现一个
Action
接口,也可实现其他接口,使可选和定制的服务成为可能。
Struts2
提供一个
ActionSupport
基类去实现
常用的接口。
Action
接口不是必须的,任何有
execute
标识的
POJO
对象都可以用作
Struts2
的
Action
对象。
Ø
线程模式
:
• Struts1 Action
是单例模式并且必须是线程安全的,因为仅有
Action
的一个实例来处理所有的请求。单例策略限制了
Struts1 Action
能作的事,并且要在开发时特别小心。
Action
资源必须是线程安全的或同步的。
• Struts2 Action
对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,
servlet
容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
Ø
Servlet
依赖
:
• Struts1 Action
依赖于
Servlet API ,
因为当一个
Action
被调用时
HttpServletRequest
和
HttpServletResponse
被传递给
execute
方法。
• Struts 2 Action
不依赖于容器,允许
Action
脱离容器单独被测试。如果需要,
Struts2 Action
仍然可以访问初始的
request
和
response
。但是,其他的元素减少或者消除了直接访问
HttpServetRequest
和
HttpServletResponse
的必要性。
Ø
可测性
:
•
测试
Struts1 Action
的一个主要问题是
execute
方法暴露了
servlet API
(这使得测试要依赖于容器)。一个第三方扩展--
Struts TestCase
--提供了一套
Struts1
的模拟对象(来进行测试)。
• Struts 2 Action
可以通过初始化、设置属性、调用方法来测试,
“
依赖注入
”
支持也使测试更容易。
Ø
捕获输入
:
• Struts1
使用
ActionForm
对象捕获输入。所有的
ActionForm
必须继承一个基类。因为其他
JavaBean
不能用作
ActionForm
,开发者经常创建多余的类捕获输入。动态
Bean
(
DynaBeans
)可以作为创建传统
ActionForm
的选择,但是,开发者可能是在重新描述
(
创建
)
已经存在的
JavaBean
(仍然会导致有冗余的
javabean
)。
• Struts 2
直接使用
Action
属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己
(
子
)
属性的
rich
对象类型。
Action
属性能够通过
web
页面上的
taglibs
访问。
Struts2
也支持
ActionForm
模式。
rich
对象类型,包括业务对象,能够用作输入
/
输出对象。这种
ModelDriven
特性简化了
taglib
对
POJO
输入对象的引用。
Ø
表达式语言:
• Struts1
整合了
JSTL
,因此使用
JSTL EL
。这种
EL
有基本对象图遍历,但是对集合和索引属性的支持很弱。
• Struts2
可以使用
JSTL
,但是也支持一个更强大和灵活的表达式语言--
"Object Graph Notation Language" (OGNL).
Ø
绑定值到页面(
view
)
:
• Struts 1
使用标准
JSP
机制把对象绑定到页面中来访问。
• Struts 2
使用
"ValueStack"
技术,使
taglib
能够访问值而不需要把你的页面(
view
)和对象绑定起来。
ValueStack
策略允许通过一系列名称相同但类型不同的属性重用页面(
view
)。
Ø
类型转换:
• Struts 1 ActionForm
属性通常都是
String
类型。
Struts1
使用
Commons-Beanutils
进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
• Struts2
使用
OGNL
进行类型转换。提供基本和常用对象的转换器。
Ø
校验:
• Struts 1
支持在
ActionForm
的
validate
方法中手动校验,或者通过
Commons Validator
的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
• Struts2
支持通过
validate
方法和
XWork
校验框架来进行校验。
XWork
校验框架使用为属性类类型定义的校验和内容校验,来支持
chain
校验子属性
Ø
Action
执行的控制:
• Struts1
支持每一个模块有单独的
Request Processors
(生命周期),但是模块中的所有
Action
必须共享相同的生命周期。
• Struts2
支持通过拦截器堆栈(
Interceptor Stacks
)为每一个
Action
创建不同的生命周期。堆栈能够根据需要和不同的
Action
一起使用。