模拟实现Struts拦截器-蕴含着代理模式，AOP，工厂模式，依赖注入，Java 反射，动态构造等机制

先说说代理模式：是来源于我们传统的思想，比如，我想去青岛办一些事，但是人不在青岛，于是我委托在青岛的朋友代理我去办。软件中的代理模式可以有约束性代理，远程代理，缓存代理等。

AOP设计哲学-我们在软件工程中，往往从纵向思维去设计软件，比如传统的三层思想（表示层，业务层，数据层），但是我们来个横行的总结，比如日志系统可以横行贯穿于这三层之中。我们要把日志系统的设计就是面向切面编程的原理。

在AOP的编程方式中有三个重要的概念：

• 目标对象，被拦截的原始对象
• 被插入的处理方法：定义在拦截器中，会在被拦截方法之前，之后自动执行的方法。
• 代理对象：以对象目标位蓝本，由系统创建的对象。

设想，我们怎样在不影响目标对象的业务逻辑的情况下，在目标对象的执行前或后去执行令一个方法，这里就利用AOP思想，java反射，动态构造。我们列举一个例子：

假设有一个宠物狗类，有两个方法，一个是Info方法（描述狗特征），一个run方法，我们怎样在info执行前，去执行类外的一个方法。我们第一思路就是修改宠物狗类，其实利用java的动态构造，反射，可以轻松实现，看代码：

Dog.java

package  Intercepter;

public   interface  Dog {

        // target object

        public   void  info();

        public   void  run();

}

DogImpl.java

package  Intercepter;

public   class  DogImpl  implements  Dog {

        @Override

        public   void  info() {

              //  TODO  Auto-generated method stub

            System.  out .println(  "I am a dog" );

      }

        @Override

        public   void  run() {

              //  TODO  Auto-generated method stub

            System.  out .println(  "I am running" );

      }

}

DogIntercepter.java

package  Intercepter;

public   class  DogIntercepter {

        public   void  method1(){

            System.  out .println(  "excute the first method of Intercepter" );

      }

        public   void  method2(){

            System.  out .println(  "excute the second method of Intercepter" );

      }

}

ProxyHandler.java

package  Intercepter;

import  java.lang.reflect.InvocationHandler;

import  java.lang.reflect.Method;

public   class  ProxyHandler  implements  InvocationHandler {

        private  Object  target ;

      DogIntercepter intercepter =  new  DogIntercepter();

      

        @Override

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

                    throws  Throwable {

              //  TODO  Auto-generated method stub

            Object result =  null ;

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

                    // 调用拦截器方法1

                    intercepter .method1();

                    // 调用目标对象方法

                  result = method.invoke(  target , args);

                    // 调用拦截器方法2

                    intercepter .method2();

            }

              else {

                  result= method.invoke(  target , args);

            }

              return  result;

      }

      

        public   void  setTarget(Object o){

              this .  target =o;

      }

}

MyProxyFacotory.java

package  Intercepter;

import  java.lang.reflect.Proxy;

public   class  MyProxyFactory {

        public   static  Object getProxy(Object o){

            ProxyHandler handler =   new  ProxyHandler();

            handler.setTarget(o);

              return  Proxy.newProxyInstance(DogImpl.  class .getClassLoader(), o.getClass().getInterfaces(), handler);

      }

}

ClientTest.java

package  Intercepter;

public   class  ClientTest {

        public   static   void   main(String[] args) {

            Dog targetDog =  new  DogImpl();

            Dog dog =  null ;

            Object proxy = MyProxyFactory. getProxy(targetDog);

              if (proxy  instanceof  Dog){

                  dog=(Dog)proxy;

            }

            dog.info();

            dog.run();

      }

}

通过ProxyHandler的帮助，系统实现了在执行info之前，调用了拦截器中的方法。轻松实现了松耦合。