java 设计模式 拦截器

拦截器（interceptor）是Struts2最强大的特性之一，也可以说是struts2的核心，拦截器可以让你在Action和result被执行之前或之后进行一些处理。同时，拦截器也可以让你将通用的代码模块化并作为可重用的类。Struts2中的很多特性都是由拦截器来完成的。拦截是AOP的一种实现策略。在Webwork的中文文档的解释为：拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。谈到拦截器，还有一个词大家应该知道——拦截器链（Interceptor
Chain，在Struts 2中称为拦截器栈Interceptor
Stack）。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用

为了便于自身理解，我们自己实现一个。
在我们的请求到来之前，加入现在我进入了一个页面，而改页面是需要先检查是否已登录，此时如果我加一个判断的话，就可以很容易实现，但是当我们的页面增多时，那么就该为我们的每个请求页面都加个判断，是相当麻烦的一件事，故此，spring或struts都为我们提供了相应的拦截器，以下是拦截器的实现原理：

首先我们需要定义一个action接口

public interface Action {    String execute();}

拦截器接口

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

调度器接口

public interface ActionInvocation {    String invoke();}

定义我们的拦截器

AroundInterceptor 拦截器

package com.cmh.intercept;import com.cmh.service.ActionInvocation;public class AroundInterceptor implements Interceptor{    @Override    public void before(ActionInvocation invocation) {        // TODO Auto-generated method stub        System.out.println("before:"+"AroundInterceptor");    }    @Override    public String intercept(ActionInvocation invocation) {        // TODO Auto-generated method stub        before(invocation);        String result = invocation.invoke();        after(invocation);        return result;    }    @Override    public void after(ActionInvocation invocation) {        // TODO Auto-generated method stub        System.out.println("after:"+"AroundInterceptor");    }}

ExceptionInterceptor拦截器

package com.cmh.intercept;import com.cmh.service.ActionInvocation;public class ExceptionInterceptor implements Interceptor{    @Override    public void before(ActionInvocation invocation) {        // TODO Auto-generated method stub        System.out.println("before:"+"ExceptionInterceptor");    }    @Override    public String intercept(ActionInvocation invocation) {        // TODO Auto-generated method stub        before(invocation);        String result = invocation.invoke();        after(invocation);        return result;    }    @Override    public void after(ActionInvocation invocation) {        // TODO Auto-generated method stub        System.out.println("after:"+"ExceptionInterceptor");    }}

I18NInterceptor拦截器

package com.cmh.intercept;import com.cmh.service.ActionInvocation;public class I18NInterceptor implements Interceptor{    @Override    public void before(ActionInvocation invocation) {        // TODO Auto-generated method stub        System.out.println("before:"+"I18NInterceptor");    }    @Override    public String intercept(ActionInvocation invocation) {        // TODO Auto-generated method stub        before(invocation);        String result = invocation.invoke();        after(invocation);        return result;    }    @Override    public void after(ActionInvocation invocation) {        // TODO Auto-generated method stub        System.out.println("after:"+"I18NInterceptor");    }}

调度器实现类DefaultActionInvoation

package com.cmh.service;import java.util.ArrayList;import java.util.List;import com.cmh.action.Action;import com.cmh.intercept.Interceptor;public class DefaultActionInvoation implements ActionInvocation{    int index = 0;    private Action action;     private List<Interceptor> interceptors = new ArrayList<Interceptor>();    /**     * Get action        * @return Action the action     */    public Action getAction() {        return action;    }    /**     * Set action     * @param action Action the action to set     */    public void setAction(Action action) {        this.action = action;    }    /**     * Set interceptors     * @param interceptors List<Interceptor> the interceptors to set     */    public void addInterceptor(Interceptor interceptors) {        this.interceptors.add(interceptors);    }    @Override    public String invoke() {//递归调用        // TODO Auto-generated method stub        String result = "";         if(index == interceptors.size()){            result = action.execute();        }else{            Interceptor interceptor =interceptors.get(index);            index++;            result = interceptor.intercept(this);        }        return result;    }}

测试类

public static void test3(){        Interceptor exptionInterceptor = new ExceptionInterceptor();          Interceptor i18nInterceptor = new I18NInterceptor();          Interceptor aroundInterceptor = new AroundInterceptor();          DefaultActionInvoation actionInvocation = new DefaultActionInvoation();          actionInvocation.addInterceptor(exptionInterceptor);          actionInvocation.addInterceptor(i18nInterceptor);          actionInvocation.addInterceptor(aroundInterceptor);          Action action = new HelloWorldAction();          actionInvocation.setAction(action);          String result = actionInvocation.invoke();          System.out.println("Action result:" + result);     }

测试结果

由以上代码不难看出，当我们的请求来到时，首先会经DefaultActionInvoation 的invoke处理，调用的次序依次为
ExceptionInterceptor->I18NInterceptor->AroundInterceptor->AroundInterceptor->I18NInterceptor->ExceptionInterceptor
最后才将我们的结果给弄出来，以上为一个拦截器最基本的原理。下面我们来看看struts2中的原代码及流程

strtus2的流程图

我们再来看看他的源代码

以下是DefaultActionInvoation 中的invoke的源代码

/**  * @throws ConfigurationException If no result can be found with the returned code  */  public String invoke() throws Exception {      String profileKey = "invoke: ";      try {       UtilTimerStack.push(profileKey);       if (executed) {       throw new IllegalStateException("Action has already executed");       }          // 依次调用拦截器堆栈中的拦截器代码执行       if (interceptors.hasNext()) {       final InterceptorMapping interceptor = (InterceptorMapping) interceptors.next();       UtilTimerStack.profile("interceptor: "+interceptor.getName(),        new UtilTimerStack.ProfilingBlock<String>() {  public String doProfiling() throws Exception {                           // 将ActionInvocation作为参数，调用interceptor中的intercept方法执行       resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);       return null;  }       });       } else {       resultCode = invokeActionOnly();       }       // this is needed because the result will be executed, then control will return to the Interceptor, which will       // return above and flow through again       if (!executed) {              // 执行PreResultListener       if (preResultListeners != null) {       for (Iterator iterator = preResultListeners.iterator();       iterator.hasNext();) {       PreResultListener listener = (PreResultListener) iterator.next();       String _profileKey="preResultListener: ";       try {       UtilTimerStack.push(_profileKey);       listener.beforeResult(this, resultCode);       }       finally {       UtilTimerStack.pop(_profileKey);       }       }       }       // now execute the result, if we're supposed to              // action与interceptor执行完毕，执行Result       if (proxy.getExecuteResult()) {       executeResult();       }       executed = true;       }       return resultCode;      }      finally {       UtilTimerStack.pop(profileKey);      }  }  

拦截器的源代码

public String intercept(ActionInvocation invocation) throws Exception {  String result = null;          before(invocation);          // 调用下一个拦截器，如果拦截器不存在，则执行Action          result = invocation.invoke();          after(invocation, result);          return result;  }  

struts的拦截器最大归功于他的动态代理模式，因为我们的action具体类都是一个继承动态代理的类。所以这就不必为每一个类都加相应的逻辑，只需继承就行了。