Struts2的拦截器机制

来源：互联网发布：股票龙虎榜软件编辑：程序博客网时间：2024/06/06 13:41

拦截器是Struts2的一个重要的组成部分，Struts2框架的拦截器是可以动态配置的，下面首先来看一个最使用JDK的反射机制实现的拦截器。
1，最简单的拦截器例子
1，业务接口，因为JDK动态代理只能对实现了接口的实例来生成代理，因此必须提供一个接口：
package com.test;
public interface Dog {
public void info();
public void run();
}
2，业务实现类：
package com.test;
public class DogImpl implements Dog {
@Override
public void info() {
   System.out.println("I'm a dog");
}
@Override
public void run() {
   System.out.println("I'm running fast");
}
}
3，用于拦截Dog实例的拦截器类：
package com.test;
//定义拦截器类
public class DogIntercepter {
public void method1(){
   System.out.println("invocate method1");
}

public void method2(){
   System.out.println("invocate method2");
}
}
4，通过反射机制，动态地调用目标对象的方法，代理类：
package com.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class ProxyHandler implements InvocationHandler {
//需要被代理的目标对象
private Object target;

//创建拦截器实例
DogIntercepter di = new DogIntercepter();

@Override
public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable {
   Object result = null;
   //如果被调用的方法名为info,就执行拦截
   if(method.getName().equals("info")){
    //调用拦截器的方法1
    di.method1();
    result = method.invoke(target, args);
    //调用拦截器的方法2
    di.method2();
   }else{
    result = method.invoke(target, args);
   }
   return result;
}
public void setTarget(Object o){
   this.target = o;
}
}
5，代理工厂类：主要作用是根据目标对象生成一个代理对象，可以不要
package com.test;
import java.lang.reflect.Proxy;
public class MyProxyFactory {
public static Object getProxy(Object obj){
   //创建代理类
   ProxyHandler handler = new ProxyHandler();
   //把该Dog实例托付给代理操作
   handler.setTarget(obj);
   //第一个参数是用来创建动态代理的ClassLoader对象，只要该对象能访问Dog接口即可
   //第二个参数是接口数组，正是代理该接口数据
   //第三个参数是代理包含的处理实例
   return Proxy.newProxyInstance(DogImpl.class.getClassLoader(),obj.getClass().getInterfaces(),handler);
}
}
6，测试方法：
package com.test;
public class TestDog {
public static void main(String[] args) {
   //创建一个Dog实例，该实例则将被做为代理的目标对象
   Dog targetObject = new DogImpl();
   Dog dog = null;
   //以目标对象创建动态代理
   Object proxy = MyProxyFactory.getProxy(targetObject);
   if(proxy instanceof Dog){
    dog = (Dog)proxy;
   }
   //正常调用
   dog.info();
   dog.run();
}
}
在这里我并没有直接使用new生成的DogImpl对象来执行方法，而是使用了代理生成的对象来执行方法，这个方法就是拦截器和目标对象方法的组合。
这其实就是AOP编程(Aspect Orient Program面向切面编程)，这里有三个重要的概念：
1，目标对象：就是最原始的业务对象
2，代理对象：以目标对象为蓝本，生成的新对象，此对象已经被拦截器所监控
3，被插入的处理方法：定义在拦截器中，会在被拦截方法之前，之后自动执行的方法
JDK的反射机制和代理机制，我在后面会有专题来进行介绍。
2，Struts2中的拦截器配置说明
1，拦截器的配置
Struts中可以配置单个拦截器，也可以几个拦截器一起配置成拦截器组，它还有一个默认的拦截器defaultStack，单个拦截器的配置如下：
<intercepter name="拦截器名" class="拦截器实现类" />
拦截器同样可以注入参数：
<intercepter name="拦截器名" class="拦截器实现类">
<param name="参数名">参数值</param>
</intercepter>
拦截器栈配置如下：
<interceptor-stack name="customStack">
     
     <interceptor-ref name="defaultStack"></interceptor-ref>
    <interceptor-ref name="其它拦截器名"></interceptor-ref>

</interceptor-stack>
拦截器栈里同样可以配置拦截器栈，这个配置跟拦截器一样。同样在拦截器栈中配置的拦截器也可以指定参数，这里的参数将会覆盖原来配置时的默认参数。
2，在Action中使用拦截器
定义了拦截器之后就可以使用它了，在Action内可以通过以下方式引用拦截器：
        
        <interceptor-ref name="fileUpload">
这里同样可以指定参数。
默认拦截器可以在定义一个包时就指定，它可以应用于这个包的所有的action，但是一旦一个action指定了拦截器之后就不再使用默认拦截器了，此时需要手动配置默认拦截器的使用。默认拦截器可以是自己的拦截器也可以是拦截器栈，配置如下：
<default-interceptor-ref name="customStack"></default-interceptor-ref>
每个包中只能指定一个默认拦截器。这里也可以配置参数，但此时的参数将取代定义拦截器时的参数。我们开发的包都继承自struts-default包，这个包里已经配置了系统的默认拦截器。
3，开发自己的拦截器
虽然Struts2提供了足够的功能强大的拦截器，但是我们也可以定义自己的拦截器来实现某些特定功能。我们只要实现com.opensymphony.xwork2.intercepter.Intercepter接口就可以了。它定义了三个方法：
destory()//销毁该拦截器之前的回调方法
init()//初始化该拦截器的回调方法
String intercept(ActionInvocation invocation)throws Exception//拦截器实现拦截的逻辑方法
Struts2还提供了一个AbstractInterceptor类，该类提供了一个init和destory方法的空实现，如果我们实现的拦截器不需要申请资源，则可以直接继承此类。
下面实现一个简单的拦截器：
package com.test;
import com.annlee.login.action.LoginAction;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
public class TestStrutsIntercepter extends AbstractInterceptor {
//这里并未使用，演示而己，此参数可以在配置时指定
private String name;

public String getName() {
   return name;
}
public void setName(String name) {
   this.name = name;
}
@Override
public String intercept(ActionInvocation arg0) throws Exception {
   //取得被拦截的Action实例,这里并不进行操作，只是演示
   LoginAction action = (LoginAction)arg0.getAction();
   System.out.println("拦截器开始时间是:" + System.currentTimeMillis());
   String result = arg0.invoke();
   System.out.println("拦截器结束时间是:" + System.currentTimeMillis());
   return result;
}
}
配置拦截器，一是定义拦截器，如下：
<interceptors>
<interceptor name="pageParamInterceptor" class="test.TestStrutsIntercepter"></interceptor>
    
    <interceptor-stack name="customStack">
     
     <interceptor-ref name="defaultStack"></interceptor-ref>
    </interceptor-stack>

   </interceptors>
注意这里的三个标签interceptors所有的拦截器和拦截器栈的定义都写在这里面，interceptor定义拦截器。
二是使用拦截器，前面已经做了介绍，只需要在Action中配置拦截器的关联即可。

4，开发只拦截某个方法的拦截器
在默认情况下，如果为某个Action定义了拦截器，则这个拦截器会拦截该Action内的所有方法，有时候我们只需要拦截某个Action中的特定方法，Struts2提供了一个MethodFilterInterceptor类，它是AbstractInterceptor类的子类，我们如果想过滤方法的话，应该继承MethodFilterInterceptor类。我们只要重写这个类的doIntercept(ActionInvocation invocation)方法就可以了，下面是一个简单的例子，代码如下：
package com.test;
import com.annlee.login.action.LoginAction;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;
public class MyMethodInterceptor extends MethodFilterInterceptor{
//拦截器的名称,会在配置文件中注入
private String name;

public String getName() {
   return name;
}
public void setName(String name) {
   this.name = name;
}
/**
* 重写这个方法，可以实现对指定方法的拦截
*/
@Override
protected String doIntercept(ActionInvocation invocation) throws Exception {
   //获取被拦截的Action实例
   LoginAction action = (LoginAction) invocation.getAction();
   System.out.println("拦截前的时刻：" + System.currentTimeMillis());
   String result = invocation.invoke();
   System.out.println("拦截后的时刻：" + System.currentTimeMillis());
   return result;
}
}
从上面的代码可以看出，上面的拦截器的拦截逻辑和前面的普通拦截器的拦截逻辑基本相同，只是普通拦截器是重写intercept方法，而这里是重写doIntercept方法。其它地方的代码都没有区别。
我们可以在配置是配置excludeMethod(不需要过滤的方法)和includeMethod(需要过滤的方法)，如果一个方法在这两者都配置了，则includeMethod优先。配置文件如下：
   <interceptors>
    <interceptor name="myMethodFilter" class="com.test.MyMethodInterceptor">
     <param name="name">方法过滤拦截器</param>
    </interceptor>
   </interceptors>

   <action name="login" class="com.annlee.login.action.LoginAction" method="login">
    <result name="input">/login.jsp</result>
            <result name="success">/mainpage.jsp</result>
            <result name="failed">/common/error.jsp</result>
            
            <interceptor-ref name="defaultStack"></interceptor-ref>
            <interceptor-ref name="myMethodFilter">
            <param name="excludeMethods">execute,logout</param>
            <param name="includeMethods">login,valid</param>
            </interceptor-ref>
        </action>
Struts2提供了几个这类方法过滤拦截器：TokenInterceptor, TokenSessionInterceptor, DefaultWorkflowInterceptor, ValidationInterceptor
拦截器的执行过程是按照栈的后进先出原则来的。
5，拦截结果的拦截器
在前面开发的拦截器中，我们将在执行Action中方法的执行之前，执行之后的操作都定义在了拦截器的拦截方法中，我们同样可以精确定义在执行Action中方法的执行之后再执行拦截器的方法，这样可以实现对Action返回结果的监听。实现拦截结果的监听必须实现PreResultListener接口，下面的例子代码如下：
package com.test;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.PreResultListener;
public class MyPreResultListener implements PreResultListener {
/**
* 定义在返回结果之前的处理
*/
@Override
public void beforeResult(ActionInvocation invocation, String resultCode) {
   System.out.println("返回的视图逻辑是：" + resultCode);
}
}
这个监听器是通过代码手动注册给某个拦截器的，下面是应用的代码：
package com.test;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
public class BeforeResultInterceptor extends AbstractInterceptor {
@Override
public String intercept(ActionInvocation invocation) throws Exception {
   //注入一个拦截结果的监听给该拦截器
  invocation.addPreResultListener(new MyPreResultListener());
   String result = invocation.invoke();
   return result;
}
}
这里要注意的一点就是在MyPreResultListener类中不能再次调用invocation.invoke()方法，这样程序会陷入一个死循环。
6，修改拦截器栈中特定拦截器的参数
有时候，我们在一个特定的Action中引用拦截器栈时，需要对拦截器栈中的某个拦截器的参数重新赋值，这里可以采用以下方法：
        <action name="login" class="com.annlee.login.action.LoginAction" method="login">
            <result name="input">/login.jsp</result>
            <result name="success">/mainpage.jsp</result>
            <result name="failed">/common/error.jsp</result>
            
            <interceptor-ref name="my-stack">
            
            <param name="second.name">改名后的拦截器名</param>
            </interceptor-ref>
        </action>
7，Struts2的内建拦截器
从Struts2框架来看，拦截器几乎完成了Struts2框架70%的工作，包括解析请求参数，将请求参数赋值给Action属性，执行数据校验，文件上传。
Struts2已经自动为每个Action配置了默认拦截器，因此我们在大部分的情况下都不用再配置任何拦截器，它的配置如下：

     <interceptor-ref name="defaultStack"></interceptor-ref>
8，实现权限控制拦截器
拦截器代码如下：
package com.test;
import java.util.Map;
import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
public class AuthorityInterceptor extends AbstractInterceptor {
@Override
public String intercept(ActionInvocation invocation) throws Exception {
   //获取请求相关的ActionContext实例
   ActionContext ctx = invocation.getInvocationContext();
   Map session = (Map) ctx.getSession();
   String user = (String) session.get("user");
   if(null==user){
    ctx.put("tips", "你还没有登录!");
    return Action.LOGIN;
   }else{
    return invocation.invoke();
   }
}
}
配置文件中的代码如下：
   <interceptors>
    
    <interceptor-stack name="customStack">
     
     <interceptor-ref name="defaultStack"></interceptor-ref>
<interceptor name="pageParamInterceptor" class="com.miracle.dm.common.web.interceptor.PageParamInterceptor"></interceptor>
    </interceptor-stack>
   </interceptors>

<default-interceptor-ref name="customStack"></default-interceptor-ref>
将工程的默认拦截器栈改为自己配置的拦截器栈，这样将需要权限控制的Action的包中引用此拦截器栈，在不需要权限控制的Action中还是引用Struts2默认的拦截器栈就可以了。

转载出处：http://chengyue2007.iteye.com/blog/978656

0 0