拦截器是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">
<!-- 引用STRUTS2默认拦截器 -->
<interceptor-ref name="defaultStack"></interceptor-ref>
<interceptor-ref name="其它拦截器名"></interceptor-ref>
</interceptor-stack>
拦截器栈里同样可以配置拦截器栈,这个配置跟拦截器一样。同样在拦截器栈中配置的拦截器也可以指定参数,这里的参数将会覆盖原来配置时的默认参数。
2,在Action中使用拦截器
定义了拦截器之后就可以使用它了,在Action内可以通过以下方式引用拦截器:
<!-- 配置fileUpload的拦截器 -->
<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">
<!-- 引用STRUTS2默认拦截器 -->
<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">
<!-- 将名为second的拦截器的name参数改掉 -->
<param name="second.name">改名后的拦截器名</param>
</interceptor-ref>
</action>
7,Struts2的内建拦截器
从Struts2框架来看,拦截器几乎完成了Struts2框架70%的工作,包括解析请求参数,将请求参数赋值给Action属性,执行数据校验,文件上传。
Struts2已经自动为每个Action配置了默认拦截器,因此我们在大部分的情况下都不用再配置任何拦截器,它的配置如下:
<!-- 引用STRUTS2默认拦截器 -->
<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">
<!-- 引用STRUTS2默认拦截器 -->
<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默认的拦截器栈就可以了。