访问值栈中对象的普通属性(get set方法)：

<s:property value="user.age"/>

<s:property value="user['age']"/>

<s:property value="user[""age""]"/>

wrong: <%--<s:property value="user[age]"/>--%>  

访问值栈中对象的普通属性(get set方法):

 <s:property value="cat.friend.name"/>  

访问值栈中对象的普通方法：<s:property value="password.length()"/>  

访问值栈中对象的普通方法：<s:property value="cat.miaomiao()" />  

访问值栈中action的普通方法：<s:property value="m()" />

访问静态方法：<s:property value="@com.bjsxt.struts2.ognl.S@s()"/>  

访问静态属性：<s:property value="@com.bjsxt.struts2.ognl.S@STR"/>  

访问Math类的静态方法：<s:property value="@@max(2,3)" />  

访问普通类的构造方法：

<s:property value="new com.bjsxt.struts2.ognl.User(8)"/>

访问List:<s:property value="users"/>  

访问List中某个元素:<s:property value="users[1]"/>  

访问List中元素某个属性的集合:<s:property value="users.{age}"/>  

访问List中元素某个属性的集合中的特定值:

<s:property value="users.{age}[0]"/>

<s:property value="users[0].age"/>  

访问Set:<s:property value="dogs"/>  

访问Set中某个元素:<s:property value="dogs[1]"/>

<!--set是没有顺序的，所以取下标值是没有意义的-->  

访问Map:<s:property value="dogMap"/>  

访问Map中某个元素:<s:property value="dogMap.dog101"/>

<s:property value="dogMap['dog101']"/>

<s:property value="dogMap[""dog101""]"/><!--取出key为dog101的值-->  

访问Map中所有的key:<s:property value="dogMap.keys"/>  

访问Map中所有的value:<s:property value="dogMap.values"/>  

访问容器的大小：<s:property value="dogMap.size()"/>

<s:property value="users.size"/> <!--不加ku9ohao也可以访问-->

投影(过滤)：<s:property value="users.{?#this.age==1}[0]"/><!--格式固定，this指循环过程中的每一个对象。取出users里age等于1的集合里面的第一个元素-->  

投影：<s:property value="users.{^#this.age>1}.{age}"/><!--^指第一个元素-->  

投影：<s:property value="users.{$#this.age>1}.{age}"/><!--$指结尾的元素-->  

投影：<s:property value="users.{$#this.age>1}.{age} == null"/><!--查看age>1的user的age是否为空-->

 []:<s:property value="[0].username"/>  

<!--指value stack栈顶的那个Action，因为action在栈顶。0值value stack从上往下数的第几0个元素 -->  

<!--[0]代表action的位置，而不是action那个对象，[0]代表从0往下数到栈底的对象的集合。-->  

<!--[0].username，如果有多个action，在第一个action里找不到[0].username，会往下找-->  

<s:form action="submit.action" >
<s:textfield name="param" label="content"/>  
<s:submit name="method1" value="方法一"  method="method1"/>
<s:submit name=" method1" value="方法二" method="method1" />      
</s:form>

try {

   XXX

} catch (Exception e) {

   Super.addFieldError(“username”, “输入有误”);

   或者：

   Super.addActionError(“输入有误”);

}

感兴趣可以研究一下源码，使用时我们只需要在页面显示这些错误就OK。

如：

<s:fielderror>

   <s:param>username</s:param>

</s:fielderror>

或者

<s:actionerror/>

但是在实际应用中，fielderror我们比较倾向于有针对性的错误信息输出，因为fielderror它本身就是个Map，可以详细指定错误的字段-原因。而且在表单提交时更合适，只要对应了error字段和提交属性的字段。Struts2会为我们自动表格排版(没试验)

修改主题:<s:form theme="simple"> 不能显示错误信息,不能自动添加表格排版,根据需要自己发挥

struts提供两种方式访问session和request，其中比较常用的是利用SPRING里面所说的IOC即控制反转

IOC方式：

action类实现ServletRequestAware接口，并新建一个HttpServletRequest request

public class UserLoginAction extends ActionSupport implements ServletRequestAware {

public void setServletRequest(HttpServletRequest request) {

this.request=request;

}

然后可以生成的request得到对象，如request.getRemoteAddr()

action类实现SessionAware接口，并创建一个MAP对象session

public class UserLoginAction extends ActionSupport implements ServletRequestAware,SessionAware{

public void setServletRequest(HttpServletRequest request) {

this.request=request;

}

public void setSession(Map session) {

this.session=session; 

}

非Ioc方式

这种方式主要是利用了com.opensymphony.xwork2.ActionContext类以及org.apache.struts2.ServletActionContext类，具体的方法如下所示。

获得request对象：

A. HttpServletRequest request = ServletActionContext.getRequest ();

B．ActionContext ct = ActionContext.getContext()

   HttpServletRequest request = (HttpServletRequest)ct.get(ServletActionContext. HTTP_REQUEST );

获得session对象：

在Struts2中底层的session都被封装成了Map类型，我们称之为SessionMap，而平常我们所说的session则是指HttpSession对象，具体的获得方法如下所示。

A．Map session = ActionContext.getSession();

B．Map session = (Map)ActionContext.getContext().get(ActionContext.SESSION);

得到这个SessionMap之后我们就可以对session进行读写了，如果我们想得到原始的HttpSession可以首先得到HttpServletRequest对象，然后通过request.getSession()来取得原始的HttpSession对象。一般情况下SessionMap已经可以完成所有的工作，我们不必再去碰底层的session了。

1. 标准的WML1.0表单提交格式

<anchor>提交

       <go href="<s:url value='/wap/postParams.action/>" method="get">

       <postfield name="param1" value="$(param1)" />

       <postfield name="param2" value="$(param2)" />

       <postfield name="struts.token.name" value="struts.token"/>

       <postfield name="struts.token" value="${sessionScope['struts.token'] }"/>

       </go>

</anchor>

2. <a href=””></a>和<s:url />完成链接效果

<a href='

    <s:url action="postParams">

       <s:param name="param1" value="#stu.id" />

       <s:param name="struts.token.name" value="struts.token" />

       <s:param name="struts.token" value="${sessionScope['struts.token']}" />

    </s:url>'>

提交</a>

3．<s:a /> 和 <s:url />一起完成链接提交

<s:url id="toUrl" action="postParams" namespace="/wap">

    <s:param name="param1" value="%{param1}"/>

    <s:param name="param2" value="%{param2}" />

    <s:param name="struts.token.name" value="struts.token" />

    <s:param name="struts.token" value="${sessionScope['struts.token'] }"/>

</s:url>

<s:a href="%{toUrl}">提交</s:a>

以上这三个方法在无线互联网开发过程中都是很实用的，具体的要看个人爱好，当然，如果你做WEB开发，你也可以直接用<s:form />

在struts2中action传递给jsp中的数据是保存在OgnlValueStack中的，所以在jsp页面中如果想利用脚本而不是sturts标签获取传入值的话，尽量使用OgnlValueStack的值获得，例如：

<%...OgnlValueStack stack = (OgnlValueStack) request.getAttribute("struts.valueStack");

Article article = (Article)(stack.findValue("article"));%>

2 sturts2标签自动转换Html标签

在使用struts2标签<s:property value="">来显示传递值的时候，会将字符串中的html标签转换，所以可以利用java脚本直接获取传入值，使用方式见第一条

SSH2要点：
Struts2.1.8 要点：
01 struts2及struts2开发环境的搭建
02 第一个struts2应用开发
03 解决struts2配置文件无提示问题
04 Action名称的搜索顺序
05 Action配置的各项默认值
06 result配置的各种视图转发类型
07 为Action属性注入值
08 指定Struts2处理的请求后缀、常量定义、常用常量
09 Struts2的处理流程与Action的管理方式
10 为应用指定多个配置文件
11 动态方法调用和使用通配符定义action
12 请求参数接收与采用复合类型接收请求参数及解决中文参数乱码问题
13 自定义类型转换器
14 全局类型转换器
15 访问或添加request、session、application属性
16 文件上传
17 多文件上传
18 自定义拦截器
19 对Action中所有方法进行输入校验
20 对action指定方法进行校验
21 输入校验的流程
22 基于XML配置方式实现对action的所有方法进行校验
23 基于XML配置方式实现对指定action方法校验与基于XML配置校验的一些特点
24 配置国际化全局资源文件、输出国际化信息
25 输出带有占位符的国际化信息
26 配置包范围国际化资源文件
27 配置Action范围国际化资源文件
28 ognl表达式
29 struts2常用标签解说
30 防止表单重复提交

Spring2.5 要点：
01 全面阐释Spring及其各项功能
02 搭建与测试Spring的开发环境 
03 编码剖析Spring管理Bean的原理 
04 Spring的三种实例化Bean的方式 
05 配置Spring管理的bean的作用域 
06 Spring管理的Bean的生命周期 
07 编码剖析Spring依赖注入的原理 
08 编码剖析Spring装配基本属性的原理 
09 Spring如何装配各种集合类型的属性 
10 使用构造器装配属性 
11 用@Resource注解完成属性装配 
12 编码剖析@Resource注解的实现原理 
13 @Autowire注解与自动装配 
14 让Spring自动扫描和管理Bean 
15 使用JDK中的Proxy技术实现AOP功能 
16 使用CGLIB实现AOP功能与AOP概念解释 
17 使用Spring的注解方式实现AOP入门 
18 使用Spring的注解方式实现AOP的细节 
19 使用Spring配置文件实现AOP 
20 aspectj的切入点语法定义细节 
21 搭建和配置Spring与jdbc整合的环境 
22 Spring集成的jdbc编码和事务管理 
23 使用Spring注解方式管理事务与传播行为详解 
24 使用Spring配置文件实现事务管理 
25 搭建和配置Spring与Hibernate整合的环境 
26 Spring集成的Hibernate编码与测试 
27 Struts与Spring集成方案1(Struts集成Spring) 
28 Struts与Spring集成方案2(Spring集成Struts) 
29 为Spring集成的Hibernate配置二级缓存 
30 Spring提供的CharacterEncoding和OpenSessionInView功能 
31 使用Spring集成JPA 
32 Struts+Spring+JPA集成 
33 使用Spring集成Struts2 

Hibernate3.3要点：
01 hibernate介绍与动手入门体验
02 hibernate入门案例的细节分析
03 hibernate入门案例的代码优化
04 Session接口及get|load|persist方法
05 实体对象的三种状态与saveOrUpdate方法
06 完善HibernateUtil类及hql查询入门
07 实体类或属性名与数据库关键字冲突问题
08 hql的命名参数与Query接口的分页查询
09 Criteria查询方式
10 使用Hibernate完成CRUD实验的步骤说明
11 完成CRUD实验并回顾和补充细节知识（上）
12 完成CRUD实验并回顾和补充细节知识（下）
13 总结分析第一天的讲解内容
14 多对一关联关系的映射与原理分析
15 多对一关联关系的检索与原理分析
16 保存多对一关联关系的更进一步分析
17 一对多关联关系的映射与原理分析
18 一对一主键关联关系的映射与原理分析
19 一对一主键关联关系的检索
20 一对一外键关联关系的映射与原理分析
21 多对多关联关系的映射与原理分析
22 多对多关联关系的检索
23 组件关联关系的映射与原理分析
24 关联关系的总结
25 Hibernate中使用的集合类型
26 关联关系的级联操作
27 inverse属性的作用与原理分析
28 分析有序集合与多对多中的inverse属性
29 继承关系_整个继承树映射到一张表
30 继承关系_每个类映射到一张表
31 继承关系_鉴别器与内连接相结合
32 继承关系_每个具体类映射一张独立表
33 load方法的懒加载及原理分析
34 一对一的懒加载分析
35 一对多和多对多的懒加载分析
36 多对一与一对一的懒加载原理分析
37 懒加载的一些扩充细节
38 缓存的原理与模拟分析
39 hibernate的内部缓存分析
40 hibernate的二级缓存配置与分析
41 hibernate二级缓存的扩充细节
42 分布式缓存的分析与研讨
43 事务与事务边界的相关知识
44 OpenSessionInView模式的代码分析
45 OpenSessionInView的时序图与缺点分析
46 事务中的悲观锁与乐观锁
47 串讲hibernate配置文件中的配置项
48 串讲hibernate映射文件中的配置项
49 Hibernate映射类型
50 Session与SessionFactory的多线程问题
51 Session的内部缓存管理与批量更新
52 Hql与Criteria查询的补充知识
53 iterate查询与N+1此查询问题
54 Hibernate的拦截器与监听器
55 本地sql查询与命名查询
56 Hiberante的最佳实践

jar作用的详解：

spring.jar 是包含有完整发布模块的单个jar 包。但是不包括mock.jar, aspects.jar, spring-

portlet.jar, and spring-hibernate2.jar。

spring-src.zip就是所有的源代码压缩包。

除了spring.jar 文件，Spring 还包括有其它21个独立的jar 包，各自包含着对应的Spring组件，用户可以根据自己的需要来选择组合自己的jar 包，而不必引入整个spring.jar 的所有类文件。

spring-core.jar
这个jar 文件包含Spring 框架基本的核心工具类。Spring 其它组件要都要使用到这个包里的类，是其

它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。外部依赖Commons Logging， (Log4J)。

spring-beans.jar
这个jar 文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean 以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI 支持，引入spring-core.jar 及spring-beans.jar 文件就可以了。
外部依赖spring-core，(CGLIB)。

spring-aop.jar
这个jar 文件包含在应用中使用Spring 的AOP 特性时所需的类和源码级元数据支持。使用基于AOP 的Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个jar包。
外部依赖spring-core， (spring-beans，AOP Alliance， CGLIB，Commons Attributes)。

spring-context.jar
这个jar 文件为Spring 核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI 所需的全部类，instrumentation组件以及校验Validation 方面的相关类,外部依赖spring-beans, (spring-aop)。

spring-dao.jar
这个jar 文件包含Spring DAO、Spring Transaction 进行数据访问的所有类。为了使用声明型事务支持，还需在自己的应用里包含spring-aop.jar。外部依赖spring-core，(spring-aop， spring-context， JTA API)。

spring-jdbc.jar
这个jar 文件包含对Spring 对JDBC 数据访问进行封装的所有类。外部依赖spring-beans，spring-dao。

spring-support.jar
这个jar 文件包含支持UI模版（Velocity，FreeMarker，JasperReports），邮件服务，脚本服务(JRuby)，缓存Cache（EHCache），任务计划Scheduling（uartz）方面的类。外部依赖spring-context, (spring-jdbc, Velocity, FreeMarker, JasperReports, BSH, Groovy, JRuby, Quartz, EHCache)

spring-web.jar
这个jar 文件包含Web 应用开发时，用到Spring 框架时所需的核心类，包括自动载入Web Application Context 特性的类、Struts 与JSF 集成类、文件上传的支持类、Filter 类和大量工具辅助类。外部依赖spring-context, Servlet API, (JSP API, JSTL, Commons FileUpload, COS)。

spring-webmvc.jar
这个jar 文件包含Spring MVC 框架相关的所有类。包括框架的Servlets，Web MVC框架，控制器和视图支持。当然，如果你的应用使用了独立的MVC 框架，则无需这个JAR 文件里的任何类。外部依赖spring-web, (spring-support，Tiles，iText，POI)。

spring-portlet.jar
spring自己实现的一个类似Spring MVC的框架。包括一个MVC框架和控制器。外部依赖spring-web， Portlet API，(spring-webmvc)。

spring-struts.jar
Struts框架支持，可以更方便更容易的集成Struts框架。外部依赖spring-web，Struts。

spring-remoting.jar
这个jar 文件包含支持EJB、远程调用Remoting（RMI、Hessian、Burlap、Http Invoker、JAX-RPC）方面的类。外部依赖spring-aop， (spring-context，spring-web，Hessian，Burlap，JAX-RPC，EJB API)。

spring-jmx.jar
这个jar包提供了对JMX 1.0/1.2的支持类。外部依赖spring-beans，spring-aop， JMX API。

spring-jms.jar
这个jar包提供了对JMS 1.0.2/1.1的支持类。外部依赖spring-beans，spring-dao，JMS API。

spring-jca.jar
对JCA 1.0的支持。外部依赖spring-beans，spring-dao， JCA API。

spring-jdo.jar
对JDO 1.0/2.0的支持。外部依赖spring-jdbc， JDO API， (spring-web)。

spring-jpa.jar
对JPA 1.0的支持。外部依赖spring-jdbc， JPA API， (spring-web)。

spring-hibernate2.jar
对Hibernate 2.1的支持，已经不建议使用。外部依赖spring-jdbc，Hibernate2，(spring-web)。

spring-hibernate3.jar
对Hibernate 3.0/3.1/3.2的支持。外部依赖spring-jdbc，Hibernate3，(spring-web)。

spring-toplink.jar
对TopLink框架的支持。外部依赖spring-jdbc，TopLink。

spring-ibatis.jar
对iBATIS SQL Maps的支持。外部依赖spring-jdbc，iBATIS SQL Maps。另外的两个包。

spring-mock.jar
这个jar 文件包含Spring 一整套mock 类来辅助应用的测试。Spring 测试套件使用了其中大量mock 类，这样测试就更加简单。模拟HttpServletRequest 和HttpServletResponse 类在Web 应用单元测试是很方便的。并且提供了对JUnit的支持。外部依赖spring-core。

spring-aspects.jar
提供对AspectJ的支持，以便可以方便的将面向方面的功能集成进IDE中，比如Eclipse AJDT。外部依赖。WEAVER JARS (dist/weavers)说明。

spring-agent.jar
Spring的InstrumentationSavingAgent (为InstrumentationLoadTimeWeaver)，一个设备代理包，可以参考JDK1.5的Instrumentation功能获得更多信息。外部依赖none (for use at JVM startup: "-javaagent:spring-agent.jar")。

spring-tomcat-weaver.jar
扩展Tomcat的ClassLoader，使其可以使用instrumentation（设备）类。外部依赖none (for deployment into Tomcat's "server/lib" directory)。如果需要使用JSP语言作为Spring's web MVC tags的参数，则需要JSP 2.0的支持。或者选择Jakarta的JSTL (standard.jar)。如何选择这些发布包，决定选用哪些发布包其实相当简单。如果你正在构建Web 应用并将全程使用Spring，那么最好就使用单个全部的spring.jar 文件；如果你的应用仅仅用到简单的Inversion of Control / Dependency Injection（IoC/DI）容器，那么只需spring-core.jar与spring-beans.jar 即可；如果你对发布的大小要求很高，那么就得精挑细选了，只取包含自己所需特性的jar 文件了。采用独立的发布包你可以避免包含自己的应用不需要的全部类。当然你可以采用其它的一些工具来设法令整个应用包变小，节省空间的重点在于准确地找出自己所需的 Spring 依赖类，然后合并所需的类与包就可以了。Eclispe 有个插件叫ClassPathHelper 可以帮你找找所依赖的类

Hibernate一共包括了23个jar包，令人眼花缭乱。下载Hibernate，例如2.0.3稳定版本，解压缩，可以看到

一个hibernate2.jar和lib目录下有22个jar包：

hibernate2.jar:
Hibernate的库，没有什么可说的，必须使用的jar包

cglib-asm.jar:
CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库，必须使用的jar包

dom4j.jar:
dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。dom4j是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在IBM developerWorks上面可以找到一篇文章，对主流的Java XML API进行 的性能、功能和易用性的评测，dom4j无论在那个方面都是非常出色的。我早在将近两年之前就开始使 用dom4j，直到现在。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML，特别值得一提的 是连Sun的JAXM也在用dom4j。这是必须使用的jar包，Hibernate用它来读写配置文件。

odmg.jar:
ODMG是一个ORM的规范，Hibernate实现了ODMG规范，这是一个核心的库，必须使用的jar包。

commons-collections.jar：
Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使用的jar包。

commons-beanutils.jar：
Apache Commons包中的一个，包含了一些Bean工具类类。必须使用的jar包。

commons-lang.jar:
Apache Commons包中的一个，包含了一些数据类型工具类，是java.lang.*的扩展。必须使用的jar包。

commons-logging.jar:
Apache Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本身包含了一个Simple Logger，但是功能很弱。在运行的时候它会先在CLASSPATH找log4j，如果有，就使用log4j，如果没有，就找JDK1.4带的java.util.logging，如果也找不到就用Simple Logger。commons-logging.jar的出现是一个历史的的遗留的遗憾，当初Apache极力游说Sun把log4j加入JDK1.4，然而JDK1.4项目小组已经 接近发布JDK1.4产品的时间了，因此拒绝了Apache的要求，使用自己的java.util.logging，这个包的功能比log4j差的很远，性能也一般。 后来Apache就开发出来了commons-logging.jar用来兼容两个logger。因此用commons-logging.jar 写的log程序，底层的Logger是可以切换的，你可以选择log4j，java.util.logging或者它自带的 Simple Logger。不过我仍然强烈建议使用log4j，因为log4j性能很高，log输出信息时间几乎等于 System.out，而处理一条log平均只需要5us。你可以在Hibernate的src目录下找到Hibernate已经为你准备好了的log4j的配置文件，你只需要到Apache 网站去下载log4j就可以了。commons-logging.jar也是必须的jar包。 使用Hibernate必须的jar包就是以上的这几个，剩下的都是可选的。

ant.jar:
Ant编译工具的jar包，用来编译Hibernate源代码的。如果你不准备修改和编译Hibernate源代码，那么就没有什么用，可选的jar包

optional.jar：
Ant的一个辅助包。

c3p0.jar：
C3PO是一个数据库连接池，Hibernate可以配置为使用C3PO连接池。如果你准备用这个连接池，就需要这个jar包。

proxool.jar：
也是一个连接池，同上。

commons-pool.jar, commons-dbcp.jar:
DBCP数据库连接池，Apache的Jakarta组织开发的，Tomcat4的连接池也是DBCP。实际上Hibernate自己也实现了一个非常非常简单的数据库连接池，加上上面3个，你实际上可以在 Hibernate上选择4种不同的数据库连接池，选择哪一个看个人的偏好，不过DBCP可能更通用一些。另外强调一点，如果在EJB中使用Hibernate，一定要用App Server的连接池，不要用以上4种连接池，否则容器管理事务不起作用。

connector.jar:
JCA 规范，如果你在App Server上把Hibernate配置为Connector的话，就需要这个jar。不过实际上一般App Server肯定会带上这个包，所以实际上是多余的包。

jaas.jar:
JAAS是用来进行权限验证的，已经包含在JDK1.4里面了。所以实际上是多余的包。

jcs.jar：
如果你准备在Hibernate中使用JCS的话，那么必须包括它，否则就不用。

jdbc2_0-stdext.jar:
JDBC2.0的扩展包，一般来说数据库连接池会用上它。不过App Server都会带上，所以也是多余的。

jta.jar：
JTA规范，当Hibernate使用JTA的时候需要，不过App Server都会带上，所以也是多余的。

是Struts2框架默认的表达式语言—其实我们可以不掌握OGNL表达式，JSTL/EL来代替

相对EL表达式，它提供了平时我们需要的一些功能，如：

1. 支持对象方法调用。如xxx.sayHello()

2. 支持类静态方法调用和值访问，表达式的格式为@[类全名（包括包路径）]@[方法名|值名]，例如：@java.lang.String@format(‘foo%s’, ‘bar’)或者

@cn.itcast.Constant@APP_NAME

1.     操作类对象

ognl有一个上下文(Context)概念，说白了上下文就是一个MAP结构，它实现了java.utils.Map接口，在Struts2中上下文(Context)的实现为ActionContext，下面是上下文（Context）的结构示意图

Struts2中的OGNL实现者为AcionContext

当Struts2接收一个请求时，会迅速创建ActionContext，ValueStack，action，然后把action存放进ValueStack，所以action的实例变量可以被OGNL访问

访问上下文（Context）中的对象徐傲使用#符号标注命名空间，如#application，#session

另外OGNL会设定一个根对象（root对象），在Struts2中根对象就是ValueStack（值栈），如果要访问根对象（即ValueStack）中对象的属性，则可以省略#命名空间，直接访问该对象的属性即可。

在Struts2中，根对象ValueStack的实现为OgnlValueStack，该对象不是我们想象的只存放单个值，而是存放一组对象。在OgnlValueStack类里有一个List类型的root变量就是使用他存放一组对象。

在root变量中处于第一位的对象叫栈顶对象，通常我们在OGNL表达式里直接写上属性的名称即可访问root变量里对象的属性，搜索顺序是从栈顶对象开始寻找，如果栈顶对象不存在该属性，就会从第二个对象寻找，如果没有找到就到第三个对象寻找，依次往下访问，知道找到为止。

注意：Struts中，OGNL表达式是需要配合Struts标签才能使用，如:<s:property value=”name”/>

由于ValueStack（值栈）是Struts2中OGNL的根对象，如果用户需要访问值栈中的对象，在JSP页面可以直接通过下面的EL表达式访问ValueStack（值栈）中对象的属性：

${foo} //获得值栈中某个对象的foo属性

如果访问其他Context中的对象，由于他们不是根对象，所以在访问时，需要添加#前缀

application对象：用于访问ServletContext，例如#application.userName或者#application[‘userName’]，相当于调用ServletContext的getAttribute(“username”)

session对象：用来访问HttpSession。例如#session.userName或者#session[‘userName’]，相当于调用session.getAttribue(“userName”)

request对象：用来访问HttpServletRequest属性（attribute）的Map，例如#request.userName或者#request[‘userName’],相当于调用request.getAttribute(“username”)

parameters对象：用于访问HTTP的请求参数，例如#parameters.userName或者

#parameters[‘userName’]，

相当于调用request.getParameter(“username”)

attr对象：用于按page->request->session->application顺序访问其属性

为什么EL表达式能够访问valueStack中对象的属性？

因为Struts2对HttpServletRequest做了进一步的封装

采用OGNL，不能访问四大作用域中的变量，只能访问ValueStack中的变量

采用OGNL表达式创建一个List/Map集合对象

如果需要一个集合元素的时候（例如List对象或者Map对象），可以使用OGNL中同集合相关的表达式。

例如使用如下代码直接生成一个List对象：

<s:set name=”list” value=”{‘zhangming’,’xiaoli’,’liming’}”/>

<s:iterator value=”#list”>

    <s:property /><br/>

</s:iterator>

set标签用于将某个值放入指定范围

scope：指定变量被放置的范围，该属性可以接受application、session、request、page或者action。如果没有设置该属性，则默认放置在OGNL Context中

value：赋给变量的值，如果没有设置该属性，则将valueStack栈顶的值赋给变量

生成一个Map对象

<s:set name=”foobar” value=”#{‘foo1’:’bar1’,’foo2’:’bar2’}” />

<s:iterator value=”#foobar” >

    <s:property value=”key”>=<s:property value=”value”/>

</s:iterator>

采用OGNL表达式判断对象是否存在于集合中：

对于集合类型，OGNL表达式可以使用in和not in两个元素符号，其中，in表达式用来判断某个元素是否在指定的集合对象中，not in判断某个元素是否不在指定的集合对象中，如下所示。

in表达式：

<s:if test=”’foo’ in {‘foo’,’bar’}>

    zai

</s:if>

<s:else>

    bu zai

</s:else>

not in 表达式：

<s:if test”’foo’ not in {‘foo’,’bar’}>

    bu zai

</s:if>

<s:else>

    zai

</s:else>

OGNL表达式的投影功能---一般不适用，我们一般会在业务层把满足条件的对象归结出来

除了in和not in之外，OGNL还允许使用某个规则获得集合对象的子集，场用的有以下3个相关操作符。

?:获得所有符合逻辑的元素

^:获得符合逻辑的第一个元素

$:获得符合逻辑的最后一个元素

例如代码：

<s:iterator value=”books.{?#this.price > 35}”>

    <s:property value=”title”/>-$<s:property value=”price” /><br/>

</s:iterator>

在上面的代码中，直接在集合后紧跟.{}运算符取出该集合的子集，{}内的表达式用于获取符合条件的元素，this指的是为了从大集合books筛选数据到小集合，需要对大集合books进行迭代，this代表当前迭代的元素。本例的表达式用于获取集合中价格大于35的书集合

books.{?#this.price > 35}

books.{……}： 要从大集合中，筛选出满足……这个条件的子集合放到value中

?：表示符合逻辑的元素

#this:迭代大集合的当前元素


 

二十四、Struts2 标签使用

property标签使用

<s:set name=”name” value=”kk” />

<s:property value=”#name” />

default:可选属性，如果需要输出的属性值为NULL，则显示该属性指定的值

escape:可选属性，指定是否格式化HTML代码。

value:可选属性，指定需要输出的属性值，如果没有指定该属性，则默认输出valueStack栈顶的值

id:可选属性，指定该元素的标识

iterator 迭代标签

iterator标签对于集合进行迭代，这里的集合包含List、Set和数组

<s:set name="list" value="{'zhangming','xiaoi','liming'}"/>

<s:iterator value="#list" status="st">

    <font color=<s:if test="#st.odd">red</s:if><s:else>blue</s:else>>

    <s:property /></font>/<br>

</s:iterator>

value:可选属性，指定被迭代的集合，如果没有设置该属性，则使用ValueStack栈顶的集合

id:可选属性，指定集合里元素的id（已被标注为过时）

status:可选属性，该属性指定迭代时的iteratorStatus实例，该实例包含如下几个方法：

    int getCount(),返回当前迭代了几个元素

    int getIndex(),返回当前迭代元素的索引

    Boolean isEven(),返回当前被迭代元素的索引是否是偶数

    Boolean isOdd(),返回当前被迭代元素的索引是否是奇数

    Boolean isFirst(),返回当前被迭代元素是否是第一个元素

    Boolean isLast(),返回当前被迭代元素是否是最后一个元素

if/elseif/else 逻辑判断

s:set name="age" value="323" scope="request"/>

<s:if test="#request.age==23">

    23

</s:if>

<s:elseif test="#request.age==21">

    21

</s:elseif>

<s:else>

    都不等

</s:else>

url标签

<a href="<s:url action="helloworld_add" namespace="/test"><s:param name="personid" value="233"/></s:url>">ssss</a>

<s:set name="myurl" value="'http://www.foshanshop.net'"/>

<s:url value="%{#myurl}" /><br>

checkboxlist复选框/radio 单选框/select下拉列表框

    集合为list:

<s:checkboxlist name="list"

list="{'Java','.Net','RoR','PHP'}" value="{'Java','.Net'}"/><br/>

    集合为map:

<s:checkboxlist name="map" list="#{1:'瑜珈用品',2:'户外用品',3:'球类',4:'自行车'}"

     listKey="key" listValue="value" value="{1,2,3}"/><br/>

     <s:radio name="raido1" list="#{1:'瑜珈用品',2:'户外用品',3:'球类',4:'自行车'}" listKey="key" listValue="value" value="1"/>

     <br/>

     <s:select name="se" list="#{1:'瑜珈用品',2:'户外用品',3:'球类',4:'自行车'}" listKey="key" listValue="value" value="1"/>

 <!-- 默认的视图主题,即不需要struts2在页面为我们输出一些代码 -->

<constant name="struts.ui.theme" value="simple" />


 

二十五、国际化

目前对笔者不适用，由于时间紧迫，不再记录

request—>StrutsPrepareAndExecuteFilteràInterceptor(Struts2内置的一些拦截器或用户自定义拦截器)àAction(用户编写的Action，类似Struts1中的Action)àResult(类似Struts1中的forward)àJsp/Htmlàresponse

StrutsPrepareAndExccuterFilter是Struts2框架的核心控制器，它负责拦截由<url-pattern>/*</url-pattern>指定的所有用户请求，当用户请求到达时，该Filter会过滤用户的请求。默认情况下，如果用户请求的路径不带后缀或者后缀以.action结尾，这时请求将被转入Struts2框架处理，否则Struts2框架将过滤该请求的处理。当请求转入Struts2框架处理时会经过一系列的拦截器，然后再转到Action。与Struts1不同，Struts2对用户每一次请求都会创建一个Action，所以Struts2的Action是线程安全的

十四、Struts2指定多个配置文件

将配置文件以模块进行划分，然后通过include导入

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC

    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>

    <include file="struts-user.xml"></include>

    <include file="struts-trade.xml"></include>

</struts>

十五、Struts2动态方法调用(在Struts2.1版本文档中已经不推荐使用了)

如果在action中存在多个方法时，我们可以使用!+方法方法名调用指定的方法，如下：

public class HelloWorldAction{

    private String message;

    public String getMessage(){

       return message;

}

public String execute() throws Exception{

    this.message = “我是execute方法”

    return “success”;

}

public String other() throw Exception{

    this.message = “我是other方法”;

}

}

假设访问上面的action的URL路径为：/struts2/test/helloworld.action

要访问action的other方法，我们可以这样调用：

/struts2/test/helloworld!other.action

如果不想使用动态方法调用，我们可以通过常量

struts.enable.DynamicMethodInvocation关闭动态方法调用.

<constant name=”struts.enable.DynamicMethodInvocation” value=”false”/>

Struts2使用通配符定义action(官方推荐)

<package name=”employee”

namespace=”/control/employee” extends=”struts-default”>

    <action name=”list_*”

class=”cn.itcast.action.HellWorldAction method=”{1}”>

<result name=”success”>

    /WEB-INF/page/message.jsp

</result>

    </action>

</package>

注：

a). *通配符可以添加多个如: list_*_*_*

b). method=”{1}” 表示取第一个*

c). 通配符可以放置多个地方如 class、result中

十六、Struts2 请求参数的接受

以下两种方法，当参数比较多的时候，用第一种方法，将会发现action中有很多setter、getter方法，这样不利于阅读action，所以建议使用第二种。

a). 采用基本类型接收请求参数(get/post)

在Action类中定义与请求参数同名的属性，Struts2便能接受请求参数并赋值给同名属性：

如：请求路径，http://localhost:8080/test/view.action?id=78

public class ProductAction{

    private Integer id;

    //struts2通过反射技术调用与请求参数同名的属性的setter方法来获取请求参数值

    public void setId(Integer id) {

       this.id = id;

}

public Integer getId{

    return id;

}

}

b). 采用符合类型接收请求参数

如：请求路径，http://localhost:8080/test/view.action?product.id=78

public class ProductAction{

    private Product product;

    public void setProduct(Product product) {

       this.product = product;

}

public Product getProduct() {

    return product;

}

}

Struts2首先通过反射技术调用Product的默认构造器创建product对象然后在通过反射技术调用product中与请求参数同名的属性的setter方法来获取请求参数

十七、Struts2有两种类型转换器

局部类型转换器/全部类型转换器

a). 自定义转换类型

package cn.itcast.type.converter;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Map;

import com.opensymphony.xwork2.conversion.impl.DefaultTypeConverter;

publicclass DateTypeConverter extends DefaultTypeConverter {

    @Override

    public Object convertValue(Map<String, Object> context, Object value, Class toType) {

       SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");

       try {

           if(toType == Date.class){//当字符串向Date类型转换时

              String[] params = (String[]) value;// request.getParameterValues()

              return dateFormat.parse(params[0]);

           }elseif(toType == String.class){//当Date转换成字符串时

              Date date = (Date) value;

              return dateFormat.format(date);

           }

       } catch (ParseException e) {}

       returnnull;

    }

}

完成具体的双向转化代码后，需要将上面的类型注册为局部类型转换器：

在Action类所有的包下放置ActionClassName-conversion.properties文件，ActionClassName是Action的类名，后面的-conversion.properties是固定写法，对于本例而言，文件的名称应为HelloWroldAction-conversion.properties。

properties文件中的内容为：

birthday=cn.itcast.type.converter.DateTypeConverter

b).自定义全局类型转换器

将上面的局部类型转换器注册为全局类型转换器：

在WEB-INF/classes下放置xwork-conversion.properties文件。在properties文件中的内容为：

待转换的类型=类型转换器的全类名

java.util.Date=cn.itcast.conversion.DateConverter

十八、访问或添加request/session/application属性

import java.util.Arrays;

import javax.servlet.ServletContext;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionContext;

public class HelloWorldAction {

    public String execute(){

       ActionContext ctx = ActionContext.getContext();

       ctx.getApplication().put("app", "应用范围");//往ServletContext里放入app

       ctx.getSession().put("ses", "session范围");//往session里放入ses

       ctx.put("req", "request范围");//往request里放入req

       ctx.put("names", Arrays.asList("老张", "老黎", "老方"));

       return "message";

    }

    public String rsa() throws Exception{

       HttpServletRequest request = ServletActionContext.getRequest();

       ServletContext servletContext = ServletActionContext.getServletContext();

       request.setAttribute("req", "请求范围属性");

       request.getSession().setAttribute("ses", "会话范围属性");

       servletContext.setAttribute("app", "应用范围属性");

       //HttpServletResponse response = ServletActionContext.getResponse();

       return "message";

    }

}

备注：ognl表达式其实完全可以通过JSTL、EL结合来代替ognl

struts.configuration

该属性指定加载Struts 2配置文件的配置文件管理器。该属性的默认值是org.apache.Struts2.config.DefaultConfiguration，这是Struts 2默认的配置文件管理器。如果需要实现自己的配置管理器，开发者则可以实现一个实现Configuration接口的类，该类可以自己加载Struts 2配置文件。

struts.locale

指定Web应用的默认Locale。 

struts.i18n.encoding

指定Web应用的默认编码集。该属性对于处理中文请求参数非常有用，对于获取中文请求参数值，应该将该属性值设置为GBK或者GB2312。

提示：当设置该参数为GBK时，相当于调用HttpServletRequest的setCharacterEncoding方法。

struts.objectFactory

指定Struts 2默认的ObjectFactory Bean，该属性默认值是spring。

struts.objectFactory.spring.autoWrite

指定Spring框架的自动装配模式，该属性的默认值是name，即默认根据Bean的name属性自动装配。

struts.objectFactory.spring.useClassCache

该属性指定整合Spring框架时，是否缓存Bean实例，该属性只允许使用true和false两个属性值，它的默认值是true。通常不建议修改该属性值。

struts.objectTypeDeterminer

该属性指定Struts 2的类型检测机制，通常支持tiger和notiger两个属性值。

struts.multipart.parser

该属性指定处理multipart/form-data的MIME类型（文件上传）请求的框架，该属性支持cos、pell和jakarta等属性值，即分别对应使用cos的文件上传框架、pell上传及common-fileupload文件上传框架。该属性的默认值为jakarta。

注意如果需要使用cos或者pell的文件上传方式，则应该将对应的JAR文件复制到Web应用中。例如，使用cos上传方式，则需要自己下载cos框架的JAR文件，并将该文件放在WEB-INF/lib路径下。

struts.multipart.saveDir

该属性指定上传文件的临时保存路径，该属性的默认值是javax.servlet.context.tempdir。

struts.multipart.maxSize

该属性指定Struts 2文件上传中整个请求内容允许的最大字节数。

struts.custom.properties

该属性指定Struts 2应用加载用户自定义的属性文件，该自定义属性文件指定的属性不会覆盖struts.properties文件中指定的属性。如果需要加载多个自定义属性文件，多个自定义属性文件的文件名以英文逗号（,）隔开。

struts.mapper.class

指定将HTTP请求映射到指定Action的映射器，Struts 2提供了默认的映射器：org.apache.struts2.dispatcher.mapper.DefaultActionMapper。默认映射器根据请求的前缀与Action的name属性完成映射。

struts.action.extension

该属性指定需要Struts 2处理的请求后缀，该属性的默认值是action，即所有匹配*.action的请求都由Struts 2处理。如果用户需要指定多个请求后缀，则多个后缀之间以英文逗号（,）隔开。

struts.serve.static

该属性设置是否通过JAR文件提供静态内容服务，该属性只支持true和false属性值，该属性的默认属性值是true。

struts.serve.static.browserCache

该属性设置浏览器是否缓存静态内容。当应用处于开发阶段时，我们希望每次请求都获得服务器的最新响应，则可设置该属性为false，生产环境下可以缓存。 

struts.enable.DynamicMethodInvocation

该属性设置Struts 2是否支持动态方法调用，该属性的默认值是true。如果需要关闭动态方法调用，则可设置该属性为false。

struts.enable.SlashesInActionNames

该属性设置Struts 2是否允许在Action名中使用斜线，该属性的默认值是false。如果开发者希望允许在Action名中使用斜线，则可设置该属性为true。

struts.tag.altSyntax

该属性指定是否允许在Struts 2标签中使用表达式语法，因为通常都需要在标签中使用表达式语法，故此属性应该设置为true，该属性的默认值是true。

struts.devMode

该属性设置Struts 2应用是否使用开发模式。如果设置该属性为true，则可以在应用出错时显示更多、更友好的出错提示。该属性只接受true和flase两个值，该属性的默认值是false。通常，应用在开发阶段，将该属性设置为true，当进入产品发布阶段后，则该属性设置为false。

struts.i18n.reload

该属性设置是否每次HTTP请求到达时，系统都重新加载资源文件。该属性默认值是false。在开发阶段将该属性设置为true会更有利于开发，但在产品发布阶段应将该属性设置为false。

提示：开发阶段将该属性设置了true，将可以在每次请求时都重新加载国际化资源文件，从而可以让开发者看到实时开发效果；产品发布阶段应该将该属性设置为 false，是为了提供响应性能，每次请求都需要重新加载资源文件会大大降低应用的性能。

struts.ui.theme

该属性指定视图标签默认的视图主题，该属性的默认值是xhtml。

struts.ui.templateDir

该属性指定视图主题所需要模板文件的位置，该属性的默认值是template，即默认加载template路径下的模板文件。

struts.ui.templateSuffix

该属性指定模板文件的后缀，该属性的默认属性值是ftl。该属性还允许使用ftl、vm或jsp，分别对应FreeMarker、Velocity和JSP模板。

struts.configuration.xml.reload

该属性设置当struts.xml文件改变后，系统是否自动重新加载该文件。该属性的默认值是false，开发阶段很实用。

struts.velocity.configfile

该属性指定Velocity框架所需的velocity.properties文件的位置。该属性的默认值为velocity.properties。

struts.velocity.contexts

该属性指定Velocity框架的Context位置，如果该框架有多个Context，则多个Context之间以英文逗号（,）隔开。

struts.velocity.toolboxlocation

该属性指定Velocity框架的toolbox的位置。

struts.url.http.port

该属性指定Web应用所在的监听端口。该属性通常没有太大的用处，只是当Struts 2需要生成URL时（例如Url标签），该属性才提供Web应用的默认端口。

struts.url.https.port

该属性类似于struts.url.http.port属性的作用，区别是该属性指定的是Web应用的加密服务端口。

struts.url.includeParams

该属性指定Struts 2生成URL时是否包含请求参数。该属性接受none、get和all三个属性值，分别对应于不包含、仅包含GET类型请求参数和包含全部请求参数。

struts.custom.i18n.resources

该属性指定Struts 2应用所需要的国际化资源文件，如果有多份国际化资源文件，则多个资源文件的文件名以英文逗号（,）隔开。

struts.dispatcher.parametersWorkaround

对于某些Java EE服务器，不支持HttpServlet Request调用getParameterMap()方法，此时可以设置该属性值为true来解决该问题。该属性的默认值是false。对于 WebLogic、Orion和OC4J服务器，通常应该设置该属性为true。

struts.freemarker.manager.classname

该属性指定Struts 2使用的FreeMarker管理器。该属性的默认值是org.apache.struts2.views.freemarker.FreemarkerManager，这是Struts 2内建的FreeMarker管理器。

struts.freemarker.wrapper.altMap

该属性只支持true和false两个属性值，默认值是true。通常无需修改该属性值。

struts.xslt.nocache

该属性指定XSLT Result是否使用样式表缓存。当应用处于开发阶段时，该属性通常被设置为true；当应用处于产品使用阶段时，该属性通常被设置为false。

struts.configuration.files

该属性指定Struts 2框架默认加载的配置文件，如果需要指定默认加载多个配置文件，则多个配置文件的文件名之间以英文逗号（,）隔开。该属性的默认值为struts- default.xml,struts-plugin.xml,struts.xml，看到该属性值，读者应该明白为什么Struts 2框架默认加载struts.xml文件了。

A：
<s:a xhref=""></s:a>-----超链接，类似于html里的<a></a>
<s:action name=""></s:action>-----执行一个view里面的一个action
<s:actionerror/>-----如果action的errors有值那么显示出来
<s:actionmessage/>-----如果action的message有值那么显示出来
<s:append></s:append>-----添加一个值到list，类似于list.add();
<s:autocompleter></s:autocompleter>-----自动完成<s:combobox>标签的内容，这个是ajax

B：
<s:bean name=""></s:bean>-----类似于struts1.x中的，JavaBean的值

C：
<s:checkbox></s:checkbox>-----复选框
<s:checkboxlist list=""></s:checkboxlist>-----多选框
<s:combobox list=""></s:combobox>-----下拉框
<s:component></s:component>-----图像符号

D：
<s:date/>-----获取日期格式
<s:datetimepicker></s:datetimepicker>-----日期输入框
<s:debug></s:debug>-----显示错误信息
<s:div></s:div>-----表示一个块，类似于html的<div></div>
<s:doubleselect list="" doubleName="" doubleList=""></s:doubleselect>-----双下拉框

E：
<s:if test=""></s:if>
<s:elseif test=""></s:elseif>
<s:else></s:else>-----这3个标签一起使用，表示条件判断

F：
<s:fielderror></s:fielderror>-----显示文件错误信息
<s:file></s:file>-----文件上传
<s:form action=""></s:form>-----获取相应form的值

G：
<s:generator separator="" val=""></s:generator>----和<s:iterator>标签一起使用

H：
<s:head/>-----在<head></head>里使用，表示头文件结束
<s:hidden></s:hidden>-----隐藏值

I：
<s:i18n name=""></s:i18n>-----加载资源包到值堆栈
<s:include value=""></s:include>-----包含一个输出，servlet或jsp页面
<s:inputtransferselect list=""></s:inputtransferselect>-----获取form的一个输入
<s:iterator></s:iterator>-----用于遍历集合

L：
<s:label></s:label>-----只读的标签

M：
<s:merge></s:merge>-----合并遍历集合出来的值

O：
<s:optgroup></s:optgroup>-----获取标签组
<s:optiontransferselect doubleList="" list="" doubleName=""></s:optiontransferselect>-----左右选择框

P：
<s:param></s:param>-----为其他标签提供参数
<s:password></s:password>-----密码输入框
<s:property/>-----得到'value'的属性
<s:push value=""></s:push>-----value的值push到栈中,从而使property标签的能够获取value的属性

R：
<s:radio list=""></s:radio>-----单选按钮
<s:reset></s:reset>-----重置按钮

S：
<s:select list=""></s:select>-----单选框
<s:set name=""></s:set>-----赋予变量一个特定范围内的值
<s:sort comparator=""></s:sort>-----通过属性给list分类
<s:submit></s:submit>-----提交按钮
<s:subset></s:subset>-----为遍历集合输出子集

T：
<s:tabbedPanel id=""></s:tabbedPanel>-----表格框
<s:table></s:table>-----表格
<s:text name=""></s:text>-----I18n文本信息
<s:textarea></s:textarea>-----文本域输入框
<s:textfield></s:textfield>-----文本输入框
<s:token></s:token>-----拦截器
<s:tree></s:tree>-----树
<s:treenode label=""></s:treenode>-----树的结构

U：
<s:updownselect list=""></s:updownselect>-----多选择框
<s:url></s:url>-----创建url 
 
 

2.Framework的概念
框架是人们用于解决相同或者相似类型问题的方案
特点：可重用性，可扩展性，可收缩性。基于请求响应（request-response）模式的应用Framework的逻辑结构
控制器：Controller
业务逻辑层：Business Logic
数据逻辑层：Data Logic

3.Struts的概念和体系结构
Struts是Apache组织的一个开源项目，主要是采用Servlet和JSP技术来实现的
Struts是一个基于Sun JavaEE平台的MVC框架，它采用MVC模式，将MVC模式分离显示逻辑和业务逻辑的能力，发挥的淋漓尽致
(Struts is a flexible control layer based on standard technologies like Java Servlets,JavaBeans,ResourceBundles,and XML,as well as various Jakarta Commons packages,like BeanUtils and Chain of Responsibility.The frameword helps you create an extensible developmnt environment for your application,based on published standards and proven design patterns)

4.Struts的实践步骤
步骤一：搭建环境
 a.导入jar包，使用其中的类
 b.建立一个配置文件，struts=config.xml
        方便struts用户使用
        一般在WEB=INF下
 c.修改web.xml
         注册struts中心控制器 --ActionServlet

<serlet>
    <servlet-name></servlet-name>
    <servlet-class></servlet-class>
    <init-param> <!-- 初始化加载配置文件 -->
        <param-name>config</param-name>
        <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup> <!-- web容器启动就加载该servlet -->
</serlet>

<servlet-mapping> <!-- 该servlet对外调用的映射 -->
    <servlet-name></servlet-name>
    <url-pattern></url-pattern>
</servlet-mapping>

 
步骤二：建立ActionForm
步骤三：建立Action
 建立一个类，继承Action，覆盖execute方法
 注册，修改配置文件struts-config.xml
  path：指明调用者（jsp）能通过中心控制器ActionServlet找到该Action
  type：指明该action类全名
  name：该action引用的form的名称

步骤四：页面访问

5.Struts的工作原理
6.Struts的组件
7.Struts的配置文件简介
8.Struts标记库
9.异常处理框架
10.校验框架
11.高级特性
12.Struts优缺点
优点：
　　Struts跟Tomcat、Turbine等诸多Apache项目一样，是开源软件，这是它的一大优点。使开发者能更深入的了解其内部实现机制。除此之外，Struts的优点主要集中体现在两个

方面：Taglib和页面导航。Taglib是Struts的标记库，灵活动用，能大大提高开发效率。另外，就目前国内的JSP开发者而言，除了使用JSP自带的常用标记外，很少开发自己的标

记，或许Struts是一个很好的起点。
　　关于页面导航，我们认为那将是今后的一个发展方向，事实上，这样做，使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维

护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。

缺点：
　　Taglib是Struts的一大优势，但对于初学者而言，却需要一个持续学习的过程，甚至还会打乱我们网页编写的习惯，但是，当我们习惯了它时，我们会觉得它真的很棒。

Struts将MVC的Controller一分为三，在获得结构更加清晰的同时，也增加了系统的复杂度。毫无疑问，要理解 Struts 必须接受一定的培训。随着变化的不断加入，这有时会令人

很沮丧。
　　Struts从产生到现在还不过3-4年时间，就已逐步越来越多运用于商业软件。虽然它现在还有不少缺点，但它是一种非常优秀的J2EE MVC实现方式，如果我们的系统准备采用

J2EE MVC架构，那么，不妨考虑一下Struts。
　　Struts 是一种基于 Web 的 MVC 解决方案，所以必须用 HTML、JSP 文件和 servlet 来实现它，Struts 需要支持 JSP 1.1 和 Servlet 2.2 规范的 servlet 容器。学习、理

解和掌握Struts是我们每个基于J2EE软件开发人员一门必修的课程，也是我们对企业J2EE技术应用的进一步深化。

/************************************************************************************************/

Struts的基本组件包

org.apache.struts.action
　基本上，控制整个struts framework的运行的核心类、组件都在这个包中，比如我们上面提到的控制器ActionServlet。已经Action,ActionForm,ActionMapping等等。struts1.1比1.0多了 DynaActionForm 类。增加了动态扩展生成FormBean功能

org.apache.struts.actions
　这个包是主要作用是提供客户的http请求和业务逻辑处理之间的特定适配器转换功能，而1.0版本中的部分动态增删FromBean的类，也在struts1.1中被Action包的DynaActionForm组件所取代

org.apache.struts.config
　提供对配置文件struts-config.xml元素的映射。这也是sturts1.1中新增的功能

org.apache.struts.util
　Strtuts为了更好支持web application的应用，体统了一个些常用服务的支持，比如Connection Pool和Message Source。

org.apache.struts.taglib
　这不是一个包，而是是一个客户标签类的集合。下面包括Bean Tags，HTML Tags，Logic Tags，Nested Tags，Template Tags这几个用于构建用户界面的标签类。

org.apache.struts.validator
　Struts1.1 framework中增加了validator framework，用于动态的配置from表单的验证。

/************************************************************************************************/
核心Struts 类和MVC 的对应

类                                                                           描述
ActionForward                                           用户指向或者视图选择
ActionForm                                                状态改变的数据
ActionMapping                                           状态改变事件
ActionServlet                                              控制器，接受用户请求和状态改变，以及发出视图选择
Action                                                        控制器的一部分，于模型交互，执行状态改变或状态查询，
                                                                以及告诉ActionServlet 下一个选择的视图

/************************************************************************************************/
Struts 使用一些配置文件和视图助手（view helpers）来沟通控制器和模型
ApplicationResources.properties                                   存储本地化信息和标签，以使应用可以国际化
struts-config.xml                                                            存储控制器对象的缺省配置，包括模型支持的用户指向，状态改变，状态查询

标记库描述符                                                           目的
struts-html.tld                                               扩展HTML Form的JSP标记
struts-bean.tld                                              扩展处理JavaBean的JSP标记
struts-logic.tld                                              扩展测试属性值的JSP标记

/************************************************************************************************/
控制器组件的配置框架中的控制器组件是有org.apache.struts.action.ActionServlet类实现的，这个类是javax.servlet.http.HttpServlet类的扩展。
ActionServlet配置：我们需要在web.xml中声明ActionServlet，并且将它配置成启动时进行加载。以下为可以配置的初始化参数：
参数                                                         默认值                                                                        描述
application                                                    Null                                                                应用程序的资源集合的类
bufferSize                                                     4096                                                                文件上传的缓冲区大小
config                                            /WEB-INF/struts-config.xml                                        配置文件的位置和名称
content                                                       Text/html                                                                     默认的内容类型
debug                                                              0                                                                          程序调试的级别
detail                                                               0                                                                         程序调试细节的级别
factory                                                         Null                                                 消息资源工厂，用于国际化中解释消息资源
formBean                            org.apache.struts.action.ActionFormBean                         封装ActionForm bean信息的类的名称
forward                              Org.apache.struts.action.ActionForward                          封装ActionForward对象信息的类的名称
locale                                                          True                                                        为true,将在用户会话中存储一个本地对象
mapping                            Org.apache.struts.action.ActionForward                              封装ActionMapping信息的类的名称
maxFileSize                                                250M                                                                 上传文件的最大尺寸
multipartClass                   Org.apache.struts.action.ActionForward                                处理多部分请求的类的名称
noCache                                                      False                                                      HTTP标头是否要设置为禁止缓寸
Null                                                             True                                                       设置为true，对于无效的信息关键字将返回null
tempDir                           作为一个servlet参数提供给程序的工作目录                        处理下载文件是使用的临时工作目录
validate                                                        True                                                              是否使用新格式的配置文件
vallidating                                                     True                                                              是否对配置文件进行有效性分析