=======================  

org.apache.struts.actions.DispatchAction.java

DispatchAction的作用简单地说就是把原来我们写在多个acton里的操作放在同一个 action里处理。 

举个例子就是如果在你的系统中有文章的管理操作，那么通常有以下操作：添加文章、察看文章、搜索文章等等，这样的话一般你会写 三个action[ArtilceSaveAction ArticleViewAction ArticleSearchAction ]分别处理各个操作,虽然说这样看起来是非常清晰、流畅的操作，但是你会发现在三个action理由太多的相同的东西。现在利用DispatchAction，我们可以把“相似”的action放在一个action里操作。 

下面以上边的三个action和到一个action里为例： 

import ****;

import org.apache.struts.actions.DispatchAction; 

public class ArticleAction extends DispatchAction{

    /**
     *AritcleAddAction
     */
      public ActionForward add(ActionMapping mapping,
                            ActionForm form,
                            HttpServletRequest request,
                           HttpServletResponse response)
          throws Exception {
          ...
          ...
          }         
    /**
     *AritcleViewAction
     */
      public ActionForward view(ActionMapping mapping,

                           ActionForm form,
                            HttpServletRequest request,
                            HttpServletResponse response)
          throws Exception {

          ...
         ...
          }         

    /**
     *AritcleSearchAction
     */
      public ActionForward search(ActionMapping mapping,
                            ActionForm form,
                            HttpServletRequest request,
                            HttpServletResponse response)
          throws Exception {
          ...

          }

}

好了，该action的框架已经完成，但是要想可用，还要有一步不可少的操作，

那就是更改你的action mapping ，还以上边的例子，如下： 

<action path="/article"

  input="/article/***.jsp"

  parameter="method" <!--#####################-->

  scope="request"

  type="com.***.ArticleAction"  

  validate="false">

  <forward name="Success" path="/article/***.jsp" redirect="true"/>

 </action> 

看到上边你会发现，它和我们通常的写法多个一项：“parameter="method"”,这是有道理的并且非常重要：DispatchAction会根据具体的method值来确定调用add,view 或者search ，如下面的来自client的请求，article.do?method=add 则会触发添加文章的操作。

LookupDispatchAction

========================

org.apache.struts.actions.LookupDispatchAction.java  

从名字大概我们也能看出LookupDispatchAction是DispatchAction的子类。他们从功能上有许多相似的地方。 通常它主要应用于“在一个表单中有多个提交按钮而这些按钮又有一个共同的名字”，这些按钮的名字要和具体的action mapping中的parameter的值对应。[这点很重要]

如下代码截取自struts-config.xml：

<action path="/editArticle"

        type="com.****.EditArticleAction"

        name="AtricleForm"

        scope="request"

        parameter="action"><!--按钮的名字此处为“action”-->

    <forward name="success" path="/***.jsp"/>

</action> 

下面给出一个jsp页面的表单部分

<html:form action="/editArticle"/>

    <html:submit property="action">

       <bean:message key="button.view"/>

    </html:submit>

    <html:submit property="action">

       <bean:message key="button.delete"/>

    </html:submit>   

</html:form> 

那么相应的ApplicationResources.properties中就会有如下片断：

button.view=View The Article

button.delete=Delete The Atricle 

此时还并为完成，在LookupDispatchAction中有一个抽象方法：

    /**
     *  Provides the mapping from resource key to method name
     *
     *@return          Resource key / method name map
     */

    protected abstract Map getKeyMethodMap();

这个方法你应该在EditArticleAction中实现，如下：

protected Map getKeyMethodMap(){
      Map map = new HashMap();
      map.put("button.view", "view");

      map.put("button.delete", "delete");

      return map; 
} 

好了，假设在你的EditArticleAction有如下方法：

  public ActionForward view(ActionMapping mapping,
          ActionForm form,
          HttpServletRequest request,
          HttpServletResponse response)
          throws IOException, ServletException {
      //......

      //......

      return mapping.findForward("success");
  }

  public ActionForward delete(ActionMapping mapping,
          ActionForm form,
          HttpServletRequest request,
          HttpServletResponse response)

          throws IOException, ServletException {

      //......

      //......

      return mapping.findForward("success");
  } 

下面实例几个假设client端的请求： 

http://....../editArticle.do此时页面有两个按钮,按钮1“View The Article”,""，按钮2“Delete The Atricle” 

当提交按钮1时调用EditArticleAction里的view方法；

当提交按钮2时调用EditArticleAction里的delete方法； 

以下还有一点说明；

如果我有一个按钮要触发action的AA方法，但是在该action没有AA方法，此时将抛出异常；如果该action中有两个AA方法，则会调用第一个。

SwitchAction

========================

org.apache.struts.actions.SwitchAction

SwitchAction主要在多模块应用中执行模块切换作用。

在Struts多模块工程中有两种方法可以切换到新模块上.首先，您可以在 struts-config.xml 中创建一个新的全局或局部转发“success”（参见下面代码）。然后可以使用 mapping.findForward("success") 切换到这个新模块上来。

<forward name="success"   contextRelative="true"
   path="/newModule/index.do"   redirect="true"/>
contextRelative＝true的意思是path是相对于应用上下文的路径，contextRelative=false则是指path是相对于模块上下文的路径。

其次，创建一个如下所示的操作，其类型是一个 SwitchAction 操作：

<action path="/switchTo" type="org.apache.struts.actions.SwitchAction" validate="false" />

然后在 struts-config-newModule.xml 中创建如下所示的操作映射。

<action-mappings>
   <action path="/index" type="com.asprise.struts.newmodule.action.IndexAction">
      <forward name="success" path="/index.jsp"/>
   </action>
</action-mappings>

接下来，编写 easyStruts/newModule/index.jsp 的代码。index.jsp 只会显示一条消息“<h1>Youare in module: newModule</h1>”。现在，启动 Tomcat 服务器，并输入 http://127.0.0.1:8080/easyStruts/switchTo.do?prefix=/newModule&page=/index.do既可。如果您想切换回默认的模块，只需输入 http://127.0.0.1:8080/easyStruts/switchTo.do?prefix=&page=/owner.jsp 即可。

struts的配置文件详解

Connection conn=DriverManager.getConnection("JDBC URL ");
      sql=" select *  from some tables ";
PreparedStatement stmt = conn.prepareStatement(sql);
      ResultSet rs = stmt.executeQuery();
ArrayList array=new ArrayList();
while (rs.next()) {
   AActionForm actionForm =new AActionForm ();
   actionForm.setId(rs.getString("Id"));
   actionForm.setName(rs.getString("Name"));           
   array.add(actionForm);
}

<logic:present name=" array " scope="request">
<logic:iterate name=" array " id=" array " 
type="com.bhsky.webis.Goods">
       <tr align="center"> 
          <td class="table2">
<bean:write name=" array " property="goodsid"/>
</td>
            <td class="table2">
<bean:write name=" array " property="goodsname"/>
</td>
        </tr>
  </logic:iterate> 
</logic:present>

三、如何应用类反射机制简化Struts应用程序的开发:





1、 先定义Action FormBean:

package com.bhsky.webis.system;
import org.apache.struts.action.*;
import javax.servlet.http.*;
    
public class UsersActionForm extends ActionForm {
private String usr_id;
private String usr_name;
public void setUsr_id(String usr_id) {
    this.usr_id = usr_id;
}
public String getUsr_id() {
    return usr_id;
}
public String getUsr_memo() {
    return usr_memo;
}
public void setUsr_name(String usr_name) {
    this.usr_name = usr_name;
}
}

/////////////////////////////////////////////////////////////////////////////
    //Function: 完成ResultSet对象向ArrayList对象为集合的对象的转化
    //Para:sql,指定的查询Sql
   //Para:className,Sql相对应得JavaBean/FormBean类的名字
   //Return:以类className为一条记录的结果集，完成ResultSet对象向ArrayList对象为集
   //合的className对象的转化
  //////////////////////////////////////////////////////////////////////////////
  public ArrayList Select(String sql,String className){
    ArrayList paraList=new ArrayList();
    try{
      if (conn == null){
        Connection();
      }
      PreparedStatement stmt = conn.prepareStatement(sql);
      ResultSet rs = stmt.executeQuery();
      String recordValue="";
      Object c1=null;
      paraList=new ArrayList();
      ResultSetMetaData rsmd = rs.getMetaData();
      int columnCount = rsmd.getColumnCount();
      while (rs.next()){
          c1=Class.forName(className).newInstance();
          for (int i=1; i<=columnCount; i++) {
            if(rs.getString(rsmd.getColumnName(i))!=null){
              recordValue=rs.getString(rsmd.getColumnName(i));
            }else{
              recordValue="";
            }
Method 
m=c1.getClass().getMethod(getSetMethodName(rsmd.getColumnName(i)),
new Class[]{recordValue.getClass()});
            m.invoke (c1, new Object[]{recordValue});
          }
          paraList.add(c1);
      }
    }catch(SQLException ex){
      
}catch(ClassNotFoundException e){

}catch(NoSuchMethodException e) {

}catch(InvocationTargetException e){

}catch (IllegalAccessException e){

}catch(InstantiationException e){

} finaly{
        closeConnection();
return paraList;
}
  }

//Function:取得用户列表
  //Para:
  //Return:返回用户列表
  /////////////////////////////////////////////////////////////////////////////
  public ArrayList getUsers(){
      ArrayList ret=null;
      DatabaseManage db=new DatabaseManage();
      String sql=" select usr_id,usr_name "
          +" from users " ;
      ret=db.Select(sql," com.bhsky. webis.system.UsersActionForm");
      return ret;
  }

public ActionForward execute(
            ActionMapping actionMapping, 
            ActionForm actionForm, 
            HttpServletRequest request, 
            HttpServletResponse httpServletResponse) 
   {
    /**@todo: complete the business logic here, this is just a skeleton.*/
    UsersActionForm uaf=(UsersActionForm)actionForm;
    SystemService ubb=new SystemService();
    ArrayList userList=ubb.getUsers();
    request.setAttribute("userList",userList);
    ActionForward actionForward=actionMapping.findForward(url);
    return actionForward;
  }

<table width="700" class="1" border="1" cellspacing="1" align="center">
            <tr>
              <td class="list" >用户ID</td>
              <td class="list" >姓  名</td>
            </tr>
            <logic:present name="userList" scope="request">
            <logic:iterate name="userList" id="userList" 
type="com.bhsky.webis.system.UsersActionForm">
            <tr>
              <td class="cell1"  height="22"><bean:write name="userList" 
property="usr_id"/></td>
              <td class="cell1"  height="22"><bean:write name="userList" 
property="usr_name"/></td>
          </tr>
            </logic:iterate>
      </logic:present>
</table>

article1.CustomerForm
package article1;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionError;
import javax.servlet.http.HttpServletRequest;

public class CustomerForm extends ActionForm {

    protected boolean nullOrBlank (String str) {
        return ((str == null) || (str.length() == 0));
    }
    public  ActionErrors validate(ActionMapping mapping,
            HttpServletRequest request) {
        ActionErrors errors = new ActionErrors();
        if (nullOrBlank(lastName)) {
            errors.add("lastName",
                   new ActionError("article1.lastName.missing"));
        }
        if (nullOrBlank(firstName)) {
            errors.add("firstName",
                   new ActionError("article1.firstName.missing"));
        }
        if (nullOrBlank(street)) {
            errors.add("street",
                   new ActionError("article1.street.missing"));
        }
        if (nullOrBlank(city)) {
            errors.add("city",
                   new ActionError("article1.city.missing"));
        }
        if (nullOrBlank(state)) {
            errors.add("state",
                   new ActionError("article1.state.missing"));
        }
        if (nullOrBlank(postalCode)) {
            errors.add("postalCode",
                   new ActionError("article1.postalCode.missing"));
        }
        if (nullOrBlank(phone)) {
            errors.add("phone",
                   new ActionError("article1.phone.missing"));
        }
        return errors;
    }

    private String lastName;
    private String firstName;
    private String street;
    private String city;
    private String state;
    private String postalCode;
    private String phone;

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getPostalCode() {
        return postalCode;
    }

    public void setPostalCode(String postalCode) {
        this.postalCode = postalCode;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}

customer.jsp
<%@ taglib uri="/WEB-INF/c.tld" prefix="c" %>
<%@ taglib prefix="fmt" uri="/WEB-INF/fmt.tld" %>
<%@ taglib uri="/WEB-INF/struts-tiles.tld" prefix="tiles" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>

<head>
<title>Example of a standard Customer form</title>
</head>
<h1>Example of a standard Customer form</h1>
<html:form action="/addCustomer">
Last Name: <html:text property="lastName"/>
<html:errors property="lastName" /><br>
First Name: <html:text property="firstName"/>
<html:errors property="firstName" /><br>
Street Addr: <html:text property="street"/>
<html:errors property="street" /><br>
City: <html:text property="city"/>
<html:errors property="city" /><br>
State: <html:text property="state" maxlength="2" size="2" />
<html:errors property="state" /><br>
Postal Code: <html:text property="postalCode" maxlength="5"
                                              size="5" />
<html:errors property="postalCode" /><br>
Telephone: <html:text property="phone" maxlength="11" size="11" />
<html:errors property="phone" /><br>
<html:submit/>
</html:form>

article1.AddCustomerAction
package article1;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionForm;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;

public class AddCustomerAction extends Action {
    public ActionForward execute(ActionMapping mapping,
                                 ActionForm form,
                                 HttpServletRequest request,
                                 HttpServletResponse response)
    throws ServletException, IOException{
        CustomerForm custForm = (CustomerForm) form;
        System.out.println("lastName   = "
                            + custForm.getLastName());
        System.out.println("firstName  = "
                            + custForm.getFirstName());
        System.out.println("street     = " + custForm.getStreet());
        System.out.println("city       = " + custForm.getCity());
        System.out.println("state      = " + custForm.getState());
        System.out.println("postalCode = "
                            + custForm.getPostalCode());
        System.out.println("phone      = " + custForm.getPhone());

        return mapping.findForward("success");
    }
}

这就是一起绑定的所有东西，他们总是与Struts一起，放在struts-config.xml 文件内:

												
												<struts-config>
<form-beans>
<form-bean name="customerForm" type="jdj.article1.Customer" />
      </form-beans>
<action-mappings>
<action path="/addCustomer" type="article1.AddCustomerAction"
                            name="customerForm" scope="request"
                            input="/addCustomer.jsp">
<forward name="success" path="/addCustomerSucceeded.jsp"
                        redirect="false" />
</action>
</action-mappings>
<message-resources parameter="ApplicationResources" />
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property value="/WEB-INF/validator-rules.xml"
              property="pathnames" />
struts-config.xml</plug-in></struts-config>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC 
  "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
  "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
 <form-beans>
  <form-bean name="customerForm" type="article1.CustomerForm" />
 </form-beans>
 <action-mappings>
  <action path="/addCustomer" type="article1.AddCustomerAction"
          name="customerForm" scope="request" input="/customer.jsp">
      <forward name="success" path="/addCustomerSucceeded.jsp"
               redirect="false" />
  </action>
 </action-mappings>
 <message-resources parameter="ApplicationResources" />
 <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
   <set-property value="/WEB-INF/validator-rules.xml"
        property="pathnames" />
 </plug-in>
</struts-config>

lastName = Bush
firstName = George
street = 1600 Pennsylvania Avenue NW
city = Washington
state = DC
postalCode = 20500
phone = 2024561414

<form-bean name="dynaCustomerForm"
           type="org.apache.struts.action.DynaActionForm">
  <form-property name="lastName" type="java.lang.String"/>
  <form-property name="firstName" type="java.lang.String"/>
  <form-property type="java.lang.String" name="street"/>
  <form-property name="city" type="java.lang.String"/>
  <form-property name="state" type="java.lang.String"/>
  <form-property name="postalCode" type="java.lang.String"/>
</form-bean>

article1.AddDynaCustomerAction
package article1;

import org.apache.struts.action.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;

public class AddDynaCustomerAction extends Action {
  public ActionForward execute(ActionMapping mapping,
                               ActionForm form,
                               HttpServletRequest request,
                               HttpServletResponse response)
                       throws ServletException, IOException{
  DynaActionForm custForm = (DynaActionForm) form;
  System.out.println("lastName   = " + custForm.get("lastName"));
  System.out.println("firstName  = " + custForm.get("firstName"));
  System.out.println("street     = " + custForm.get("street"));
  System.out.println("city       = " + custForm.get("city"));
  System.out.println("state      = " + custForm.get("state"));
  System.out.println("postalCode = "
                      + custForm.get("postalCode"));
  System.out.println("phone      = " + custForm.get("phone"));

      return mapping.findForward("success");
     }
}

article1.DynaCustomerForm
package article1;

import org.apache.struts.action.*;

import javax.servlet.http.HttpServletRequest;

public class DynaCustomerForm extends DynaActionForm {

protected boolean nullOrBlank (String str) {
  return ((str == null) || (str.length() == 0));
 }

public ActionErrors validate(ActionMapping mapping,
                    HttpServletRequest request) {
  ActionErrors errors = new ActionErrors();
  if (nullOrBlank((String)this.get("lastName"))) {
    errors.add("lastName",
           new ActionError("article1.lastName.missing"));
  }
  if (nullOrBlank((String)this.get("firstName"))) {
    errors.add("firstName",
           new ActionError("article1.firstName.missing"));
  }
  if (nullOrBlank((String)this.get("street"))) {
    errors.add("street",
           new ActionError("article1.street.missing"));
  }
  if (nullOrBlank((String)this.get("city"))) {
    errors.add("city", new ActionError("article1.city.missing"));
  }
  if (nullOrBlank((String)this.get("state"))) {
    errors.add("state",
           new ActionError("article1.state.missing"));
  }
  if (nullOrBlank((String)this.get("postalCode"))) {
    errors.add("postalCode",
           new ActionError("article1.postalCode.missing"));
  }
  if (nullOrBlank((String)this.get("phone"))) {
    errors.add("phone", new ActionError("article1.phone.missing"));
  }
  return errors;
 }

}

Struts是源代码开放的企业级Web应用开发框架，它的设计目的是从整体上减轻构造企业Web应用的负担。本文通过一个Struts应用的实例，帮助你迅速掌握Struts。

　　Struts是在Jakarta项目下开发的源代码开放软件，由一系列的框架类、辅助类和定制的JSP标记库构成，定位在基于Model 2设计模式的J2EE应用开发。Model 2体系是MVC（Model-View-Controller）体系的一种应用。在MVC体系中，数据模型（Model）、表现逻辑（View）和控制逻辑（Controller）是分离的组件，但它们可以互相通信。Struts力图从整体上减轻构造企业级Web应用的负担，并提供国际化和数据库连接池支持。

　　Struts体系可以看成两个相对独立的部分：第一个部分是Struts API，用于编写支持Struts的应用组件；第二部分是Struts的JSP标记库，由html、bean、logic和template四个标记组成。Struts的两个部分有着各自不同的用户。对于规模较小的项目，同一个用户可能同时使用这两个部分；但对于规模较大的项目，通常开发者使用API组件，而负责HTML页面布局的人使用标记库。

　　Struts的设计目标是为Model 2 Web应用开发提供一个强大的框架。同时，Struts还包含了一些实用组件，例如Digest，但这些组件并不从属于上面提到的两个部分。

　　Struts应用的体系结构

　　对于从传统编程环境转入Web开发的人来说，Web编程中令人很不习惯的一个特点是缺乏“程序”。传统的应用总是有主入口点、流程控制和出口点。但在Web网站上，用户可能从任何地方进入，按照一种完全随机的次序访问各个页面，甚至可能跳过多个页面，也可能在一、两个小时内毫无动静。这是HTTP访问的基本特征，无论是Struts还是其他Web编程框架，都无法改变这一点。然而，Struts能够隐藏Web访问固有的“混乱”，帮助开发者建立起清晰和明确的秩序和规则。

　　在Struts应用中，有一个称为ActionServlet的主调度程序（或称为分配器），如图1所示。不过，并非所有的请求都必须通过ActionServlet。用户的请求目标可以是非Struts的页面，也可以是那些使用了Struts标记库但不使用Struts请求分配服务的页面。这正是Struts体系的优点之一：按需使用。许多编程框架要求你要么不用，要么全部使用，而且一旦你决定使用，以后要悔改从前的错误就会付出高昂的代价。Struts按需使用的优点与这类系统形成了强烈对比。

　　

　　图1 Struts框架中的请求处理

　　Struts应用由下面这些基本模块构成：

　　1.配置信息;

　　2.Servlet，主要是Struts的ActionServlet;

　　3.动作类（Action），执行逻辑和控制（请求分配）功能，它们由ActionServlet调用；

　　4.JSP页面（属于View），常常通过动作类分派；

　　5.JSP标记库，根据需要使用；

　　6.各种形式的JavaBean，包括用户定义的JavaBean。

　　典型的Struts应用要用到三种配置文件：web.xml、struts-config.xml和可选的应用资源文件。

　　web.xml是Web应用的标准配置文件，是所有J2EE Web应用必需的组成部分。应用服务器通过该配置文件把URL映射到Servlet和JSP，通过该配置文件为Servlet和JSP指定启动参数。为Struts应用提供的基本web.xml文件很简单，真正必需的只有一个主ActionServlet定义，以及一个确保Struts请求传递到ActionServlet的映射。按照惯例，以“.do”结尾的URL都是Struts请求，例如/login.do。应用服务器利用web.xml文件中的映射，把该请求传递给ActionServlet。接着，ActionServlet决定如何分配该请求。ActionServlet的决定依据是struts-config.xml中定义的规则，和/或是通过ActionServlet派生类额外定义的分配逻辑。

　　struts-config.xml称为Struts配置文件。Struts应用是一个依靠struts-config.xml文件把组件连接起来的网络。struts-config.xml文件为Web应用的组件定义了逻辑名称，也定义了它们在Struts框架下的属性和关系，就像web.xml文件在Web应用框架之内定义组件一样。struts-config.xml文件包含了与Struts框架有关的应用信息，这些信息分四个类：

　　1.数据源信息，它是可选的。在这里可以指定一个或者多个JDBC数据源，使得数据库定义信息集中化。对于数据库访问，Struts还有一个额外的优点，即支持基本的数据库连接池功能。

　　2. Form Bean是JavaBean的一种特殊类型，它简化了Web表单的处理。

　　3. Global Forwards是全局性的转发定义信息。Struts动作按照一种“请求—转发”机制运行。为了最大限度地分　　离动作模块与转发目标，这里使用了一种映射机制，允许通过同义词引用转发目标。一些目标页面可能被多个动作类引用，例如登录页面，因此可以在全局转发定义部分把逻辑目标页面映射到物理目标页面，避免把这部分信息加入到动作定义部分。

　　4. Actions定义了Struts应用体系的请求分配信息，它们是核心分配器的补充定义，负责处理各种具体的请求类型。

一个简单的应用

　　基于Struts的Web应用和普通Web应用有着许多同样的要求，但Struts应用也有自己特殊的需求。一个可部署的Web应用应该可组织和构成一个WAR文件。WAR文件是带有图2所示目录结构的JAR包。对于Struts Web应用来说，Web-INF目录下还要加上一些额外的文件，例如struts-confg.xml文件和标记库描述器（TLD）文件。注意：应用的资源应该放入应用的类路径下，也就是Web-INF/lib目录或Web-INF/class目录下的JAR包内。对于大多数简单的Struts页面，我们只用到Struts标记库，而按照MVC的术语就不需要涉及Model和Controller部分，只涉及View。请看图3所示的主页例子。虽然这个页面没有表单，但Struts仍能够在设计这类页面时提供帮助。

　　

　　图2 Struts应用的目录结构

　　

　　图3 一个简单的View

　　要管理会话，最简单的途径是使用Cookie。会话标识符被传递到客户端之后，客户端把它保存到Cookie，以后的每次请求就把Cookie发送到服务器。然而，和其他的许多Web解决方案一样，Cookie方案也不是万能的，因为一些用户可能不信任Cookie，关闭浏览器的Cookie支持。由于这种情况，URL改写技术就出现了。使用URL改写技术时，整个网站的所有URL后面都将加上会话标识符。虽然这个方案不像采用Cookie方案那样简单、稳固，但它确实行得通。URL改写技术的不稳固是有两方面的原因。首先，和Cookie不同，URL没有过期时间，如果一个带有会话标识的URL被截取后又重新在以后的访问中使用，那么这种URL不会很有用，因为会话一般在一定的时间后会被作废。其次，如果有一个URL链接的后面没有带上会话标识符，整个链都会中断，客户程序无法再次获取会话标识符，除非它备份了带有会话标识符的URL访问历史。

Servlet能够只通过一次方法调用完成URL改写。从技术上讲，JSP也一样能够办到这一点，但一个好的JSP页面应该不包含Java代码，或包含尽量少的Java代码。为此，Struts提供了一个链接标记。本例使用了该标记来维持客户端和服务器之间的会话状态信息。

　　绑定View、Model和Controller

　　前面的简单页面不需要Struts分配器，因为它只有简单的链接。图4显示了一个比较复杂的“类别”页面。它列举出了数据库中的类别条目，并将这些条目分别链接到对应的编辑页面。为显示这个页面，我们就要用到Struts的ActionServlet分配机制。

　　

　　图4 类别页面

　　在web.xml文件中，放入一项表示所有以“.do”结尾的URL请求必须发送给Struts分配器的声明。这里的分配器可以是org.apache.struts.action.ActionServlet或其扩展类。Struts分配器在启动时读取struts-config.xml文件，并构造出一个动作映射图。本例指定了一个名为ShowCategories的动作类，来处理“ShowCategories”动作。可以看出，Struts应用的基本工作模式是：主分配器调用一个动作分配器，动作分配器确定或构造出Model部分（一个JavaBean或其它Java对象），并把它提供给View（通常是一个JSP页面）。

　　本例使用Bean的情况稍微有点复杂，它有多个数据项，因此我们不是使用单个提供数据的Bean，而是要生成一组Bean。遗憾的是，JSP页面以HTML为基础，HTML没有提供循环或其他控制逻辑。不过，Struts的logic:iterate允许对数组进行迭代操作，如下面的代码片断所示：

<table>
<logic:iterate id="category"
type="com.strutsdemo.Category"
name="<%= Constants.CATALOG_CATEGORIES %>"
scope="application">
<tr>
<td>
<html:link page="/editCategory.do"
 name="category"
 property="mapping">
 编辑
</html:link>
<html:link page="/removeCategory.do"
 name="category"
 property="mapping">
 删除
</html:link>
<bean:write name="category"
 property="category"/>
</td>
</tr>
</logic:iterate>
</table>

为保证上述操作顺利进行，在struts-config.xml文件中加入声明，指定由哪一个动作处理器来处理指定的动作：

<action path="/showCategories"
   scope="request"
   type="com.strutsdemo.ShowCategoriesAction"
   unknown="false"
   validate="false">
   <forward name="viewCategories" path="/      
   ShowCategories.jsp"/>
</action>

准备阶段

　　一次典型的编辑会话要求有一个动作处理器准备View，即一个作为View的JSP页面，还要求有第二个动作处理器存储更新后的View。当然，存储操作之后会有第二个属于View的页面被显示，例如一个“数据已经更新，点击此处继续”的页面（参见表1）。

　　 表1：基于Form Bean的编辑过程要用到的部件

<action path="/editCategory"
   scope="request"
   name="catForm"
   type="com.strutsdemo.EditCategoryAction"
   unknown="false"
   validate="false">
   <forward name="success"
   path="/EditCategory.jsp"/>
</action>

<action path="/saveCategory"
   scope="request"
   name="catForm"
   type="com.strutsdemo.SaveCategoryAction"
   unknown="false"
   input="/EditCategory1.jsp"
      validate="true">
   <forward name="success"
      path="/CategoryUpdated.jsp"/>
</action>

构造和运行Struts应用

　　要构造和运行本文的示例应用，你必须了解如何使用Jakarta的Ant工具。如果你还不了解Ant，现在该是学习它的时候了！赶紧到网站下载Ant，通常要解开压缩，设置一下ANT_HOME环境变量，然后把Ant加入到执行路径就可以了。

本文示例的build.xml需要稍微定制一下，修改指示本地Tomcat位置的配置，使它能够找到在Tomcat下编译所必需的类。另外，你还要有一份Struts的JAR。你可以去下载最新的版本。

　　struts-config.xml文件是粘合Struts应用各个部分的配置文件。在部署完成后的Web应用中，struts-config.xml在Web-INF目录下。你应该修改一下数据源配置，使之符合你当前使用的DBMS环境。数据模型和SQL模式文件在下载包的DBMS目录下，SQL文件针对PostgreSQL DBMS编写。

　　示例中src/com/strutsdemo/ShowCategoriesAction. java是一个简单的分配器。ActionForward()是请求分配方法，从ActionServlet调用。该方法可以完成主要的工作，例如分析请求参数、执行计算，以及构造出View使用的JavaBean。另外，该方法还要根据处理结果，确定下一个要显示的是什么页面：可能是预设的多个页面之一，也可能是一个错误信息页面。

　　ActionForward()的请求分配过程

　　当然，最复杂的处理过程与表单有关。ActionForward方法的请求分配过程是：

　　1. ActionServlet，对请求进行解码。由于为动作指定了Form Bean，ActionServlet处理Form Bean（参见下面有关“ActionServlet如何使用Form Bean”的说明）。然后，请求传递给了EditCategoryAction。

　　2. EditCategoryAction；准备处理View，或者从数据库装入现有数据，或者创建新的数据项。动作处理器利用Mapping.findForward把控制传递给EditCategory.jsp。

　　3. DitCategory.jsp，显示出Form Bean，允许用户编辑数据。用户提交数据后，控制转到ActionServlet。

　　4. ActionServlet，对请求进行解码。这一次，Form Bean将从View的数据初始化，因为它是一个Struts的JSP表单页面。由于有Form Bean，且struts-config.xml中指定了“validate=‘true’”，名为“catForm”的Form Bean的validate()方法被调用。如果用户提交的数据未能通过合法性验证，则控制转到EditCategory1.jsp。

　　5. EditCategory1.jsp，它只是EditCategory.jsp略加修改后的一个版本。如果有必要，原始编辑页面和带有错误提示的编辑页面可以使用同一个View。Struts的JSP标记能够帮助我们轻松地办到这一点。该页面提交给/saveCategory.do。这样，用户就在这几个页面之间绕圈子，直到他跳转到一个与编辑操作无关的页面，或者他提交的数据通过了合法性验证。

　　6. 如果Form Bean合法性验证通过，ActionServlet把请求（包括Form Bean）传递给SaveCategoryAction。在这个例子中，“save”可能意味着创建操作，也可能意味着更新操作，具体由URL提供的选项决定。写入数据的操作通过调用Form Bean的store()方法完成。注意：实际的应用应当使用某种类型的事务管理机制（或使用EJB，因为EJB有内建的事务管理机制），以避免并发访问带来的问题。

　　ActionServlet如何使用Form Bean

　　涉及Form Bean的ActionServlet处理过程包含六个步骤：

　　1. 找到或创建Form Bean；

　　2. 据从HTTP请求传入的相应数据，更新Form Bean的各个属性；

　　3. 检查用户是否点击了“取消”按钮。如是，跳过步骤4和步骤5；

　　4. 验证Form Bean数据的合法性；

　　5. 如数据未能通过合法性验证，发送“input=”参数中指定的View；

　　6. 否则，把Form Bean传递给动作处理器

1）需求：

2）问题：

3)解决办法：