1<init-param>
 2      <param-name>config</param-name>
 3      <param-value>/WEB-INF/struts-config.xml</param-value>
 4  </init-param>
 5    <!-- config后面的/ma表示模块名，访问ma模块里的配置文件的action中的url路径位：应用路径/模块名/url.do  -->
 6   <init-param>
 7      <param-name>config/ma</param-name>
 8      <param-value>/WEB-INF/ma/struts-config.xml</param-value>
 9   </init-param>
10     <init-param>
11      <param-name>config/mb</param-name>
12      <param-value>/WEB-INF/mb/struts-config.xml</param-value>
13     </init-param>
14    或者
15        <init-param>
16              <param-name>config</param-name>
17              <param-value>/WEB-INF/struts-config.xml</param-value>
18            </init-param>
19        <init-param>
20        <param-name>config/catalog</param-name>
21        <param-value>/WEB-INF/ma-struts-config.xml</param-value>
22        </init-param>
23         <init-param>
24        <param-name>config/authorize</param-name>
25           <param-value>/WEB-INF/mb-struts-config.xml</param-value>
26</init-param>
27

（3）ActionServlet的process()方法的主要工作有：

      1）根据请求信息获知所请求的模块名称，从ServletContext中获得与请求模块对应的的

ModuleConfig对象，并存储到request中。

2）根据模块信息获得相应的RequestProcessor对象，一个模块对应一个RequestProcessor

对象，RequestProcessor对象将关联与所属模块对应的ModuleConfig对象。

3）调用RequestProcessor对象的process方法，将request和response作为参数传递给它。 3、RequestProcessor类

（1）Struts框架只允许应用中存在一个ActionServlet类，但每个应用程序模块都有各自的RequestProcessor类实例。

（2）RequestProcessor对象的process方法的主要工作：

      1）调用自己的 processPreprocess(request, response)方法，该方法不进行任何操作，用于

子类重写扩展其功能。

2）获得与请求地址所匹配的ActionMapping对象，AcionMapping对象用于封装一个特

定acion的配置信息。

3）根据ActionMapping中的配置信息获得ActionForm对象（该对象将缓存到request

或session中），并将表单数据填充到ActionForm中，然后根据ActionMapping的配置决

定是否验证ActionForm，如果验证，将调用ActionForm的validate方法，若其返回的

ActionErros对象中包含ActionMessage对象则表示验证失败，将转向action配置信息input

属性所指示的地址。

4）如果ActionForm无需验证或验证通过将创建并缓存与请求地址匹配的Action对象，

将ActionMapping对象、ActionForm对象、request和response作为参数调用其execute

方法。

5）根据Action对象的execute方法返回的ActionForward对象，将请求转发或重定向到

该ActionForward所封装的地址。

4、Action类

（1）Action类是用户请求和业务逻辑之间的桥梁

（2）ActionServlet对所有的请求作集中的统一处理，每个不同的Action类具体处理不同的请求。

（3）每个Action类都需要实现execute()方法，RequestProcessor类创建一个Action实例后，就会调用其execute()方法。

（4）struts-config.xml：

 1<action-mappings> 
 2<action path=”/ 路径，当请求时×××.do时 FC就调用该Action的execute方法”
 3type=”Action类的名称（包名.类名）” 
 4name=”该Action关联的ActionForm的名称” 
 5<!--如果有，则FC在调用execute方法之前要获得ActionForm对象（第一次
 6调用该Action时创建，然后从request或者session）并且用请求参数对
 7其填充，然后将其（ActionForm对象）作为参数调用execute方法 -->
 8attribute=” 缓存ActionForm对象的名称（key），不写key就是name的值” 
 9scope=” 缓存ActionForm的范围（request|session）默认是session” 
10validate=”是否要验证true|false” 
11<!--如果是true，则FC在填充ActionForm之后，调用Action的execute之前，
12会验证该ActionForm对象（一种是调用validate方法，另外一种是使用
13validation框架）--> 
14input=”” 和validate=”true” 联用，表示验证失败后，FC把请求转向的地址 
15parameter=”” 是一个附加的属性，对于不同的Action可能有不同的意义 
16<!--封装该Action可能转发（重定向）的地址信息-->
17<forward name=”” 该forward的名称(用于mapping.findForward方法) 
18path=”” 地址必须以“/”开头 redirect=”” 表示是否重定向/>
19… … … 
20</ action > 
21</action-mappings>
22

5、内置的Struts Action类

（1）目的

1）减少Action类的数目

2）便于代码的维护

（2）DispatchAction

 1）特点：

①DispatchAction 类是Action 类的子类；

②共享同一个Action 的路径；

③共享一个ActionForm，多个不同action path，可以在同一个类中。

2）DispatchAction 的写法：

 1public class MyDispatchAction extends DispatchAction{
 2
 3ActionForward login(ActionForm form,HttpServletRequest request,
 4
 5HttpServletResponse response,ActionMapping mapping)throws Exception {
 6
 7return mapping.findForward(“sucess”)；
 8
 9}    
10
11}
12
13

  
注意：不要覆盖execute()方法

3）DispatchAction 的配置文件：

1<action path="/dispatch" type=" MyDispatchAction " parameter="method">
2
3<forward name="sucess" path="/ message.jsp "/>
4
5</action>
6

注意：parameter 属性是和表单中隐藏域的名字相对应的

      4）DispatchAction 页面：

   <form action=“${pageContext.request.contextPath}/dispatch.do" method="post">

<input type="hidden" name="method"  value=“login"/>

<!--

使用隐藏域为struts 传递要调用的自定义Action 中方法的名字，通过与strutsconfig.xml 中action 标签的parameter 属性相对应来获取隐藏域的value。

-->

<input type="submit" value="submit"/>

</form>

<a href="${pageContext.request.contextPath}/dispatch.do?method=login">Login</a>

（3）MappingDispatchAction

      1）特点：

① MappingDispatchAction 类是DispatchAction 的子类

②可以匹配多个action 路径

③可以不共享同一个ActionForm

2）MappingDispatchAction 的写法

 1public class MyMappingDispatchAction extends MappingDispatchAction{
 2
 3ActionForward login(ActionForm form,HttpServletRequest request,
 4
 5HttpServletResponse response,ActionMapping mapping) throws Exception{
 6
 7return mapping.findForward(“success")
 8
 9}
10
11}
12
13

3）MappingDispatchAction 的配置文件

      <action path="/mapping/login" type=" MyMappingDispatchAction "

parameter=“login">

<forward name=“success" path="/message.jsp"/>

</action>

注意：parameter 属性是指定调用方法的名字

4）MappingDispatchAction 页面

<form action=“${pageContext.request.contextPath}/mapping/login.do" method="post">

<input type="submit" value="submit"/>

</form>

注意：在JSP 页面中不需要再使用隐藏域来传递参数了，在form 中的action 就可以

直接使用xxx.do 匹配了。

（4）LookupDispatchAction

      1）特点：

      ①LookupDispatchAction 类也是DispatchAction 类的子类。

  ②解决一个表单的多个同名提交按钮的问题。

  ③通过使用资源文件，用submit 按钮的value 来作为资源文件中的key 所对应的值，通

过这个值来找到对应的key，再使用这个key 来获得指定Map 中所对应的值，这个值就

是要调用的方法名。

注意：在继承LookupDispatchAction 时，要覆盖getKeyMethodMap()方法，并定义Map，

向Map 中放入指定的键值对。

      2）LookupDispatchAction 的写法

 1 public class TestLookupDispatchAction extends LookupDispatchAction {
 2
 3   public ActionForward login(ActionMapping mapping, ActionForm form,
 4
 5        HttpServletRequest request, HttpServletResponse response)throws Exception{
 6
 7              return mapping.findForward("success");
 8
 9   }
10
11      public ActionForward register(ActionMapping mapping, ActionForm form,
12
13                 HttpServletRequest request, HttpServletResponse response)throws Exception{
14
15                      return mapping.findForward("register");
16
17      }
18
19      public Map getKeyMethodMap() {
20
21           Map map = new HashMap();
22
23           //key 为资源文件的key 值，value 为action 中的方法名。
24
25           map.put("submit.login", "login");
26
27           map.put("submit.register", "register");
28
29           return map;
30
31      }
32
33}
34
35

3）LookupDispatchAction 资源文件

           MessageResource.properties文件中

submit.login=login

submit.register=register

4）LookupDispatchAction 的配置文件：

 1 <form-beans >
 2
 3               <form-bean name="lookupForm" type="form.LookupForm" />
 4
 5</form-beans>
 6
 7        <action-mappings>
 8
 9                     <action path="/lookup" name="lookupForm"
10
11type="action.TestLookupDispatchAction" parameter="submit">
12
13                            <forward name="success" path="/jsp/success.jsp"/>
14
15                            <forward name="register" path="/jsp/register.jsp"/>
16
17      </action>
18
19</action-mappings>
20
21<message-resources parameter="MessageResource" />
22
23

5）LookupDispatchAction 页面：

 1<html:form action="/lookup" styleId="lookupForm" 
 2
 3styleClass="lookupForm">
 4
 5                  userName:<html:text property="name" /><br>
 6
 7                  password:<html:password property="pwd" redisplay="false" />
 8
 9                  <br> <br>
10
11                  <html:submit property="submit">
12
13                      <bean:message key="submit.login" />
14
15                  </html:submit>
16
17                  <html:submit property="submit">
18
19                       <bean:message key="submit.register" />
20
21                  </html:submit>
22
23           </html:form>
24
25

      注意：页面中的property="submit"与struts-config.xml中action的parameter元素值相同

四、ActionForm

1、为什么使用form？

（1）用户提交的数据封装成对象

（2）表单数据的缓存。

（3）表单信息验证（服务器端验证）

2、ActionForm的生命周期

（1）ActionForm Bean有两种存在范围：request和session

      1）如果存在于request范围，它仅在当前的请求/响应生命周期中有效

      2）如果存在于session范围，同一个ActionForm实例在整个Http会话中有效

注意：在struts配置文件中，<action>元素的scope属性用来设置ActionForm的范围，

默认值为session。

3、配置ActionForm

（1）action和form的关系是：一对多

（2）struts-config.xml

     <form-beans>

<form-bean name="userForm" type="form.UserForm"/>

… … …

</form-beans>

（3）在某一个Action的配置中可以写：

<action path="/add" type="action.AddUserAction" name="userForm"/>

4、Form验证

（1）验证：

1）表单级验证：（不访问数据库）

           ①JavaScript做的是客户端验证，可以减少服务器端的负担，但不够安全

           ②在服务器端的Form验证避免跳过客户端的校验

      2）业务逻辑验证：

由Action负责完成

（2）validator()方法

      1）调用的条件：

      ①Form继承ActionForm，并且为ActionForm配置了Action映射，即<form-bean>元素的name属性和<action>元素的name属性匹配。

      ②<action>元素的validate属性为true

      2）validate()方法

           该方法返回ActionErrors对象，如果返回的ActionErrors对象为null，或者

不包含任何ActionMessage对象，就表示没有错误，数据验证通过。如果ActionErrors中包含ActionMessage对象，就表示发生了验证错误。

3）validate()方法主要负责检查数据的格式和语法，而不负责数据是否符合业务逻辑。

（3）Validator框架（验证框架）

1）validate()方法验证的局限性：

①必须通过程序代码来实现验证逻辑，如果验证逻辑发生变化，必须重新编写和编译

程序代码

②当系统中有多个ActionForm Bean，并且它们包含一些相同的验证逻辑时，开发人员必须对每个ActionForm Bean进行重复编程，完成相同的验证逻辑，这会降低代码的可重用性。

      2）主要依赖的jar文件：

       ①jakart-oro.jar：提供了一组处理文本的类，具有文本替换、过滤和分割等功能

       ②commons-validator.jar：提供了一个简单、可扩展的验证框架，包含了通用的验证方

法和验证规则。

3）条件：

      ①validator-rules.xml validation.xml

②struts-config.xml 写plug-in

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

        <set-property property="pathnames"

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

                    /WEB-INF/validation.xml"/>

 </plug-in>

③Form必须继承ValidatorForm（ActionForm子类）

4）validator-rules.xml中规定了常见的验证需求。一般不需要改变。

5）validation.xml是form验证的配置文件。

<form-validation>

      <formset>

           <form name="需要验证的form的名，如果有attribute属性重命名，此处

使用重命名。">

                      <field property="name" depends="required">

<!--property属性表示要验证的form对象的属性名-->

<!--depends属性表示要适用的验证逻辑（required是validator-rules.xml中规

定的验证方式。）

如果depends属性包含多个验证规则，则用“，”隔开。

如果调用depends属性指定的验证规则时验证失败，就不会再调用下

一个规则。-->

<arg0 key="form.username" />

<!-- validator-rules.xml中的每一个验证逻辑都对应res文件中的key（key所对应的值是出错信息）但是出错信息有占位符（{0},{1},{2},…）, arg0表示填充出错信息中，{0}占位符的信息…

注意：实际填充的是key所指字符串在res文件中所对应的值-->

</field>

</form>

</formset>

</form-validation>

切记：Validator框架不能用于验证标准的ActionForm类。如果要使用Validator框架，

应该采用ActionForm类的两个子类：DynaValidatorForm（支持动态ActionForm）和ValidatorForm（支持标准ActionForm）。

5、动态ActionForm

（1）ActionForm 的缺点：表单的改动会触发FormBean 的大量改动（应用程序停器，而且

FromBean 维护量大）。

（2）动态FormBean 是指，Struts 已提供给我们DynaActionForm(是ActionForm 的子类)，我们只需通过配置文件进行配置。

（3）DynaActionForm的写法：

①struts-config.xml

<form-bean name="dynaActionForm"

type="org.apache.struts.action.DynaActionForm">

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

          <form-property name="age" type="java.lang.Integer"/>

</form-bean>

注意：Type 表示属性类型，注意若为基本类型时要用其包装类。

      <action path="/dyna" name="dynaActionForm"

                type="action.TestDynaActionFormAction" scope="request">

<forward name="success"

path="/jsp/testDynaActionForm_success.jsp"></forward>

 </action>

②TestDynaActionForm.jsp

    <h1> 测试DynaActionForm</h1>

    <hr>

    <form action="dyna.do" method="post">

          姓名：<input type="text" name="name"/> <br>

          年龄：<input type="text" name="age" /> <br>

          <input type="submit" value="保存"> <br>

        </form>

③TestDynaActionFormAction.java

      public class TestDynaActionFormAction extends Action {

      @Override

      public ActionForward execute(ActionMapping mapping,

ActionForm form,HttpServletRequest request,

HttpServletResponse response) throws Exception {

                 DynaActionForm daf = (DynaActionForm) form;

                 String name = (String)daf.get("name");    //取daf中的值

                 Integer age = (Integer)daf.get("age");

                 System.out.println("name:" + name + " <===> age:" + age);

                 return mapping.findForward("success");

      }

}

④testDynaActionForm_success.jsp（取DynaActionForm的值）

      <center>

       <h1>测试动态ActionForm</h1>

       <hr>

       姓名：${dynaActionForm.map.name } <br>

       年龄：${dynaActionForm.map.age }<br>

</center>

（3）访问动态ActionForm 与访问普通ActionForm 的最大区别：属性的访问方式不同。

1）普通ActionForm—— getter setter 方法。

2）动态ActionForm—— DynaActionForm 把所有属性保存在Map 中。

public Object get(String name)

public void set(String name, Object value)

注意：DynaActionForm 的校验不太方便。需要继承DynaActionForm，但是写了代码又不能满足动态的功能了。

五、异常处理：

1、处理流程：

（1）Action  throw Exception

（2）Action Servlet  ExceptionHandler

（3）ExceptionHandler 处理Exception ExceptionHandler 会读配置文件

ActionMessage -> request Attribute

ActionForward

（4）ActionServlet ActionForward

2、配置struts 的异常处理

全局的异常处理

<global-exceptions>

<exception key="error" path="xxx/xxx" type="xxx.xxx.Xxxx">

</global-exceptions>

<action path="xxx/xxx" type="xxx.xxx.Xxxx">

....

<exception key="xxx" path="xxx/xxx" type="xxx.xxx.Xxxx">

</action>

在exception 标签中的key，也就是在出现异常时会封装在ActionErrors 中，也就是可以在页面中使用。

ActionError(String key, Object value0)，可以通过在构造ActionError 时，指定不同的key 值来对异常进行分类，并且在html:error 标签的自己构造ActionErrors 并使用下面的方法发送void saveErrors(HttpServletRequest request,ActionErrors errors)这个方法用以把封装了异常的ActionErrors 的key 存储到request 中。

六、Struts标签库

1、html标签库

（1）<html:form> 对应html 中的<form>，使用<html:form>会将表单中的属性自动封装成Form，他的action属性可以直接写struts 的配置文件中的path

（2）<html:text>、<html:password>、<html:textarea>、<html:hidden>、<html:submit>

<html:reset>、<html:checkbox>、<html:radio>、<html:select>、<html:option>

以上者写标签的使用是和html 中的form 相对应的。

（3）<html:options>这个标签用来表示一组选择项

<%

java.util.ArrayList list=new java.util.ArrayList();

list.add(new org.apache.struts.util.LabelValueBean("show value","value"));

list.add(new org.apache.struts.util.LabelValueBean("show value1","value1"));

pageContext.setAttribute("vlauelist" list);

%>

<html:form action="xxx.do">

<html:select property="test">

<html:options collection="valuelist" property="value" labelProperty="label"/>

</html:select>

</html:form>

2、Bean标签库

（1）bean 标签库，是用来访为JavaBean 的属性或者是为Bean 的属性赋值，创建JavaBean，类似于JSP 中的jsp:useBean 动作的功能。

（2）bean 标签库中的标签中大部分都有以下的属性：

1）id="xxx" 指定Bean 的名字标识,Bean 在被读出后将引用保存在以这个id 命名的对象中，也就是在JSP 中使用的变量的引用。

2）name="xxxx"指定要读取Bean 的名字

3）property="xxxx"

4）scope="page|request|session|application"

（3）资源读取标签

      1）<bean:resource>读取资源文件

2）<bean:cookie>使用这个标签可以对Cookie 进行操作

      3）<bean:header>读取header 信息

      eg.

<bean:resource id="indexpage" name="index.jsp"/>

<bean:write name="indexpage"/>

<bean:head id="head" name="user-agent"/>

<bean:write name="head"/>

<bean:cookie id="testcookie" name="/taglib/bean-cookie" value="emptyValue"/>

<%

if(testcookie.getValue.equals("emptyValue")){

javax.servlet.http.Cookie cook=

new javax.servlet.http.Cookie("/taglib/beancookie","taglib cookie");

cook.setComment("test");

cook.setMaxAge(3600);

response.addCookie(cook);

}

%>

（4）将资源写到页面的标签

1）<bean:write>将Bean 的属性加入到输出流中

<bean:write name="xxx"/>name 属性是要加入的资源，也就是先前在其他资源标签中的

id 属性定义的名字

2）<bean:define>定义变量

eg.

<bean:define id="test" value="test in Struts">

<bean:write name="test"/>

3）<bean:message>读取消息，可以根据key 读取消息。

eg.

<bean:message key="org.test">