Struts2学习笔记（5）--拦截器

Interceptor （底层通过动态代理实现）
1.建包 ...interceptor
自定义拦截器
第一种方式：
实现xwork包下的Interceptor接口
init() {} 初始化时调用
destroy() {} 销毁时调用
class MyInterceptor implements Interceptor {
private String hello;
//setter...getter...
public void init() {
System.out.println("init()...");
System.out.println( hello );
}
public void destroy() {
System.out.println("destroy()...");
}
public String intercept(ActionInvocation invocation) throws Exception {
System.out.println("intercept()1...");
//拦截器有拦截器站
//invoke()将判断是否还有下一个拦截器，有就执行下一个拦截器，没有则开始执行被拦截的类
String result = invocation.invoke();
System.out.println("finish1...");
return result;
}
---------------------------------
第二种方式：
1.继承AbstractInterceptor
该类实现了Interceptor接口，并且空实现了init()和destroy()方法
public class MyInterceptor extends AbstractInterceptor {
public String intercept(ActionInvocation invocation) throws Exception {
System.out.println("intercept()2...");
String result = invocation.invoke();
System.out.println("finish2...");
return result;
}
}

----------------------------

2. struts.xml 配置
<struts>
struts采用包名把不同的action区分开，相同类似功能的放在一个包里
包之间是可以有继承关系的，
extends="struts-default" 相当于把struts2-core-2.0.11.jar下的struts-default.xml的东西给继承过来了
其中包括N多的拦截器

<package name="包名" extends="struts-default">

定义拦截器
<interceptors>
定义多个拦截器时可以包含多个<interceptor>
<interceptor name="myInterceptor" class="com....interceptor.MyInterceptor"/>
<interceptor name="myInterceptor2" class="...">
为拦截器配置参数
name对应到拦截器类中的字段属性，该属性需要有set、get方法
当启动拦截器时这项配置将会吧world作为值赋给私有成员hello
也可以在引用拦截器时改变这个值
<param name="hello">world</param>
</interceptor>
</interceptors>
声明拦截器栈
<interceptors-stack name="myInterceptorStack">
引用拦截器
<interceptor-ref name="myInterceptor" />
<interceptor-ref name="myInterceptor2" />
拦截器栈中可以包含拦截器栈
<interceptor-ref name="defaultStack" /> defaultStack---Struts2默认的拦截器

</interceptors-stack>
<interceptors-stack name="myInterceptorStack2">
<interceptor-ref name="myInterceptor" />
引用拦截器栈
<interceptor-ref name="myInterceptorStack" />
</interceptors-stack>
<action ...>
<result name="...">...</result>
...
使用拦截器 action被请求一次，拦截器的intercept()就被执行一次
引用拦截器
<interceptor-ref name="myInterceptor" />
<interceptor-ref name="myInterceptor2" >
使用拦截器时对hello赋值，会改变引用时的赋值
<param name="hello">welcome</param>
</interceptor-ref>
<interceptor-ref name="defaultStack" /> 手动导入Struts2默认的拦截器栈
</action>
定义默认的拦截器栈
他会自动的把默认的拦截器附加到每一个Action中去
在一个包中，可以有0或1个默认的拦截器栈
如果在一个<action>中手动的指定一个拦截器，默认的拦截器就不会再自动的加到这个action里
只能通过手工的方式再导入一下
<default-interceptor-ref name="defaultStack" />
</package>
</struts>

=======================================
如果调用多个拦截器，执行顺序是怎样的？
如：
<interceptors>
<interceptor name="myInterceptor" class="..."></interceptor>
<interceptor name="myInterceptor2" class="..."></interceptor>
</interceptors>
<interceptors-stack name="myInterceptorStack">
执行顺序 按 配置的顺序
<interceptor-ref name="myInterceptor" />
<interceptor-ref name="myInterceptor2" />
</interceptors-stack>

注：拦截器会在调用invoke()方法调用之前和之后都会执行
拦截器1 1 中invoke方法前的语句
|_________拦截器2 2 中invoke方法后的语句
|__________
|
invoke() 执行invoke()方法
__________|
|
________拦截器2 2 中invoke方法后的语句
|
拦截器1 1 中invoke方法后的语句

==================================================
第三中方式：指定拦截的方法
如果拦截器没有做任何配合话，它会拦截所有的逻辑执行方法
如果<action>中method="execute" 指定了方法，它便只拦截execute方法
还可以通过方法过滤拦截器来指定拦截或不拦截的方法

--------------------------------------------------
继承MethodFilterInterceptor
public class MyInterceptor3 extends MethodFilterInterceptor {
@Override
public void init() {
System.out.println("init3");
}
//intercept()已经实现好了，不用去管他
//需要重写一下doIntercept
@Override
public String doIntercept(ActionInvocation invocation) throws Exception {
System.out.println("intercept()3...");
String result = invocation.invoke();
System.out.println("finish3...");
return result;
}
}
---------------------------------------------------
MethodFilterInterceptor中包含两个protected的属性
Set includeMethods : 包含谁
Set excludeMethods : 排除谁

<interceptors>
<interceptor name="myInterceptor3" class="..."></interceptor>
</interceptors>

<action ...>
<result ...>...</result>
...

<interceptor-ref name="myInterceptor3" >
包含 要拦截方法 多个用逗号分开
<param name="includeMethods">execute,test</param>

排除 不拦截的方法 多个用逗号分开
<param name="excludeMethods">execute</param>
</interceptor-ref>
<interceptor-ref name="defaulteStack" />
</action>

注：
如果 既包含includeMethod和excludeMethod，includeMethod一定会被拦截不管是否以把它排除

================
补充
================
-------------------------------
Java的过滤器 Filer:
-------------------------------
3个方法：
init( FilterConfig filterConfig ) {} 初始化时调用
destroy() {} 过滤器销毁时调用
过滤器链
doFilter( ServletRequest request, ServletResponse response, FilterChain chain ) {}

-------------------------------
Strust2的监听器
-------------------------------
PreResultListener接口
void beforeResult(ActionInvocation invocation, String resultCode) {}
监听的点是当你执行完execute()并返回到显示页面之前，beforeResult()方法被执行

--------------
1.
建立包：listener
2.
建立类：MyListener 继承 PreResultListener
3.
重写beforeResult方法
public class MyListener implements PreResultListener {
public void beforeResult(ActionInvocation invocation, String resultCode) {

// resultCode为 action中业务逻辑方法的返回值
System.out.println("result=" + resultCode);
}
}
4.
把监听器注册到拦截器中
public class MyInterceptor3 extends MethodFilterInterceptor {
@Override
public void init() {
System.out.println("init3");
}
@Override
public String doIntercept(ActionInvocation invocation) throws Exception {
//注册自己定义的监听器
invocation.addPreResultListener( new MyListener() );
System.out.println("intercept()3...");
String result = invocation.invoke();
System.out.println("finish3...");
return result;
}
}