JFinal的拦截器笔记

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