模拟实现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之前，调用了拦截器中的方法。轻松实现了松耦合。