Struts2自定义拦截器的实现

拦截器体系是Struts2的一个重要组成部分，对应struts2框架而言，可以将其理解为一个空容器，正是大量的内建拦截器完成了该框架的大部分操作。

因为struts2框架的拦截器是动态配置的（而不是以硬编码方式写死在框架源代码中的），所有开发者可以非常方便的扩展struts2框架，只要提供自己的拦截器实现类，并将其配置在struts.xml文件中即可。实际上，在struts2中开发自己的拦截器是如此简单的事，因此，开发者可非常方便的将多个Action中需要重复执行的动作放在拦截器中定义，从而提供更好的代码复用。

Struts2的拦截器体系是一种AOP(面向切面编程)设计哲学，它允许开发人员以一种简单的方式来进行AOP方式的开发

 

拦截器机制体现的是一种软件复用的原则

 

拦截器的意义：

拦截器是对调用方法的改进。实际上，当称某个实例是一个拦截器时，这是就其行为上而言；但从代码角度来看，拦截器就是一个类，这个类也包含方法，只是这个方法是特殊方法，它会在目标方法调用之前“自动执行”。

 

第一步：创建一个接口Dog

public interface Dog {      

         //狗信息

         publicvoid info();

         //狗跑

         publicvoid run();

}

 

第二步：创建一个实现上述接口的类，并实现方法

public class DogImpl implements Dog{

         publicvoid info() {

                   System.out.println("我是一只猎狗......");

                  

         }

         publicvoid run() {

                   System.out.println("我奔跑迅速.....");

                  

         }

}

 

第三步：创建一个拦截器（其实拦截器与普通的类没有什么区别）

public class DogInterceptor {

        

         publicvoid log(){

                   System.out.println("************************通用方法一****************************");

         }

                   publicvoid safe(){

                   System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&通用方法二&&&&&&&&&&&&&&&&&&&&&&&&&&&");

         }

}

 

第四步：根据目标对象  产生代理对象

public class MyProxyFactory {

 

         publicstatic Object getProxy(Object target) {

                   //创建代理类的处理类

                   ProxyHandlerproxyHandler = new ProxyHandler();

 

                   //传递目标对象 到代理对象中

                   proxyHandler.setTarget(target);

                   /**

                    * 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序

                    * loader - 定义代理类的类加载器 

                    * interfaces - 代理类要实现的接口列表

                    * h - 指派方法调用的调用处理程序

                    */

                   returnProxy.newProxyInstance(DogImpl.class.getClassLoader(), target

                                     .getClass().getInterfaces(),proxyHandler);

         }

}

 

第五步：代理实例调用处理程序

public class ProxyHandler implementsInvocationHandler{

         //声明被代理的目标对象

         privateObject target;

         //创建一个拦截器的实例

         DogInterceptordogInterceptor = new DogInterceptor();

         //执行代理目标方法的时候 ，该invoke方法被自动调用

         publicObject invoke(Object proxy, Method method, Object[] args)

                            throwsThrowable {

                   //声明返回值

                   Objectresult = null;

                   //method获取方法的名称 根据 名称判断是否是info方法

                   if(method.getName().equals("info")){

                            //在此方法前调用 通用方法一

                            dogInterceptor.log();

                            //对带有指定参数的指定对象调用由此 Method 对象表示的底层方法

                            result= method.invoke(target, args);

                            //在此方法后调用通用方法二

                       dogInterceptor.safe();

                           

                   }else{

                            //如果不是info方法  直接去执行底层的方法

                            result= method.invoke(target, args);

                   }

                   //返回

                   returnresult;

         }

         //传入目标对象

         publicvoid setTarget(Object target) {

                   this.target= target;

         }

}

 

第六步：测试

public class DogTest {

         publicstatic void main(String[] args) {

                  Dog targetDog = new DogImpl();

                   Objectproxy = MyProxyFactory.getProxy(targetDog);

                   Dogdog = null;

                   if(proxy instanceof Dog) {

                            dog= (Dog) proxy;

                   }

                   if(dog != null) {

                            dog.info();

                            dog.run();

                   }

         }

}