Struts 1.XX 内置Action

在WEB应用开发中，有时候JSP网页间可以直接相互调用或者转发；有时候Servlet也会通过表单隐藏字段来访问不同的业务方法。然而，应用Struts框架使得所有的用户请求都因该通过控制器。在struts框架中提供了一些内置Action类，在应用中使用这些类可以大大的提高开发效率。
常用的内置Action：
1. ForwardAction。
2. IncludeAction。
3. DispatchAction。
4. MappingDispatchAction。
5. LookupDispatchAction。
6. SwitchAction。

[size=medium][b]一, ForwardAction。[/b][/size]
作用：适合用于页面与页面之间的跳转（在JSP网页中，尽管可以直接通过jspforward标签把请求转发给其他Web组件，但是Struts框架提倡先把请求转发给控制器，再由控制器来负责请求转发）。
用法：主要是在struts配置文件中配置一个ForwardAction。配置如下：

<action-mappings >
  <action path="/url " type="org.apache.struts.actions.ForwardAction" parameter=""></action> 
</action-mappings>

其中path参数是找到该Action的url路径，这个一般写在你提交的时候的表单中的action或者超链接的href里面。type是apache提供的struts内置Action类----ForwardAction类，这个类在这里是固定的。而另一个parameter参数是配置跳转以后的页面地址。
配置了以上以后就可以在页面中使用超链接或者表单提交访问以上配置的action了，前提是你超链接或者form表单的action要与上面配置的action中的path参数保持一致。这样就可以实现页面之间的跳转了。

[size=medium][b]二, IncludeAction。[/b][/size]
作用：适合用于将指定页面包含在当前页面中。
用法：主要是在struts配置文件中配置一个IncludeAction。配置如下：

<action-mappings >
  <action path="/url " type="org.apache.struts.actions.IncludeAction" parameter=""></action> 
</action-mappings>

其中path参数是找到该Action的url路径，这个一般写在你提交的时候的表单中的action或者超链接的href里面。type是apache提供的struts内置Action类----IncludeAction类，这个类在这里是固定的。而另一个parameter参数是配置需要包含近来的页面地址。
配置了以上以后就可以在页面中使用：
<jsp:include page="这里的path要与上面action里面的path保持一致，才能正确的访问到上面的action "></jsp:include>
这样就可以在访问该页面的时候就把指定页面给包含进来。

[size=medium][b]三, DispatchAction。[/b][/size]
作用：通常，在一个Action类中，只能完成一种业务操作，如果希望在同一个Action类中完成一组相关的业务操作，可以使用DispatchAction类。
用法：在struts配置文件中配置一个Action。配置如下：

<action-mappings>
  	<action path="/url" type=" " parameter=" "></action>
</action-mappings>

其中，path参数和上面一样是找到Action的url路径，这个一般写在你提交的时候的表单中的action或者超链接的href里面。
Type属性是填写我们实现了DispatchAction类的那个类的全限定名。DispatchAction的主要作用是处理在一个表单里面有多个提交项，也就是有多个业务，那内置DispatchAction怎么知道我提交的是什么，提交后该调用什么方法？因为是多个提交，所以处理的也是多个业务。为了解决这个问题，所以我们必须去实现DispatchAction这个类，然后我们自己在实现的子类中编写方法。如：

package com.lovo.struts.action;
public class MyDispatchAction extends DispatchAction{
	public ActionForward add(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response)
			throws Exception { 
		System.out.println("This is Add");
		return null;
	}
}

这里就是实现了DispatchAction类，并编写了一个add方法。所以这个时候，type的全限定名就是“com.lovo.struts.action.MyDispatchAction”。
最后一个参数----parameter，这个参数的作用是用于区别是哪个按钮提交的，并且找到对应的方法，然后调用（比如我写了一个类似这样的Action，它继承自DispatchAction类，包含了三个操作方法，有add (),update(),delete()。当我想要调用这个Action的add操作时，提交的URL应该类似这样的：
　　saveSubscription.do?method=add）。
在使用DispatchAction这个内置Action的时候要注意一下几点：
1. parameter的属性值是可以任意起的，只要你记得在传参数的时候统一就可以了。
2.在调用DispatchAction的时候method参数（也就是parameter参数对应值和这个值对应的方法名----如：method=add这里就不是为空）是不能为空的，如果空，DispatchAction会调用unspecified方法并抛出异常。
3.继承DispatchAction，不要重写execute方法，说白了就是不要出现execute方法（如果出现了，就掉不到自己写的那些方法了）。

DispatchAciton使用就是这么简单，好处在于非常方便我们程序员了，开发中我感觉的确省了好多代码，至少以前的三个类文件变成了现在一个类了，而且在后期维护的时候感觉也是方便很多。


[size=medium][b]四, MappingDispatchAction。[/b][/size]
如果大家用过DispatchAction的话，接触MappingDispatchAction的话就不是很难了，大家记住了这是struts1.2里新加入的，org.apache.struts.actions.MappingDispatchAction继承于org.apache.struts.actions.DispatchAction。
首先说一下它的的优点：
（1）可以为每个响应用户请求的Action方法定义自己的name,validate,input和scope等参数，而在使用DispatchAction时，这些参数都是被Action中的所有方法所共享的。
（2）在使用DispatchAction时，所执行的Action方法在url中是能显示出来的，也就是用户可以通过地址栏或者提交的数据得到所执行的方法。这有安全隐患。而MappingDispatchAction则避免了用户知道响应用户请求的Action方法的名称。
作用：通常，在一个Action类中，只能完成一种业务操作，如果希望在同一个Action类中完成一组相关的业务操作，可以使用MappingDispatchAction类。
用法：在struts配置文件中配置一个Action。配置如下：

<action-mappings>
  	<action path="/url" type=" " parameter=" "></action>
</action-mappings>

在<action-mappings>元素中，action的path参数是找到该Action的url路径，这个一般写在你提交的时候的表单中的action或者超链接的href里面。
Type属性是填写我们实现了MappingDispatchAction类的那个类的全限定名。记住这里继承MappingDispatchAction，不要重写execute方法。
第三个参数parameter的作用是指定我们要调用的方法的方法名。看个例子：

package com.lovo.struts.action;
public class MyMappingDispatchAction extends MappingDispatchAction{
	//不能重写
/*	public ActionForward execute(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		// TODO Auto-generated method stub
		System.out.println("This is Execute");
		return null;
	}
*/

	public ActionForward myAdd(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		System.out.println("This is Add");
		return null;
	}

	public ActionForward myDel(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		System.out.println("This is Del");
		return null;
	}
}

如果要调用myAdd方法就应该如下配置：

<action-mappings>
<action path="/mappingAdd" type="com.lovo.struts.action.MyMappingDispatchAction" parameter="myAdd">
</action>
</action-mappings>

相反如果我需要调用myDel方法：

<action-mappings>
<action path="/mappingDel" type="com.lovo.struts.action.MyMappingDispatchAction" parameter="myDel">
</action>
</action-mappings>

这样配置可以看出，MappingDispatchAction中需要为每个表单调用的每个方法都要进行Action的配置，尽管type指向的是同一个MappingDispatchAction类，这也是MappingDispatchAction的一个特点。

MappingDispatchAction和DispatchAction的比较：
1.维护方面。
DispatchAction虽然将相同或者类似的功能模块集中到了一个类中了,易于代码维护,也大大减少了配置文件中配置标签的长度,但是他必需要求开发人员在请求中再带上一个参数,这就额外的增加了很多麻烦,维护起来不方便。
MappingDispatchAction不用带上这样的参数，只需要给其一个指定的路径就可以找到该方法
2在代码的实现上。
MappingDispatchAction和DispatchAction没有什么区别，完全一样的代码,只需继承两个不同的类分别是 MappingDispatchAction和DispatchAction，他们同样不能覆盖父类的execute()方法
3.在功能方面。
MappingDispatchAction中如果不同页面传过来的请求里面有多个表单,但是一个action标签只能指定一个FormAction来验证,这样明显存在不灵活的地方。
MappingDispatchAction对于不同的功能使用不同的action标签来指定，这样就可以灵活地使用不同的ActionForm 了。


[size=medium][b]五, LookupDispatchAction。[/b][/size]
作用：LookupDispatchAction类是DispatchAction的子类，在LookupDispatchAction类中也可以定义多个业务方法。通常LookupDispatchAction主要应用于在一个表单中有多个提交按钮，而这些按钮又有一个共同的名字的场合，这些按钮的名字和具体的ActionMapping的parameter属性值相对应。
用法：也是先配置struts文件中的ActionMapping。

<action-mappings>
  	<action path="/url" name="" type="" parameter=""></action>
</action-mappings>

path参数和上面一样是找到Action的url路径，这个一般写在你提交的时候的表单中的action或者超链接的href里面。
Type属性是填写我们实现了LookupDispatchAction类的那个类的全限定名。记住这里继承LookupDispatchAction，不要重写execute方法。
Parameter属性又与上面有所区别了，这里的parameter的值需要与页面确定调用方法的这个属性的name保持一致。如：
现在假设您的表单页面包括以下的内容：

...
<form name="editForm" method="post" 
action="edit.do"> 
.....
<input type="submit" name="method" value="Save"/> 
<input type="submit" name="method" value="Preview"/>
<input type="submit" name="method" value="Reset"/> 
</form>
...

这里我们在配置parameter的时候，值就应该是method。
还要记住我们要在实现了LookupDispatchAction的类中重写一个方法：

 protected Map getKeyMethodMap() { 
        Map map = new HashMap();
        map.put("button.save", "save");
        map.put("button.preview", "preview"); 
        map.put("button.reset", "reset"); 
        return map; 
}

当您按下任一个按钮时，请求参数中会包括method=Save或是method=Preview或是method= Reset，假设是method=Save好了，LookupDispatchAction会根据它作为value，在讯息资讯档找到对应的key，然後 根据key与getKeyMethodMap()得知要执行的方法为save()方法。

实现了LookupDispatchAction的java代码：

package com.lovo;
public class EditAction extends LookupDispatchAction { 
    protected Map getKeyMethodMap() { 
        Map map = new HashMap();
        map.put("button.save", "save");
        map.put("button.preview", "preview"); 
        map.put("button.reset", "reset"); 
        return map; 
    }

    public ActionForward save(ActionMapping mapping, 
                              ActionForm form, 
                              HttpServletRequest request, 
                              HttpServletResponse response) 
                                 throws Exception { 
        // ...... 
    }

    public ActionForward preview(ActionMapping mapping, 
                              ActionForm form, 
                              HttpServletRequest request, 
                              HttpServletResponse response) 
                                 throws Exception { 
        // ...... 
    }

    public ActionForward reset(ActionMapping mapping, 
                              ActionForm form, 
                              HttpServletRequest request, 
                              HttpServletResponse response) 
                                 throws Exception { 
        // ...... 
    }                                                              
}

配置文件就应该如下配置：

...
   <action path="/edit"
           type="com.lovo.EditAction" 
           parameter="method" 
           name="editForm"/>
...

[size=medium][b]六, SwitchAction。[/b][/size]
SwitchAction用于从一个模块转换至另一个模块，当您的应用程序分作多个模块时，您有两个方法可以在模块之间切换，第一个方法是使用相对于Context的路径来进行 forward 查找，我们之前在介绍模块化时就是使用这个方法：
代码:

    <global-forwards> 
         <forward 
             name="login" 
             contextRelative="true" 
             path="/login/Login.do" 
             redirect="true"/> 
    </global-forwards> 

这是在全区可查找的 forward 中的设定，在<action>卷标中也可以像上面一样使用<forward>卷标,，例如：
代码:

   <action ... > 
         <forward 
             name="login" 
             contextRelative="true" 
             path="/login/Login.do" 
             redirect="true"/> 
     </action> 

另一切换模块的方法就是使用SwitchAction，它需要在请求中带两个参数，一个是prefix，用来指定模块前缀名称，一个是page，用来指定相对于模块的资源路径，例如我们可以这么设定：
代码:

  <action-mappings> 
         <action 
             path="/LoginSwitch" 
             type="org.apache.struts.actions.SwitchAction"/> 

         </action-mappings> 

还记得要在WEB.XML中配置你要跳转模块的路径：

    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <init-param>
      <param-name>config/ma</param-name>
      <param-value>/WEB-INF/struts-moduleA.xml</param-value>
    </init-param>

之后我们可以使用这样的路径与参数来请求login模块的Login.do
<a href="login/Login.do?prefix=/ma&page=/LoginSwitch.do">Test</a>