InterCeptor
1>>>>>>
Method级别的拦截器：
用@Before(xxx.class)给某个方法添加一个拦截器：
//测试methodInterceptor的用法
@Before(MethodInterceptor.class)
publicvoid testMethod(){
render("index.html");
}
作用只在这个方法上边生效，而在其他的方法上边不生效的。
结果可以从控制台看出来，如下，当访问默认的index的时候，只有一个interceptor，而访问具体的某个方法的时候，会出现具体的某个方法的MethodInterceptor：如下：
2>>>>>
Class级别的Interceptor,如下：
@Before(ClassInterceptor.class)//class级别
publicclass FrontController extendsController {
publicvoid index(){
setAttr("msg", "Hello,JFinal!");
render("index.html");
}
//测试methodInterceptor的用法
@Before(MethodInterceptor.class) //method级别
publicvoid testMethod(){
render("index.html");
}
}
当访问的时候，是Class级别的在整个类里面的方法都会执行该拦截器，但是method级别的只是在特定的方法上边执行的，执行的顺序是限制性Class级别的，在执行Method级别的，如下；
3>>>>>
Global级别的拦截器：
在Config.java中配置：
@Override
publicvoid configInterceptor(Interceptors me) {
me.add(new GlobalInterceptor());//配置全局的拦截器
//me.addGlobalActionInterceptor(newGlobalInterceptor());//拦截所有的Action
}
测试结果如下，先执行全局，在执行class，最后执行Method级别的拦截器：
Inject拦截器的效果
4>>>>>
通过DuangDuang让一个类拥有AOP的能力：
Inject增强（方法级别）：
//serviceImp是我们需要增强的类
publicclass ServiceImp {
@Before(InjectInterceptor.class)
publicvoid testInject(){
System.out.println("testInject");
}
publicvoid commenInject(){
System.out.println("commen~~~~~");
}
}
如果没有在方法上边增强，就不会调用拦截器，如果增强的话，就会调用，如下，testInject被增强了，而Comment是没有增强的
如果将其设置成类级别的拦截器，则不管某个方法增强与否，都会执行该拦截器：如下的testInjec和commen都执行了InjectInterceptor拦截器：
5>>>
通过DuangDuang让一个类拥有AOP的能力：关键是在调用的action中进行Duang增强，即在其方法上边进行拦截：
publicvoid InjectMethod(){
System.out.println("================================");
//关键如下：
ServiceImp service=Duang.duang(ServiceImp.class);
service.testInject();
service.commenInject();
System.out.println("=================================");
//关键如下：会在具体的方法进行增强
ServiceImp2 service2=Duang.duang(ServiceImp2.class);
service2.testInject();
service2.commenInject();
render("index.html");
}
配置全局的service的拦截器：
@Override
publicvoid configInterceptor(Interceptors me) {
//me.add(newGlobalInterceptor());//配置全局的拦截器
//me.addGlobalActionInterceptor(newGlobalInterceptor());//拦截所有的Action
me.addGlobalServiceInterceptor(new InjectInterceptor());//配置全局的service的拦截器
}
其中的service类如下：
serviceImp2：
//serviceImp2是我们需要增强的类
publicclass ServiceImp2 {
publicvoid testInject(){
System.out.println("testInject2~~~~~~~");
}
publicvoid commenInject(){
System.out.println("commen2~~~~~");
}
}
ServiceImp：
//serviceImp是我们需要增强的类
//@Before(InjectInterceptor.class)
publicclass ServiceImp {
//@Before(InjectInterceptor.class)
publicvoid testInject(){
System.out.println("testInject");
}
publicvoid commenInject(){
System.out.println("commen~~~~~");
}
}
结果如下：
会在每一个方法上边进行增强。
总结：
1~~~~~
me.addGlobalServiceInterceptor(newInjectInterceptor());
这个是通过DUangDuang给每个目标类进行增强，动态为一些业务方法增强。
2~~~
1）me.add(new GlobalInterceptor());
2）me.addGlobalActionInterceptor(newGlobalInterceptor());
3）me.addGlobalServiceInterceptor(new InjectInterceptor());
前两个是一样的，底层都是相同的实现，但是第三个是配置DUangDuang使用。
Enhancer
实际和DUangDuang是一个效果，可以互相替换
publicvoid InjectMethod(){
System.out.println("================================");
//关键如下：
ServiceImpservice=Duang.duang(ServiceImp.class);
service.testInject();
service.commenInject();
System.out.println("=================================");
//关键如下：
ServiceImp2service2=Duang.duang(ServiceImp2.class);
service2.testInject();
service2.commenInject();
System.out.println("=================Enhancer方法================");
//关键如下：
//ServiceImp3service3=Duang.duang(ServiceImp3.class);
ServiceImp3 service3=Enhancer.
enhance(ServiceImp3.class,InjectInterceptor.class);
service3.testInject();
service3.commenInject();
render("index.html");
}
但是在Config.java中没有设置拦截器
如下：
@Override
publicvoid configInterceptor(Interceptors me) {
//me.add(newGlobalInterceptor());//配置全局的拦截器
//me.addGlobalActionInterceptor(newGlobalInterceptor());//拦截所有的Action
//me.addGlobalServiceInterceptor(newInjectInterceptor());//配置全局的service的拦截器
}
结果如下：在没有在Enhancer中设置增强的上边没有增强，而在设置了增强的方法上边进行了增强。
注意：DUangDuang和EnhancerEnhancer是一样的。
拦截器栈
多个Interceptor组成拦截器栈，如下：
//多个拦截器的时候用{},执行的顺序从左到右，级别从高到低执行
@Before({AInterceptor.class,BInterceptor.class})
publicvoid testInterceptorStack(){
renderTemplate("index.html");
}
这个是用在了method级别的拦截器栈，其他Class级别，全局级别的同理。
结果如下：
其执行的顺序是按照从左到右，级别是从高到低。
Clear注解
不带参数的，不带参数的可以清除本身以上的所有的拦截器。可以是method级别，也可以是Class级别等。
带参数的，带参数的可以清除本身以上的参数中指定的拦截器。
注意：如果带参数的，其中有自己的拦截器，这时候是不起作用的
比如：
1>>>
@Before(AInterceptor.class)
@Clear({AInterceptor.class,BInterceptor.class,CInterceptor.class})
public void inter(){
renderTemplate(“index.jsp”);
}
此时是清除不掉AInterceptor这个拦截器的，因为只是对本身以上的才起作用的。
2>>>
@Before({AInterceptor.class,BInterceptor.class,CInterceptor.class})
Class A {
@Clear({AInterceptor.class})
public void inter(){
renderTemplate(“index.jsp”);
}
}
上边这个例子可以吧AInterceptor这个拦截器清除掉。
3>>>
Before(ClassInterceptor.class)
publicclass FrontController extendsController {
//测试methodInterceptor的用法
@Before(MethodInterceptor.class)
@Clear
publicvoid testMethod(){
render("index.html");
}
注意：上边这个例子可以清除的是ClassInterceptor这个拦截器，而不会清除本身的MethodInterceptor这个拦截器的，需要注意。
总结：
上边的这几个Clear注解和拦截器的使用差不多是一样的，既可以是Global、Inject、Class、Method级别的等等，也可以使用拦截器栈，即在Clear({})中使用{}来指定来清除多个拦截器。
拦截器的总结：
拦截器的优先级别：
1. Global
2. Inject (InjectorInterceptor、RouterInterceptor)
3. Class
4. Method