Struct2 拦截器

拦截器的整个过程

程序是在执行Action之前调用的拦截器，整个过程是这样子的

这里面注意两个问题:

public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context,
                              ActionMapping mapping) throws ServletException {

        Map<String, Object> extraContext = createContextMap(request, response, mapping, context);

        // If there was a previous value stack, then create a new copy and pass it in to be used by the new Action
        ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
try {

            Configuration config = configurationManager.getConfiguration();
            ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(
                    namespace, name, method, extraContext, true, false);

            request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());
                                            这个字段就是"struts.valueStack"

// if the ActionMapping says to go straight to a result, do it!
            if (mapping.getResult() != null) {

            } else {
                proxy.execute();
            }

        } catch (ConfigurationException e) {        

    }

就看里面标记的这几句，这个方法的作用设置好valueStack，然后放到request范围里

也就是说通过request可以得到valueStack对象；

so，在视图上拿valueStack对象的方式就有以下两种：

1.request.getAttribute()

2.ongl: #request.structs.valueStack

第二个是循环Interceptor的问题，每一个Interceptor里面其实都调用了invoke方法，

那么这个调用是怎么实现的呢，

现在做一个模拟就明白了

拦截器原理模拟

使用最简单的java工程做实验

然后定义一个Action,表示最后要执行的东东

public class Action {
    public void execute() {
        System.out.println("execute!");
    }
}

然后最重要的是定义一个ActionInvocation

import java.util.ArrayList;
import java.util.List;

public class ActionInvocation {
    List<Interceptor> interceptors = new ArrayList<Interceptor>();
    int index = -1;
    Action a = new Action();

    public ActionInvocation() {
        this.interceptors.add(new FirstInterceptor());
        this.interceptors.add(new SecondInterceptor());
    }

     //首先遍历每一个拦截器，当遍历完了之后，执行Action的方法
    public void invoke() {
        index ++;
        if(index >= this.interceptors.size()) {
            a.execute();
        }else {

            this.interceptors.get(index).intercept(this);
        }
    }
}

先定义一个接口，相当于拦截器

public interface Interceptor {
    public void intercept(ActionInvocation invocation) ;
}

然后两个类实现这个接口

public class FirstInterceptor implements Interceptor {

    public void intercept(ActionInvocation invocation) {
        System.out.println(1);
        //在里面又返回调用ActionInvocation 的Invoke方法
        invocation.invoke();
        System.out.println(-1);
    }
}

public class SecondInterceptor implements Interceptor {

    public void intercept(ActionInvocation invocation) {
        System.out.println(2);
        invocation.invoke();
        System.out.println(-2);
    }
}

定义主方法

public class Main {
    public static void main(String[] args) {
        new ActionInvocation().invoke();
    }
}

最后的结果是

1
2
execute!
-2
-1

这里面最关键的地方就是转来转去用的都是同一个ActionInvocation 对象

流程大概是：

实线表示直接调用，虚线表示方法返回

上图是完整的调用过程

因为ActionInvocation调用Second是在First内部，只是转折了一下，所以可以理解为First调用了Second

通过Struct官方的图来理解整个过程

最主要的思想是在执行Action之前拦一下，在执行之后拦一下

从这个图中，也可以理解什么叫做AOP，面向切面编程

本来有没有拦截器Struct方法都能执行

但是突然冒出一个拦截器有种在执行之前切上一刀的感觉

拦截器的有点是可插入，可抽回

拦截器可以用在敏感字符处理，在提交的数据进入服务器的时候，首先检查数据是不是有敏感字符

还可以用在权限上面

我们想一下如果没有拦截器怎么做权限

有两种方式：

一个是在Action类中的exection方法里面进行判断

一个是在Jsp的头的session里面进行判断

这样做是要在每一个Action和JSP里面都要写的啊

当然权限判断现在有很好的spring security

定义自己的Struct拦截器

这个其实就是重复造成轮子的过程，只要看看别人的轮子是怎么造出来的就可以了。

首先：定义一个MyInterceptor类

package com.bjsxt.interceptor;

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

public class MyInterceptor implements Interceptor {

    public void destroy() {
        // TODO Auto-generated method stub

    }

    public void init() {
        // TODO Auto-generated method stub

    }

    public String intercept(ActionInvocation invocation) throws Exception {
        long start = System.currentTimeMillis();
        String r = invocation.invoke();
        long end = System.currentTimeMillis();
        System.out.println("action time = " + (end - start));
        return r;
    }

}

然后要把这个拦截器加到配置里面

在Struct里面，默认拦截器都是放在/struts-default.xml 里面，当然我们不能改人家的代码。

修改Struct.xml

    <package name="test" namespace="/" extends="struts-default">

       首先声明这个拦截器
        <interceptors>
            <interceptor name="my" class="com.bjsxt.interceptor.MyInterceptor"></interceptor>
        </interceptors>

        <action name="test" class="com.bjsxt.action.TestAction">
            <result>/test.jsp</result>
            <interceptor-ref name="my"></interceptor-ref>
            <interceptor-ref name="defaultStack"></interceptor-ref>
        </action>

    </package>

       在实际开发过程中，自定义拦截器实际上是很少很少用到的。一方面，Struct已经为我们写出来很多拦截器，另一方面，一旦我们自定义了拦截器，那么我们的代码就和Struct绑定上了，以后如果再换成其他架构基本上是无法实现的。