细谈Struts2 详解

(一）自己实现struts2框架

 Struts最早是作为Apache Jakarta项目的组成部分,项目的创立者希望通过对该项目的研究，改进和提高JavaServer Pages 、Servlet、标签库以及面向对象的技术水准。最初的struts1.x很快在企业开发中流行了起来，与此同时，当时还有一个非常的优秀的web开发框架诞生，那就是webwork，但webwork没有像struts1那么幸运，没有得到流行，但webwork简洁、灵活功能强大等优点绝不输于当时流行的strut1.x。当然struts1开发人员不是也没有意识到这一点。于是struts 和WebWork得到了结合，webwork算是利用struts的名气来发展自己吧，于是struts2诞生了。

Struts2概述

　   Struts 2是Struts的下一代产品，是在 struts 和WebWork的技术基础上进行了合并的全新的Struts 2框架。其全新的Struts 2的体系结构与Struts 1的体系结构的差别巨大。Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与Servlet API完全脱离开，所以Struts 2可以理解为WebWork的更新产品。虽然从Struts 1到Struts 2有着太大的变化，但是相对于WebWork，Struts 2只有很小的变化。由于struts1现在开发中很少在用到，所以我们直接进入struts2的学习，但以前的项目中还是大多数保留着struts1的应用。由于struts是基于mvc模式的框架，所以我们学习struts的第一步就是开发自己的基于MVC的框架

首先看一下一个MVC的流程图的例子：

       就像图中例子，在视图层add。Jsp中写一个提交两个数据的表单，表单提交给控制器，在控制器中通过它所提交的uri获得表单所要提交的action，然后把请求交给action，然后在action中调用业务逻辑的方法进行逻辑运算，获得结果，把结果保存起来，然后，把所有返回的界面作为返回结果返回给控制器，然后控制器根据返回的界面的字符串选择转发到该界面

下面我们就用程序，把这个流程实现出来：

1.首先要把表单界面写出来：add.jsp

 <form action="add.action" method="post"><div align="center"><font color="#8000ff">

      font><font size="5" color="#8000ff"><strong>加法器实现strong>font><br/>

      div><table align="center">

      <tr>

      <td>第一个数：td>

      <td><input type="text" name="firstNmb"/>td>

      tr>

      <tr>

      <td>第二个数：td>

      <td><input type="text" name="secondNmb"/>td>

      tr>

      <tr align="center">

      <td colspan="2"><input type="submit" value=" 求和"/>    <input type="reset"/ value="重置">td>

      tr>

      table>

     form>

2.创建控制器，其实这里的控制器就是一个servlet，这里我们给规定凡是请求后缀是.action的都提交到这个控制器里，controller.java:

 public void doPost(HttpServletRequest request, HttpServletResponse response)

 throws ServletException, IOException {

 String path=request.getRequestURI();

 String realPath=path.substring(path.lastIndexOf("/")+1, path.lastIndexOf("."));

 Action action=null;

 String path2=null;

 if("add".equals(realPath)){

 action=new AddAction();

 path2=action.execute(request, response);

 }

           .........

          If(....){

                  .......

               }

 request.getRequestDispatcher(path2).forward(request, response);

 }

因为控制器是一个servlet，所以在web.xml中要对他进行配置：

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

 <web-app version="2.5"

 xmlns="http://java.sun.com/xml/ns/javaee"

 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

 http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

   <servlet>

     <servlet-name>Controllerservlet-name>

     <servlet-class>zxj.struts2.servlet.Controllerservlet-class>

   servlet>

   <servlet-mapping>

     <servlet-name>Controllerservlet-name>

     <url-pattern>*.actionurl-pattern>

   servlet-mapping>

 web-app>

      下面来看一下action里面应该写的内容，由于一直以来都提倡面向接口编程，并且面向接口编程也能很好的体现java的可扩展性，所以我们对所有的action提供一个共同的接口：action.java：

 public interface Action {

 public String result(HttpServletRequest request,HttpServletResponse response);

 }

      

下面是具体的action实现：addaction.java：其中具体的业务逻辑调用的add方法就是两个数相加，这里就不贴代码了：

 

 public String execute(HttpServletRequest request,

 HttpServletResponse response) {

 double i=Double.parseDouble(request.getAttribute("firstNmb").toString());

 double n=Double.parseDouble(request.getAttribute("secondNmb").toString());

 Calculator c=new Calculator();

 double result=c.add(i, n);

 request.setAttribute("result", result);

 return "add_result.jsp";

 }

 }

 

        这些就是我们自己写的mvc的基本框架，当然这里面有很多不足的地方，这里只是为了演示基于mvc框架的基本架构，具体细节都可以细化和扩展性的实现，比如控制器里面的选择哪个action，这个可以用配置文件来实现的，基本思路：在控制器中获得所请求action的前缀名，然后去解析所配置的文件，在然后拿着这个前缀名去找配置文件中相符的action所对应的类，然后在利用反射执行对应类的方法，根据然后在执行完action后，获得结果，然后从配置中获得获该结果对应的界面，这样就可以很好的体现了这个程序的可扩展性了。

      到这里我相信大家应该对基于mvc的框架的执行流程有一定的了解了，相信大家一定对学习struts2框架迫不接待了，那大家就等待着下一篇博客:细谈struts2之初识struts2框架

（二）开发第一个struts2的实例

 上面已经带大家对基于mvc业务流程熟悉了一下，现在我们就用对mvc实现最好的框架struts2来开发一个应用实例。虽然现在MyEclipse8.5以上版本已经开始支持Struts2，但为了我们能更好的熟悉开发struts2的业务流程，现在我们还是手动去搭配环境。首先我们需要到struts.apache.org去下载struts-2.2.3-all包。现在最高版本应该达到2.3了。要想正常使用Struts2，至少需要如下五个包（可能会因为Struts2的版本不同，包名略有差异，但包名的前半部是一样的）。

    struts2-core-2.0.11.1.jar

    xwork-2.0.4.jar

    commons-logging-1.0.4.jar

    freemarker-2.3.8.jar

ognl-2.6.11.jar

注：貌似好像一些高版本的还需要加入一些其他jar包，如下图所示：

  

 好了，jar包加入之后，我们下一步开始搭配配置环境了。很多同学可能会有这样的疑问，为什么我提交的请求能到struts.xml去找对应的action呢？？至少我刚开始学习的时候有这么个疑问。现在答案即可以为大家揭晓了，因为struts2的核心是拦截器，一切请求都要经过拦截器才转发给所对应的action的。Struts2中第一个拦截请求的就是org.apache.struts2.dispatcher.FilterDispatcher这个拦截器（下一篇博客我们即将对这个拦截器的源码进行分析），拦截器对请求进行一些处理之后然后去struts.xml寻找对应的action。我们一起来看一下web.xml的配置：

 xml version="1.0" encoding="UTF-8"?>
 <web-app version="2.4"
     xmlns="http://java.sun.com/xml/ns/j2ee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
     http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
     <filter>
     <filter-name>struts2filter-name>
     <filter-class>org.apache.struts2.dispatcher.FilterDispatcherfilter-class>
     filter>
     <filter-mapping>
     <filter-name>struts2filter-name>
     <url-pattern>*.actionurl-pattern>
     filter-mapping>
   <welcome-file-list>
     <welcome-file>index.jspwelcome-file>
   welcome-file-list>
 web-app>

      在struts2官方提供的文档中要求，在服务器class文件夹下建立struts.xml文件。由于在web项目部署到服务器上，开启服务器对web项目进行编译时会自动把src文件夹下的文件加载到服务器class文件夹下，所以我们直接在src下面建立struts.xml文件，具体struts.xml配置如下：

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

     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
     "http://struts.apache.org/dtds/struts-2.0.dtd">
 <struts>
 <constant name="struts.i18n.encoding" value="utf-8" />
     <package name="struts2" extends="struts-default">
         <action name="" class="">
             <result name="">result>
             <result name="">result>
         action>
     package>
 struts>

注：上述代码具体意义：

1.标签主要是用来修改struts.properties配置文件信息，name和value分别相当于struts.properties文件中的name和value

2.主要是作为分包作用，比如一个项目分好几个模块，这里可以每一个模块分配一个包，一个struts.xml文件中可以出现多个标签，这里一定要有extends="struts-default"，因为struts的核心拦截器都配置在struts-default包中，如果没有这个，所有请求都不会请求到

3.一个标签对应一个action类，主要是通过action标签中的去寻找class，然后执行对应的class。Action标签里有一个一个method属性，他可以指定执行action中的哪个方法

下面我们就开始以登录为例来写一下struts2开发的视图层：

Login.jsp

 <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
 <%
 String path = request.getContextPath();
 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
 %>
 <html>
   <head>
   head>
     <body>
   <form action="LoginAction.action">
    <input type="text" name="username"/><br/>
    <input type="password" name="password"/><br/>
    <input type="submit" value="提交"/>
    form>
   body>
 html>

好了，视图层写完了，下面就要开始写核心action了，由于业务逻辑层就是判断用户名和密码是否与固定的admin和123456相等，所以本程序只是为了测试，就不再单独抽出来了，直接写在action里面了LoginAction.java

 package com.bzu.action;
 public class LoginAction {

     private String username;
     private String password;
     public String getUsername() {
         return username;
     }
     public void setUsername(String username) {
         this.username = username;
     }
     public String getPassword() {
         return password;
     }
     public void setPassword(String password) {
         this.password = password;
     }
     public String execute(){

         if(username.equals("admin")&&password.equals("123456"))
             return "success";
         return "fail";
     }
 }

从上面的程序可以看出，我们在action中要把form表单中数据都以私有变量的形式定义出来，然后在提供对应的set和get方法。很多同学可能在这又有疑问了。为什么给他提供set和get方法，form表单中的数据就可以设置到对应的属性上呢？为什么他会默认的去执行execute方法呢？为什么把配置文件中action标签对应的method属性修改后就可以执行新设置的方法呢？呵呵，在这在卖个关子，在接下来的博客中，会为大家一一把这些疑问解决。

Action写完之后，我们就可以把struts.xml对应的写上了，本程序完整的struts.xml：

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

     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
     "http://struts.apache.org/dtds/struts-2.0.dtd">
 <struts>
 <constant name="struts.i18n.encoding" value="utf-8" />
     <package name="struts2" extends="struts-default">
         <action name="LoginAction" class="com.bzu.action.LoginAction">
             <result name="success">success.jspresult>
             <result name="fail">fail.jspresult>
         action>
     package>
 struts>

 

对应的success.jsp和fai.jsp没什么内容，就是显示成功和失败几个字。

好了，到此，我们的第一个struts2的应用程序就写完了，下面我们一起来看一下运行结果：

————》

（三）struts2拦截器源码分析

 通过前面我们知道了struts2实现请求转发和配置文件加载都是拦截器进行的操作，这也就是为什么我们要在web.xml配置struts2的拦截器的原因了。我们知道，在开发struts2应用开发的时候我们要在web.xml进行配置拦截器org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter（在一些老版的一般配置org.apache.struts2.dispatcher.FilterDispatcher），不知道大家刚开始学的时候有没有这个疑问，为什么通过这个拦截器我们就可以拦截到我们提交的请求，并且一些配置文件就可以得到加载呢？不管你有没有，反正我是有。我想这个问题的答案，我们是非常有必要去看一下这个拦截器的源码去找。

打开StrutsPrepareAndExecuteFilter拦截器源码我们可以看出以下类的信息

属性摘要：

Protected        List              excludedPatterns 

protected      ExecuteOperations      execute 
protected      PrepareOperations       prepare

         我们可以看出StrutsPrepareAndExecuteFilter与普通的Filter并无区别，方法除继承自Filter外，仅有一个回调方法，第三部分我们将按照Filter方法调用顺序，init—>doFilter—>destroy顺序地分析源码。

提供的方法：

destroy()	继承自Filter，用于资源释放
doFilter(ServletRequest req, ServletResponse res, FilterChain chain)	继承自Filter，执行方法
init(FilterConfig filterConfig)	继承自Filter，初始化参数
postInit(Dispatcher dispatcher, FilterConfig filterConfig)	Callback for post initialization（一个空的方法，用于方法回调初始化）

下面我们一一对这些方法看一下：

1.init方法：我们先整体看一下这个方法：

 

 public void init(FilterConfig filterConfig) throws ServletException {

 InitOperations init = new InitOperations();

 try {

 //封装filterConfig，其中有个主要方法getInitParameterNames将参数名字以String格式存储在List中

 FilterHostConfig config = new FilterHostConfig(filterConfig);

 // 初始化struts内部日志

 init.initLogging(config);

 //创建dispatcher ，并初始化，这部分下面我们重点分析，初始化时加载那些资源

 Dispatcher dispatcher = init.initDispatcher(config);

 init.initStaticContentLoader(config, dispatcher);

 //初始化类属性：prepare 、execute

 prepare = new PrepareOperations(filterConfig.getServletContext(), dispatcher);

 execute = new ExecuteOperations(filterConfig.getServletContext(), dispatcher);

 this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);

 //回调空的postInit方法

 postInit(dispatcher, filterConfig);

 } finally {

 init.cleanup();

 }

 }

      首先开一下FilterHostConfig 这个封装configfilter的类：  这个类总共不超过二三十行代码getInitParameterNames是这个类的核心，将Filter初始化参数名称有枚举类型转为Iterator。此类的主要作为是对filterConfig 封装。具体代码如下：

 

 public Iterator getInitParameterNames() {

        return   MakeIterator.convert(config.getInitParameterNames());

    }

下面咱接着一块看Dispatcher dispatcher = init.initDispatcher(config);这是重点，创建并初始化Dispatcher  ，看一下具体代码：

   

 public Dispatcher initDispatcher( HostConfig filterConfig ) {

        Dispatcher dispatcher = createDispatcher(filterConfig);

        dispatcher.init();

        return dispatcher;

    }


 span style="font-size:18px;"><span style="color:#000000;background:rgb(255,255,255);">     span><span style="color:#000000;background:rgb(255,255,255);"><span style="color:#cc0000;"><strong>创建<span style="font-family:Verdana;">Dispatcherspan><span style="font-family:'宋体';">，会读取 span><span style="font-family:Verdana;">filterConfig span><span style="font-family:'宋体';">中的配置信息，将配置信息解析出来，封装成为一个span><span style="font-family:Verdana;">Mapspan>strong>span><span style="font-family:'宋体';">，然后span>span><span style="color:#000000;background:rgb(255,255,255);">根据span><span style="color:#000000;background:rgb(255,255,255);">servlet<span style="font-family:'宋体';">上下文和参数span><span style="font-family:Verdana;">Mapspan><span style="font-family:'宋体';">构造span><span style="font-family:Verdana;">Dispatcher span><span style="font-family:'宋体';">：span>span>span>

 private Dispatcher createDispatcher( HostConfig filterConfig ) {

 Map params = new HashMap();

 for ( Iterator e = filterConfig.getInitParameterNames(); e.hasNext(); ) {

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

 String value = filterConfig.getInitParameter(name);

 params.put(name, value);

 }

 return new Dispatcher(filterConfig.getServletContext(), params);

 }

      Dispatcher构造玩以后，开始对他进行初始化，加载struts2的相关配置文件，将按照顺序逐一加载：default.properties，struts-default.xml,struts-plugin.xml,struts.xml，……我们一起看看他是怎么一步步的加载这些文件的 dispatcher的init()方法：

   

 public void init() {


     if (configurationManager == null) {

     configurationManager = createConfigurationManager(BeanSelectionProvider.DEFAULT_BEAN_NAME);

     }
         try {

             init_DefaultProperties(); // [1]

             init_TraditionalXmlConfigurations(); // [2]

             init_LegacyStrutsProperties(); // [3]

             init_CustomConfigurationProviders(); // [5]

             init_FilterInitParameters() ; // [6]

             init_AliasStandardObjects() ; // [7]


             Container container = init_PreloadConfiguration();

             container.inject(this);

             init_CheckConfigurationReloading(container);

             init_CheckWebLogicWorkaround(container);


             if (!dispatcherListeners.isEmpty()) {

                 for (DispatcherListener l : dispatcherListeners) {

                     l.dispatcherInitialized(this);

                 }

             }

         } catch (Exception ex) {

             if (LOG.isErrorEnabled())

                 LOG.error("Dispatcher initialization failed", ex);

             throw new StrutsException(ex);

         }

     }

下面我们一起来看一下【1】，【2】，【3】，【5】，【6】的源码，看一下什么都一目了然了：

• DefaultPropertiesProvider

1.这个方法中是将一个DefaultPropertiesProvider对象追加到ConfigurationManager对象内部的ConfigurationProvider队列中。 DefaultPropertiesProvider的register()方法可以载入org/apache/struts2/default.properties中定义的属性。

 try {

            defaultSettings = new PropertiesSettings("org/apache/struts2/default");

        } catch (Exception e) {

            throw new ConfigurationException("Could not find or error in org/apache/struts2/default.properties", e);

        }

• init_TraditionalXmlConfigurations()方法

2. 调用init_TraditionalXmlConfigurations()方法，实现载入FilterDispatcher的配置中所定义的config属性。 如果用户没有定义config属性，struts默认会载入DEFAULT_CONFIGURATION_PATHS这个值所代表的xml文件。它的值为"struts-default.xml,struts-plugin.xml,struts.xml"。也就是说框架默认会载入这三个项目xml文件。如果文件类型是XML格式，则按照xwork-x.x.dtd模板进行读取。如果，是Struts的配置文件，则按struts-2.X.dtd模板进行读取。

 private static final String DEFAULT_CONFIGURATION_PATHS = "struts-default.xml,struts-plugin.xml,struts.xml";

• LegacyPropertiesConfigurationProvider类

3.创建一个LegacyPropertiesConfigurationProvider类，并将它追加到ConfigurationManager对象内部的ConfigurationProvider队列中。LegacyPropertiesConfigurationProvider类载入struts.properties中的配置，这个文件中的配置可以覆盖default.properties中的。其子类是DefaultPropertiesProvider类

• init_CustomConfigurationProviders()

5.init_CustomConfigurationProviders()此方法处理的是FilterDispatcher的配置中所定义的configProviders属性。负责载入用户自定义的ConfigurationProvider。

 String configProvs = initParams.get("configProviders");

         if (configProvs != null) {

             String[] classes = configProvs.split("\\s*[,]\\s*");

             for (String cname : classes) {

                 try {

                     Class cls = ClassLoaderUtils.loadClass(cname, this.getClass());

                     ConfigurationProvider prov = (ConfigurationProvider)cls.newInstance();

                     configurationManager.addConfigurationProvider(prov);

                 } catch (InstantiationException e) {

                     throw new ConfigurationException("Unable to instantiate provider: "+cname, e);

                 } catch (IllegalAccessException e) {

                     throw new ConfigurationException("Unable to access provider: "+cname, e);

                 } catch (ClassNotFoundException e) {

                     throw new ConfigurationException("Unable to locate provider class: "+cname, e);

                 }

             }

         }

• init_FilterInitParameters()

6.init_FilterInitParameters()此方法用来处理FilterDispatcher的配置中所定义的所有属性

• init_AliasStandardObjects()

7. init_AliasStandardObjects()，将一个BeanSelectionProvider类追加到ConfigurationManager对象内部的ConfigurationProvider队列中。BeanSelectionProvider类主要实现加载org/apache/struts2/struts-messages。

 private void init_AliasStandardObjects() {
         configurationManager.addConfigurationProvider(
 new BeanSelectionProvider());
 }

相信看到这大家应该明白了，struts2的一些配置的加载顺序和加载时所做的工作，其实有些地方我也不是理解的很清楚。其他具体的就不在说了，init方法占时先介绍到这

2、doFilter方法

     doFilter是过滤器的执行方法，它拦截提交的HttpServletRequest请求，HttpServletResponse响应，作为strtus2的核心拦截器，在doFilter里面到底做了哪些工作，我们将逐行解读其源码，大体源码如下：

 public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {

 //父类向子类转：强转为http请求、响应

 HttpServletRequest request = (HttpServletRequest) req;

 HttpServletResponse response = (HttpServletResponse) res;

 try {

 //设置编码和国际化

 prepare.setEncodingAndLocale(request, response);

 //创建Action上下文（重点）

 prepare.createActionContext(request, response);

 prepare.assignDispatcherToThread();

 if ( excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {

 chain.doFilter(request, response);

 } else {

 request = prepare.wrapRequest(request);

 ActionMapping mapping = prepare.findActionMapping(request, response, true);

 if (mapping == null) {

 boolean handled = execute.executeStaticResourceRequest(request, response);

 if (!handled) {

 chain.doFilter(request, response);

 }

 } else {

 execute.executeAction(request, response, mapping);

 }

 }

 } finally {

 prepare.cleanupRequest(request);

 }

 }

下面我们就逐句的来的看一下：设置字符编码和国际化很简单prepare调用了setEncodingAndLocale，然后调用了dispatcher方法的prepare方法：

 /**

 * Sets the request encoding and locale on the response

 */

 public void setEncodingAndLocale(HttpServletRequest request, HttpServletResponse response) {

 dispatcher.prepare(request, response);

 }

看下prepare方法，这个方法很简单只是设置了encoding 、locale ，做的只是一些辅助的工作：

 public void prepare(HttpServletRequest request, HttpServletResponse response) {

 String encoding = null;

 if (defaultEncoding != null) {

 encoding = defaultEncoding;

 }

 Locale locale = null;

 if (defaultLocale != null) {

 locale = LocalizedTextUtil.localeFromString(defaultLocale, request.getLocale());

 }

 if (encoding != null) {

 try {

 request.setCharacterEncoding(encoding);

 } catch (Exception e) {

 LOG.error("Error setting character encoding to '" + encoding + "' - ignoring.", e);

 }

 }

 if (locale != null) {

 response.setLocale(locale);

 }

 if (paramsWorkaroundEnabled) {

 request.getParameter("foo"); // simply read any parameter (existing or not) to "prime" the request

 }

 }

下面咱重点看一下创建Action上下文重点

   Action上下文创建（重点）

       ActionContext是一个容器，这个容易主要存储request、session、application、parameters等相关信息.ActionContext是一个线程的本地变量，这意味着不同的action之间不会共享ActionContext，所以也不用考虑线程安全问题。其实质是一个Map，key是标示request、session、……的字符串，值是其对应的对象：

static ThreadLocal actionContext = new ThreadLocal();

Map context;

下面我们看起来下创建action上下文的源码：

 /**

 *创建Action上下文，初始化thread local

 */

 public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response) {

 ActionContext ctx;

 Integer counter = 1;

 Integer oldCounter = (Integer) request.getAttribute(CLEANUP_RECURSION_COUNTER);

 if (oldCounter != null) {

 counter = oldCounter + 1;

 }



 //注意此处是从ThreadLocal中获取此ActionContext变量

 ActionContext oldContext = ActionContext.getContext();

 if (oldContext != null) {

 // detected existing context, so we are probably in a forward

 ctx = new ActionContext(new HashMap<String, Object>(oldContext.getContextMap()));

 } else {

 ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();

 stack.getContext().putAll(dispatcher.createContextMap(request, response, null, servletContext));

 //stack.getContext()返回的是一个Map<String，Object>，根据此Map构造一个ActionContext

 ctx = new ActionContext(stack.getContext());

 }

 request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);

 //将ActionContext存如ThreadLocal

 ActionContext.setContext(ctx);

 return ctx;

 }

一句句来看：

ValueStackstack= dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();  

dispatcher.getContainer().getInstance(ValueStackFactory.class)根据字面估计一下就是创建ValueStackFactory的实例。这个地方我也只是根据字面来理解的。ValueStackFactory是接口，其默认实现是OgnlValueStackFactory，调用OgnlValueStackFactory的createValueStack()：

下面看一下OgnlValueStack的构造方法  

 protected OgnlValueStack(XWorkConverter xworkConverter, CompoundRootAccessor accessor, TextProvider prov, boolean allowStaticAccess) {

       //new一个CompoundRoot出来

     setRoot(xworkConverter, accessor, new CompoundRoot(), allowStaticAccess);

     push(prov);

 }

接下来看一下setRoot方法：

 protected void setRoot(XWorkConverter xworkConverter, CompoundRootAccessor accessor, CompoundRoot compoundRoot,

                        boolean allowStaticMethodAccess) {

     //OgnlValueStack.root = compoundRoot;

     this.root = compoundRoot;

 1    //方法/属性访问策略。

     this.securityMemberAccess = new SecurityMemberAccess(allowStaticMethodAccess);

     //创建context了，创建context使用的是ongl的默认方式。

     //Ognl.createDefaultContext返回一个OgnlContext类型的实例

     //这个OgnlContext里面，root是OgnlValueStack中的compoundRoot，map是OgnlContext自己创建的private Map _values = new HashMap(23);

     this.context = Ognl.createDefaultContext(this.root, accessor, new OgnlTypeConverterWrapper(xworkConverter), securityMemberAccess);



      //不是太理解，猜测如下：

     //context是刚刚创建的OgnlContext，其中的HashMap类型_values加入如下k-v:

    //key:com.opensymphony.xwork2.util.ValueStack.ValueStack

     //value:this,这个应该是当前的OgnlValueStack实例。

     //刚刚用断点跟了一下，_values里面是：

     //com.opensymphony.xwork2.ActionContext.container=com.opensymphony.xwork2.inject.ContainerImpl@96231e

     //com.opensymphony.xwork2.util.ValueStack.ValueStack=com.opensymphony.xwork2.ognl.OgnlValueStack@4d912

     context.put(VALUE_STACK, this);

   //此时：OgnlValueStack中的compoundRoot是空的；

    //context是一个OgnlContext，其中的_root指向OgnlValueStack中的root，_values里面的东西，如刚才所述。

     //OgnlContext中的额外设置。

     Ognl.setClassResolver(context, accessor);

     ((OgnlContext) context).setTraceEvaluations(false);

     ((OgnlContext) context).setKeepLastEvaluation(false);

 }

  上面代码中dispatcher.createContextMap，如何封装相关参数：，我们以RequestMap为例，其他的原理都一样：主要方法实现：

 //map的get实现

 public Object get(Object key) {

 return request.getAttribute(key.toString());

 }

 //map的put实现

 public Object put(Object key, Object value) {

 Object oldValue = get(key);

 entries = null;

 request.setAttribute(key.toString(), value);

 return oldValue;

 }

        到此，几乎StrutsPrepareAndExecuteFilter大部分的源码都涉及到了。自己感觉都好乱，所以还请大家见谅，能力有限，希望大家可以共同学习

（四）struts2中action执行流程和源码分析

struts执行流程

 首先我们看一下struts官方给我们提供的struts执行流程

 从上面流程图我们可以看出struts执行的流程大体分一下阶段：

1. 初始的请求通过一条标准的过滤器链，到达servlet 容器( 比如tomcat 容器，WebSphere 容器)。

2. 过滤器链包括可选的ActionContextCleanUp 过滤器，用于系统整合技术，如SiteMesh 插件。

3. 接着调用FilterDispatcher，FilterDispatcher 查找ActionMapper，以确定这个请求是否需要调用某个Action。

4. 如果ActionMapper 确定需要调用某个Action，FilterDispatcher 将控制权交给ActionProxy。

5. ActionProxy 依照框架的配置文件(struts.xml)，找到需要调用的Action 类。

6. ActionProxy 创建一个ActionInvocation 的实例。ActionInvocation 先调用相关的拦截器（Action 调用之前的部分），最后调用Action。

7. 一旦Action 调用返回结果，ActionInvocation 根据struts.xml 配置文件，查找对应的转发路径。返回结果通常是（但不总是，也可能是另外的一个Action 链）JSP 技术或者FreeMarker的模版技术的网页呈现。Struts2 的标签和其他视图层组件，帮助呈现我们所需要的显示结果。在此，我想说清楚一些，最终的显示结果一定是HTML 标签。标签库技术和其他视图层技术只是为了动态生成HTML 标签。

8. 接着按照相反次序执行拦截器链( 执行Action 调用之后的部分)。最后，响应通过滤器链返回（过滤器技术执行流程与拦截器一样，都是先执行前面部分，后执行后面部）。如果过滤器链中存在ActionContextCleanUp，FilterDispatcher 不会清理线程局部的ActionContext。如果不存在ActionContextCleanUp 过滤器，FilterDispatcher 会清除所有线程局部变量。

下面我们就来具体分析一下3-6四个步骤：

步骤三：FilterDispatcher 查找ActionMapper，以确定这个请求是否需要调用某个Action。

1）

 ActionMapping mapping;

             try {

                 mapping = actionMapper.getMapping(request, dispatcher.getConfigurationManager());

             } catch (Exception ex) {

                 log.error("error getting ActionMapping", ex);

                 dispatcher.sendError(request, response, servletContext, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex);

                 return;
             }

  

2）调用actionmapper去寻找对应的ActionMapping，因为actionmapper是一个接口，所有我们去他对应的实现类（DefaultActionMapper）里面去找getMapping方法，下面我们来看一下实现类里面的getMapping方法源代码：

 

 public ActionMapping getMapping(HttpServletRequest request,

                                     ConfigurationManager configManager) {

         ActionMapping mapping = new ActionMapping();

         String uri = getUri(request);
         int indexOfSemicolon = uri.indexOf(";");

         uri = (indexOfSemicolon > -1) ? uri.substring(0, indexOfSemicolon) : uri;

         uri = dropExtension(uri, mapping);

         if (uri == null) {

             return null;

         }

         parseNameAndNamespace(uri, mapping, configManager);

         handleSpecialParameters(request, mapping);

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

             return null;

         }
         parseActionName(mapping);

         return mapping;
 }

      ActionMapping 代表struts.xml 文件中的一个Action 配置，被传入到serviceAction 中。注意ActionMapping 不代表Action 集合，只代表某个对应的Action。如果是一个Action 请求，( 请求路径在struts.xml 有对应的Action 配置，即actionmapping不为空)，则调用dispatcher.serviceAction() 处理。找到对应的ActionMapping，下一步就去找具体的执行哪一个action，从FilterDispatcher源码中我们可以找到下一步流程：

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

    从上面可以看出，FilterDispatcher类中是调用的serviceAction方法来寻找的去调用哪一个action。serviceAction()方法作用：加载Action 类，调用Action 类的方法，转向到响应结果。响应结果指 标签所代表的对象。

步骤四、五、六：如果ActionMapper 确定需要调用某个Action，FilterDispatcher 将控制权交给ActionProxy。

我们来看一下具体的serviceAction源码：

 public void serviceAction(HttpServletRequest request, HttpServletResponse response,

 ServletContext context, ActionMapping mapping) throws ServletException {

 Map extraContext = createContextMap

 (request, response, mapping, context);

 //1 以下代码目的为获取ValueStack，代理在调用的时候使用的是本值栈的副本

 ValueStack stack = (ValueStack) request.getAttribute

 (ServletActionContext.STRUTS_VALUESTACK_KEY);

 boolean nullStack = stack == null;

 if (nullStack) {

 ActionContext ctx = ActionContext.getContext();

 if (ctx != null) {

 stack = ctx.getValueStack();

 }

 }

 //2 创建ValueStack 的副本

 if (stack != null) {

 extraContext.put(ActionContext.VALUE_STACK,

 valueStackFactory.createValueStack(stack));

 }

 String timerKey = "Handling request from Dispatcher";

 try {

 UtilTimerStack.push(timerKey);

 //3 这个是获取配置文件中 配置的字符串，action 对象已经在核心控制器中创建

 String namespace = mapping.getNamespace();

 String name = mapping.getName();

 String method = mapping.getMethod();

 // xwork 的配置信息

 Configuration config = configurationManager.getConfiguration();

 //4 动态创建ActionProxy

 ActionProxy proxy =

 config.getContainer().getInstance(ActionProxyFactory.class).

 createActionProxy(namespace, name, method, extraContext, true, false);

 request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY,

 proxy.getInvocation().getStack());

 //5 调用代理

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

 Result result = mapping.getResult();

 result.execute(proxy.getInvocation());

 } else {

 proxy.execute();

 }

 //6 处理结束后，恢复值栈的代理调用前状态

 if (!nullStack) {

 request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);

 }

 } catch (ConfigurationException e) {

 //7 如果action 或者result 没有找到，调用sendError 报404 错误

 }

关于valuestack说明一下：

1.valueStack 的建立是在doFilter 的开始部分，在Action 处理之前。即使访问静态资源ValueStack 依然会建立，保存在request 作用域。

2. ValueStack 在逻辑上包含2 个部分：object stack 和context map，object stack 包含Action 与Action 相关的对象。

context map 包含各种映射关系。request,session,application,attr,parameters 都保存在context map 里。

parameters: 请求参数

atrr: 依次搜索page, request, session, 最后application 作用域。

几点说明：

1. Valuestack 对象保存在request 里，对应的key 是ServletActionContext.STRUTS_VALUESTACK_KEY。调用代理之前首先创建Valuestack 副本，调用代理时使用副本，调用后使用原实例恢复。本处的值栈指object stack。

2. Dispatcher 实例，创建一个Action 代理对象。并把处理委托给代理对象的execute 方法。

最后我们在一起看一下ActionInvocation实现类中invoke方法执行的流程：invoke源代码：

  public String invoke() throws Exception {

         String profileKey = "invoke: ";

         try {

             UtilTimerStack.push(profileKey);

             if (executed) {

                 throw new IllegalStateException("Action has already executed");

             }

             if (interceptors.hasNext()) {

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

                 String interceptorMsg = "interceptor: " + interceptor.getName();

                 UtilTimerStack.push(interceptorMsg);

                 try {

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

                             }

                 finally {

                     UtilTimerStack.pop(interceptorMsg);

                 }

             } else {

                 resultCode = invokeActionOnly();

             }


                if (!executed) {

                 if (preResultListeners != null) {

                     for (Object preResultListener : preResultListeners) {

                         PreResultListener listener = (PreResultListener) preResultListener;


                         String _profileKey = "preResultListener: ";

                         try {

                             UtilTimerStack.push(_profileKey);

                             listener.beforeResult(this, resultCode);

                         }

                         finally {

                             UtilTimerStack.pop(_profileKey);

                         }

                     }

                 }


                    if (proxy.getExecuteResult()) {

                     executeResult();

                 }


                 executed = true;

             }
             return resultCode;

         }

         finally {

             UtilTimerStack.pop(profileKey);

        }
 }

        这里算是执行action中方法的最后一步了吧，至此，action的整个流程就基本差不多了，从头到尾看下来，说实话，感触很多，很多不明白的地方，这算是近了自己最大的努力去看这些源码，感觉从里面收获了很多，里面很多的机制和知识点值得我们去学习，记住了圣思源张龙老师的那句话：源码面前，一目了然

（五）action基础知识和数据校验

一：首先看一下struts2中action的实现方式：

1.建立普通的pojo类：

 这种方式能够实现简单的action功能，但struts2内自带的一些验证和其他功能不能够实现

2.继承ActionSupport类实现action

 因为ActionSupport已经实现了Action接口，还实现了Validateable接口，提供了数据校验功能。通过继承该ActionSupport类，可以简化Struts 2的Action开发。

3.实现action接口

 这个接口里面定义了一些action所要实现的功能的标准，但验证等功能没有，所以一般还是继承actionsupport来实现action

Action 跟 Actionsupport 的区别：

当我们在写action的时候,可以实现Action接口,也可以继承Actionsupport这个类.到底这两个有什么区别呢? 

Action接口有: 

 public static final java.lang.String SUCCESS = "success";

 public static final java.lang.String NONE = "none";

 public static final java.lang.String ERROR = "error";

 public static final java.lang.String INPUT = "input";

 public static final java.lang.String LOGIN = "login";

 public abstract java.lang.String execute() throws java.lang.Exception;

而Actionsupport这个工具类在实现了Action接口的基础上还定义了一个validate()方法,重写该方法,它会在execute()方法之前执行,如校验失败,会转入input处，必须在配置该Action时配置input属性。 

另外,Actionsupport还提供了一个getText(String key)方法还实现国际化,该方法从资源文件上获取国际化信息. 

这样在自定义标签时可以定义一个变量为new actionsupport对象实现国际化。

ActionSupport类的作用 

       struts2不要求我们自己设计的action类继承任何的struts基类或struts接口，但是我们为了方便实现我们自己的action，大多数情况下都会继承com.opensymphony.xwork2.ActionSupport类，并重写此类里的public String execute() throws Exception方法。因为此类中实现了很多的实用借口，提供了很多默认方法，这些默认方法包括国际化信息的方法、默认的处理用户请求的方法等，这样可以大大的简化Acion的开发。 

      Struts2中通常直接使用Action来封装HTTP请求参数，因此，Action类里还应该包含与请求参数对应的属性，并且为属性提供对应的getter和setter方法。

二．action数据校验

    在上面应用中，即使浏览者输入任何用户名、密码，系统也会处理用户请求。在我们整个HelloWorld应用中，这种空用户名、空密码的情况不会引起太大的问题。但如果数据需要保存到数据库，或者需要根据用户输入的用户名、密码查询数据，这些空输入可能引起异常。为了避免用户的输入引起底层异常，通常我们会在进行业务逻辑操作之前，先执行基本的数据校验。    

Action数据校验功能是struts2给我们提供的一个服务器端简单验证的功能，这个功能使我们简化了一些没必要的代码。下面看一下具体实现：

1.继承ActionSupport

ActionSupport类是一个工具类，它已经实现了Action接口。除此之外，它还实现了Validateable接口，提供了数据校验功能。通过继承该ActionSupport类，可以简化Struts 2的Action开在Validatable接口中定义了一个validate()方法，重写该方法，如果校验表单输入域出现错误，则将错误添加到ActionSupport类的fieldErrors域中，然后通过OGNL表达式负责输出为了让Struts 2增加输入数据校验的功能，改写程序中的LoginAction，增加重写validate方法。下面看一下具体代码实现：

 package com.bzu.action;

 import com.opensymphony.xwork2.ActionSupport;

 public class LoginAction extends ActionSupport {

 private String username;

 private String password;

 public String getUsername() {

 return username;

 }

 public void setUsername(String username) {

 this.username = username;

 }

 public String getPassword() {

 return password;

 }

 public void setPassword(String password) {

 this.password = password;

 }

 public void validate() {

 if("".equals(username))

 this.addActionError("soory,the username can't blank");

 if("".equals(password))

 this.addActionError("soory,the password can't blank");

 }

 public String execute(){

 if(username.equals("admin")&&password.equals("123456"))

 return "success";

 return "fail";

 }

 }

      这里简单的实现了表单数据验证功能，上面的Action类重写了validate方法，该方法会在执行系统的execute方法之前执行，如果执行该方法之后，Action类的fieldErrors中已经包含了数据校验错误，请求将被转发到input逻辑视图处。但还是要注意以下几点：

1.在实现表单验证功能的时候一定不要忘记了在struts.xml中相对应的action中配置result=“input”，因为表单验证失败默认返回的字符串为input，如果没有的话会找不到这个结果而报错。

2.数据验证中，如果数据不符的时候可以报三种错误，我们上面代码中只是列举了action错误，另外两种是Field字段的错误，还有一种就是actionMessage。

3.注意在显示界面接收action错误时，要在想显示错误的地方加上 <s:actionerror/>标签，如果想接收Filed域的错误时，一定要用struts标签，如果不用的话是不会显示字段错误的

2.使用Struts 2的校验框架

上面的输入校验是通过重写ActionSupport类的validate方法实现的，这种方法虽然不错，但需要大量重写的validate方法——毕竟，重复书写相同的代码不是一件吸引人的事情。
类似于Struts 1，Struts 2也允许通过定义配置文件来完成数据校验。Struts 2的校验框架实际上是基于XWork的validator框架。
下面还是使用原来的Action类（即不重写validate方法），却增加一个校验配置文件，校验配置文件通过使用Struts 2已有的校验器，完成对表单域的校验。Struts 2提供了大量的数据校验器，包括表单域校验器和非表单域校验器两种。 本应用主要使用了requiredstring校验器，该校验器是一个必填校验器——指定某个表单域必须输入。
下面是校验规则的定义文件：

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

 >

 <validators>

 <field name="username">

 <field-validator type="requiredstring">

 <param name="trim">falseparam>

 <message>username can't be blank!message>

 field-validator>

 <field-validator type="stringlength">

 <param name="minLength">4param>

 <param name="maxLength">6param>

 <param name="trim">falseparam>

 <message key="username.invalid">message>

 field-validator>

 field>

 <field name="password">

 <field-validator type="requiredstring">

 <message>password can't be blank!message>

 field-validator>

 <field-validator type="stringlength">

 <param name="minLength">4param>

 <param name="maxLength">6param>

 <message>length of password should be between ${minLength} and ${maxLength}message>

 field-validator>

 field>

 <field name="age">

 <field-validator type="required">

 <message>age can't be blank!message>

 field-validator>

 <field-validator type="int">

 <param name="min">10param>

 <param name="max">40param>

 <message>age should be between ${min} and ${max}message>

 field-validator>

 field>

 validators>

定义完该校验规则文件后，该文件的命名应该遵守如下规则：
ActionName-validation.xml：其中ActionName就是需要校验的Action的类名。因此上面的校验规则文件应该命名为“LoginAction-validation.xml”，且该文件应该与Action类的class文件位于同一个路径下。因此，将上面的校验规则文件放在WEB-INF/classes/lee路径下即可。当然，在struts.xml文件的Action定义中，一样需要定义input的逻辑视图名，将input逻辑视图映射到login.jsp页面。在这种校验方式下，无需书写校验代码，只需要通过配置文件指定校验规则即可，因此提供了更好的可维护性。

三、action中的执行方法

Action中默认的执行方法是execute方法，这个方法执行请求，然后转向其他的页面，这是常规的做法，但有时候我们不想用这个方法名，为了代码的可读性，我们希望让他执行我们自己定义的方法，下面我们就来看一下执行其他方法的两种方法：

1.在struts.xml配置method属性

其实执行execute方法是对应action在配置文件method的默认方法，所以要想执行其他的方法，我们可以修改这里的默认方法，只要把默认的方法改为我们自定义的方法就可以了。部分配置代码：

 "LoginAction" class="com.bzu.action.LoginAction" method="login">

 "success">success.jsp

 "fail">fail.jsp

 "input">login.jsp



 "RegisteAction" class="com.bzu.action.LoginAction" method="registe">

 "success">success.jsp

 "fail">fail.jsp

 "input">login.jsp

2.DMI（动态直接调用）

 这种方法不需要进行struts.xml的配置。而是在html或者jsp页面中通过标示符号指定了要调用的方法。 关键的标示符号为"！"号，具体看一下下面表单：

 

 "LoginAction!login">



   username："username">

   password："password">

   "提交">

3.提交按钮指定提交方法

 普通的提交按钮我们会这么写： <s:submit value="提交">s:submit>

当我们想提交到我们指定的方法时我们可以在这个标签里添加一个method属性指定要提交的方法，如下：

 

 <s:submit value="提交" method="login">s:submit>

4.使用通配符配置Action

 这种方法可以解决action配置文件混乱的问题，减少action的配置：

 

 <action name="helloworld_*" class="com.bird.action.HelloWorld" method="{1}">

          <result name="success">/WEB-INF/jsp/{1}_success.jspresult>

   action>

 <span style="font-size:18px;"><span style="color:#000000;">   span>span>

   在name属性的值后面加上*，意思是只要你请求的action名字以helloworld开头，本action就是你找的action，然后method是大括号加上1，这个1代表第一个星号的值，这样就可以动态执行请求的方法。

       

最后说一点，有时候用户在地址栏随便输入的时候，找不到对应的action，直接对报出一些错误，这样的界面一般都很难看，所以为了能给用户一个友好的提示界面，一般我们会再struts.xml文件配置默认的action，代码如下：

（六）获取servletAPI和封装表单数据

一：获取servletAPI的三种方法

       在传统的Web开发中，经常会用到Servlet API中的HttpServletRequest、HttpSession和ServletContext。Struts 2框架让我们可以直接访问和设置action及模型对象的数据，这降低了对HttpServletRequest对象的使用需求，同时降低了对servletAPI的依赖性，从而降低了与servletAPI的耦合度。但在某些应用中，我们可 能会需要在action中去访问HttpServletRequest等对象，所以有时候我们不得不拉近struts2和servletAPI的关系，但struts2也有尽量减少耦合度的方法，下面我们就一起具体看一下在struts2中获得ServletAPI的三种方法：

 

1.ServletAPI解藕方式（一）获取Map对象：

    为了避免与Servlet API耦合在一起，方便Action类做单元测试，Struts 2对HttpServletRequest、HttpSession和ServletContext进行了封装，构造了三个Map对象来替代这三种对象，在Action中，直接使用HttpServletRequest、HttpSession和ServletContext对应的Map对象来保存和读取 数据。可以通过com.opensymphony.xwork2.ActionContext类来得到这三个对象。ActionContext是Action执行的上下文，保存了很多对象如parameters、request、session、application和locale等。通过ActionContext类获取Map对象的方法为：

 ActionContextcontext=ActionContext.getContext(); --得到Action执行的上下文

 Maprequest=(Map)context.get("request");--得到HttpServletRequest的Map对象

 Mapsession=context.getSession();--得到HttpSession的Map对象

 Mapapplication=context.getApplication();--得到ServletContext的Map对象

          ActionContext中保存的数据能够从请求对象中得到，其中的奥妙就在于Struts 2中的org.apache.struts2.dispatcher.StrutsRequestWrapper类，这个类是 HttpServletRequest的包装类，它重写了getAttribute()方法（在页面中获取request对象的属性就要调用这个方法）， 在这个方法中，它首先在请求对象中查找属性，如果没有找到（如果你在ActionContext中保存数据，当然就找不到了），则到 ActionContext中去查找。这就是为什么在ActionContext中保存的数据能够从请求对象中得到的原因。

2.IOC（控制反转）获取servletAPI

     Action类还有另一种获得ServletAPI的解耦方式，这就是我们可以让他实现某些特定的接口，让Struts2框架在运行时向Action实例注入request、session和application对象。这种方式也就是IOC（控制反转）方式，与之对应的三个接口和它们的方法如下所示：

 public class SampleAction implementsAction,
 RequestAware, SessionAware, ApplicationAware
 {
 private Map request;
 private Map session;
 private Map application;

 @Override
 public void setRequest(Map request)
 {this.request = request;}

 @Override
 public void setSession(Map session)
 {this.session = session;}

 @Override
 public void setApplication(Map application)
 {this.application = application;}

 }

ServletRequestAware接口和ServletContextAware接口不属于同一个包，前者在org.apache.struts2.interceptor包中，后者在org.apache.struts2.util包中，这很让人迷惑。

 

3.与Servlet API耦合的访问方式

    直接访问Servlet API将使你的Action与Servlet环境耦合在一起，我们知道对于HttpServletRequest、 HttpServletResponse和ServletContext这些对象，它们都是由Servlet容器来构造的，与这些对象绑定在一起，测试时就需要有Servlet容器，不便于Action的单元测试。但有时候，我们又确实需要直接访问这些对象，那么当然是以完成任务需求为主。要直接获取HttpServletRequest和ServletContext对象，可以使用org.apache.struts2. ServletActionContext类，该类是ActionContext的子类，在这个类中定义下面两个静态方法：

1.得到HttpServletRequest对象：

public static HttpServletRequestgetRequest()

2.得到ServletContext对象：

public static ServletContextgetServletContext()

此外，ServletActionContext类还给出了获取HttpServletResponse对象的方法，如下：

public static HttpServletResponsegetResponse()

ServletActionContext类并没有给出直接得到HttpSession对象的方法，HttpSession对象可以通过HttpServletRequest对象来得到。

除了上述的方法调用得到HttpServletRequest和ServletContext对象外，还可以调用ActionContext对象的 get()方法，传递ServletActionContext.HTTP_REQUEST和 ServletActionContext.SERVLET_CONTEXT键值来得到HttpServletRequest和 ServletContext对象同样的，也可以向ActionContext的get()方法传递ServletActionContext.HTTP_ RESPONSE键值来得到HttpServletResponse对象

 

       总结：通过上面三种方式的讲解我们可以看出，三种获得servletAPI的方式基本都差不多，通常我们建议大家采用第一种方式来获取HttpServletRequest和ServletContext对象，这样简单而又清晰，并且降低了和servletAPI的耦合度，这样也方便进行单元测试

二：struts2封装请求参数三种方式

     在struts2开发应用中，我们可能经常要求获得视图层传过来的很多数据，一般都是一个实体类的n多属性，很多时候实体类的属性特别多，这时候如果还是按以前的方式在action里面一个个的定义出这些属性的私有变量，然后在提供set、get方法的话，这样就会使整个action太臃肿，严重妨碍了代码的可阅读性，并且也违背了代码的可复用性，这时我们就需要对这些请求参数进行封装，提高代码的可复用性，下面我们就一起来具体看一下三种封装请求参数的方法：

1.利用实体类封装参数

        这种方式是封装参数最简单的方法，一般也比较常用，因为在我们的struts应用程序中，我们一般会根据数据库的信息写出对应的实体类，所以这正好使我们可以利用的，下面我们看一下具体操作：

1.创建实体类user（包括用户名和密码属性），这里比较简单，我们就不贴出代码了。

2.创建action，这里我们主要是来看一下action接收数据的属性这个地方，我们就不是在一一定义这些属性的私有变量了，我们直接定义一个对应实体类的私有对象就可以了，代码如下：

 package com.bzu.action;

 publicclass LoginAction extends ActionSupport {

     private User user;

     public User getUser() {

         returnuser;

     }

     publicvoid setUser(User user) {

         this.user = user;

     }

     public String execute(){

     if(user.getUsername().equals("admin")&&user.getPassword().equals("123456"))

             return"success";

         return"fail";

     }

 }

3.定义表单，这里我们需要注意一下，这里表单里面的控件的name属性定义有一定的要求，定义name时我们应该定义为：对象.属性的形式，示例代码：

 <s:form action="LoginAction">

   <s:actionerror/>

  <s:textfield name="user.username">s:textfield>

 <s:password name="user.password">s:password>

   <s:submit value="提交" >s:submit>

    s:form>

4.配置struts.xml，这里配置和平常一样，这里就不再重复了

至此，我们简单的实体类封装请求参数就完成了，我相信大家一定也会感觉很简单吧

 

2.模型驱动封装请求参数

      模型驱动是指使用 JavaBean 来封装来回请求的参数 . 这种方式的好处就是减少了 action 的压力。既用于封装来回请求的参数 , 也保护了控制逻辑 , 使它的结构清晰 . 这就是模型驱动的优势 .

下面我们具体来看一下模型驱动的具体实现：

模型驱动的实现主要是体现在action上

1.首先建立一个实体，比较简单，这里就不再写了。

2.建立action类，继承自ActionSupport，实现ModelDriven接口，这个接口定义了一个getModel()方法，用于返回定义的Model，然后调用set方法，进行赋值。代码示例：

 publicclass LoginAction3 extends ActionSupport implementsModelDriven {
  private User user=new&nb