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