Struts2学习（五）拦截器介绍

什么是拦截器

拦截器（Interceptor）是Struts 2的一个强有力的工具，有许多功能都是构建于它之上，如国际化、转换器，校验等。

拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。

说到拦截器有一个东西不能落下——拦截器链（Interceptor Chain，在Struts 2中称为拦截器栈Interceptor Stack）。

拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。

实现原理

Struts 2的拦截器实现相对简单。当请求到达Struts 2的ServletDispatcher时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表（list），最后一个一个地调用列表中的拦截器。

拦截器调用序列图

示例演示

我们先创建一个简单的拦截器来演示下

先创建第一个拦截器FirstInterceptor

package cn.lovepi.chapter05.interceptor;

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

/**
 * Created by icarus on 2016/7/9.
 * 拦截器演示
 */
public class FirstInterceptor implements Interceptor {
   private String some;
    /**
     * 拦截器销毁方法
     */
    @Override
    public void destroy() {

    }

    /**
     * 初始化方法，当系统启动的时候拦截器就已经初始化完毕了
     */
    @Override
    public void init() {
        System.out.println(some+"拦截器初始化完成");
    }

    /**
     * 拦截器核心代码
     * @param actionInvocation
     * @return
     * @throws Exception
     */
    @Override
    public String intercept(ActionInvocation actionInvocation) throws Exception {
        // 让到达拦截器的请求继续前进，访问需要访问的资源，
        // 也就是放过去的意思，返回值就是经过action的返回字符串
        // 这个字符串到达struts.xml中的result中去。
        System.out.println("进入First拦截器");
        String returnName=actionInvocation.invoke();
        System.out.println("退出First拦截器");
        System.out.println("returnName"+returnName);
        return returnName;
    }

    public String getSome() {
        return some;
    }

    public void setSome(String some) {
        this.some = some;
    }
}

在文件中配置该拦截器

<package name="chapter05" extends="struts-default">
         <!--拦截器必须得配置在package包下第一个位置-->
         <interceptors>
             <interceptor name="ch05FirstInterceptor" class="cn.lovepi.chapter05.interceptor.FirstInterceptor">
                 <!--配置属性值-->
                 <param name="some">icarus</param>
             </interceptor>
         </interceptors>
         <!--拦截器演示Action-->
         <action name="ch05LoginAction" class="cn.lovepi.chapter05.action.LoginAction">
             <interceptor-ref name="ch05FirstInterceptor"/>
             <!--必须配置默认拦截器-->
             <interceptor-ref name="defaultStack"/>
             <result name="success">/chapter05/login.jsp</result>
         </action>
</package>

可以看到我们的拦截器必须配置在package包下的第一个位置，使用<interceptors>标签来进行配置，可以配置多个拦截器，使用<interceptor>标签来进行配置。还可以在拦截器中设置其属性的，使用<param>标签来对其属性进行赋值。

在配置好拦截器之后，想要在某个Action中使用拦截器，则使用<interceptor-ref>标签来进行指定。

注意：其实系统在执行Action之前都会执行默认的拦截器，也就是说每一个Action标签当中其实都有一句：

<interceptor-ref name="defaultStack"/>

但是这种情况在你配置了一个自定义的拦截器之后便会改变。 自定义的拦截器会将默认的拦截器覆盖掉 ，这时系统中只有一个自定义拦截器起作用，但是我们知道 Struts2 当中的许多功能都是基于默认的拦截器实现的，如国际化、转换器，校验等。所以我们在引入了自定义的拦截器之后一定要引入默认的拦截器到 Action 当中。

接下来我们创建第二个拦截器SecondInterceptor

package cn.lovepi.chapter05.interceptor;

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

/**
 * Created by icarus on 2016/7/9.
 * 拦截器演示
 */
public class SecondInterceptor implements Interceptor {
    /**
     * 拦截器销毁方法
     */
    @Override
    public void destroy() {

    }

    /**
     * 初始化方法，当系统启动的时候拦截器就已经初始化完毕了
     */
    @Override
    public void init() {
        System.out.println("Second拦截器初始化完成");
    }

    /**
     * 拦截器核心代码
     * @param actionInvocation
     * @return
     * @throws Exception
     */
    @Override
    public String intercept(ActionInvocation actionInvocation) throws Exception {
        // 让到达拦截器的请求继续前进，访问需要访问的资源，
        // 也就是放过去的意思，返回值就是经过action的返回字符串
        // 这个字符串到达struts.xml中的result中去。
        System.out.println("进入Second拦截器");
        String returnName=actionInvocation.invoke();
        System.out.println("退出Second拦截器");
        return returnName;
    }
}

接下来在项目中配置第二个拦截器

<package name="chapter05" extends="struts-default">
         <!--拦截器必须得配置在package包下第一个位置-->
         <interceptors>
             <interceptor name="ch05FirstInterceptor" class="cn.lovepi.chapter05.interceptor.FirstInterceptor">
                 <!--配置属性值-->
                 <param name="some">icarus</param>
             </interceptor>
             <!--配置第二个拦截器，没有相关属性就需要使用param了-->
             <interceptor name="ch05SecondInterceptor" class="cn.lovepi.chapter05.interceptor.SecondInterceptor"/>
         </interceptors>
         <!--拦截器演示Action-->
         <action name="ch05LoginAction" class="cn.lovepi.chapter05.action.LoginAction">
             <interceptor-ref name="ch05FirstInterceptor"/>
             <interceptor-ref name="ch05SecondInterceptor"/>
             <!--必须配置默认拦截器-->
             <interceptor-ref name="defaultStack"/>
             <result name="success">/chapter05/login.jsp</result>
         </action>
</package>

执行项目，会发现输出的结果是：

这里便引出了拦截器当中一个非常重要的概念------拦截器栈

拦截器栈的执行顺序可以抽象成以下模式：

对应的拦截器栈在Struts.xml文件当中也可以使用<interceptor-stack>标签来表示

那么上面那个示例的配置文件就可变为下面的形式：

<package name="chapter05" extends="struts-default">
         <!--拦截器必须得配置在package包下第一个位置-->
         <interceptors>
             <interceptor name="ch05FirstInterceptor" class="cn.lovepi.chapter05.interceptor.FirstInterceptor">
                 <!--配置属性值-->
                 <param name="some">icarus</param>
             </interceptor>
             <!--配置第二个拦截器，没有相关属性就需要使用param了-->
             <interceptor name="ch05SecondInterceptor" class="cn.lovepi.chapter05.interceptor.SecondInterceptor"/>
             <!--拦截器栈配置-->
             <interceptor-stack name="cho5AllInterceptor" >
                 <interceptor-ref name="ch05FirstInterceptor"/>
                 <interceptor-ref name="ch05SecondInterceptor"/>
                 <!--必须设置默认拦截器-->
                 <interceptor-ref name="defaultStack"/>
             </interceptor-stack>
         </interceptors>
         <!--拦截器演示Action-->
         <action name="ch05LoginAction" class="cn.lovepi.chapter05.action.LoginAction">
             <!--只需引入一个拦截器即可-->
             <interceptor-ref name="cho5AllInterceptor"/>
             <result name="success">/chapter05/login.jsp</result>
         </action>
</package>

在这里便可以引入一个新的概念，全局拦截器和全局result

<!--系统默认拦截器，对这个包中的所有action都适用-->
<default-interceptor-ref name="cho5AllInterceptor"/>
<!--全局的返回result，当包中任何一个action方法返回error都会去error界面-->
<global-results>
     <result name="error">/error.jsp</result>
</global-results>

还有一些其他的全局设置参数，因为不长使用便不在介绍了，可以自行了解。

我们目前所设置的Action都是直接使用一个类来实现ActionSupport接口，并重写接口默认的execute方法来实现的。所有的逻辑代码全在一个方法中，这对于一个类来说其实是有些浪费的，假如我们需要实现一个功能当中的增删改查方法的话岂不是要编写四个类…….

其实我们是可以在Action类中设置自己的方法的，只需在配置文件中配置到对应的方法即可。

如下我们在一个继承了ActionSupport类中编写了add、delete、update、show四个方法

package cn.lovepi.chapter05.action;

import com.opensymphony.xwork2.ActionSupport;

/**
 * Created by icarus on 2016/7/9.
 * 通配符引入示例
 */
public class UsersAction extends ActionSupport{
//    /**
//     * 默认的execute方法
//     * @return
//     * @throws Exception
//     */
//    @Override
//    public String execute() throws Exception {
//        System.out.println("进入execute方法");
//        return SUCCESS;
//    }
    /*
    但是对于一个类来说，只有一个执行方法是有些浪费的。
    我们可以自定义一些方法，然后在struts.xml文件中配置相应的方法
     */
    public String add() throws Exception{
        System.out.println("进入add方法");
        return "add_success";
    }
    public String show() throws Exception{
        System.out.println("进入show方法");
        return "show_success";
    }
    public String update() throws Exception{
        System.out.println("进入update方法");
        return "update_success";
    }
    public String delete() throws Exception{
        System.out.println("进入delete方法");
        return "delete_success";
    }
}

我们可以在类中对每个方法的 Action 进行配置

 <action name="chapter05UsersActionAdd" class="cn.lovepi.chapter05.action.UsersAction" method="add">
     <result name="success">/chapter05/index.jsp</result>
</action>
<action name="chapter05UsersActionShow" class="cn.lovepi.chapter05.action.UsersAction" method="show">
     <result name="success">/chapter05/index.jsp</result>
</action>
<action name="chapter05UsersActionUpdate" class="cn.lovepi.chapter05.action.UsersAction" method="update">
     <result name="success">/chapter05/index.jsp</result>
</action>
<action name="chapter05UsersActionDelete" class="cn.lovepi.chapter05.action.UsersAction" method="delete">
     <result name="success">/chapter05/index.jsp</result>
</action>

但是这样配置起来过于繁琐

接下来我们使用通配符来进行配置：

通配符可用于代替字符。通常地，星号“*”匹配0个或以上的字符，问号“?”匹配1个字符。

这样的话，上面的那些action可以用如下的代码进行配置：

<!--使用通配符方法配置,说白了就是在数星星，第一个星星的内容用{1}来代表-->
<action name="users_*" class="cn.lovepi.chapter05.action.UsersAction" method="{1}">
       <interceptor-ref name="ch05MethodInterceptor"/>
       <!--必须配置默认的拦截器-->
       <interceptor-ref name="defaultStack"/>
       <result name="{1}_success">/chapter05/{1}index.jsp</result>
</action>

在这里我们是对方法进行拦截器，所有我们得使用对应的方法拦截器

方法拦截器和普通的拦截器有所不同，普通的拦截器是实现Interceptor接口而方法拦截器是继承自MethodFilterInterceptor

package cn.lovepi.chapter05.interceptor;

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

/**
 * Created by icarus on 2016/7/10.
 * 方法拦截器，只针对对应的方法来进行拦截
 */
public class MethodInterceptor extends MethodFilterInterceptor{
    @Override
    protected String doIntercept(ActionInvocation actionInvocation) throws Exception {
        System.out.println("进入方法拦截器");
        String returnName=actionInvocation.invoke();
        System.out.println("退出方法拦截器");
        return returnName;
    }
}

这实际开发中，正确使用通配符来编写配置文件可以大大提高我们的开发效率同时也可以规范我们的代码。

<!--实际项目开发中所使用的通配符配置，第一个*是类名，第二个*是类中对应的方法
在表单的action中也要按照这种方式来编写
其实，使用通配符来配置同时也是一种编码规范-->
<action name="*_*" class="cn.lovepi.chapter05.action.{1}Action" method="{2}">
   <result name="{1}_{2}_success">/chapter05/{1}{2}index.jsp</result>
</action>

Struts2学习（五）拦截器介绍

猜你喜欢