Struts in Action读书笔记

转自  http://blog.csdn.net/Jiangcx/archive/2008/03/31/2234196.aspx
用了这么长时间的Struts，却从来没有完整地看完一本书，经过一段时间Qone的开发，更是发现了对Struts掌握的不够好，终于完整地把《Struts  in  Action》看了一遍，发现很多以前不会的东东，这本书不错，从原理到实践，都讲的很好。希望以后能有时间再看几遍。现将读书笔记贴在这儿留作纪念。笔记写的很简单，只是捡一些自己不会的或认为很重要的记了一下，看的是英文版，很多不知道怎么翻译的，也直接摘的英文原句。不推荐大家参考我的笔记，呵呵。


Struts In Action

----Building web applications with the leading Java framework

第一部分 初识Struts
<!--[if !supportLists]-->第一章   <!--[endif]-->简介
1.1本书宗旨
本书旨在帮助web开发者更好地使用Struts web应用程序框架。Struts基于一些标准的技术，例如Java Beans，Java Servlets，JSP等。Struts能帮助web开发者快速简单地构建web应用。

1.1.1谁创建了Struts
Struts是Apache Software Fundation的Jakarta项目的一部分。Struts的主要架构师和开发者是Craig R. McClanahan。

1.1.2 Struts为何开源
         几乎所有的Java工具和框架都是开源的，开源框架对大家来说是双赢的。

1.1.3 为什么叫做Struts
         Struts名称用以提醒我们结构的重要性。

1.2 什么是应用程序框架
         框架是一个可复用的，半成品的应用，可以被特殊化以生产定制化的应用程序。

1.2.1 其他类型的框架
         Lucene，Scaffold Toolkit，Struts Validator，Tiles tag Library。

1.3 必需的技术
         这些技术也是所有Java web应用必需的技术。

1.3.1 HTTP
         Web应用使用HTTP来在浏览器端和服务器端之间传输数据。HTTP是一种无状态的协议。HTTP能成为通用标准的一个原因在于它的简单性，HTTP请求和相应都是简单的文本文档。

         由于HTTP是无状态的，这使跟踪使用者和请求很成问题，通常的两种方法是使用Cookies和URL重写。Cookie是用户电脑上的特殊的信息包。URL重写在页面地址中存储一种特殊的引用用来跟踪使用者。

1.3.2 CGI（Common Gateway Interface）
         第一种被广泛使用的用来创造动态内容的标准是CGI。CGI使用标准的操作系统特性，例如环境变量或者标准I/O在web服务器和主机的其他应用程序之间创建一个桥或网关，其他应用程序可以查看web服务器发送给它的请求并创建定制化的响应。

         CGI的两个缺点：为每个请求创建CGI程序，操作系统不可移植。

1.3.3 Java Servlets
         Java Servlet平台关注了CGI的两个缺点，一是更好的性能和资源利用率，二是Java的操作系统可移植性。

         为使通用的Web服务器可以访问servlets，servlets被插放在容器中。

         与CGI程序不同，并不对每个request创建一个新的servlet，只是为每一个请求创建一个线程，Java 线程比CGI程序使用的服务器端进程要节省资源。

1.3.4 JavaServer Pages
         Java Servlets使页面设计和业务逻辑处理混在一起，无法实现明确的分工。

         为向页面引入动态元素，开发者可以在HTML中插入JSP脚本元素，共有三种：expressions（<%=%>），Scriplet（<%%>）和declarations（<%!%>）。

         一个JSP页面实际就是一个Java Servlet。

1.3.5 JSP标签
         Scritplet快速、简单、强大，但是把java代码和HTML混合在一起，一个更好的选择是使用JSP标签。

         大部分的Struts开发者使用JSP和自定义的标签来创造应用中的动态内容。

1.3.6 JavaBean
         页面的动态数据可以使用一个JavaBean来传递，JSP标签可以使用这个JavaBean的属性来定制动态内容。

1.3.7 Model 2
         Servlet/JSP的0.92发布版把在同一个应用中使用JSP和Servlet的体系结构描述为Model 2。

         Struts框架基于Model 2，并提供了一个基础的自定义标签库，使Struts更易使用。

1.4 高瞩远瞻Struts
         Struts使用Model 2体系结构，Struts的ActionServlet控制导航流。Struts的Action类用来访问业务类，当ActionServlet从容器接受到一个request时，它使用URI来决定使用哪一个Action来处理这个request。Action可以验证输入和从业务层获取来自数据库或其他数据设备的信息。

         为了获取输入数据，Action并不是从request中获取所有的数据，而是ActionServlet将输入都绑定到一个JavaBean，输入beans都是Struts的ActionForm类的子类。ActionServlet通过request的路径来决定使用哪个ActionForm。ActionForm都继承自org.apache.struts.action.ActionForm。

    每一个HTTP的request，都要使用一个HTTP的response来回答。通常，Struts的Action不直接产生response，而是跳转到另外的资源如JSP。Struts提供了ActionForward类，可以用来使用逻辑名称来存储到达一个页面的路径。Action向Servlet选择和返回一个ActionForward， Servlet使用存储在ActionForward对象中的路径来调用页面和完成response。

         Struts将这些详细信息都绑定到一个ActionMapping对象中，每一个ActionMapping都与一个特定的路径相关，当这个路径被请求时，Servlet获取ActionMapping对象，这个对象告诉 Servlet使用哪一个Action，ActionForm和ActionForward。

         所有这些详细信息，Action，ActionForm，ActionMapping，ActionForward，都在struts-config.xml文件中声明。ActionServlet在启动时读取此文件并创建一个配置对象的数据库。在运行时Struts引用这些对象，而不是文件本身。

1.4.1 构建一个简单应用
         这个应用用来注册用户名和密码，通过这个实例可以接触到使用struts来开发应用的方方面面。

1.4.2 开发前的准备
         所需的工具：

<!--[if !supportLists]-->n  <!--[endif]-->JDK

<!--[if !supportLists]-->n  <!--[endif]-->一个现代的Web容器（例如Tomcat）

<!--[if !supportLists]-->n  <!--[endif]-->一个简单的文本编辑器

部署一个web应用最方便的办法是使用WAR文件（Web Archive file），只要简单的把WAR文件放在Tomcat的webapps目录下。

1.4.3 开始开发
<!--[if !supportLists]-->n  <!--[endif]-->创建ActionForm

ActionForm对于HTML表单中的每一个字段都对应一个属性。ActionServlet负责匹配request和ActionForm中的属性的参数，如果匹配就调用ActionForm的setter方法，设置从request得到的值。

<!--[if !supportLists]-->n  <!--[endif]-->创建Action

Action继承自org.apache.struts.Action。ActionServlet创建ActionForm并传递给Action。Action一般负责验证输入，获取业务信息和决定向servlet返回哪个ActionForward。

<!--[if !supportLists]-->n  <!--[endif]-->创建Struts配置文件（struts-config.xml）

Struts框架使用配置文件作为部署的描述子。这使我们可以创建和改变与路径关联的ActionMapping，而无需重新编译Java类。

<!--[if !supportLists]-->n  <!--[endif]-->创建页面

1.4.4 Looking Back
1.5 总结
<!--[if !supportLists]-->第二章   <!--[endif]-->探索Struts框架
2.1 Talking the talk
2.2 为何需要Struts
2.2.1 退一步，进三步
         很多现代的开发环境，包括Swing，都使用MVC结构作为框架的基础。

2.2.2 进入Struts
         Struts的中心是一个MVC式的控制器。Struts控制器连接view和model之间的鸿沟。

2.2.3 Struts控制器组件
         Struts控制器是一组可编程的组件，这些组件使开发者可以精确定义他们的应用程序如何与用户交互。这些组件将笨拙的实现细节隐藏在逻辑名称后面，

<!--[if !supportLists]-->n  <!--[endif]-->超链接

对于开发者来说，超链接是应用程序中一些资源的路径，这些可能是页面，或者是自定义的Action。它可以包含一些特殊的参数。在Struts中，开发者可以将超链接定义为一个ActionForward。这些对象具有一个逻辑名称和一个path属性，开发者设定path属性，然后通过逻辑名称来引用这个ActionForward。

<!--[if !supportLists]-->n  <!--[endif]-->HTML表单

Struts提供了ActionForm类来处理来自HTML表单的输入，验证这些输入，以及重新显示这些表单。

Struts配置通过一组描述子来引用ActionForm类：<form-beans>和<form-bean>元素。Struts配置列出了它使用的ActionForm beans，并且赋予这些ActionForm类一个逻辑名称，以在程序中引用。

<!--[if !supportLists]-->n  <!--[endif]-->自定义Actions

HTML表单使用一个action参数告诉浏览器向何处传送表单数据，Struts框架提供了Action类来接受表单数据。框架自动地创建，传送合适的ActionForm给Action对象。Action可以直接从ActionForm得到它需要的数据。Action返回一个ActionForward对象给控制器。

<!--[if !supportLists]-->n  <!--[endif]-->ActionMappings

ActionMapping使得同一个Action对象可以被不同的映射使用，例如一个mapping使用需要验证，另一个不需要验证。

<!--[if !supportLists]-->n  <!--[endif]-->ActionServlet

Struts的ActionServlet一直在幕后工作，将所有其他的组件连接起来。

<!--[if !supportLists]-->n  <!--[endif]-->区域化

Struts组件具有区域化的特性。

2.2.4 使用Struts开发web应用程序
         Struts将表现层与Model分离。

2.3 为何需要框架
         为何web开发具有挑战性？

2.3.1 The web—a never-ending kludge
         Web开发者受双层折磨：一是使用web浏览器作为客户端，二是使用web协议进行通信。Web浏览器使用HTTP协议进行通信，展现使用HTML创建的页面。Web浏览器发送HTTP请求，产生HTML作为响应。这对于预先写好的页面是一个不错的平台，但我们大部分人都是写动态的页面。

         HTTP协议和web浏览器决定了web应用的书写方式，这种方式有很多限制。

2.3.2 Servlet解决方案
         Servlet构建于HTTP之上，并提供了session上下文用以帮助跟踪应用程序的用户。

         Servlet规范描述了一个管理servlets的容器。

         对于数据库访问，Java编程框架提供了JDBC。

         对于访问远程数据库的高性能应用，可以使用EJB平台，大部分的Java应用程序框架，包括Struts，都可以在EJB上使用。

         Struts构建在servlet平台之上，提供了无缝的环境。

2.3.3 Servlet框架
         通常来说，Web应用程序框架的焦点是辅助从web浏览器取得数据，给程序结构使用，和将程序结构的数据输送到web浏览器，展示给用户。

通用框架策略

Java web应用程序框架使用几个通用的技术来使产品的设计、书写、维护更加容易：

<!--[if !supportLists]-->n  <!--[endif]-->外部配置文件。提供开发者不想混入代码的一些实现细节。

<!--[if !supportLists]-->n  <!--[endif]-->中心控制器。

<!--[if !supportLists]-->n  <!--[endif]-->外部表现系统。

2.3.4 白盒—黑盒体
         白盒框架很强地依赖于面向对象的特性如继承和动态绑定，而黑盒框架倾向于为可插入的组件定义接口，并且提供基于这些接口的基础组件。

2.4 Struts，Model 2和MVC
2.4.1 MVC的演化
         MVC是构建Smalltalk程序的一个框架。

2.4.2 Model 2的兴起
         将JSP与Servlet一起使用被称作是Model 2（只使用JSP为Model 1）。

2.4.3 应用程序分层—解耦View
         Model 2与MVC被认为是不同的一个原因是观察者通知模式在web环境下不能很好地工作。HTTP是一个pull的协议，客户端请求，服务器端响应，没有请求就没有响应。观察者模式需要一个push的协议。

         分层的web应用使用的是一个“平”的MVC模式。

2.4.4 Struts对Model 2，MVC和分层结构的实现
         Struts对Model 2的实现是，提供了一个控制器servlet用来管理jsp页面和其他表现层设备之间的流转。Struts对MVC和分层结构的实现是：使用ActionForwards和ActionMappings保持控制流决策处于表现层之外，

2.5 Struts控制流
2.5.1 The big picture
Struts的请求响应过程：

<!--[if !supportLists]-->n  <!--[endif]-->客户请求匹配Action URI模式的路径

<!--[if !supportLists]-->n  <!--[endif]-->容器将请求传递给ActionServlet

<!--[if !supportLists]-->n  <!--[endif]-->如果是模块化的应用程序，ActionServlet选择相应的模块

<!--[if !supportLists]-->n  <!--[endif]-->ActionServlet查找路径的映射

<!--[if !supportLists]-->n  <!--[endif]-->如果映射指定了一个form bean，ActionServlet检查是否已经存在，否则创建一个

<!--[if !supportLists]-->n  <!--[endif]-->如果存在form bean，则ActionServlet重置form bean，并根据HTTP请求重新计算

<!--[if !supportLists]-->n  <!--[endif]-->如果映射的validate属性设置为true，则调用form bean的validate方法

<!--[if !supportLists]-->n  <!--[endif]-->如果验证失败，servlet将转发到input属性指定的路径，本控制流结束

<!--[if !supportLists]-->n  <!--[endif]-->如果映射指定了一个Action类型，如果已经存在则重用，否则实例化一个对象

<!--[if !supportLists]-->n  <!--[endif]-->调用Action的perform或者execute方法，传递给它已经实例化的form bean，或者null。

<!--[if !supportLists]-->n  <!--[endif]-->Action可以创建form bean，调用业务对象，或者做其他一些该做的事情

<!--[if !supportLists]-->n  <!--[endif]-->Action向ActionServlet返回一个ActionForward对象

<!--[if !supportLists]-->n  <!--[endif]-->如果返回的ActionForward是另一个Action URI，则重新开始；否则显示页面或其他资源。通常是一个jsp页面，使用Jasper或同等物来产生页面。

<!--[if !supportLists]-->n  <!--[endif]-->如果Jsp使用了Struts的HTML标签，则从request中取得合适的ActionForm，并从ActionForm产生控件。否则<html:form>产生一个ActionForm，从Struts1.1开始，form标签如果自己创建ActionForm则调用ActionForm的reset方法。

2.5.2 细节
Request被容器接收

Struts框架的主干组件是ActionServlet。同所有的servlet一样，他存活在一个容器之中，如Tomcat，Resin或Weblogic。当容器启动的时候，它读取部署描述子（web.xml）来决定加载哪些servlets。

         其中一个标准的servlet设置是servlet mapping。容器使用这样的设置来决定哪些请求发送给哪一个servlet。

<servlet-mapping>

<servlet-name>action</servlet-name>

<url-pattern>/do/*</url-pattern>

</servlet-mapping>

Request被我们的ActionServlet接收

         当我们的ActionServlet接收一个请求时，使用一连串的操作来处理地域化，映射，form bean，最后是Action。

处理MultiPartRequest。如果是Multipart请求（表单具有MIME附件），则servlet使用一个特殊的句柄（handler）来包装这个request，以避免在后来的处理中出错。

处理路径。ActionServlet检查路径是否是一个应用程序模块的路径。如果是，则选择相应模块的配置。

处理地域化。缺省情况下，ActionServlet将检查用户的会话中是否存在一个标准的locale对象。如果不存在ActionServlet将放一个这样的对象在session中。这个对象用来向每一个用户提供区域化的表现。

处理内容和NoCache。缺省的MIME类型和可选的request头被加到响应中。

处理映射。ActionServlet检查是否存在一个mapping与我们正在处理的path相对应，如果没有找到则转发到缺省的Action，如果没有缺省的Action则产生一个“bad request”错误。如果找到这样的mapping，则放在request中以备后来使用。

处理角色。ActionServlet检查用户是否被授权访问这个Action。

处理ActionForm。ActionServlet检查mapping是否指定了一个ActionForm。如果指定了，则ActionServlet检查在指定的范围内（缺省是session范围）是否存在一个对象，如果不存在，则创建一个对象。

处理算值。调用ActionForm的reset方法，并使用反射自动产生值。符合ActionForm属性的参数将被应用。其他的参数或属性被忽略。

处理验证。调用ActionForm的validate方法，如果返回false，则控制交给mapping指定的input属性，action不会被处理。

处理转发或包含。如果ActionMapping指定了forward或include属性，则控制转交给另一个资源。否则ActionServlet将请求代理给Action对象。

处理Action。如果mapping指定了一个Action类型，则servlet检查是否已经存在一个Action类型的实例化对象，如果没有找到则实例化一个Action类型的对象，每一个类只有一个Action对象（单例模式），这个Action对象通过多线程处理所有的请求。Servlet调用Action的perform或execute方法，并把actionmapping，request，response和form bean传递给这个方法。

         Action是一个控制类，不应该用来处理应用程序的核心业务逻辑。

Action返回一个ActionForward

Jasper或同等物产生一个Jsp

         当Servlet发送一个请求给Jsp时，请求由其他的服务，如Jasper来处理。

其他的servlet产生响应

         处理完Action后，request可以传递给其他的servlet或服务。

2.5.3 Struts高效吗？
         通常来讲，Struts应当会提交适度设计的Web应用。

Struts不仅thread-safe而且thread-dependant。

ActionForm beans最小化子类代码并缩短了子类继承结构。

Struts标签库提供通用的功能。

Struts组件是可以被应用程序重用的。

Struts的区域化策略减少了重复JSP的需要。

Struts是使用开发的体系结构设计的。

Struts是轻量级的。

Struts是符合标准的。

Struts是开源的，且文档比较充分。

Struts是独立于model的。

2.6 Struts的长处与短处
2.6.1 弱点
<!--[if !supportLists]-->第三章   <!--[endif]--> 构建一个简单的应用程序
3.1 Strut By Strut
3.1.1 为什么选择一个Logon程序？
         容易理解、简单自包含、很多应用程序都需要。

3.2 总览Logon程序
3.2.1 开始旅程
3.2.2 将要看到的页面
         欢迎页面和Logon页面。

3.2.3 欢迎页面
3.2.4 Logon页面
3.2.5 再看欢迎页面
3.2.6 与欢迎页面说再见
3.2.7 聚集的特性
3.3 深入剖析Logon应用程序
3.3.1 欢迎页面的浏览器代码
Jsessionid键值：为了跟踪用户，使用cookies和URL重写技术。但是不是所有的浏览器客户端都支持cookies，所以第一次请求时，容器都会创建一个jsessionid，如果在接下来的请求中容器发现客户端接受cookies，则可以略过重写URL。

3.3.2 欢迎页面的JSP代码
<%@ taglib uri="/tags/struts-html" prefix="html" %>

<%@ taglib uri="/tags/struts-logic" prefix="logic" %>

是JSP的同等物，用来引入扩展标签供页面的其余部分使用。

         <html:base/>产生一个标准的HTML的base标签，一些引用，如图片，可以使用与最初Jsp页面的相对位置。之所以使用这个标签，是因为对于动态的应用程序，我们访问的地址并不是Jsp页面的地址，可能是Action，java类等的地址。

         Struts的所有逻辑标签都使用this和notThis的形式，不提供else标签。

         可以给一个连接一个逻辑名称，使用逻辑名称来引用（<html:link>）。这种映射在配置文件中配置。这样，如果要修改链接，只需要在配置文件中修改一次。

3.3.3 欢迎页面的配置代码
         配置文件的缺省名称是struts-config.xml。

3.3.4 Logon页面的浏览器代码
         标签库的描述子TLD在web.xml文件中给出。

         <html:form>标签的focus属性，产生javascript代码，使相应的控件获得焦点。

         <html:text>标签产生一个文本域的HTML输入控件。

         <html:password>的redisplay属性可以控制返回时是否设置值。

         <html:submit>产生标准的HTML的submit控件。

         <html:reset>产生标准的HTML的reset控件。

3.3.5 Logon页面的配置代码
         /LogonSubmit：ActionMapping

         app.LogonForm

         app.LogonAction

3.3.6 LogonSubmit代码
         ActionMapping的input属性：如果验证失败，返回input指定的地方。

3.3.7 LogonForm代码
         基类ActionForm包含reset方法，如果mapping的scope设置为request，则不必实现reset方法。

3.3.8 LogonAction代码
         Action的execute方法比perform方法提供了更好的异常处理，其他都一样。

         Debug级别在Web部署描述子web.xml中指定。

3.3.9 LogoffAction代码
3.4 构造一个应用程序
3.4.1 定义需求
3.4.2 规划应用程序
视图

控制器

模型

3.4.3 规划代码树
3.4.4 配置开发工具
         使用ant作为构建工具。

3.4.5 配置build.xml文件
3.4.6 配置web.xml文件
         Java2 Servlet框架使用web.xml文件来配置应用程序。标明使用的servlets和其他一些设置。对于Struts应用，只需要配置一个servlet和一些标签库。

3.4.7 配置struts-config.xml文件
welcome Action

容器要求必需使用一个页面作为welcome页面。通常的解决方式是使用一个index.jsp，来重定向到welcome Action。

3.4.8 测试部署的结果
Struts Blank应用程序可以用来测试环境，它包含了很多系统检查。

3.4.9 构造自己的欢迎页面
3.4.10 构造Logon页面
3.4.11 构造Constants类
3.4.12 构造其他类
3.4.13 创建用户目录
3.4.14 配置ActionErrors
         作为构建的过程，要把要把应用程序资源文档拷贝到classes目录下，以便ActionServlet能够找到。

3.4.15 编译和测试Logon页面
3.4.16 修补欢迎页面
3.4.17 Struts的ActionForward Action
         我们要尽可能链接到Struts的Action，而不是JSP。但是为每一个JSP配置一个Action非常麻烦，可以使用ForwardAction，只要将parameter属性配置为JSP的地址即可。

<!--[if !supportLists]-->第四章   <!--[endif]-->配置Struts组件
4.1 三个XML文件和一个Properties文件
         Struts开发者必需维护一些配置文件。

<!--[if !supportLists]-->n  <!--[endif]-->web.xml。这个文件是Java Servlet规范需要的，servlet/JSP容器需要此文件加载和启动程序。

<!--[if !supportLists]-->n  <!--[endif]-->struts-config.xml。

<!--[if !supportLists]-->n  <!--[endif]-->build.xml。ant工具需要的，不是必需的。

<!--[if !supportLists]-->n  <!--[endif]-->application.properties。提供消息资源。

4.1.1 其他一些文件
         如果使用其他一些可选的组件如Tiles框架、Struts Validator，还需要配置其他一些XML配置文件。如果您把程序化成多个模块，则每个模块可以使用自己的struts配置文件和消息资源文件。

4.2 Web应用程序部署描述子
4.2.1 web.xml文件
         Struts框架包含两个组件需要由应用程序的部署描述子来配置：ActionServlet和标签库，其中标签库是可选的。

         <load-on-startup>设置为2，允许先加载其他的servlets。这样就支持从ActionServlet继承的情况。

         <taglib-location>提供与标签库描述子的相对位置，标签库描述子TLD是标签库的实际类型（Java类）。

4.2.2 ActionServlet参数
         multipartClass，用来处理文件上传的类。

         validating，是否使用DTD来验证Struts配置文件。

4.3 Struts配置
         Struts配置文件与ActionServlet一起创建应用程序的控制层。

4.3.1 细节，还是细节
         Struts配置文件中的每一个组件都是一个Java对象。

4.3.2 变更管理
         存在一些Struts GUIs，可以维护Struts的XML配置文件。

4.3.3Protected Variation的原则
         Struts配置文件的很大一部分细节是关于表示层的。

4.4 Struts配置元素
         Struts使用Digester及配置文件的DTD来解析Struts配置文件。

         Struts配置元素：

<!--[if !supportLists]-->n  <!--[endif]-->data-sources，包含一组DataSource对象（JDBC2.0标准扩展）

<!--[if !supportLists]-->n  <!--[endif]-->data-source，指定一个DataSource对象，作为servlet上下文属性

<!--[if !supportLists]-->n  <!--[endif]-->set-property，指定一个附加的JavaBean的方法名和初识值

<!--[if !supportLists]-->n  <!--[endif]-->global-exceptions，描述一组Action对象可能抛出的异常

<!--[if !supportLists]-->n  <!--[endif]-->exceptions，为exception类型注册ExceptionHandler

<!--[if !supportLists]-->n  <!--[endif]-->form-beans，描述一组bean描述子

<!--[if !supportLists]-->n  <!--[endif]-->form-bean，描述一个FormBean的子类，以便供<action>引用

<!--[if !supportLists]-->n  <!--[endif]-->form-properties，描述一个可以用来配置DynaActionForm及其子类的实例的JavaBean属性

<!--[if !supportLists]-->n  <!--[endif]-->global-forwards，描述一组ActionForward，可以被所有Action用来作为返回值

<!--[if !supportLists]-->n  <!--[endif]-->forward

<!--[if !supportLists]-->n  <!--[endif]-->action-mappings

<!--[if !supportLists]-->n  <!--[endif]-->action

<!--[if !supportLists]-->n  <!--[endif]-->controller，描述ControllerConfig bean，它封装一个应用程序模块的运行时配置

<!--[if !supportLists]-->n  <!--[endif]-->message-resources，描述一个MessageResources对象

<!--[if !supportLists]-->n  <!--[endif]-->plug-in，指定一个通用的应用程序插件模块的类，可以接受应用启动和关闭事件

Scioworks Camino和Struts Console可以直接管理Struts配置文件。Adalon和ObjectAssembly可以可视化设计产品，并生成初始的Struts配置文件，Java类和JSP

4.4.1 global-exceptions
         Struts框架提供了一个缺省的ExceptionHandler（org.apache.struts.action.ExceptionHandler），它将异常存储为request-scope的属性，为你的exception信息创建一个ActionError对象，并把控制转发到你选择的JSP或其他URI。<html:errors>会自动打印带有地域版本的异常信息。ExceptionHandler可以被继承以添加新的行为。每一个异常都可以指定它自己的handler类。

         为注册异常，需要提供Exception类型，消息资源key，以及response路径，如：

<exception

type="org.apache.struts.webapp.example.ExpiredPasswordException"

key="expired.password"

path="/changePassword.jsp"/>

4.4.2 form-beans
         DynaActionForms在创建的时候，需要额外的属性，我们需要一个地方来存放这些元素。

         ActionFormBean也可以包含property属性来使用DynaActionForm。




         <form-bean name="logonForm" type="org.apache.struts.action.DynaActionForm">

<form-property name="username" type="java.lang.String"/>

<form-property name="password" type="java.lang.String"/>

</form-bean>

         使用DynaActionForm不需要使用ActionForm的子类。

4.4.3 global-forwards
         ActionForward将一个逻辑名称和一个URI联系起来。其他组件只需要引用这个逻辑名称。

         ActionForward的主要使用者是Action。

4.4.4 action-mappings
         ActionMappings描述应用程序可以执行什么样的操作和指令。

4.4.5 controller
         Struts允许多个应用程序模块共享一个控制器servlet。每一个模块有自己的Struts配置文件，可以独立于其他模块开发。controller允许每一个模块指定一个独立的ActionServlet的参数。

4.4.6 message-resources
4.4.7 plug-in
         PlugIn接口声明Init和Destroy方法，控制器可以在适当的时候调用。PlugIn Action可以在Struts配置文件中通过<plug-in>注册。

4.4.8 data-sources
         与数据获取层架起一座桥梁。

4.4.9 rolling your own
4.4.10 一个Struts配置文件框架
4.5 应用程序资源文件
         Struts框架为每一个用户维护一个标准的Locale对象（Java.Util.Locale）。应用程序资源文件的缺省名称是通过在web.xml文件中为ActionServlet初始化application参数。这个参数没有缺省值，必需为这个参数赋值才能使用Struts的ResouceBundle。

         使用ant可以将资源文件从源文件树拷贝到二进制类目录下。

4.6 ant build文件
4.7 配置Struts的核心组件
4.7.1 安装Java和Java Servlet容器
         Struts发布版本中包含的文档，有配置各种servlet容器的技术说明。

4.7.2 安装开发环境
         可以使用jEdit和jEdit的ant插件。

4.7.3 安装Struts核心文件
         Struts的发布版本包含了部署Struts的所有文件。

         检查单：

<!--[if !supportLists]-->n  <!--[endif]-->下载并解压Struts发布版本

<!--[if !supportLists]-->n  <!--[endif]-->将所有的jar包拷贝的/WEB-INF/lib/下

<!--[if !supportLists]-->n  <!--[endif]-->将所有的tld文件拷贝到/WEB-INF/下

<!--[if !supportLists]-->n  <!--[endif]-->将所有的xml文件拷贝到/WEB-INF/下

<!--[if !supportLists]-->n  <!--[endif]-->创建部署描述子

<!--[if !supportLists]-->n  <!--[endif]-->创建Struts配置文件

<!--[if !supportLists]-->n  <!--[endif]-->创建消息资源bundle

<!--[if !supportLists]-->n  <!--[endif]-->创建ant build文件

4.8 配置Tiles框架
         Tiles框架是Struts的可选组件，是强大的页面组装工具。

         Tiles检查单：

<!--[if !supportLists]-->n  <!--[endif]-->将struts-tiles.tld和tiles-config.dtd文件从Struts的lib目录拷贝到/WEB-INF/目录

<!--[if !supportLists]-->n  <!--[endif]-->将以下片段插入到web.xml文件中

<taglib>

<taglib-uri>/tags/tiles</taglib-uri>

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

</taglib>

<!--[if !supportLists]-->n  <!--[endif]-->将空的tiles-defs.xml文件拷贝到/WEB-INF/目录，格式如下：

<!DOCTYPE tiles-definitions PUBLIC

"-//Apache Software Foundation//DTD Tiles Configuration//EN"

"http://jakarta.apache.org/struts/dtds/tiles-config.dtd">

<tiles-definitions>

<!-- skeleton definition

<definition

name="${name}"

path="${path}">

<put

name="${name}"

value="${value}"/>

</definition>

end blank definition -->

</tiles-definitions>

<!--[if !supportLists]-->n  <!--[endif]-->在struts-config.xml文件的</struts-config>的结束元素之前加入<plug-in>元素：

<plug-in className="org.apache.struts.tiles.TilesPlugin" >

<set-property

property="definitions-config"

value="/WEB-INF/tiles-defs.xml" />

</plug-in>

4.9 配置StrutsValidator
         Struts Validator也是Struts的一个可选组件。

         配置Validator的检查单：

<!--[if !supportLists]-->n  <!--[endif]-->struts-validator.tld和validator-rules.xml文件拷贝到/WEB-INF/目录

<!--[if !supportLists]-->n  <!--[endif]-->将以下片段拷贝到web.xml文件：

<taglib>

<taglib-uri>/tags/validator</taglib-uri>

<taglib-location>/WEB-INF/struts-validator.tld</taglib-location>

</taglib>

<!--[if !supportLists]-->n  <!--[endif]-->在/WEB-INF/目录下创建空白的validations.xml:

<form-validation>

<formset>

<!-- skeleton form

<form name="${}">

<field

property="${}"

depends="${}">

<arg0 key="${}"/>

</field>

</form>

end skeleton form -->

</formset>

</form-validation>

<!--[if !supportLists]-->n  <!--[endif]-->在struts-config.xml文件的</struts-config>元素前添加<plug-in>元素：

<plug-in className="org.apache.struts.validator.ValidatorPlugIn">

<set-property

property="pathnames"

value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>

</plug-in>

4.10 从Struts Blank应用程序开始
         build.xml文件中可能引用了您的机器中没有的文件：

         <property name=" jdbc20ext.jar"

value="/javasoft/lib/jdbc2_0-stdext.jar"/>

<property name="servlet.jar"

value="/javasoft/lib/servlet.jar"/>

<property name="distpath.project"

value="/projects/lib"/>

jdbc2_0-stdext.jar和servlet.jar是创建JavaDocs所需要的。

<!--[if !supportLists]-->n  <!--[endif]-->容器中应该包含servlet.jar文件

<!--[if !supportLists]-->n  <!--[endif]-->Struts的发布版本中包含jdbc2_0-stdext.jar，很多容器（如Tomcat）中也包含。

4.11 配置模块化应用程序
4.11.1 分治法
         每个模块使用自己的struts-config.xml配置文件

4.11.2 页面前缀
4.11.3 Retrofitting a configuration
4.12 共享Struts的JAR包
         Struts的JAR包可以被容器中的所有Struts应用共享。

第二部分 Raising your framework
<!--[if !supportLists]-->第五章   <!--[endif]-->处理ActionForms
5.1 吃进去的是草，挤出来的是奶
         Struts包含了一些JSP标签，可以用来书写动态的HTML控件。如同很多标签库一样，Struts标签也是同JavaBeans一起工作。每一个JSP标签都有一个property属性，提供bean中的一个property的名称。JavaBean的这个property的值用来作为控件的值。

5.1.1 ActionForm需求
         如果要使用ActionForm来验证输入，则必需实现validate方法。

         如果要初始化properties，则必需实现reset方法，用以在获取ActionForm的properties的值之前调用。

5.2 ActionForm的多重功能
5.2.1 ActionForm作为域捕获器
         Struts使用ActionForms来弥补HTML和HTTP的缺点。

5.2.2 ActionForm作为数据缓冲
         ActionForm并不是输入的目的地，只是验证和传输前的缓冲区。

5.2.3 ActionForm作为数据验证器
         ActionForm的validate方法是一个扩展点，在这里你可以调用业务层方法来验证输入。

5.2.4 ActionForm作为类型转换器
         ActionForm的properties只能是String或boolean类型。

5.2.5 ActionForm作为对象传输者
5.2.6 ActionForm作为火墙
5.3 ActionForm设计效果
<!--[if !supportLists]-->n  <!--[endif]-->与业务层的bean具有相同的property名称

<!--[if !supportLists]-->n  <!--[endif]-->最小化自定义的代码

<!--[if !supportLists]-->n  <!--[endif]-->封装helper方法

<!--[if !supportLists]-->n  <!--[endif]-->包含其他JavaBeans

5.3.1 ActionForms可能会共享名称
5.3.2 ActionForms可以最小化自定义的代码
5.3.3 ActionForms可以封装helpers
5.3.4 ActionForms可以嵌套其他beans
<html:text property="values.telephoneText" size="14" maxlength="14"/>

等同于

aForm.getValues().getTelephoneText()

浏览器端会这样传输数据：

values.telephoneText=555-1234

自动获取机制会这样取值：

aForm.getValues().setTelephoneText(

(String) request.getAttribute(valueBean.telephoneText);

5.4 ActionForm支持
5.4.1 map-backed ActionForms
         在ActionForm中可以这样调用方法来获取Map中的记录：

         public void setValue(String key, Object value)

public Object getValue(String key)

在JSP中：

<html:text property="value(key)"/>

和

<bean:write name="formBean" property="value(key)"/>

5.4.2 DynaActionForm
         使用DynaActionForm，可以通过Struts的配置文件指定JavaBean的properties。

5.5 ActionForm的疑问
5.5.1 为什么ActionForm不直接就是一个Map？
5.5.2 为什么ActionForm不设计成普通的JavaBean？
5.5.3 为什么ActionForm不设计成接口？
5.6 对ActionForms的反思
5.6.1 实现一个业务层的接口
5.6.2 嵌套一个mutable的值对象
5.6.3 设置一个immutable的值对象
5.6.4 设置一个mutable的值对象
5.6.5 使用一个工厂方法
5.6.6 传递一个Map
         BeanUtils

5.6.7 通过反射传递值
5.6.8 使用适配器类
5.7 BaseForm
         这个类处理区域化，分派控制，管理自动计算等。

5.7.1 SessionLocale
         缺省情况下，ActionServlet会在每个用户的session对象中自动创建一个locale对象。SessionLocale相关的方法可以用来管理这个对象。

5.7.2 分派
5.7.3 自动计算值
         处理数据转换。可以在ActionForm和Bean之间转换，以及将ActionForm中的值转换成Map。

5.7.4 BaseMapForm
<!--[if !supportLists]-->第六章   <!--[endif]-->使用ActionForwards
6.1 ActionForwards做什么？
         理想情况下ActionForwads应该在程序的每一个入口被用到—任何链接到另外一个页面的地方。

6.2 ActionForwards如何工作？
         基类具有四个属性：name，path，redirect，className。

6.2.1 forward与redirect
<!--[if !supportLists]-->n  <!--[endif]-->Forward保存request中的所有内容和request上下文。

<!--[if !supportLists]-->n  <!--[endif]-->Redirect只是web客户端重新创建一个request。

转发Requests

Java Servlet容器具有一个内置的机制，使request可以传递给另一个组件，叫做转发。

重定向Requests

当ActionForward的redirect属性设置为true时，ActionServlet发送一个HTTP响应，高速浏览器重新提交一个请求给这个path。Request中的原始参数不会保留，request上下文会消失。

6.3 Global和Local Forwards
<!--[if !supportLists]-->n  <!--[endif]-->Global ActionForwads对应用程序中的所有Action都是可用的。

<!--[if !supportLists]-->n  <!--[endif]-->Local ActionForwards在ActionMapping中定义，只对从这个ActionMapping中调用的Action可用。

Global都应该定义成常量。Scaffold包中定义了一些常用的常量。

6.4 运行时参数
         有两个地方可以改变ActionForwad的查询组件。

6.4.1 在页面中增加参数
         可以在<html:link>标签中增加参数，例如：

         <html:link forward="article" paramId="key" paramProperty="key" name="articleForm">

<bean:write name="articleForm" property="name">

</html:link>

6.4.2 在Action中增加参数
         ConvertUtils提供了addParam方法。

6.5 动态的Forwards
         可以动态创建ActionForward对象，给它设定参数。

6.6 为什么地址栏不改变？
         要改变的话，只能redirect。

6.7 打造自己的ActionForward
         在Struts1.0中，要在web.xml文件中配置，在Struts1.1中，要配置Struts配置文件。

<!--[if !supportLists]-->第七章   <!--[endif]-->使用ActionMappings进行设计
7.1 进入ActionMappings
7.1.1 ActionMapping bean
         ActionMappings用来扩展Action对象而不是Action类。

7.1.2 ActionMappings目录
         ActionMappings代表了Struts应用的核心设计。

7.2      ActionMapping属性
7.2.1 path属性
         ActionMapping的虚拟引用。

7.2.2 forward属性
         如果forward属性被指定了，则request不会传递给Action，而是调用RequestDispather.forward。

7.2.3 include属性
         与forward同时使用。这两个属性与type属性是互斥的。

7.2.4 type属性
         一个Action类可以被多个actionMapping使用。

7.2.5 className属性
         指定自定义的ActionMapping子类的qualified名称。

7.2.6 name属性
         Form bean的逻辑名称。

7.2.7 roles属性
         一组逗号分隔的role列表，这些roles可以访问这个ActionMapping对象。

7.2.8 scope属性
         设置ActionForm的范围，缺省是session范围的。

7.2.9 validate属性
         如果validate设置为true，ActionServlet会调用ActionForm的validate方法，如果validate返回false，则request被转发到input指定的资源。

7.2.10 input属性
         Struts1.1中input属性可以指定为一个ActionForward的名称。如果要在input属性使用ActionForward，要为controller属性的inputForward设成true。

7.2.11 parameter属性
         ResourceUtils提供方法来加载一个properties文件。

7.2.12 attribute属性
         在同一个上下文环境中使用两份相同的ActionForm时，可以使用attribute属性命名另外一个。

7.2.13 prefix和suffix属性
         如同attribute，如果前缀是a，Formbean名为bean，则aBean=。。。和bean=。。。一样。

7.2.14 unkown ActionMapping
         处理404。

7.3 嵌套组件
7.3.1 Local Forwards
         先检查local forwards，再检查global forwards，如果都没有，则返回null。

7.3.2 Local exceptions
         可以为ActionMapping指定特定的ExceptionHandler。

7.4 打造自己的ActionMapping
         框架提供了两个基础的ActionMapping类，SessionActionMapping和RequestActionMapping。如果使用SessionActionMapping，则scope默认为session。

<!--[if !supportLists]-->第八章   <!--[endif]-->使用Action对象
8.1 准备，就绪，开始
         Actions是Struts框架中最灵活的类。

         Actions的核心职责：

<!--[if !supportLists]-->n  <!--[endif]-->访问业务层

<!--[if !supportLists]-->n  <!--[endif]-->为表示层准备业务对象

<!--[if !supportLists]-->n  <!--[endif]-->处理两个层之间出现的数据错误

8.2 使用Action对象
8.2.1 Actions是什么？
         如同servlet一样，Action是多线程的，一个Action类只有一个对象在应用中被使用。

         Actions是线程安全的，如果要继承Action，在自己的Action类中不能在多个方法中共用属性，所有的值都要通过参数传递来保证线程安全。

8.2.2 Actions什么时候被调用？
         当需要Action时，ActionServlet会通过Action的perform或execute方法来调用。

8.2.3 Actions做什么？
         一个典型的Action的通用职责：

<!--[if !supportLists]-->n  <!--[endif]-->验证先决条件或断言

<!--[if !supportLists]-->n  <!--[endif]-->调用任何需要的业务层方法

<!--[if !supportLists]-->n  <!--[endif]-->检测任何处理错误

<!--[if !supportLists]-->n  <!--[endif]-->路由控制到合适的视图

避免把业务逻辑放在Action类中是很重要的。

Struts消息可以接受最多4个参数。

在Struts1.1中可以使用更灵活的消息标签：

<logic:messagesPresent>

<UL>

<html:messages id="error">

<LI><bean:write name="error"/></LI>

</html:messages>

</UL>

</logic:messagesPresent>

在Struts1.1中消息和error可以分别传递，以使用不同的样式，使用方法同error：

saveMessages

ActionMessage

8.2.4 Action是什么样子？
8.3 标准的Actions
8.3.1 标准的bridge Action类
         用来集成Struts和应用程序中的其他Servlets。

         ForwardAction

         ForwardAction只是简单地把控制转发给其他资源，可以是任意具有URI的资源。

         IncludeAction

         当指定的servlet完成后，可以返回控制。

8.3.2 标准的base Action类
         BaseAction（Scaffold）

         DispatchAction

         LookupDispatchAction

         SwitchAction

                  SwitchAction可以切换到另外一个模块，并把控制转发到那个模块的path。

8.4 Chaining Actions
8.4.1 Starting fresh
8.5 Scaffold Actions
         所有的标准的Scaffold Actions都继承自BaseAction。

8.5.1 Forward-only Actions
         这样的Action类只是一个简单的dispatcher。

         SuccessAction

         RelayAction

适应于同一个页面有多个Submit按钮，而且使用不同的ActionMapping的情况，使用的时候要在页面设置一个参数。

         ParameterAction

                   转发的时候还传递参数。

         FindForwardAction

8.5.2 Helper Actions
         BaseHelperAction

         ProcessAction

         ExistsAttributeAction

         RemoveAttributeAction

8.6 Base View Actions
         Struts框架支持Action创建response。你可以创建自己的View Action来产生动态图片，创建PDFs，使用XSL样式表合并XML等。

8.7 Helper Action技术
8.7.1 可选转发技术
         首先检查特定的ActionForward存在，如果不存在，则忽略可选的行为。

8.7.2 Calling ahead
8.7.3 捕获chained异常
8.7.4 灵巧的错误转发
8.7.5 确认success
         ProcessResult类。

8.7.6 切换视图
8.7.7 反射方法
8.7.8 反射类
8.8 使用灵巧的转发
<!--[if !supportLists]-->第九章   <!--[endif]-->扩展ActionServlet
9.1 Where is the beef？
         大多数情况下，ActionServlet不需要被继承，直接使用应该可以满足需求。

         ActionServlet的扩展点都是通过plugin的，而不是继承。

9.1.1 Servlet的三人帮
         在所有的可插入的（Pluggable）组件中，RequestProcessor组件是最强大的。

         RequestProcessor处理的一个高层问题是异常处理，Exception类可以注册一个Handler如果是没有注册的Exception，RequestProcessor使用ExceptionHandler处理。

         很多应用程序需要访问自己特殊的资源，为方便在Struts中初始化自定义的资源，可以向Controller注册一个PlugIn Action。控制器会在启动的时候调用这个Action的init方法，关闭的时候调用这个Action的destroy方法。

9.2 RequestProcessor
         当一个request进来的时候，servlet选择应用程序模块，并把request交给RequestProcessor，每一个模块都可以加载自己的RequestProcessor的子类，或者直接使用RequestProcessor。

         RequestProcessor提供了一些可以重写的方法，用来扩展RequestProcessor。

9.2.1 process方法
         可以扩展的方法都是在process方法中调用的，process方法的职责是处理HttpServletRequest和产生相应的HttpServletResponse。

         为创建响应，典型的，processActionForward方法会将request发送给JSP页面或其他资源。

9.2.2 processRoles方法
         RequestProcessor的扩展点中，最有可能被完全重写的方法就是processRoles。processRoles的职责就是检查用户是否被允许访问Action。缺省的行为是使用标准的Java Security API。

         缺省的行为是，通过request的参数，用ActionMapping中指定的role列表和IsUserInRole方法，如果用户属于指定的roles，则验证通过。

         通过重写processRoles，可以容易地将此特性适应于合适的基于应用程序的安全模式。

9.3 ExceptionHandler
         ActionServlet会捕获所有异常，如果捕获了一个异常，它首先检查你是否已经为这个异常注册了handler，先检查local的，再检查global的。

         如果ActionServlet没有找到handler，将重新抛出这个异常。

         ExceptionHandler可以在Struts配置文件中注册，如果<exception>元素的path属性没有指定，则使用ActionMapping的input属性。
         <exception>元素的属性包含handler和className，可以用来指定自定义的ExceptionHandler，也可以为这个handler指定一个自定义的配置bean。
         自定义的handler必需继承自缺省的ExceptionHandler。入口方法是execute。

         ExceptionConfig bean表示从Struts配置文件中读取的原始的<exception>元素。如果需要其他属性，可以继承ExceptionConfig类，在配置文件中通过<set-property>初始化属性。

9.4 PlugIn
         允许一个Action实现PlugIn接口的init和destroy方法。

第二部分 构建自己的页面
<!--[if !supportLists]-->第十章   <!--[endif]-->显示动态内容
10.1 Tag-you’re it
         Struts发布版本包含了一组预先写好的JSP标签，可以把Struts框架和JSP标签结合起来。

         JSTL。

10.1.1 JSP标签有什么好处？
服务器端页面

有很多服务器端页面：ActionServer Pages，ColdFusion Pages，PHP，Velocity模板，JSP等。

10.1.2 Struts与JSTL
         JSTL的实现有很多与Struts标签库重叠的地方。JSTL需要容器支持Servlet2.3和JSP1.2，如Tomcat 4，Resin 2。

         JSTL并没有消除自定义标签扩展的需求。

         JSTL表达式语言

         JSTL提供的表达式语言（EL）来替换scriplets。

10.1.3 Struts标签与MVC
         Struts标签提供了所有应用程序需要的来创建MVC式的表示层的所有功能。

10.2 使用标签扩展
10.2.1 怎样书写标签扩展？
         JSP标签是用Java语言使用标签扩展API书写的。这些类解析XML格式的tag，使用tag的属性作为类的方法的参数。

         与JSP的base标签相对应，有一个BaseTag类，BaseTag类扩展了一个API类，BaseSupport，重写了doStartTag方法。

10.2.2 如何安装标签扩展？
1. 安装JAR和TLD文件。

2. 更新web.xml文件。

3. 在页面中引入新的taglib文件。

10.2.3 标签扩展不是什么？
<!--[if !supportLists]-->n  <!--[endif]-->标签扩展不能被所有HTML可视化编辑器支持

<!--[if !supportLists]-->n  <!--[endif]-->不是所有的scriptlet都能被的标签扩展替换

<!--[if !supportLists]-->n  <!--[endif]-->标签扩展不是JavaServer Faces

10.3 Struts标签库
         Struts发布版本包含4个关键的标签库：bean，html，logic和nesting。html中几乎所有的标签都依赖于Struts框架，其他三个库中几乎所有的标签都不依赖于Struts框架。

10.3.1 Struts标签的共同特性
自动定位范围

在寻找对象的时候，Struts标签会自动检查标准上下文—page，request，session和application，使用找到的第一个实例。

共同属性名称

         id，name，property，scope

扩展的语法

         嵌套引用，如：foo.bar.baz

运行时表达式

         标签的属性中可以使用scriptlet。

同用的错误处理

10.3.2 bean标签
         11个bean标签（cookie，define，header，include，message，page，parameter，resource，size，struts，write）可以用来：

<!--[if !supportLists]-->n  <!--[endif]-->从HTTP头、request参数，cookie，或者任何范围内存在的对象创建脚本变量

<!--[if !supportLists]-->n  <!--[endif]-->从response向另外一个request创建一个新的bean，从应用程序资源或Struts配置对象

<!--[if !supportLists]-->n  <!--[endif]-->确定一个Collection或Map的大小

<!--[if !supportLists]-->n  <!--[endif]-->自动地从应用程序资源文件为当前用户创建区域或消息

<!--[if !supportLists]-->n  <!--[endif]-->书写任何可用的bean的属性

只有message和struts依赖于Struts框架，其他标签可以应用于任何应用程序。

Bean标签最佳实践

最常用的标签<bean:write>和<bean:message>。

10.3.3 html标签
Html标签和scriplet版本的区别：

<!--[if !supportLists]-->n  <!--[endif]-->Scriplet要求bean要在jsp中先定义后使用，html标签没有这个要求。

<!--[if !supportLists]-->n  <!--[endif]-->缺省情况下，Struts标签在整个form中使用，不需要为每一个控件指定。

共同属性

name:ActionForm或JavaBean的名称

on*：事件处理

accessKey：按下赋给元素的accessKey使元素获得焦点

tabindex

style

StyleClass

10.3.4 logic标签
包含三个逻辑标签：evaluation标签，控制流标签，和重复标签。

Evaluation标签—共同属性

Cookie，header，parameter，name，property

控制流标签

在index.jsp中可以使用：

<%@ taglib uri="/tags/struts-logic" prefix="logic" %>

<logic:forward name="welcome"/>

Repeat标签

<logic:iterate>

10.4 使用Struts的JSP标签
10.4.1 Struts标签团队
         各类标签库联合使用可以达到一些效果。

10.4.2 基础
声明一个Form

<html:form></html:form>

产生html控件元素

使用ActionForm bean的property。

选择radio按钮

         Property相同，value设置好，如果ActionForm与html:radio的property值相同的property的value相同，则checked。

过滤HTML

<bean:write>标签自动过滤特殊字符，如果要取消，则把filter属性设置成false。

清除密码

Redisplay属性设置成false，则密码一直以空的形式出现。

使用事务性标志

解决重复提交问题。

<html:form>自动使用同步标志，在Action端HTMLHTMLHTML可以通过调用saveToken(request)。

对options使用集合

         从Struts1.1开始，可以使用LabelValueBean。

对checkbox使用数组

         Mutibox控件。

区域化labels

         <bean:message>

区域化options

区域化集合

10.4.3 技巧
使用ImageButtonBean表示ImageButton

使用bean标签创建自定义控件

使用数组捕获重复的参数

使用<bean:size>测试集合的大小

迭代集合的一部分

暴露迭代的下标

使用嵌套的<present>和<notEmpty>测试bean属性

为稳定的option list使用application范围的对象

使用rewrite为样式表，javascripts和其他资产产生URLs

使用JSP标签产生JavaScript

         大部分web开发者都依赖于javascript来创建表示层的核心特性，Struts开发者也不例外。

使用<bean:write>从bean产生javascript

重命名submit按钮来避免javascript冲突

使用无form按钮

使用action作为input属性来重新创建依赖的对象

使用动态的form Actions

使用可选择的message标签

         <logic:messagesPresent>

<UL>

<html:messages id="error">

<LI><bean:write name="error"/></LI>

</html:messages>

</UL>

</logic:messagesPresent>

可以指定某个消息显示在某个控件的旁边。

10.4.4 成功的控制
10.5 可选的视图
10.5.1 Struts与JSP
         Struts本身并不处理JSP，而是容器负责处理。

10.5.2 Servlet上下文
         三个标准的上下文：request，session，application。

10.5.3 超越JSP
         使用Struts可以扩展XSLT和Velocity。

<!--[if !supportLists]-->第十一章            <!--[endif]-->使用Tiles开发应用程序
11.1 调整布局
可用性是当今web应用设计的一个主要关注点，而一致性是可用性的一个主要成分。

11.1.1 使用动态模板分层
         将显示与内容分离的一个方法是使用动态的JSP include。JSP规范提供了静态和动态的include。动态include的标准JSP动作是<jsp:include>。

         我们利用动态include的方法是，把服务器端页面分解成多个片段（fragment），每一个片段负责自己的一部分工作。背景模板可以设置缺省格式和布局，可以在运行时包含include来显示内容。动态的include将被包含的页面的输出展开到原始页面。Tiles框架使用jsp动作的一种更高级的形式。在Tiles应用程序中，背景、布局、模板通常定义头部、菜单体、内容和尾部的位置。其他页面被包含进来来填充这些位置。如果头部变化，只需要改变模板文件，这个变化会自动地体现在包含模板的页面。HTML的标准组件，如CSS，可以很好地与动态模板工作。

11.1.2 模板的效果
         每一项技术都有一些折衷，使用模板的效果如下：

<!--[if !supportLists]-->n  <!--[endif]-->JSP包含技术已经是良好建立而且可靠，趋向于在大型应用里也表现良好。包含动态模板的技术是核心Java Servlet API的一部分。

<!--[if !supportLists]-->n  <!--[endif]-->大部分的容器都为JSP和象servlet include这样特性做了优化。

<!--[if !supportLists]-->n  <!--[endif]-->被包含的页面通常输出HTML片段，不能用标准的HTML编辑器维护。

<!--[if !supportLists]-->n  <!--[endif]-->大部分的站点都在源代码变化的时候重新编译JSP。模板创建了更多的页面，也创建了更多的变化的可能性。

<!--[if !supportLists]-->n  <!--[endif]-->模板实际上重用了代码。

11.1.3 使用模板
         一些术语：

         动态元素（Dynamic element）:JSP翻译器识别出的JSP的一部分，包括action，directive，expression，JSP标签或者scriplet。

         模板数据（Template data）：没有被JSP翻译器识别出的JSP的一部分，通常是标记和可见的文本。

         模板页（Template page）：一个包含另一个页，或被另一个页包含的JSP。

         模板文件（Template file）：被一个模板页面包含的静态文件或JSP。

         Tile：Template file的缩写。

         Layout：关于Tiles如何定位于页面的描述。

         Tiles：一个使模板和布局更容易和更强大的框架。

         定义（Definition）：一个Tiles特性，它允许一个布局被指定为一个模板页或JavaBean。定义可以用XML文档来描述。

11.1.4 结合模板，Tiles和Struts
         Tiles框架通过使用简单有效的标签库使模板布局的使用更加简单。

         通常情况下，一个JSP模板系统使用一个模板文件作为布局，另一个模板文件作为填充组件。

11.2 构建一个布局模板
         构建任何一个布局的第一步是识别组件的组成部分。对于一个经典的web页面，组成部分有header，menu，body，footer。创建一个这样布局的模板页很简单：

<!--[if !supportLists]-->1.       <!--[endif]-->打开一个新的JSP页面。

<!--[if !supportLists]-->2.       <!--[endif]-->引入Tiles标签库。

<!--[if !supportLists]-->3.       <!--[endif]-->创建一个HTML表格，使其cells与模板页的骨架匹配。

<!--[if !supportLists]-->4.       <!--[endif]-->使用一个Tiles JSP标签（<tiles:insert>）为布局的每一个部分命名。

我们每创建一个cell来放置布局组件，我们都放置一个JSP标签（<tiles:insert attribute=”aName”>。这使我们能够不断地使用这样的布局，每一次只要为tiles传递不同的路径即可。

我们的经典布局可以构造成一个完整的独立的模板页，只要再加上HTML标记的其余部分。

11.2.1 说了半天，到底什么是tile?
         严格地说，tile是JSP页面的一个矩形区域。

         Tile对象支持一些重要的特性，如参数和定义。

         参数

         Tile可以在运行时通过参数或属性的形式接受变量信息。Tiles参数通常叫做属性（Attributes），以区别於request的参数。Tile属性在插入tile时定义，而且只对这个tile可见。Tile的attributes可以是字符串或其他类型。

         定义

         定义存储一组attributes，使一个屏幕描述成为一个拥有唯一表示的可辩别的对象。声明一个基类屏幕定义，然后派生这个基类屏幕定义以创建其他屏幕定义。

11.2.2 部署一个Tiles模板
         <tiles:insert>

                   <tiles:put/>

         </tiles:insert>

11.2.3 增加样式表
         使用<html:base>与<html:rewrite>。

11.2.4 模板与MVC
         可以重构既存系统得到一个MVC模板系统。

11.3 Tiles定义
11.3.1 声明定义
         一个定义需要如下信息：

<!--[if !supportLists]-->n  <!--[endif]-->基础模板文件的路径

<!--[if !supportLists]-->n  <!--[endif]-->传递给模板的0个或多个属性列表

<!--[if !supportLists]-->n  <!--[endif]-->定义的一个标识符

仅通过向特性列表中增加identity，会增加一些功能：

<!--[if !supportLists]-->n  <!--[endif]-->可以在部署的时候通过额外的或替换的属性来重载定义。

<!--[if !supportLists]-->n  <!--[endif]-->可以扩展定义，把一个定义作为另一个的基础。

<!--[if !supportLists]-->n  <!--[endif]-->可以重用定义，把定义存储在JSP中或从XML文档加载。

<!--[if !supportLists]-->n  <!--[endif]-->定义可以是Struts ActionForward的目标。

11.3.2 JSP声明
         用JSP中使用Tiles定义的过程包括：

<!--[if !supportLists]-->n  <!--[endif]-->用JSP声明一个定义

<!--[if !supportLists]-->n  <!--[endif]-->部署JSP声明的定义

<!--[if !supportLists]-->n  <!--[endif]-->重载定义

<!--[if !supportLists]-->n  <!--[endif]-->使用JSPs重用定义

11.3.3 配置文件声明
         每一个定义通过name属性标识。

11.4 Tiles属性
         Tiles存储它的属性在自己的上下文中。

11.4.1 useAttribute
         <tiles:useAttribute name="myAttribute" />或

         <tiles:useAttribute attributeName="anAttribute" name="myAttribute" />

         这样声明之后，可以这样使用：

         <bean:write name="myAttribute" />

11.4.2 importAttribute
         <tiles:importAttribute>将所有tiles属性导入到page上下文。

11.4.3 put
         <tiles:put>将一个值与一个tiles属性关联。

11.4.4 putList与add
         Tiles的属性可以是java.util.List类型。

11.5 将应用程序移植到Tiles
         将应用程序移植到Tiles与重构的“抽取方法”相似。

11.5.1 安装Tiles框架
         首先，备份所有东西。

         Tiles与Struts1.1集成在一起的。

11.5.2 测试缺省配置
         将web.xml文件中debug和detail参数设置成2。查看所有的错误信息。

11.5.3 审查页面
         识别布局。

         识别Tiles

         命名候选组件

11.5.4 使用<tiles:insert>重构页面
11.5.5 抽取<tiles:insert>到定义
11.5.6 规范基础布局
11.5.7 将定义细化到基类和扩展类
11.5.8 开发一个规程
         经过几个页面的重构，应该可以开发一个规程。前几个页面是根据应用程序的流程，到后来就可以根据规程one by one进行重构。

11.5.9 管理移植
<!--[if !supportLists]-->第十二章            <!--[endif]-->验证用户输入
12.1 见文知意
         一个健壮的应用程序检查所有的输入，守卫所有可预见的错误。

12.1.1 不能拒绝输入
         缺省情况下，HTML元素接受用户输入的所有内容。可以使用javascript来控制，但是用户可以关闭javascript功能。使用业务层验证数据不合适，特别是对于分布式系统，业务对象可能在远程，使用业务对象来验证成本比较高。

12.1.2 web层验证
         在一个无模型的、分布式环境下，我们需要验证规程做如下事情：

<!--[if !supportLists]-->n  <!--[endif]-->要求一些字段必需有值

<!--[if !supportLists]-->n  <!--[endif]-->确认给定的值属于预期的模式或范围

<!--[if !supportLists]-->n  <!--[endif]-->一次性检查整个form并返回一个message列表

<!--[if !supportLists]-->n  <!--[endif]-->比较多个字段的值

<!--[if !supportLists]-->n  <!--[endif]-->返回原始的输入用来纠正

<!--[if !supportLists]-->n  <!--[endif]-->当需要显示消息时，显示区域化的消息

<!--[if !supportLists]-->n  <!--[endif]-->如果javascript被禁用，要执行服务器端的验证

<!--[if !supportLists]-->n  <!--[endif]-->松散耦合：验证的规则应该和标记语言或java语言分离。

<!--[if !supportLists]-->n  <!--[endif]-->客户端验证：客户端验证是不安全的。虽然不能依赖于客户端验证，但客户端验证仍然是很有用的，因为可以使用户获得即时的反馈。

12.1.3 验证器的效果
         使用Jakarta Commons Validator的效果有：

<!--[if !supportLists]-->n  <!--[endif]-->验证器是一个框架组件，可以满足上一节提到的需求。

<!--[if !supportLists]-->n  <!--[endif]-->验证器通过XML文件配置，来对form的输入域产生验证规则。

<!--[if !supportLists]-->n  <!--[endif]-->验证器定义的规则也是通过XML文件配置。

<!--[if !supportLists]-->n  <!--[endif]-->提供了对于基本类型的验证器，如果需要可以创建自己的验证器。

<!--[if !supportLists]-->n  <!--[endif]-->正则表达式可以提供基于模式的验证，如邮编和电话号码。

<!--[if !supportLists]-->n  <!--[endif]-->支持多页面的和区域化的验证。

使用Jakarta Commons Validator有以下好处：

<!--[if !supportLists]-->n  <!--[endif]-->优化资源的使用：提供Javascript验证，只要用户没有禁用，服务器端验证是得到保证的。

<!--[if !supportLists]-->n  <!--[endif]-->单点维护：服务器端和客户端验证通过同一个配置产生。

<!--[if !supportLists]-->n  <!--[endif]-->可扩展性：自定义验证可以定义为正则表达式或者java代