struts2 拦截器拦截action中指定方法

1.继承类MethodFilterInterceptor(此类是类AbstractInterceptor的子类)

import java.util.Map;

import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;

/*
 *拦截指定方法 
 */
public class MyFilterInterceptor  extends MethodFilterInterceptor{
 private static final long serialVersionUID = 1L;
 private String name;
    public void setName(String name)
   {
        this.name = name;
    }
 @Override
 protected String doIntercept(ActionInvocation invocation) throws Exception {
  //取得请求相关的ActionContext实例 
  ActionContext ctx = invocation.getInvocationContext(); 
  Map session = ctx.getSession(); 
  //取出名为user的Session属性 
  String user = (String)session.get("user"); 
  //如果没有登陆，或者登陆所用的用户名不是scott，都返回重新登陆 
  if (user != null && user.equals("scott") ) 
  { 
  return invocation.invoke(); 
  } 
  //没有登陆，将服务器提示设置成一个HttpServletRequest属性 
  ctx.put("tip" , "您还没有登陆，请输入scott,tiger登陆系统"); 
  //直接返回login的逻辑视图 
  return Action.LOGIN; 
 }

}

2.struts.xml配置

<package name="site" extends="struts-default" namespace="/site">
 <interceptors> 
 <!-- 定义了一个名为authority的拦截器 --> 
  <interceptor name="authority"/> <!--上面自定义的拦截器类-->
  <interceptor-stack name="myDefault">
   <interceptor-ref name="authority"> <!-- 引用拦截器  -->
    <param name="includeMethods">getALL,getPart,listUser</param> <!-- 设置需要拦截的方法，多个以逗号隔开 -->
   </interceptor-ref>
   <interceptor-ref name="defaultStack"></interceptor-ref>
  </interceptor-stack>
 </interceptors>
 <default-interceptor-ref name="myDefault"></default-interceptor-ref>

  <!-- 全局 -->
 <global-results> 
  <!-- 当返回login视图名时，转入/login.jsp页面 --> 
  <result name="login">/login.jsp</result> 
 </global-results>
<action name="site">

  <!--省略跳转-->

</action>

</package>

转自：http://enetq.blog.51cto.com/479739/542619

在Action中使用拦截器，默认情况下回拦截Action中所有的方法，但是在某些情况下，可能只需要拦截Action中的一个或多个方法，有时候也希望不拦截某个方法，这个在Struts2中是怎么实现的呢 ？

拦截器方法过滤：让拦截器有选择的拦截Action中的某个方法！

Struts2中提供了一个MethodFilterInterceptor类，开发者自定义的拦截器只需要继承该类就可以使用这个方法过滤的功能，来拦截Action中特定的方法！

查看API文档 可以看到这个类为：

1. /*
2.  * Copyright 2002-2006,2009 The Apache Software Foundation.
3.  *
4.  * Licensed under the Apache License, Version 2.0 (the ”License”);
5.  * you may not use this file except in compliance with the License.
6.  * You may obtain a copy of the License at
7.  *
8.  *      http://www.apache.org/licenses/LICENSE-2.0
9.  *
10.  * Unless required by applicable law or agreed to in writing, software
11.  * distributed under the License is distributed on an ”AS IS” BASIS,
12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13.  * See the License for the specific language governing permissions and
14.  * limitations under the License.
15.  */
17. package com.opensymphony.xwork2.interceptor;
19. import com.opensymphony.xwork2.ActionInvocation;
20. import com.opensymphony.xwork2.util.TextParseUtil;
21. import com.opensymphony.xwork2.util.logging.Logger;
22. import com.opensymphony.xwork2.util.logging.LoggerFactory;
24. import java.util.Collections;
25. import java.util.Set;
28. /**
29.  * <!– START SNIPPET: javadoc –>
30.  *
31.  * MethodFilterInterceptor is an abstract <code>Interceptor</code> used as
32.  * a base class for interceptors that will filter execution based on method
33.  * names according to specified included/excluded method lists.
34.  *
35.  * <p/>
36.  *
37.  * Settable parameters are as follows:
38.  *
39.  * <ul>
40.  *      <li>excludeMethods - method names to be excluded from interceptor processing</li>
41.  *      <li>includeMethods - method names to be included in interceptor processing</li>
42.  * </ul>
43.  *
44.  * <p/>
45.  *
46.  * <b>NOTE:</b> If method name are available in both includeMethods and
47.  * excludeMethods, it will be considered as an included method:
48.  * includeMethods takes precedence over excludeMethods.
49.  *
50.  * <p/>
51.  *
52.  * Interceptors that extends this capability include:
53.  *
54.  * <ul>
55.  *    <li>TokenInterceptor</li>
56.  *    <li>TokenSessionStoreInterceptor</li>
57.  *    <li>DefaultWorkflowInterceptor</li>
58.  *    <li>ValidationInterceptor</li>
59.  * </ul>
60.  *
61.  * <!– END SNIPPET: javadoc –>
62.  *
63.  * @author <a href=’mailto:the_mindstorm[at]evolva[dot]ro’>Alexandru Popescu</a>
64.  * @author Rainer Hermanns
65.  *
66.  * @see org.apache.struts2.interceptor.TokenInterceptor
67.  * @see org.apache.struts2.interceptor.TokenSessionStoreInterceptor
68.  * @see com.opensymphony.xwork2.interceptor.DefaultWorkflowInterceptor
69.  * @see com.opensymphony.xwork2.validator.ValidationInterceptor
70.  *
71.  * @version $Date: 2009-12-27 19:18:29 +0100 (Sun, 27 Dec 2009) $ $Id: MethodFilterInterceptor.java 894090 2009-12-27 18:18:29Z martinc $
72.  */
73. public abstract class MethodFilterInterceptor extends AbstractInterceptor {
74.     protected transient Logger log = LoggerFactory.getLogger(getClass());
76.     protected Set<String> excludeMethods = Collections.emptySet();
77.     protected Set<String> includeMethods = Collections.emptySet();
79.     public void setExcludeMethods(String excludeMethods) {
80.         this.excludeMethods = TextParseUtil.commaDelimitedStringToSet(excludeMethods);
81.     }
83.     public Set<String> getExcludeMethodsSet() {
84.         return excludeMethods;
85.     }
87.     public void setIncludeMethods(String includeMethods) {
88.         this.includeMethods = TextParseUtil.commaDelimitedStringToSet(includeMethods);
89.     }
91.     public Set<String> getIncludeMethodsSet() {
92.         return includeMethods;
93.     }
95.     @Override
96.     public String intercept(ActionInvocation invocation) throws Exception {
97.         if (applyInterceptor(invocation)) {
98.             return doIntercept(invocation);
99.         }
100.         return invocation.invoke();
101.     }
103.     protected boolean applyInterceptor(ActionInvocation invocation) {
104.         String method = invocation.getProxy().getMethod();
105.         // ValidationInterceptor
106.         boolean applyMethod = MethodFilterInterceptorUtil.applyMethod(excludeMethods, includeMethods, method);
107.         if (log.isDebugEnabled()) {
108.             if (!applyMethod) {
109.                 log.debug(“Skipping Interceptor… Method [" + method + "] found in exclude list.”);
110.             }
111.         }
112.         return applyMethod;
113.     }
115.     /**
116.      * Subclasses must override to implement the interceptor logic.
117.      *
118.      * @param invocation the action invocation
119.      * @return the result of invocation
120.      * @throws Exception
121.      */
122.     protected abstract String doIntercept(ActionInvocation invocation) throws Exception;
124. }

是AbstractInterceptor拦截器的子类，实现了Interceptor和Serializable接口

MethodFilerInterceptor实现方法过滤中用到的两个参数

主要方法：

①protected abstract String doIntercept(ActionInvocation invocation) throws Exception;  必须重写此方法，实现拦截。

②String interceptor(ActionInvocation invocation):继承自AbstractInterceptor类，方法不需要强制重写

③void setExcludeMethods(String excludeMethods):设置拦截器黑名单，参数为Action一方法名。拦截器不拦截该方法

④void setIncludeMethods(String includeMethods):设置拦截器白名单，参数为Action一方法名。拦截器会拦截该方法

⑤Set<String> getExcludeMethodsSet()：获得拦截器的黑名单

⑥Set<String> getIncludeMethodsSet()：获得拦截器的白名单

一般开发者只需要重写doIntercept方法即可！下面给出一个实例：

一。实现方法过滤的拦截器实现类：FilterInterceptor.java继承自MethodFilterInterceptor类

1. package com.yaxing.interceptor;
3. import java.util.Date;
5. import com.opensymphony.xwork2.ActionInvocation;
6. import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;
8. public class FilterInterceptor extends MethodFilterInterceptor {
9.     private String name;
12.     public String getName() {
13.         return name;
14.     }
17.     public void setName(String name) {
18.         this.name = name;
19.     }
22.     @Override
23.     protected String doIntercept(ActionInvocation invocation) throws Exception {
24.         // TODO Auto-generated method stub
25.         FilterAction fa= (FilterAction)invocation.getAction();
26.         System.out.println(name+”拦截器在Action执行前拦截”+new Date());
27.         String result=invocation.invoke();
28.         System.out.println(name+”拦截器在Action执行后拦截”+new Date());
29.         return result;
30.     }
32. }

在该类中name属性用来标识拦截器的名称，方便控制台的输出

二。Action：业务控制器FilterAction.java

1. package com.yaxing.interceptor;
3. import com.opensymphony.xwork2.ActionSupport;
5. public class FilterAction extends ActionSupport {
6.     private String msg;
8.     public String getMsg() {
9.         return msg;
10.     }
12.     public void setMsg(String msg) {
13.         this.msg = msg;
14.     }
15.     public String method1() throws Exception {
16.         System.out.println(“Action执行方法：method1（）”);
17.         return SUCCESS;
18.     }
19.     public String method2() throws Exception {
20.         System.out.println(“Action执行方法：method2（）”);
21.         return SUCCESS;
22.     }
24.     public String method3() throws Exception {
25.         System.out.println(“Action执行方法：method3（）”);
26.         return SUCCESS;
27.     }
30. }

三。配置文件struts.xml

1. <?xml version=”1.0″ encoding=”UTF-8″ ?>
2. <!DOCTYPE struts PUBLIC ”-//Apache Software Foundation//DTD Struts Configuration 2.1//EN” ”http://struts.apache.org/dtds/struts-2.1.dtd”>
3. <struts>
4. <package name=”filterexample” extends=”struts-default” namespace=”/ch5″>
5.     <interceptors>
6. <!–定义拦截器–>
7.         <interceptor name=”Myinterceptor” class=”com.yaxing.interceptor.Myinterceptor”></interceptor>
8.         <interceptor name=”SimpleInterceptor” class=”com.yaxing.interceptor.SimpleInterceptor”></interceptor>
9.         <interceptor name=”FilterInterceptor” class=”com.yaxing.interceptor.FilterInterceptor”></interceptor>
10.     </interceptors>
11.     <action  name=”Reg” class=”com.yaxing.interceptor.Reg” method=”execute”>
12.            <result name=”success”>/Success.jsp</result>
13.            <result name=”input”>/Reg.jsp</result>
14.            <interceptor-ref name=”defaultStack”></interceptor-ref>
15.            <interceptor-ref name=”SimpleInterceptor”></interceptor-ref>
16.     </action>
17.     <action name=”FilterAction” class=”com.yaxing.interceptor.FilterAction”>
18.             <result name=”success”>/MethodFilter.jsp</result>
19. <!–使用拦截器–>
20.             <interceptor-ref name=”defaultStack”></interceptor-ref>
21.             <interceptor-ref name=”FilterInterceptor”>
22. <!–拦截器黑白名单–>
23.                  <param name=”includeMethods”>method1</param>
24.                  <param name=”excludeMethods”>method2</param>
25. <!–指定参数name的值–>
26. <param name=”name”>FilterMethod</param>
27.             </interceptor-ref>
30.     </action>
32. </package>
34. </struts>

四。jsp视图 MethodFilter.jsp

1. <%@ page language=”java” import=”java.util.*” pageEncoding=”UTF-8″%>
2. <%@ taglib prefix=”s” uri=”/struts-tags” %>
4. <!DOCTYPE HTML PUBLIC ”-//W3C//DTD HTML 4.01 Transitional//EN”>
5. <html>
6.   <head>
9.     <title>My JSP ’MethodFilter.jsp’ starting page</title>
11.     <meta http-equiv=”pragma” content=”no-cache”>
12.     <meta http-equiv=”cache-control” content=”no-cache”>
13.     <meta http-equiv=”expires” content=”0″>
14.     <meta http-equiv=”keywords” content=”keyword1,keyword2,keyword3″>
15.     <meta http-equiv=”description” content=”This is my page”>
16.     <!–
17.     <link rel=”stylesheet” type=”text/css” href=”styles.css”>
18.     –>
20.   </head>
22.   <body>
23.     <s:form id=”id” action=”FilterAction!method1.action”>
24.        <s:textfield name=”msg” label=”请输入信息:”/>
25.        <s:submit value=”提交”/>
26.     </s:form>
27.   </body>
28. </html>

五：运行结果：

①

可以看出method1方法拦截了。而method2方法是放到了黑名单中。

②将JSP视图中action 换成FilterAction!method2.action 输出信息

因为指定method2为黑名单，不会拦截，因此是没有拦截信息的。

③将JSP视图中action 换成FilterAction!method3.action 输出信息

可以看到，虽然没有在黑名单中指定method3，因为配置文件显示指定了白名单，所以拦截器只拦截白名单中指定的方法！

http://www.cnblogs.com/ribavnu/archive/2013/03/15/2960891.html

Struts2拦截器的方法过滤

struts2框架提供了MethodInterceptor类， 自定义的拦截器只要集成该类，就可以使用拦截器的方法过滤功能，来拦截Action中的特定方法。

关于struts2的自定义拦截器和struts2的详细流程 – Java

http://www.94cto.com/index/Article/content/id/63218.html

1.其实我们大家平常都会用struts2用的很多，但是有的时候我们并不是真正的了解struts2的运行机制，下面给大家分享一下struts2的运行流程。MVC框架

解释如下：

1. 所有请求被Struts2核心控制器StrutsPreparaedAndExecuteFilter拦截

2.根据ActionMapper提供的信息决定如何进行下一步

3.ActionMapper主要依赖Struts2的配置文件struts.xml

4.接下来为每个Action创建Action代理类ActionProxy

5.执行ActionProxy的execute()方法

6.在执行execute()方式时会逐个执行Struts2中的拦截器

7.执行完成拦截器后才会真正执行目标Action

8.目标Action需要返会转向的视图名称

9.ActionProxy取得视图名称对象Result完成转向

10.生成resposne对象完成本次请求

2.在struts2中默认有18个拦截器，他们帮助完成很多的工作，比如像处理异常啊，国际化，文件上传等等18个拦截器如下，如果没有拦截器我们都没法为属性设值，所以在struts2的xml文件中，我们必须需要extends=“struts-defalut”。

<span style="font-size:18px;"><interceptor-stack name="defaultStack">
                <interceptor-ref name="exception"/>
                <interceptor-ref name="alias"/>
                <interceptor-ref name="servletConfig"/>
                <interceptor-ref name="i18n"/>
                <interceptor-ref name="prepare"/>
                <interceptor-ref name="chain"/>
                <interceptor-ref name="debugging"/>
                <interceptor-ref name="scopedModelDriven"/>
                <interceptor-ref name="modelDriven"/>
                <interceptor-ref name="fileUpload"/>
                <interceptor-ref name="checkbox"/>
                <interceptor-ref name="multiselect"/>
                <interceptor-ref name="staticParams"/>
                <interceptor-ref name="actionMappingParams"/>
                <interceptor-ref name="params">
                  <param name="excludeParams">dojo..*,^struts..*</param>
                </interceptor-ref>
                <interceptor-ref name="conversionError"/>
                <interceptor-ref name="validation">
                    <param name="excludeMethods">input,back,cancel,browse</param>
                </interceptor-ref>
                <interceptor-ref name="workflow">
                    <param name="excludeMethods">input,back,cancel,browse</param>
                </interceptor-ref>
            </interceptor-stack>
</span>

3.如果我们想扩展框架的功能，那么我们就需要自己写拦截器，那么如何来实现拦截器呢？

① 首先在创建计算action执行时间拦截器时，两种方法，继承父类：AbstractInterceptor，实现接口：Interceptor。重写里边的方法：intercept()方法。代码如下：

第一种方式：

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

public class MyLogInterceptor extends AbstractInterceptor {

	@Override
	public String intercept(ActionInvocation invocation) throws Exception {
		System.out.println("开始记录日志");
		//继续执行（调用后面的拦截器（取决于actionInvocation放置拦截器的迭代器中是否存在拦截器）
		//如果存在拦截器就执行拦截器，否则执行Action）
		String resultCode = invocation.invoke();
		System.out.println("结束记录日志");
		return resultCode;
	}

}

第二种方式

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.Interceptor;

public class MySecurityInterceptor implements Interceptor {

	public void destroy() {
	}

	public void init() {
	}

	public String intercept(ActionInvocation invocation) throws Exception {
		System.out.println("开始检查安全性");
		//继续调用
		String resultCode = invocation.invoke();
		System.out.println("结束检查安全性");
		return resultCode;
	}

}

②然后struts.xml中需要声明我们拦截器，如果直接声明，那么我们默认的18个拦截器将不起作用，如何配置及时每个action都能起到作用，又是所有的拦截器都执行呢？需要利用到拦截器栈来对框架默认的拦截器栈进行覆盖：（代码如下）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
	<!-- 当struts.xml配置文件发生修改，会立刻加载，在生产环境下最好不要配置 -->
	<constant name="struts.configuration.xml.reload" value="true"/>
	<!-- 会提供更加友好的提示信息 -->
	<constant name="struts.devMode" value="true"/>
	<!-- 需要继承struts-default包，这样就拥有的最基本的功能 -->
	<package name="struts2" extends="struts-default">
		<interceptors>
			<!-- 定义记录日志拦截器 -->
			<interceptor name="myLogInterceptor" class="com.bjpowernode.struts2.MyLogInterceptor"/>
			<!-- 定义检查安全性拦截器 -->
			<interceptor name="mySecurityInterceptor" class="com.bjpowernode.struts2.MySecurityInterceptor"/>

			<interceptor-stack name="myInterceptorStack">
				 <interceptor-ref name="defaultStack"/>
				 <interceptor-ref name="myLogInterceptor"/>
				 <interceptor-ref name="mySecurityInterceptor"/>
			</interceptor-stack>
		</interceptors>
		<!-- 定义为缺省拦截器，所有的Action都会得到使用 -->
		<default-interceptor-ref name="myInterceptorStack"/>		
		<action name="login" class="com.bjpowernode.struts2.LoginAction">
			<!-- 
				使用日志记录拦截器 
				如果自定了拦截器，必须显示引用Struts2默认的拦截器
			<interceptor-ref name="myLogInterceptor"/>
			-->
		    <!-- 引用Struts2默认的拦截器 -->
		    <!-- 
		    <interceptor-ref name="defaultStack"/>
		     -->
			<!-- 使用日志记录拦截器  -->
			<!-- 
			<interceptor-ref name="myLogInterceptor"/>
			 -->
			<!-- 使用检查安全性拦截器 -->
			<!-- 
			<interceptor-ref name="mySecurityInterceptor"/>
			 -->
			 <!-- 引入自定义的拦截器栈 -->
			<!-- 
			<interceptor-ref name="myInterceptorStack"/>
			 -->
			<result>/login_success.jsp</result> 
			<result name="error">/login_error.jsp</result>
		</action>
	</package>
</struts>

4.总结一下

Struts2的拦截器

1、Struts2的拦截器只能拦截Action，拦截器是AOP的一种思路，可以使我们的系统架构
更松散（耦合度低），可以插拔，容易互换，代码不改变的情况下很容易满足客户需求
其实体现了OCP

2、如何实现拦截器？（整个拦截器体现了责任链模式，Filter也体现了责任链模式）
* 继承AbstractInterceptor（体现了缺省适配器模式）
* 实现Interceptor

3、如果自定了拦截器，缺省拦截器会失效，必须显示引用Struts2默认的拦截器

4、拦截器栈，多个拦截器的和

5、定义缺省拦截器<default-interceptor-ref>,所有的Action都会使用

6、拦截器的执行原理，在ActionInvocation中有一个成员变量Iterator，这个Iterator中保存了所有的
拦截器，每次都会取得Iterator进行next,如果找到了拦截器就会执行，否则就执行Action，都执行完了
拦截器出栈（其实出栈就是拦截器的intercept方法弹出栈）

Struts2拦截器设置例外情况

权限拦截器如下：

配置如下：