Struts2教程

时间 2019-11-30

原文原文链接

第一章　搭建Struts2开发环境

在Struts的官方网站上，写着下面两段话：css

Apache Struts 2 is an elegant, extensible framework for creating enterprise-ready Java web applications. The framework is designed to streamline the full development cycle, from building, to deploying, to maintaining applications over time.html

Apache Struts 2 was originally known as WebWork 2. After working independently for several years, the WebWork and Struts communities joined forces to create Struts2. This new version of Struts is simpler to use and closer to how Struts was always meant to be.java

其大意为：Apache Struts2是一个为企业级应用打造的优秀的、可扩展的WEB框架，该框架旨在充分精简应用程序的开发周期，从而减小建立、发布直到应用所花费的时间。程序员

Apache Struts2本来就是闻名中外的Webwork2，在各自经历几年的发展以后，Struts和WebWork社区决定合二为一，也就是今天的Struts2。web

Struts是一个基于Model2的MVC框架，为应用程序的WEB层提供了良好的结构严谨的实现。Struts发展较早，早期的Struts1.X已被不少J2EE程序员熟悉，通过多年来的发展，这支队伍变得愈来愈大，不少企业级应用程序都是基于Struts开发的。apache

Struts2与Struts1.X已经不能再放到一块儿比较，虽然都是对MVC架构模式的实现，本质却彻底不一样。Struts2的前身是WebWork，其实现方式和功能都要优于Struts1.X,可是，Struts先入为主，不少应用程序都基于Struts，其生命力和普及度使得WebWork落于下风。随着新思想和新架构的不断涌入，特别是WEB2.0被大量说起，Struts1.x显然没法跟上突飞猛进的变化，在不少应用上显得力不从心，最终催生了Struts2.0。能够说Struts2.0是为变而变。编程

很大程度上，Struts2.0没法避开投机取巧的嫌疑。不过，借助Struts的名声，加上WebWork构建良好的框架，两者取长补短，确实不失为一种黄金组合和一种绝佳的宣传方式。数组

笔者杜撰此文时，能够下载到的最新版本为2.1.0，但他的魅力已初露尖角，应该会有很好的前途。浏览器

Struts2的新特征

若是读者熟悉Struts1.X，会发现Struts2比Struts1.X有了巨大的变化：安全

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开发组，翻译：tianxinet（胖猴）。

Struts2的环境要求

Apache Struts2的环境需求以下：

Servlet API 2.4

JSP API 2.0

Java 5

须要提醒的是，在Struts中会用到Annotation，因此请将JDK版本升级到1.5.

Struts2环境搭建

4.1Struts的下载

从游览器输入http://people.apache.org/builds/struts/，便可看到Struts的各个版本列表。从下图中能够发现，如今Struts2.0的最新版是2.1.0,发布于2007年10月29。

（图1）

(图2)

从图2中能够看出，便可以分开下载，又能够一次所有下载。所有下载的大小为83M,

下表注明了各个压缩包的做用。

压缩包名称	做用
struts-2.1.0-docs.zip	文档，包含了Struts2API
struts-2.1.0-lib.zip	构建Struts2工程所须要的包
struts-2.1.0-src.zip	Struts2的全部源代码
struts2-blank-2.1.0.war	空白工程
struts-2.1.0-all.zip	大集成，包括上面全部的内容

4.2　开发工具介绍

目前J2EE开发工具主要分为Eclipse和NetBeans两大阵营，Eclipse的最高版本为3.3,NetBeans的最高版本为6.0.今天刚刚重新闻上看到，NetBeans6.0的英文正式版正式发布了，真是可喜可贺。

笔者在开发时以Eclipse为主，但Eclipse并不支持WEB开发，须要安装相应插件。MyEclipse是一个功能强大且框架支持很是普遍的WEB开发插件，该产品是收费项目。目前MyEclipse的最高版本为6.0,即使如此，尚不支持Struts2.0,咱们只能手工配置Struts2.0的开发环境。

4.3　库文件

从网站上下载的Struts2包含了二三十个库文件，但大多数是可选的，有些库是插件，用于和其余框架的整合。

读者可自行下载struts2-blank-2.1.0.war压缩包，展开后是一个很是简单的项目，从WEB-INF/lib目录中能够看到5个库文件，解释以下：

包名	说明
commons-logging-1.0.4.jar	日志管理
freemarker-2.3.8.jar	表现层框架，定义了struts2的可视组件主题（theme）
ognl-2.6.11.jar	OGNL表达式语言，struts2支持该EL
struts2-core-2.0.10.jar	struts2的核心库
xwork-2.0.4.jar	webwork的核心库，天然须要它的支持

（图3）

4.3　使用Eclipse搭建Struts2的开发环境

4.3.1建立用户库

将Struts2所需的包建成用户库，能够更加方便地进行管理和使用，这是一个好的习惯——编程从习惯开始。

1.选择菜单Window->Preferences->Java->Build Path->User Libraries。如图4：

(图4)

2.点击右侧的New…按钮，建立一个新的用户库，弹出如图5所示对话框：

(图5)

3.输入用户库的名称，如：Struts2，点击OK按钮，该对话框自动关闭。结果如图6所示：

（图6）

此时，右侧的按钮被点亮。

4.点击“Add JARS…”按钮，添加用户库所需的库文件，在Struts2中，至少要包含上文中提到的5个库文件。添加后效果如图7所示：

（图7）

5.点击“OK”完成。

4.3.2开发第一个Struts2应用程序——世界，你好

开发WEB应用程序，本文使用了MyEclipse插件。该插件为收费软件，目前提供英文版和日文版，不一样的版本能够运行在Windows、Linux等操做系统上。为了方便用户，MyEclipse有一个Full版，连同Eclipse一块儿安装，对于初学者而言，能够减小不少麻烦和困扰。

读者可自行去http://www.myeclipseide.com/网站下载该软件的共享版本。建议读者下载MyEclipse5.5（这也是笔者使用的版本），这个版本相对比较稳定，MyEclipse6.0还处于测试之中。

入门教程老是以HelloWorld做为学习的第一步，天然笔者也不例外。本示例从游览器输入网址，提交请求后在页面中显示“世界，你好”的信息。

1.新建WEB工程，如图8所示：

（图8）

2.点击“Next”，输入工程名，如图9所示：

（图9）

3.点击“Finish”完成。

4.如今将Struts2的库导入到工程中，右击工程名称弹出快捷菜单，选择Build Path->Add Libraries…，如图10所示。

（图10）

5.从弹出的对话框中选择“User Libraries”，如图11所示。

（图11）

6. 单击下一步，咱们看到，上文中建立的用户库出如今列表中，在“Struts2”前的复选框上打勾，点击“Finish”完成。如图12。

（图12）

7.将Struts2所带的过滤器org.apache.struts2.dispatcher.FilterDispatcher配置到工程的web.xml文件中，默认状况下，该过滤器拦截请求字符串中以.action结尾的请求，并将该请求委托给指定的Action进行处理。最直观的表现就是调用Action的execute()方法。代码以下：

代码清单1：web.xml

<filter-name>struts2</filter-name>

<filter-class>

org.apache.struts2.dispatcher.FilterDispatcher

</filter-class>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

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

</filter-mapping>

注：在Sturts1.X中，该行为由Servlet完成。

8.建立包com.lizanhong.action，并在该包中建立HelloWorldAction类，该类继承自com.opensymphony.xwork2.ActionSupport。理论上，Action能够不继承任何类或实现任何接口，以加强程序的可测试性，这也是和Struts1.X不一样的地方。可是，继承自ActionSupport能够减小更多的编码工做。

在ActionSupport中，定义了方法execute()，当用户向该Action发送请求时，会自动调用。程序代码以下：

代码清单2：HelloWorldAction.java

package com.lizanhong.action;

import com.opensymphony.xwork2.ActionSupport;

publicclass HelloWorldAction extends ActionSupport {

@Override

public String execute() throws Exception {

System.out.println("Action执行了。");

returnSUCCESS;

}

注：ActionSupport是Struts2提供的类，功能相似于Struts1.x中的Action类，该类封装了几个有用的功能，好比：

getText()：从资源文件中获取国际化消息。

addFieldError()：验证输入未经过时添加错误消息，支持国际化。

execute()：该方法通常会被重写，当客户端向Action发送请求时，会调用此方法。

总结起来，该类主要提供了错误消息的支持和国际化支持。

在工程类路径下建立struts.xml文件，这是Struts2的配置文件，相似于Struts1.x中的struts-config.xml，在struts.xml文件中能够配置Action、Bean、Interceptor等组件。

代码清单3：struts.xml

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN""http://struts.apache.org/dtds/struts-2.0.dtd">

<result>/result.jsp</result>

</action>

</package>

</struts>

注：WEB应用程序的类路径是指WEB-INF/classes目录，在Eclipse中，建立在src目录下的文件最终发布后会自动复制到WEB-INF/classes目录下。

代码清单3中涉及到不少标签，如下是简单的解释：

标签名称	说明
include	包含其余xml文件，在示例中，这意味着struts.xml能够访问定义在struts-default.xml文件中的组件。该元素可使得Struts2定义多个配置文件，“分而治之”。要注意的是，任何一个struts2配置文件都应该和struts.xml有相同的格式，包括doctype，而且能够放在类路径下的任何地方。
package	为Action或截拦器分组。 name：名称，必填项，名称自定义，没特别要求。方便别的package引用。 extends：package能继承其余的package，即经过该属性实现，值为另外一个package的name。在示例中，extends =”struts-default”是从struts-default.xml中继承的。
action	定义Action，name属性为访问时用到的名称，class属性是Action的类名。
result	根据Action的返回值定义页面导航。 Action的预约义的返回值有： String SUCCESS = "success"; String NONE = "none"; String ERROR = "error"; String INPUT = "input"; String LOGIN = "login"; 好比，当Action返回SUCCESS时但愿转到ok.jsp页面，则能够这样写： <result name=”success”>ok.jsp</result> 其中，name的缺省为success。

9.result.jsp是一个很是简单的jsp页面，输出“世界，你好”。

代码清单4：result.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

String path = request.getContextPath();

String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<head>

<title>My JSP 'result.jsp' starting page</title>

<!--

-->

</head>

<body>

世界，你好. <br>

</body>

</html>

9.发布工程，在浏览器中输入：http://localhost:8081/Struts2Demo/helloworld.action，在控制台输出“Action执行了。”

10.在浏览器的结果以下图13：

(图13)

struts.xml的定义文件

代码清单5：struts-2.0.dtd

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

<!--

Struts configuration DTD.

Use the following DOCTYPE

<!DOCTYPE struts PUBLIC

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

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

-->

<!ELEMENT struts (package|include|bean|constant)*>

<!ELEMENT package (result-types?, interceptors?, default-interceptor-ref?, default-action-ref?, global-results?, global-exception-mappings?, action*)>

<!ATTLIST package

name CDATA #REQUIRED

extends CDATA #IMPLIED

namespace CDATA #IMPLIED

abstract CDATA #IMPLIED

externalReferenceResolver NMTOKEN #IMPLIED

<!ELEMENT result-types (result-type+)>

<!ELEMENT result-type (param*)>

<!ATTLIST result-type

name CDATA #REQUIRED

class CDATA #REQUIRED

default (true|false) "false"

<!ELEMENT interceptors (interceptor|interceptor-stack)+>

<!ELEMENT interceptor (param*)>

<!ATTLIST interceptor

name CDATA #REQUIRED

class CDATA #REQUIRED

<!ELEMENT interceptor-stack (interceptor-ref+)>

<!ATTLIST interceptor-stack

name CDATA #REQUIRED

<!ELEMENT interceptor-ref (param*)>

<!ATTLIST interceptor-ref

name CDATA #REQUIRED

<!ELEMENT default-interceptor-ref (param*)>

<!ATTLIST default-interceptor-ref

name CDATA #REQUIRED

<!ELEMENT default-action-ref (param*)>

<!ATTLIST default-action-ref

name CDATA #REQUIRED

<!ELEMENT global-results (result+)>

<!ELEMENT global-exception-mappings (exception-mapping+)>

<!ELEMENT action (param|result|interceptor-ref|exception-mapping)*>

<!ATTLIST action

name CDATA #REQUIRED

class CDATA #IMPLIED

method CDATA #IMPLIED

converter CDATA #IMPLIED

<!ELEMENT param (#PCDATA)>

<!ATTLIST param

name CDATA #REQUIRED

<!ELEMENT result (#PCDATA|param)*>

<!ATTLIST result

name CDATA #IMPLIED

type CDATA #IMPLIED

<!ELEMENT exception-mapping (#PCDATA|param)*>

<!ATTLIST exception-mapping

name CDATA #IMPLIED

exception CDATA #REQUIRED

result CDATA #REQUIRED

<!ELEMENT include (#PCDATA)>

<!ATTLIST include

file CDATA #REQUIRED

<!ELEMENT bean (#PCDATA)>

<!ATTLIST bean

type CDATA #IMPLIED

name CDATA #IMPLIED

class CDATA #REQUIRED

scope CDATA #IMPLIED

static CDATA #IMPLIED

optional CDATA #IMPLIED

<!ELEMENT constant (#PCDATA)>

<!ATTLIST constant

name CDATA #REQUIRED

value CDATA #REQUIRED

总结

Struts是一个时下很是流行并被许多企业级应用程序采用的WEB框架，Struts2在Struts1.x的基础上进行了大量改造，和WebWork合二为一，引进了更多的新观念、新思想和新技术，使之更符合J2EE应用程序开发的须要。

“工欲善其事，必先利其器”，掌握一两种开发工具，可以大大提升编程效率，也能加强开发者的信心。学习一门新技术时，第一个应用程序很是重要，若是第一个最简单的程序运行不成功，会使得学习者的积极性大打折扣，这也是笔者不肯意看到的。因此，本章图文并茂地详细介绍了Struts2应用程序的开发过程，并尽量少的说起陌生的概念和术语。

第二章　Struts2的工做机制及分析

概述

本章讲述Struts2的工做原理。

读者若是曾经学习过Struts1.x或者有过Struts1.x的开发经验，那么千万不要想固然地觉得这一章能够跳过。实际上Struts1.x与Struts2并没有咱们想象的血缘关系。虽然Struts2的开发小组极力保留Struts1.x的习惯，但由于Struts2的核心设计彻底改变，从思想到设计到工做流程，都有了很大的不一样。

Struts2是Struts社区和WebWork社区的共同成果，咱们甚至能够说，Struts2是WebWork的升级版，他采用的正是WebWork的核心，因此，Struts2并非一个不成熟的产品，相反，构建在WebWork基础之上的Struts2是一个运行稳定、性能优异、设计成熟的WEB框架。

本章主要对Struts的源代码进行分析，由于Struts2与WebWork的关系如此密不可分，所以，读者须要下载xwork的源代码，访问http://www.opensymphony.com/xwork/download.action便可自行下载。

下载的Struts2源代码文件是一个名叫struts-2.1.0-src.zip的压缩包，里面的目录和文件很是多，读者能够定位到struts-2.1.0-src"struts-2.0.10"src"core"src"main"java目录下查看Struts2的源文件，如图14所示。

（图14）

主要的包和类

Struts2框架的正常运行，除了占核心地位的xwork的支持之外，Struts2自己也提供了许多类，这些类被分门别类组织到不一样的包中。从源代码中发现，基本上每个Struts2类都访问了WebWork提供的功能，从而也能够看出Struts2与WebWork千丝万缕的联系。但不管如何，Struts2的核心功能好比将请求委托给哪一个Action处理都是由xwork完成的，Struts2只是在WebWork的基础上作了适当的简化、增强和封装，并少许保留Struts1.x中的习惯。

如下是对各包的简要说明：

包名	说明
org.apache.struts2. components	该包封装视图组件，Struts2在视图组件上有了很大增强，不只增长了组件的属性个数，更新增了几个很是有用的组件，如updownselect、doubleselect、datetimepicker、token、tree等。另外，Struts2可视化视图组件开始支持主题(theme)，缺省状况下，使用自带的缺省主题，若是要自定义页面效果，须要将组件的theme属性设置为simple。
org.apache.struts2. config	该包定义与配置相关的接口和类。实际上，工程中的xml和properties文件的读取和解析都是由WebWork完成的，Struts只作了少许的工做。
org.apache.struts2.dispatcher	Struts2的核心包，最重要的类都放在该包中。
org.apache.struts2.impl	该包只定义了3个类，他们是StrutsActionProxy、StrutsActionProxyFactory、StrutsObjectFactory，这三个类都是对xwork的扩展。
org.apache.struts2.interceptor	定义内置的截拦器。
org.apache.struts2.util	实用包。
org.apache.struts2.validators	只定义了一个类：DWRValidator。
org.apache.struts2.views	提供freemarker、jsp、velocity等不一样类型的页面呈现。

下表是对一些重要类的说明：

类名	说明
org.apache.struts2.dispatcher. Dispatcher	该类有两个做用：一、初始化二、调用指定的Action的execute()方法。
org.apache.struts2.dispatcher. FilterDispatcher	这是一个过滤器。文档中已明确说明，若是没有经验，配置时请将url-pattern的值设成/*。该类有四个做用：一、执行Action 二、清理ActionContext，避免内存泄漏三、处理静态内容（Serving static content）四、为请求启动xwork’s的截拦器链。
com.opensymphony.xwork2. ActionProxy	Action的代理接口。
com.opensymphony.xwork2. ctionProxyFactory	生产ActionProxy的工厂。
com.opensymphony.xwork2.ActionInvocation	负责调用Action和截拦器。
com.opensymphony.xwork2.config.providers. XmlConfigurationProvider	负责Struts2的配置文件的解析。

Struts2的工做机制

3.1Struts2体系结构图

Strut2的体系结构如图15所示：

（图15）

3.2Struts2的工做机制

从图15能够看出，一个请求在Struts2框架中的处理大概分为如下几个步骤：

一、客户端初始化一个指向Servlet容器（例如Tomcat）的请求；

二、这个请求通过一系列的过滤器（Filter）（这些过滤器中有一个叫作ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其余框架的集成颇有帮助，例如：SiteMesh Plugin）；

三、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否须要调用某个Action；

四、若是ActionMapper决定须要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；

五、ActionProxy经过Configuration Manager询问框架的配置文件，找到须要调用的Action类；

六、ActionProxy建立一个ActionInvocation的实例。

七、ActionInvocation实例使用命名模式来调用，在调用Action的过程先后，涉及到相关拦截器（Intercepter）的调用。

八、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果一般是（但不老是，也多是另外的一个Action链）一个须要被表示的JSP或者FreeMarker的模版。在表示的过程当中可使用Struts2 框架中继承的标签。在这个过程当中须要涉及到ActionMapper。

注：以上步骤参考至网上，具体网址已忘记。在此表示感谢！

3.3Struts2源代码分析

和Struts1.x不一样，Struts2的启动是经过FilterDispatcher过滤器实现的。下面是该过滤器在web.xml文件中的配置：

代码清单6：web.xml（截取）

<filter-name>struts2</filter-name>

<filter-class>

org.apache.struts2.dispatcher.FilterDispatcher

</filter-class>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

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

</filter-mapping>

Struts2建议，在对Struts2的配置尚不熟悉的状况下，将url-pattern配置为/*，这样该过滤器将截拦全部请求。

实际上，FilterDispatcher除了实现Filter接口之外，还实现了StrutsStatics接口，继承代码以下：

代码清单7：FilterDispatcher结构

publicclass FilterDispatcher implements StrutsStatics, Filter {

}

StrutsStatics并无定义业务方法，只定义了若干个常量。Struts2对经常使用的接口进行了从新封装，好比HttpServletRequest、HttpServletResponse、HttpServletContext等。　如下是StrutsStatics的定义：

代码清单8：StrutsStatics.java

publicinterface StrutsStatics {

/**

*ConstantfortheHTTPrequestobject.

publicstaticfinal String HTTP_REQUEST ="com.opensymphony.xwork2.dispatcher.HttpServletRequest";

/**

*ConstantfortheHTTPresponseobject.

publicstaticfinal String HTTP_RESPONSE ="com.opensymphony.xwork2.dispatcher.HttpServletResponse";

/**

*ConstantforanHTTPrequest dispatcher}.

publicstaticfinal String SERVLET_DISPATCHER ="com.opensymphony.xwork2.dispatcher.ServletDispatcher";

/**

*Constantfortheservlet context}object.

publicstaticfinal String SERVLET_CONTEXT ="com.opensymphony.xwork2.dispatcher.ServletContext";

/**

*ConstantfortheJSPpage context}.

publicstaticfinal String PAGE_CONTEXT = "com.opensymphony.xwork2.dispatcher.PageContext";

/**ConstantforthePortletContextobject*/

publicstaticfinal String STRUTS_PORTLET_CONTEXT = "struts.portlet.context";

}

容器启动后，FilterDispatcher被实例化，调用init(FilterConfig filterConfig)方法。该方法建立Dispatcher类的对象，而且将FilterDispatcher配置的初始化参数传到对象中（详情请参考代码清单10），并负责Action的执行。而后获得参数packages，值得注意的是，还有另外三个固定的包和该参数进行拼接，分别是org.apache.struts2.static、template、和org.apache.struts2.interceptor.debugging，中间用空格隔开，通过解析将包名变成路径后存储到一个名叫pathPrefixes的数组中，这些目录中的文件会被自动搜寻。

代码清单9：FilterDispatcher.init()方法

publicvoid init(FilterConfig filterConfig) throws ServletException {

this.filterConfig = filterConfig;

dispatcher = createDispatcher(filterConfig);

dispatcher.init();

String param = filterConfig.getInitParameter("packages");

String packages = "org.apache.struts2.static template org.apache.struts2.interceptor.debugging";

if (param != null) {

packages = param + " " + packages;

}

this.pathPrefixes = parse(packages);

}

代码清单10：FilterDispatcher.createDispatcher()方法

protected Dispatcher createDispatcher(FilterConfig filterConfig) {

Map<String,String> params = new HashMap<String,String>();

for (Enumeration e = filterConfig.getInitParameterNames(); e.hasMoreElements(); ) {

String name = (String) e.nextElement();

String value = filterConfig.getInitParameter(name);

params.put(name, value);

}

returnnew Dispatcher(filterConfig.getServletContext(), params);

}

当用户向Struts2发送请求时，FilterDispatcher的doFilter()方法自动调用，这个方法很是关键。首先，Struts2对请求对象进行从新包装，这次包装根据请求内容的类型不一样，返回不一样的对象，若是为multipart/form-data类型，则返回MultiPartRequestWrapper类型的对象，该对象服务于文件上传，不然返回StrutsRequestWrapper类型的对象，MultiPartRequestWrapper是StrutsRequestWrapper的子类，而这两个类都是HttpServletRequest接口的实现。包装请求对象如代码清单11所示：

代码清单11：FilterDispatcher.prepareDispatcherAndWrapRequest()方法

protectedHttpServletRequest prepareDispatcherAndWrapRequest(

HttpServletRequest request,

HttpServletResponse response) throws ServletException {

Dispatcher du = Dispatcher.getInstance();

if (du == null) {

Dispatcher.setInstance(dispatcher);

dispatcher.prepare(request, response);

} else {

dispatcher = du;

}

try {

request = dispatcher.wrapRequest(request, getServletContext());

} catch (IOException e) {

String message = "Could not wrap servlet request with MultipartRequestWrapper!";

LOG.error(message, e);

thrownew ServletException(message, e);

}

return request;

}

request对象从新包装后，经过ActionMapper的getMapping()方法获得请求的Action，Action的配置信息存储在ActionMapping对象中，该语句以下：mapping = actionMapper.getMapping(request, dispatcher.getConfigurationManager());。下面是ActionMapping接口的实现类DefaultActionMapper的getMapping()方法的源代码：

代码清单12：DefaultActionMapper.getMapping()方法

public ActionMapping getMapping(HttpServletRequest request,

ConfigurationManager configManager) {

ActionMapping mapping = new ActionMapping();

String uri = getUri(request);//获得请求路径的URI，如：testAtcion.action或testAction!method

uri = dropExtension(uri);//删除扩展名，默认扩展名为action，在代码中的定义是List extensions = new ArrayList() {{ add("action");}};

if (uri == null) {

returnnull;

}

parseNameAndNamespace(uri, mapping, configManager);//从uri变量中解析出Action的name和namespace

handleSpecialParameters(request, mapping);//将请求参数中的重复项去掉

//若是Action的name没有解析出来，直接返回

if (mapping.getName() == null) {

returnnull;

}

//下面处理形如testAction!method格式的请求路径

if (allowDynamicMethodCalls) {

// handle "name!method" convention.

String name = mapping.getName();

int exclamation = name.lastIndexOf("!");//!是Action名称和方法名的分隔符

if (exclamation != -1) {

mapping.setName(name.substring(0, exclamation));//提取左边为name

mapping.setMethod(name.substring(exclamation + 1));//提取右边的method

}

return mapping;

}

该代码的活动图以下：

（图16）

从代码中看出，getMapping()方法返回ActionMapping类型的对象，该对象包含三个参数：Action的name、namespace和要调用的方法method。

若是getMapping()方法返回ActionMapping对象为null，则FilterDispatcher认为用户请求不是Action，天然另当别论，FilterDispatcher会作一件很是有意思的事：若是请求以/struts开头，会自动查找在web.xml文件中配置的packages初始化参数，就像下面这样(注意粗斜体部分)：

代码清单13：web.xml(部分)

<filter-name>struts2</filter-name>

<filter-class>

org.apache.struts2.dispatcher.FilterDispatcher

</filter-class>

<init-param>

<param-name>packages</param-name>

<param-value>com.lizanhong.action</param-value>

</init-param>

</filter>

FilterDispatcher会将com.lizanhong.action包下的文件看成静态资源处理，即直接在页面上显示文件内容，不过会忽略扩展名为class的文件。好比在com.lizanhong.action包下有一个aaa.txt的文本文件，其内容为“中华人民共和国”，访问http://localhost:8081/Struts2Demo/struts/aaa.txt时会有如图17的输出：

（图17）

查找静态资源的源代码如清单14：

代码清单14：FilterDispatcher.findStaticResource()方法

protectedvoid findStaticResource(String name, HttpServletRequest request, HttpServletResponse response) throws IOException {

if (!name.endsWith(".class")) {//忽略class文件

//遍历packages参数

for (String pathPrefix : pathPrefixes) {

InputStream is = findInputStream(name, pathPrefix);//读取请求文件流

if (is != null) {

……（省略部分代码）

// set the content-type header

String contentType = getContentType(name);//读取内容类型

if (contentType != null) {

response.setContentType(contentType);//从新设置内容类型

}

……（省略部分代码）

try {

//将读取到的文件流以每次复制4096个字节的方式循环输出

copy(is, response.getOutputStream());

} finally {

is.close();

}

return;

}

若是用户请求的资源不是以/struts开头——多是.jsp文件，也多是.html文件，则经过过滤器链继续往下传送，直到到达请求的资源为止。

若是getMapping()方法返回有效的ActionMapping对象，则被认为正在请求某个Action，将调用Dispatcher.serviceAction(request, response, servletContext, mapping)方法，该方法是处理Action的关键所在。上述过程的源代码如清单15所示。

代码清单15：FilterDispatcher.doFilter()方法

publicvoid doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throwsIOException, ServletException {

HttpServletRequest request = (HttpServletRequest) req;

HttpServletResponse response = (HttpServletResponse) res;

ServletContext servletContext = getServletContext();

String timerKey = "FilterDispatcher_doFilter: ";

try {

UtilTimerStack.push(timerKey);

request = prepareDispatcherAndWrapRequest(request, response);//从新包装request

ActionMapping mapping;

try {

mapping = actionMapper.getMapping(request, dispatcher.getConfigurationManager());//获得存储Action信息的ActionMapping对象

} catch (Exception ex) {

……（省略部分代码）

return;

}

if (mapping == null) {//若是mapping为null，则认为不是请求Action资源

String resourcePath = RequestUtils.getServletPath(request);

if ("".equals(resourcePath) && null != request.getPathInfo()) {

resourcePath = request.getPathInfo();

}

//若是请求的资源以/struts开头，则看成静态资源处理

if (serveStatic && resourcePath.startsWith("/struts")) {

String name = resourcePath.substring("/struts".length());

findStaticResource(name, request, response);

} else {

//不然，过滤器链继续往下传递

chain.doFilter(request, response);

}

// The framework did its job here

return;

}

//若是请求的资源是Action，则调用serviceAction方法。

dispatcher.serviceAction(request, response, servletContext, mapping);

} finally {

try {

ActionContextCleanUp.cleanUp(req);

} finally {

UtilTimerStack.pop(timerKey);

}

这段代码的活动图如图18所示：

（图18）

在Dispatcher.serviceAction()方法中，先加载Struts2的配置文件，若是没有人为配置，则默认加载struts-default.xml、struts-plugin.xml和struts.xml，而且将配置信息保存在形如com.opensymphony.xwork2.config.entities.XxxxConfig的类中。

类com.opensymphony.xwork2.config.providers.XmlConfigurationProvider负责配置文件的读取和解析，addAction()方法负责读取<action>标签，并将数据保存在ActionConfig中；addResultTypes()方法负责将<result-type>标签转化为ResultTypeConfig对象；loadInterceptors()方法负责将<interceptor>标签转化为InterceptorConfi对象；loadInterceptorStack()方法负责将<interceptor-ref>标签转化为InterceptorStackConfig对象；loadInterceptorStacks()方法负责将<interceptor-stack>标签转化成InterceptorStackConfig对象。而上面的方法最终会被addPackage()方法调用，将所读取到的数据聚集到PackageConfig对象中，细节请参考代码清单16。

代码清单16：XmlConfigurationProvider.addPackage()方法

protected PackageConfig addPackage(Element packageElement) throws ConfigurationException {

PackageConfig newPackage = buildPackageContext(packageElement);

if (newPackage.isNeedsRefresh()) {

return newPackage;

}

if (LOG.isDebugEnabled()) {

LOG.debug("Loaded " + newPackage);

}

// add result types (and default result) to this package

addResultTypes(newPackage, packageElement);

// load the interceptors and interceptor stacks for this package

loadInterceptors(newPackage, packageElement);

// load the default interceptor reference for this package

loadDefaultInterceptorRef(newPackage, packageElement);

// load the default class ref for this package

loadDefaultClassRef(newPackage, packageElement);

// load the global result list for this package

loadGlobalResults(newPackage, packageElement);

// load the global exception handler list for this package

loadGlobalExceptionMappings(newPackage, packageElement);

// get actions

NodeList actionList = packageElement.getElementsByTagName("action");

for (int i = 0; i < actionList.getLength(); i++) {

Element actionElement = (Element) actionList.item(i);

addAction(actionElement, newPackage);

}

// load the default action reference for this package

loadDefaultActionRef(newPackage, packageElement);

configuration.addPackageConfig(newPackage.getName(), newPackage);

return newPackage;

}

活动图如图19所示：

（图19）

配置信息加载完成后，建立一个Action的代理对象——ActionProxy引用，实际上对Action的调用正是经过ActionProxy实现的，而ActionProxy又由ActionProxyFactory建立，ActionProxyFactory是建立ActionProxy的工厂。

注：ActionProxy和ActionProxyFactory都是接口，他们的默认实现类分别是DefaultActionProxy和DefaultActionProxyFactory，位于com.opensymphony.xwork2包下。

在这里，咱们绝对有必要介绍一下com.opensymphony.xwork2.DefaultActionInvocation类，该类是对ActionInvocation接口的默认实现，负责Action和截拦器的执行。

在DefaultActionInvocation类中，定义了invoke()方法，该方法实现了截拦器的递归调用和执行Action的execute()方法。其中，递归调用截拦器的代码如清单17所示：

代码清单17：调用截拦器，DefaultActionInvocation.invoke()方法的部分代码

if (interceptors.hasNext()) {

//从截拦器集合中取出当前的截拦器

final InterceptorMapping interceptor = (InterceptorMapping) interceptors.next();

UtilTimerStack.profile("interceptor: "+interceptor.getName(),

new UtilTimerStack.ProfilingBlock<String>() {

public String doProfiling() throws Exception {

//执行截拦器（Interceptor）接口中定义的intercept方法

resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);

returnnull;

}

});

}

从代码中彷佛看不到截拦器的递归调用，实际上是否递归彻底取决于程序员对程序的控制，先来看一下Interceptor接口的定义：

代码清单18：Interceptor.java

publicinterface Interceptor extends Serializable {

void destroy();

void init();

String intercept(ActionInvocation invocation) throws Exception;

}

全部的截拦器必须实现intercept方法，而该方法的参数偏偏又是ActionInvocation，因此，若是在intercept方法中调用invocation.invoke()，代码清单17会再次执行，从Action的Intercepor列表中找到下一个截拦器，依此递归。下面是一个自定义截拦器示例：

代码清单19：CustomIntercepter.java

publicclass CustomIntercepter extends AbstractInterceptor {

@Override

public String intercept(ActionInvocation actionInvocation) throws Exception

{

actionInvocation.invoke();

return"李赞红";

}

截拦器的调用活动图如图20所示：

（图20）

若是截拦器所有执行完毕，则调用invokeActionOnly()方法执行Action，invokeActionOnly()方法基本没作什么工做，只调用了invokeAction()方法。

为了执行Action，必须先建立该对象，该工做在DefaultActionInvocation的构造方法中调用init()方法早早完成。调用过程是：DefaultActionInvocation()->init()->createAction()。建立Action的代码以下：

代码清单20：DefaultActionInvocation.createAction()方法

protectedvoid createAction(Map contextMap) {

try {

action = objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);

} catch (InstantiationException e) {

……异常代码省略

}

Action建立好后，轮到invokeAction()大显身手了，该方法比较长，但关键语句实在不多，用心点看不会很难。

代码清单20：DefaultActionInvocation.invokeAction()方法

protected String invokeAction(Object action, ActionConfig actionConfig) throws Exception {

//获取Action中定义的execute()方法名称,实际上该方法是能够随便定义的

String methodName = proxy.getMethod();

String timerKey = "invokeAction: "+proxy.getActionName();

try {

UtilTimerStack.push(timerKey);

Method method;

try {

//将方法名转化成Method对象

method = getAction().getClass().getMethod(methodName, new Class[0]);

} catch (NoSuchMethodException e) {

// hmm -- OK, try doXxx instead

try {

//若是Method出错,则尝试在方法名前加do,再转成Method对象

String altMethodName = "do" + methodName.substring(0, 1).toUpperCase() + methodName.substring(1);

method = getAction().getClass().getMethod(altMethodName, new Class[0]);

} catch (NoSuchMethodException e1) {

// throw the original one

throw e;

}

//执行方法

Object methodResult = method.invoke(action, new Object[0]);

//处理跳转

if (methodResult instanceof Result) {

this.result = (Result) methodResult;

returnnull;

} else {

return (String) methodResult;

}

} catch (NoSuchMethodException e) {

……省略异常代码

} finally {

UtilTimerStack.pop(timerKey);

}

刚才使用了一段插述，咱们继续回到ActionProxy类。

咱们说Action的调用是经过ActionProxy实现的，其实就是调用了ActionProxy.execute()方法，而该方法又调用了ActionInvocation.invoke()方法。归根到底，最后调用的是DefaultActionInvocation.invokeAction()方法。

如下是调用关系图：

其中：

Ø ActionProxy：管理Action的生命周期，它是设置和执行Action的起始点。

Ø ActionInvocation：在ActionProxy层之下，它表示了Action的执行状态。它持有Action实例和全部的Interceptor

如下是serviceAction()方法的定义：

代码清单21：Dispatcher.serviceAction()方法

publicvoid serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context,

ActionMapping mapping) throws ServletException {

Map<String, Object> extraContext = createContextMap(request, response, mapping, context);

// If there was a previous value stack, then create a new copy and pass it in to be used by the new Action

ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);

if (stack != null) {

extraContext.put(ActionContext.VALUE_STACK, ValueStackFactory.getFactory().createValueStack(stack));

}

String timerKey = "Handling request from Dispatcher";

try {

UtilTimerStack.push(timerKey);

String namespace = mapping.getNamespace();

String name = mapping.getName();

String method = mapping.getMethod();

Configuration config = configurationManager.getConfiguration();

ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(

namespace, name, extraContext, true, false);

proxy.setMethod(method);

request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());

// if the ActionMapping says to go straight to a result, do it!

if (mapping.getResult() != null) {

Result result = mapping.getResult();

result.execute(proxy.getInvocation());

} else {

proxy.execute();

}

// If there was a previous value stack then set it back onto the request

if (stack != null) {

request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);

}

} catch (ConfigurationException e) {

LOG.error("Could not find action or result", e);

sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);

} catch (Exception e) {

thrownew ServletException(e);

} finally {

UtilTimerStack.pop(timerKey);

}

最后，经过Result完成页面的跳转。

3.4　本小节总结

整体来说，Struts2的工做机制比Struts1.x要复杂不少，但咱们不得不佩服Struts和WebWork开发小组的功底，代码如此优雅，甚至可以感觉看到两个开发小组心神相通的默契。两个字：佩服。

如下是Struts2运行时调用方法的顺序图：

（图21）

4、总结

阅读源代码是一件很是辛苦的事，对读者自己的要求也很高，一方面要有扎实的功底，另外一方面要有超强的耐力和恒心。本章目的就是但愿能帮助读者理清一条思路，在必要的地方做出简单的解释，达到事半功倍的效果。

固然，笔者不可能为读者解释全部类，这也不是个人初衷。Struts2+xwork一共有700余类，除了为读者作到如今的这些，已没法再作更多的事情。读者能够到Struts官方网站下载帮助文档，慢慢阅读和理解，相信会受益颇丰。

本章并不适合java语言初学者或者对java博大精深的思想理解不深的读者阅读，这其中涉及到太多的术语和类的使用，特别不要去钻牛角尖，容易使自信心受损。基本搞清楚Struts2的使用以后，再回过头来阅读本章，对一些知识点和思想也许会有更深的体会。

若是读者的java功底比较浑厚，并且对Struts2充满兴趣，但又没太多时间研究，不妨仔细阅读本章，再对照Struts的源代码，但愿对您有所帮助。

Struts2教程

第一章 搭建Struts2开发环境

Struts2的新特征

Struts2的环境要求

Struts2环境搭建

4.1Struts的下载

4.2 开发工具介绍

4.3 库文件

4.3 使用Eclipse搭建Struts2的开发环境

4.3.1建立用户库

4.3.2开发第一个Struts2应用程序——世界，你好

struts.xml的定义文件

总结

第二章 Struts2的工做机制及分析

概述

主要的包和类

Struts2的工做机制

3.1Struts2体系结构图

3.2Struts2的工做机制

3.3Struts2源代码分析

3.4 本小节总结

4、 总结

第一章　搭建Struts2开发环境

4.2　开发工具介绍

4.3　库文件

4.3　使用Eclipse搭建Struts2的开发环境

第二章　Struts2的工做机制及分析

3.4　本小节总结

4、总结