Struts2拦截器精解

最新推荐文章于 2020-12-07 16:23:00 发布
最新推荐文章于 2020-12-07 16:23:00 发布
阅读量448 收藏
点赞数
分类专栏： Struts2 文章标签： struts2拦截器

       上篇博客对Struts2的体系结构做了初步的了解，Struts2是以WebWork作为处理核心，并采用拦截器的机制来处理用户的请求，同时它还集成了Struts1丰富的标签库。另外上篇博客还对Struts2的配置使用进行了初步的介绍，下面将会集中讨论Struts2的拦截器。


一、拦截器


  1、拦截器小介


       拦截器的功能类似于web.xml文件中的Filter，能对用户的请求进行拦截，通过拦截用户的请求来实现对页面的控制。拦截器是在Struts-core-2.2.3.jar中进行配置的，原始的拦截器是在struts-default.xml中配置的，里面封存了拦截器的基本使用方法。

       Struts2拦截器功能类似于Servlet过滤器。在Action执行execute方法前，Struts2会首先执行struts.xml中引用的拦截器，如果有多个拦截器则会按照上下顺序依次执行，在执行完所有的拦截器的interceptor方法后，会执行Action的execute方法。

        Struts2的拦截器必须从com.opensymphoy.xwork2.interceptor.Interceptor中实现该接口，在被定义的拦截器中有下面三个方法需要被实现：

[java] view plain copy
print ?
  1. void destroy();   
  2. void init();   
  3. String intercept(ActionInvocation invocation) throws Exception;  
void destroy(); 
void init(); 
String intercept(ActionInvocation invocation) throws Exception;

       自定义的拦截器需要重写上面三个方法。另外Struts2的拦截器配置文件struts.xml它是继承了原始文件struts-default.xml文件的，这样在相应的<package>中就会自动拥有struts-default.xml中的所有配置信息了。具体代码如下：

[html] view plain copy
print ?
  1. <package name="demo" extends="struts-default" > ... </package>  
<package name="demo" extends="struts-default" > ... </package>


  2、Demo


       想要使用拦截器必须要经过配置，struts2采用的是映射的方法，所以想用使用某一个功能就必须在配置文件中配置，拦截器也不例外。所以必须在package中添加相应的拦截器元素，同时将拦截器关联相应的class文件，这样在执行action前才会执行相应的拦截器，具体使用方法如下。


      （1）添加配置文件struts.xml，并在该文件中添加拦截器

[html] view plain copy
print ?
  1. <package name="testLogin" namespace="/" extends="struts-default">  
  2.     <!-- 拦截器 -->  
  3.     <interceptors>  
  4.         <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>  
  5.     </interceptors>  
  6.           
  7.     <action name="demo" class="com.action.LoginAction">  
  8.         <result name="error" type="redirect">/error.jsp</result>  
  9.         <result name="success">/success.jsp</result>  
  10.         <result name="checkError">/checkSession.jsp</result>  
  11.         <interceptor-ref name="myInterceptor"></interceptor-ref>  
  12.         <interceptor-ref name="defaultStack"></interceptor-ref>  
  13.     </action>  
  14. </package>  
<package name="testLogin" namespace="/" extends="struts-default">
	<!-- 拦截器 -->
	<interceptors>
		<interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>
	</interceptors>
		
	<action name="demo" class="com.action.LoginAction">
		<result name="error" type="redirect">/error.jsp</result>
		<result name="success">/success.jsp</result>
		<result name="checkError">/checkSession.jsp</result>
		<interceptor-ref name="myInterceptor"></interceptor-ref>
		<interceptor-ref name="defaultStack"></interceptor-ref>
	</action>
</package>

        上面的package中添加了一个名为myInterceptor的拦截器，并为该拦截器注册了一个Java类，该类名称为MyInterceptor，并被封存在com.interceptor包中。另外还在该package中添加了相应的action，在执行该action前会首先执行myInterceptor拦截器。


      （2）编写被注册的拦截器类MyInterceptor，该类必须实现com.opensymphoy.xwork2.interceptor.Interceptor接口，并重写相应的方法

[java] view plain copy
print ?
  1. package com.interceptor;  
  2.   
  3. import java.util.Map;  
  4.   
  5. import com.entity.User;  
  6. import com.opensymphony.xwork2.ActionContext;  
  7. import com.opensymphony.xwork2.ActionInvocation;  
  8. import com.opensymphony.xwork2.interceptor.Interceptor;  
  9.   
  10. public class MyInterceptor implements Interceptor{  
  11.   
  12.     private User user;  
  13.       
  14.       
  15.     public User getUser() {  
  16.         return user;  
  17.     }  
  18.   
  19.     public void setUser(User user) {  
  20.         this.user = user;  
  21.     }  
  22.   
  23.     @Override  
  24.     public void destroy() {  
  25.         // TODO Auto-generated method stub  
  26.         System.out.println("----destroy()----");  
  27.     }  
  28.   
  29.     @Override  
  30.     public void init() {  
  31.         // TODO Auto-generated method stub  
  32.         System.out.println("-----Init()-------");  
  33.     }  
  34.   
  35.     @Override  
  36.     public String intercept(ActionInvocation invocation) throws Exception {  
  37.         // TODO Auto-generated method stub  
  38.         System.out.println("----intercept()------");  
  39.         Map<String, Object> session= invocation.getInvocationContext().getSession();  
  40.         if(session.get("username")!=null){  
  41.             System.out.println("登陆成功！");          
  42.             //session.put("username",user.getUsername());  
  43.             return invocation.invoke();  
  44.         }else{  
  45.             System.out.println("登陆失败！");  
  46.             return "checkError";  
  47.         }  
  48.     }  
  49.   
  50. }  
package com.interceptor;

import java.util.Map;

import com.entity.User;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.Interceptor;

public class MyInterceptor implements Interceptor{

	private User user;
	
	
	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		System.out.println("----destroy()----");
	}

	@Override
	public void init() {
		// TODO Auto-generated method stub
		System.out.println("-----Init()-------");
	}

	@Override
	public String intercept(ActionInvocation invocation) throws Exception {
		// TODO Auto-generated method stub
		System.out.println("----intercept()------");
		Map<String, Object> session= invocation.getInvocationContext().getSession();
		if(session.get("username")!=null){
			System.out.println("登陆成功！");		
			//session.put("username",user.getUsername());
			return invocation.invoke();
		}else{
			System.out.println("登陆失败！");
			return "checkError";
		}
	}

}


       （3）经过前面两步后，拦截器已经配置完成，最后一部就是使用拦截器了，在显示页面上添加相应的标签，并为标签指定上面创建的名为demo的action，然后执行页面即可在控制台中打印出相应的拦截器内容。

[html] view plain copy
print ?
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"  
  2.     pageEncoding="UTF-8"%>  
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  4. <html>  
  5. <head>  
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
  7. <title>Insert title here</title>  
  8. </head>  
  9. <body>  
  10.     <form action="demo">  
  11.         用户名：<input type="text" name="username"><br>  
  12.         密  码：<input type="text" name="password"><br>  
  13.         <input type="submit" name="ok" value="提交">  
  14.     </form>  
  15. </body>  
  16. </html>  
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	<form action="demo">
		用户名：<input type="text" name="username"><br>
		密  码：<input type="text" name="password"><br>
		<input type="submit" name="ok" value="提交">
	</form>
</body>
</html>

打印输出内容：

        分析输出结果，程序编译阶段首先会去读取配置文件struts.xml，在该配置文件action中顺序查找是否添加了拦截器，如果添加了拦截器则根据拦截器名称在<interceptors>中查找是否定义了该拦截器或者拦截器栈，如果发现定义的是拦截器则根据拦截器查找对应的注册的class，最后在包内查找注册的class并执行相应的init()方法；程序运行阶段的大致流程和编译阶段类似，用户在前台提交请求后，会按照注册的action在struts.xml中查找与之相对应的，如果查找到将会查找拦截器，没有查找到的话会相应的抛错，最后执行拦截器注册类的intercept方法。


  3、拦截器栈


       拦截器同样有栈的概念，它是将使用的拦截器定义到共有的状态下来实现统一管理，这样在package中就可以做到拦截器的共享了，大大便利了拦截器的使用。在一个package中往往会用到重复的interceptor，如果每次都在Action中添加interceptor-ref的话就会很麻烦，那么拦截器栈就是为了解决这个问题而产生的，具体配置如下：

[html] view plain copy
print ?
  1. <package name="testLogin" namespace="/" extends="struts-default">  
  2.         <!-- 拦截器 -->  
  3.         <interceptors>  
  4.             <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>  
  5.             <!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->  
  6.             <interceptor-stack name="defaultstack1">  
  7.                 <interceptor-ref name="myInterceptor"></interceptor-ref>  
  8.                 <interceptor-ref name="defaultStack"></interceptor-ref>  
  9.             </interceptor-stack>  
  10.         </interceptors>  
  11.           
  12.         <action name="demo" class="com.action.LoginAction">  
  13.             <result name="error" type="redirect">/error.jsp</result>  
  14.             <result name="success">/success.jsp</result>  
  15.             <result name="checkError">/checkSession.jsp</result>  
  16.             <interceptor-ref name="defaultstack1"></interceptor-ref>  
  17.         </action>  
  18. </package>  
<package name="testLogin" namespace="/" extends="struts-default">
		<!-- 拦截器 -->
		<interceptors>
			<interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>
			<!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->
			<interceptor-stack name="defaultstack1">
				<interceptor-ref name="myInterceptor"></interceptor-ref>
				<interceptor-ref name="defaultStack"></interceptor-ref>
			</interceptor-stack>
		</interceptors>
		
		<action name="demo" class="com.action.LoginAction">
			<result name="error" type="redirect">/error.jsp</result>
			<result name="success">/success.jsp</result>
			<result name="checkError">/checkSession.jsp</result>
			<interceptor-ref name="defaultstack1"></interceptor-ref>
		</action>
</package>

        实例中使用了interceptor-stack来定义了一个名称为defaultstack1的拦截器栈，在该栈中添加了要执行的拦截器，把拦截器做了封装，在Action中直接调用该拦截器栈即可，实现了拦截器栈的共享。


  4、默认拦截器栈


        另外可以定义默认的拦截器栈，即：如果某个Action中没有定义拦截器，那么它会默认执行该公共的拦截器。它和interceptors标签属于同一等级的，使用default-interceptor-ref定义。

[html] view plain copy
print ?
  1. <package name="testLogin" namespace="/" extends="struts-default">  
  2.     <!-- 拦截器 -->  
  3.     <interceptors>  
  4.         <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>  
  5.         <!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->  
  6.         <interceptor-stack name="defaultinter">  
  7.             <interceptor-ref name="myInterceptor"></interceptor-ref>  
  8.             <interceptor-ref name="defaultStack"></interceptor-ref>  
  9.         </interceptor-stack>  
  10.     </interceptors>  
  11.       
  12.     <!-- 定义默认的拦截器栈，会自动注册到action中 -->  
  13.     <default-interceptor-ref name="defaultinter"></default-interceptor-ref>  
  14.       
  15.     <action name="demo" class="com.action.LoginAction">  
  16.         <result name="error" type="redirect">/error.jsp</result>  
  17.         <result name="success">/success.jsp</result>  
  18.         <result name="checkError">/checkSession.jsp</result>  
  19.     </action>  
  20. </package>  
<package name="testLogin" namespace="/" extends="struts-default">
	<!-- 拦截器 -->
	<interceptors>
		<interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>
		<!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->
		<interceptor-stack name="defaultinter">
			<interceptor-ref name="myInterceptor"></interceptor-ref>
			<interceptor-ref name="defaultStack"></interceptor-ref>
		</interceptor-stack>
	</interceptors>
	
	<!-- 定义默认的拦截器栈，会自动注册到action中 -->
	<default-interceptor-ref name="defaultinter"></default-interceptor-ref>
	
	<action name="demo" class="com.action.LoginAction">
		<result name="error" type="redirect">/error.jsp</result>
		<result name="success">/success.jsp</result>
		<result name="checkError">/checkSession.jsp</result>
	</action>
</package>

      定义的默认的拦截器栈只是在Action没有指定拦截器的情况下才执行自定义默认的拦截器栈的，如果在Action中重定义了拦截器，那么它会覆盖自定义默认的拦截器栈的。

  5、不执行任何拦截器


      还有一种情况是一个package中定义了默认的拦截器，但是在编写的某个Action中并不需要执行任何拦截器，那么此时可以在相应的Action中添加一个名称为defaultStack的拦截器即可，它是系统默认的拦截器，不会有任何操作。

[html] view plain copy
print ?
  1. <package name="testLogin" namespace="/" extends="struts-default">  
  2.     <!-- 拦截器 -->  
  3.     <interceptors>  
  4.         <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>  
  5.         <!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->  
  6.         <interceptor-stack name="defaultinter">  
  7.             <interceptor-ref name="myInterceptor"></interceptor-ref>  
  8.             <interceptor-ref name="defaultStack"></interceptor-ref>  
  9.         </interceptor-stack>  
  10.     </interceptors>  
  11.       
  12.     <!-- 定义默认的拦截器栈，会自动注册到action中 -->  
  13.     <default-interceptor-ref name="defaultinter"></default-interceptor-ref>  
  14.       
  15.     <action name="demo" class="com.action.LoginAction">  
  16.         <result name="error" type="redirect">/error.jsp</result>  
  17.         <result name="success">/success.jsp</result>  
  18.         <result name="checkError">/checkSession.jsp</result>  
  19.           
  20.         <!-- 添加defaultStack保证不执行拦截器 -->  
  21.         <interceptor-ref name="defaultStack"></interceptor-ref>  
  22.     </action>  
  23. </package>  
<package name="testLogin" namespace="/" extends="struts-default">
	<!-- 拦截器 -->
	<interceptors>
		<interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>
		<!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->
		<interceptor-stack name="defaultinter">
			<interceptor-ref name="myInterceptor"></interceptor-ref>
			<interceptor-ref name="defaultStack"></interceptor-ref>
		</interceptor-stack>
	</interceptors>
	
	<!-- 定义默认的拦截器栈，会自动注册到action中 -->
	<default-interceptor-ref name="defaultinter"></default-interceptor-ref>
	
	<action name="demo" class="com.action.LoginAction">
		<result name="error" type="redirect">/error.jsp</result>
		<result name="success">/success.jsp</result>
		<result name="checkError">/checkSession.jsp</result>
		
		<!-- 添加defaultStack保证不执行拦截器 -->
		<interceptor-ref name="defaultStack"></interceptor-ref>
	</action>
</package>


  6、拦截方法


      6.1 用法

        上面的拦截器只是实现了对Action的拦截，其实拦截器的功能很强大，它也可以拦截相应Action方法。和拦截Action不同的是想要拦截方法就必须继承类MethodFilterInterceptor，该类封存在xwork-core.jar中，又一次证明了WebWork是Struts2的核心。另外还需要在配置文件中添加相应的属性来确定拦截的方法和不拦截的方法，具体配置方法如下：

[html] view plain copy
print ?
  1. <package name="testLogin" namespace="/" extends="struts-default">  
  2.     <!-- 拦截器 -->  
  3.     <interceptors>  
  4.         <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>  
  5.         <!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->  
  6.         <interceptor-stack name="defaultinter">  
  7.             <interceptor-ref name="myInterceptor"></interceptor-ref>  
  8.             <interceptor-ref name="defaultStack"></interceptor-ref>  
  9.         </interceptor-stack>  
  10.     </interceptors>  
  11.       
  12.     <action name="demo" class="com.action.LoginAction">  
  13.         <result name="error" type="redirect">/error.jsp</result>  
  14.         <result name="success">/success.jsp</result>  
  15.         <result name="checkError">/checkSession.jsp</result>  
  16.           
  17.         <!-- 在defaultStack中配置拦截方法，参数includeMethods中添加被拦截的方法名称，excludeMethods中添加不需要拦截的名称 -->  
  18.         <interceptor-ref name="defaultStack">  
  19.             <param name="includeMethods">添加要拦截的方法名称</param><!-- 拦截方法 -->  
  20.             <param name="excludeMethods">添加不需要拦截的方法名称</param><!-- 不拦截方法 -->  
  21.         </interceptor-ref>  
  22.     </action>  
  23. </package>  
<package name="testLogin" namespace="/" extends="struts-default">
	<!-- 拦截器 -->
	<interceptors>
		<interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>
		<!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->
		<interceptor-stack name="defaultinter">
			<interceptor-ref name="myInterceptor"></interceptor-ref>
			<interceptor-ref name="defaultStack"></interceptor-ref>
		</interceptor-stack>
	</interceptors>
	
	<action name="demo" class="com.action.LoginAction">
		<result name="error" type="redirect">/error.jsp</result>
		<result name="success">/success.jsp</result>
		<result name="checkError">/checkSession.jsp</result>
		
		<!-- 在defaultStack中配置拦截方法，参数includeMethods中添加被拦截的方法名称，excludeMethods中添加不需要拦截的名称 -->
		<interceptor-ref name="defaultStack">
			<param name="includeMethods">添加要拦截的方法名称</param><!-- 拦截方法 -->
			<param name="excludeMethods">添加不需要拦截的方法名称</param><!-- 不拦截方法 -->
		</interceptor-ref>
	</action>
</package>

      继承MethodFilterInterceptor类的相应拦截方法的类中的代码：

[java] view plain copy
print ?
  1. package com.interceptor;  
  2.   
  3. import java.util.Map;  
  4. import com.opensymphony.xwork2.ActionContext;  
  5. import com.opensymphony.xwork2.ActionInvocation;  
  6. import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;  
  7.   
  8. public class inter extends MethodFilterInterceptor {  
  9.   
  10.     @Override  
  11.     public String doIntercept(ActionInvocation invocation) throws Exception {  
  12.         System.out.println("--intercept()--");  
  13.         //获取相应的Session  
  14.         Map<String,Object> session=invocation.getInvocationContext().getSession();  
  15.           
  16.         Map request=(Map)ActionContext.getContext().get("request");  
  17.           
  18.         String username=(String)request.get("user.username");  
  19.         if(session.get("username") != null){  
  20.             String result=invocation.invoke();  
  21.               
  22.             System.out.println("--end()--");  
  23.             return result;  
  24.         }  
  25.     }  
  26.   
  27. }  
package com.interceptor;

import java.util.Map;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;

public class inter extends MethodFilterInterceptor {

	@Override
	public String doIntercept(ActionInvocation invocation) throws Exception {
		System.out.println("--intercept()--");
		//获取相应的Session
		Map<String,Object> session=invocation.getInvocationContext().getSession();
		
		Map request=(Map)ActionContext.getContext().get("request");
		
		String username=(String)request.get("user.username");
		if(session.get("username") != null){
			String result=invocation.invoke();
			
			System.out.println("--end()--");
			return result;
		}
	}

}

    6.2 Demo

       来看一个拦截方法的实例，并对结果进行分析。下面的实例演示拦截方法的输出结果，在实例中分别创建了一个loginAction类，添加Action要执行的方法；Inter类，拦截器中重写MethodFilterInterceptor方法，在控制台中输出是否对某个方法进行拦截；login.jsp文件，添加三个按钮，分别演示三个方法的执行。

      （1）struts.xml内方法拦截器的定义，在package中定义了一个名称为inter的拦截器，在拦截器中指定了参数，includeMethods用来拦截Method1，excludeMethods中的Method2表示不拦截Methods2方法，具体配置如下代码：

[html] view plain copy
print ?
  1. <!DOCTYPE struts PUBLIC  
  2.           "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
  3.           "http://struts.apache.org/dtds/struts-2.0.dtd">  
  4. <struts>  
  5.     <constant name="struts.action.extension" value=","></constant>  
  6.       
  7.     <package name="login" extends="struts-default">    
  8.         <interceptors>  
  9.             <interceptor name="inter" class="com.interceptor.inter">  
  10.                 <param name="includeMethods">Method1</param> <!-- 拦截Method1方法 -->  
  11.                 <param name="excludeMethods">Method2</param>  
  12.             </interceptor>  
  13.             <interceptor-stack name="myInterceptor">  
  14.                 <interceptor-ref name="inter"></interceptor-ref>  
  15.                 <interceptor-ref name="defaultStack"></interceptor-ref>  
  16.             </interceptor-stack>  
  17.         </interceptors>  
  18.               
  19.         <action name="loginaction" class="com.action.loginAction">  
  20.             <result name="success">success.jsp</result>  
  21.             <result name="error">error.jsp</result>  
  22.             <result name="cancel" type="redirectAction">Welcome</result>  
  23.             <interceptor-ref name="inter"></interceptor-ref>  
  24.             <interceptor-ref name="defaultStack"></interceptor-ref>  
  25.         </action>  
  26.     </package>  
  27. </struts>  
<!DOCTYPE struts PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
          "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <constant name="struts.action.extension" value=","></constant>
	
    <package name="login" extends="struts-default">  
    	<interceptors>
    		<interceptor name="inter" class="com.interceptor.inter">
    			<param name="includeMethods">Method1</param> <!-- 拦截Method1方法 -->
    			<param name="excludeMethods">Method2</param>
    		</interceptor>
    		<interceptor-stack name="myInterceptor">
    			<interceptor-ref name="inter"></interceptor-ref>
    			<interceptor-ref name="defaultStack"></interceptor-ref>
    		</interceptor-stack>
    	</interceptors>
    	 	
    	<action name="loginaction" class="com.action.loginAction">
    		<result name="success">success.jsp</result>
    		<result name="error">error.jsp</result>
    		<result name="cancel" type="redirectAction">Welcome</result>
    		<interceptor-ref name="inter"></interceptor-ref>
    		<interceptor-ref name="defaultStack"></interceptor-ref>
    	</action>
    </package>
</struts>

       （2）loginAction类，配置login.jsp中的action，分别在该类中添加Method1-Method3三个方法，其中Method1被拦截，Method2和Method3不被拦截，最后我们查看输出结果。

[java] view plain copy
print ?
  1. package com.action;  
  2.   
  3. import com.opensymphony.xwork2.ActionSupport;  
  4.   
  5. public class loginAction extends ActionSupport {  
  6.     @Override  
  7.     public String execute() throws Exception {  
  8.         if(this.username.equals("admin") && this.password.equals("admin")){  
  9.             return "success";  
  10.         }else if(this.username.equals("cancel") && this.password.equals("cancel")){  
  11.             return "cancel";  
  12.         }else{  
  13.             return "error";  
  14.         }  
  15.     }  
  16.       
  17.     public void Method1(){  
  18.         System.out.println("执行方法:Method1");  
  19.     }  
  20.       
  21.     public void Method2(){  
  22.         System.out.println("执行方法:Method2");  
  23.     }  
  24.       
  25.     public void Method3(){  
  26.         System.out.println("执行方法:Method3");  
  27.     }  
  28.       
  29.     private String username;  
  30.     private String password;  
  31.       
  32.     public String getUsername(){  
  33.         return this.username;  
  34.     }  
  35.       
  36.     public void setUsername(String username){         
  37.         this.username=username;  
  38.     }  
  39.       
  40.     public String getPassword(){  
  41.         return this.password;  
  42.     }  
  43.       
  44.     public void setPassword(String password){  
  45.         this.password=password;  
  46.     }  
  47.       
  48.       
  49. }  
package com.action;

import com.opensymphony.xwork2.ActionSupport;

public class loginAction extends ActionSupport {
	@Override
	public String execute() throws Exception {
		if(this.username.equals("admin") && this.password.equals("admin")){
			return "success";
		}else if(this.username.equals("cancel") && this.password.equals("cancel")){
			return "cancel";
		}else{
			return "error";
		}
	}
	
	public void Method1(){
		System.out.println("执行方法:Method1");
	}
	
	public void Method2(){
		System.out.println("执行方法:Method2");
	}
	
	public void Method3(){
		System.out.println("执行方法:Method3");
	}
	
	private String username;
	private String password;
	
	public String getUsername(){
		return this.username;
	}
	
	public void setUsername(String username){		
		this.username=username;
	}
	
	public String getPassword(){
		return this.password;
	}
	
	public void setPassword(String password){
		this.password=password;
	}
	
	
}

        （3）inter类，继承MethodFilterInterceptor类，用来实现拦截方法。重写doIntercept方法，在该方法中添加拦截的相应信息。
[java] view plain copy
print ?
  1. package com.interceptor;  
  2.   
  3. import java.util.Date;  
  4. import java.util.Map;  
  5.   
  6. import com.action.loginAction;  
  7. import com.opensymphony.xwork2.ActionContext;  
  8. import com.opensymphony.xwork2.ActionInvocation;  
  9. import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;  
  10.   
  11. public class inter extends MethodFilterInterceptor {  
  12.       
  13.     @Override  
  14.     protected String doIntercept(ActionInvocation invocation) throws Exception {  
  15.         // TODO Auto-generated method stub    
  16.          System.out.println("拦截器在Action执行前拦截"+new Date());    
  17.          String result=invocation.invoke();  //执行Action方法  
  18.          System.out.println("拦截器在Action执行后拦截"+new Date());    
  19.         return result;    
  20.   
  21.     }  
  22.   
  23. }  
package com.interceptor;

import java.util.Date;
import java.util.Map;

import com.action.loginAction;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;

public class inter extends MethodFilterInterceptor {
	
	@Override
	protected String doIntercept(ActionInvocation invocation) throws Exception {
		// TODO Auto-generated method stub  
		 System.out.println("拦截器在Action执行前拦截"+new Date());  
		 String result=invocation.invoke();  //执行Action方法
		 System.out.println("拦截器在Action执行后拦截"+new Date());  
 		return result;  

 	}

}

     （4）login.jsp，在jsp页面上添加三个按钮，分别演示三个方法，判断拦截器对方法的拦截情况。三个按钮在点击后回发的action是在javascript中动态的进行添加的，这样做达到了一个form中执行不同的action的方法，当然还有其它的方法，将会在下篇文章中讨论。
[html] view plain copy
print ?
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"  
  2.     pageEncoding="UTF-8"%>  
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  4. <html>  
  5. <head>  
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
  7. <title>Insert title here</title>  
  8. <script type="text/javascript">  
  9.       
  10.     //方法1，定义被拦截的方法的实例  
  11.     function method1(){  
  12.         var form=document.forms[0];  
  13.         form.action="loginaction!Method1";  
  14.         form.submit();  
  15.     }  
  16.       
  17.     //方法2，为按钮2添加不拦截的方法  
  18.     function method2(){  
  19.         var form=document.forms[0];  
  20.         form.action="loginaction!Method2";  
  21.         form.submit();  
  22.     }  
  23.       
  24.     //方法3，为按钮3添加不拦截的方法  
  25.     function method3(){  
  26.         var form=document.forms[0];  
  27.         form.action="loginaction!Method3";  
  28.         form.submit();  
  29.     }  
  30. </script>  
  31. </head>  
  32. <body>  
  33.     <form>  
  34.         用户名：<input type="text" name="username"><br>  
  35.         密     码：<input type="text" name="password"><br>  
  36.         <input type="submit" name="ok" value="按钮1" onclick="method1()">  
  37.         <input type="submit" name="ok1" value="按钮2" onclick="method2()">  
  38.         <input type="submit" name="ok2" value="按钮3" onclick="method3()">  
  39.     </form>  
  40. </body>  
  41. </html>  
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript">
	
	//方法1，定义被拦截的方法的实例
	function method1(){
		var form=document.forms[0];
		form.action="loginaction!Method1";
		form.submit();
	}
	
	//方法2，为按钮2添加不拦截的方法
	function method2(){
		var form=document.forms[0];
		form.action="loginaction!Method2";
		form.submit();
	}
	
	//方法3，为按钮3添加不拦截的方法
	function method3(){
		var form=document.forms[0];
		form.action="loginaction!Method3";
		form.submit();
	}
</script>
</head>
<body>
	<form>
		用户名：<input type="text" name="username"><br>
		密     码：<input type="text" name="password"><br>
		<input type="submit" name="ok" value="按钮1" οnclick="method1()">
		<input type="submit" name="ok1" value="按钮2" οnclick="method2()">
		<input type="submit" name="ok2" value="按钮3" οnclick="method3()">
	</form>
</body>
</html>

        运行完成后的页面视图：
             
       （5）分析运行结果，分别单击按钮1、2、3，在控制台中输出结果，按钮1是绑定的method1，该方法在struts.xml中进行了拦截如果结果正确的话会显示被拦截的结果，而相应的按钮2和3只输出运行结果，因为它们没有被拦截。那看下面的结果图：

        结果图正好正是了我们的分析结果，按钮1被拦截了，执行了inter类中的doIntercept方法，二相应的按钮2和3没有被拦截。也就是说，Method1被放到了方法拦截器的白名单内，执行要拦截该方法；Method2被放到了拦截器黑名单内，不需要拦截该方法；Method3不做任何处理。

结语


        对于拦截器的内容就总结到这里，拦截器提供了很强大的功能，使得开发人员能够在运行时控制输出结果，增加了编程的灵活性。另外对于任何理论性的东西都不要试图去记忆，一定要理性的去分析，多多实践，动手做几个实例，分析结果更深刻的理解。


转载地址：http://blog.csdn.net/zhang_xinxiu/article/details/24892735

elementf
关注
专栏目录
SSH中的权限拦截器
时光刻下的容颜
01-25 2833
拦截器，曾经好像听说过你的名字，好神秘的样子，不知道你的容颜是怎样的动人？         在百度的搜素引擎里敲下“拦截器”，好像你没有在百度百科中里出现，好像更增加了你的一份神圣感。         终于，广西下雪了广东也下雪了，南方的人们揭开了雪菇凉的神秘面纱，是怎样的兴奋与雀跃。前一段时间做了一个Java的项目中，终于亲临触摸了你的或许是部分的真实。         可以简单地
Java Web整合开发实战：基于Struts 2+Hibernate+Spring(PDF)
02-28
8章 Struts之拦截器使用技巧 9章 在Struts中应用Ajax技术 10章 Struts之项目实战 3篇 持久层框架Hibernate技术 11章 Hibernate快速上手 12章 精解Hibernate之核心文件 13章 探究Hibernate之核心接口 14章 ...
【SSH2（实践篇）】--Struts2拦截器精解
热门推荐
航帆远洋
05-03 2万+
struts2拦截器提供了很强大的功能，使得开发人员能够在运行时控制输出结果，增加了编程的灵活性。另外对于任何理论性的东西都不要试图去记忆，一定要理性的去分析，多多实践，动手做几个实例，分析结果更深刻的理解。
菜鸟学习SSH（四）——Struts2拦截器
810364804
12-04 131
什么是拦截器 拦截器（Interceptor）是Struts 2的一个强有力的工具，有许多功能都是构建于它之上，如国际化（前两篇博客介绍过）、转换器，校验等。 拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。 说到拦截器有一...
SSH拦截器
zpz_326的博客
07-20 277
package com.jkxy.util; import java.util.Map; import com.jkxy.entity.User; import com.opensymphony.xwork2.Action; import com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.inter
拦截器
qq_40202431的博客
06-19 120
概述：java里的拦截器是动态拦截Action调用的对象，在AOP（Aspect-Oriented Programming）中拦截器用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。 实现 自定义一个拦截器需要三步： 1 .自定义一个实现Interceptor接口（或者继承自AbstractInterceptor）的类。 2 .在struts.xml中注册上一步...
Struts2.1.6实战：拦截器、输入校验与自定义应用
本课程是Struts2.1.6实战教程的第三部分，主要讲解了Struts2框架中的核心组件——拦截器及其应用。课程由徐桥编写，内容分为以下几个重点： 1. **拦截器的概述**：首先介绍了拦截器的定义，它在Struts2中扮演着关键...
Struts2.1.6实战教程：开发环境搭建与首个应用
它提供了更强大的拦截器机制，支持更多种数据源的绑定，以及更灵活的配置方式。Struts2.x的设计使得开发者能够更好地实现模型-视图-控制器模式，提高代码的可维护性和可扩展性。 课程内容首先介绍了Struts2.1.8.1-...
ssh最新框架搭建,加入拦截器
10-23
在博客http://blog.csdn.net/u014201191/article/details/49339143 中讲解的ssh框架搭建基本,调试通过,好好学习
SSH开发配置权限拦截器
老隋的播客
02-03 388
1.编写拦截器 public class PrivilegeInterceptor extends MethodFilterInterceptor { @Override protected String doIntercept(ActionInvocation invocation) throws Exception { //判断session中是否有用户登录信息 User e...
spring-mvc 的 拦截器应用例子
weixin_33806300的博客
06-16 120
23.4 使用拦截器 2009-09-27 15:20 徐林林 清华大学出版社 我要评论(0) 字号：T | T 《Java Web编程从入门到实践（15小时高清晰、交互式视频教学）》第23章SSpring的Web架构，本章结合实例讲解了Spring MVC框架的各个组件的使用方法、Spring拦截器和数据验证的使用方法，以及Spring和Str...
SSH 登录拦截器(过滤器)！
分享我的点点滴滴，在成长路上与你同行！
08-19 622
import java.io.IOException; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servlet.ServletException; import javax.servlet.ServletReques
SSH中事务配置详解（使用拦截器）
sqjhwl的专栏
05-29 822
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="ht
网上商城SSH——拦截器
Up was the only direction your compass navigate.
02-12 372
    什么是拦截器？    java里的拦截器是动态拦截Action调用的对象。他提供了一种机制可以让开发人员定义在一个action执行的前后执行的代码，也可以在action执行前组织其执行，同时提供了一种可以提取action中可重用部分的方式。    大部分时候，拦截器方法都是通过代理的方式来调用的。Struts 2的拦截器实现相对简单。当请求到达Struts 2的ServletDispatc...
SSH学习-拦截器的使用
weixin_30243533的博客
05-18 259
与Spring类似，Struts2也有拦截器Interceptor，拦截器是java动态拦截action请求的对象，其可以复用，扩展，适合封装通用的处理。下面将学习拦截器作用的时机，以及如何使用拦截器，做简单的记录。 拦截器作用时机 浏览器发送请求到服务端，正常会经历如下几步：浏览器发送请求→filter处理→action处理→result→返回浏览器。 加上拦截器后的过程：浏览器发送请求→...
SSH Chapter 11 Struts2 拦截器
weixin_40154786的博客
12-07 278
SSH Chapter 11 Struts2 拦截器 本章目标 : 掌握Struts 2架构 掌握Struts 2拦截器 掌握Struts 2框架的文件上传和下载 1 . Struts 2 架构分析 2006年，WebWork与Struts这两个优秀的JavaEE Web框架（Web Framework）的团体，决定合作共同开发一个新的，整合了WebWork与Struts优点，并且更加优雅、扩展性更强的框架，命名为“Struts2”，原Struts的1.x版本产品称为”Struts1”。 Struts
SSH-------------配置 登录的拦截器
qq_32659773的博客
04-29 187
配置登录拦截器是防止在未登录的情况访问不该访问的资源 》原理图 》实现步骤 登录拦截器一般配置合session使用，我们需要把登录信息放置在session里 登录拦截器代码 public class BOSLoginInterceptor extends MethodFilterInterceptor{ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值