代理模式

/**
    * 【代理模式】
    *      特征：
    *          代理类 与 委托类 有相同的接口；
    *          代理类 负责 为委托类 预处理消息、过滤消息、把消息转发给委托类、事后处理消息等；
    *
    *      根据代理类的创建时期，分为2种：
    *          静态代理类：
    *              程序运行前，代理类就已经存在；
    *          动态代理类：
    *              程序运行时，运用反射机制动态创建代理类；
    */

/**
    * 【静态代理类】
    *      public interface HelloService{
    *          String echo(String msg);
    *      }
    *
    *      // 委托类
    *      public class HelloServiceImpl implements HelloService{
    *          public String echo(String msg){
    *              return "echo:"+msg;
    *          }
    *      }
    *
    *      // 代理类
    *      public class HelloServiceProxy implements HelloService{
    *          private HelloService helloService;
    *
    *          public HelloServiceProxy(HelloService helloService){
    *              this.helloService=helloService;
    *          }
    *
    *          public String echo(String msg){
    *              System.out.println("before calling echo()");
    *              String result=helloService.echo(msg);
    *              System.out.println("after calling echo()");
    *              return result;
    *          }
    *      }
    *
    *      public static void main(String args[]){
    *          HelloService helloService=new HelloServiceImpl();
    *          HelloService helloServiceProxy=new HelloServiceProxy(helloService);
    *          System.out.println(helloServiceProxy.echo("hello"));
    *      }
    */

/**
    * 【动态代理类】
    *      java.lang.reflect包中的 Proxy、InvocationHandler 提供了 生成动态代理类的能力；
    *
    *      public class Proxy implements java.io.Serializable {
    *          // 创建 动态代理类
    *          public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) throws IllegalArgumentException{}
    *
    *          // 创建 动态代理类的实例
    *          public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)throws IllegalArgumentException{}
    *      }
    *
    *      public interface InvocationHandler {
    *          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
    *      }
    *
    *      【Proxy创建的代理类有如下特点】
    *          1、public、final、非抽象
    *          2、继承 java.lang.reflect.Proxy
    *          3、名称以 $Proxy 开头
    *          4、实现 参数中interfaces 指定所有接口
    *          5、都有一个 public的构造方法，构造方法有一个 InvocationHandler类型的参数
    *          6、Proxy.isProxyClass 判断一个类是否为动态代理类
    *
    *      【Proxy创建的代理实例有如下特点】
    *          1、每个动态代理类实例 都与 一个InvocationHandler实例 关联
    *          2、Proxy.getInvocationHandler 返回与 代理类实例 关联的InvocationHandler实例
    *          3、当程序调用 代理类实例的方法时，会调用 与 代理类实例关联的InvocationHandler实例的 invoke方法
    *
    *
    *      public interface HelloService{
    *          String echo(String msg);
    *      }
    *
    *      // 委托类
    *      public class HelloServiceImpl implements HelloService{
    *          public String echo(String msg){
    *              return "echo:"+msg;
    *          }
    *      }
    *
    *      // 代理工厂
    *      public class HelloServiceProxyFactory {
    *
    *          public static <T> T getHelloServiceProxy(final Object object, final Class<?>... interfaces) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    *              MyHandler myHandler = new MyHandler(object);
    *
    *              // 第1种方式创建代理类实例
    *              Class<?> proxyClass = Proxy.getProxyClass(object.getClass().getClassLoader(), interfaces);
    *              Constructor<?> constructor = proxyClass.getConstructor(new Class[]{InvocationHandler.class});
    *              T newInstance = (T) constructor.newInstance(myHandler);
    *              return newInstance;
    *
    *              // 第2种方式创建代理类实例
    *              T newProxyInstance = (T) Proxy.newProxyInstance(o.getClass().getClassLoader(), interfaces, myHandler);
    *              return newProxyInstance;
    *          }
    *
    *          static class MyHandler implements InvocationHandler{
    *
    *              private Object object;
    *
    *              public MyHandler(){}
    *
    *              public MyHandler(Object o){
    *                  this.object = o;
    *              }
    *
    *              @Override
    *              public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    *                  System.out.println("before calling "+method);
    *                  Object result=method.invoke(object, args);
    *                  System.out.println("after calling "+method);
    *                  return result;
    *              }
    *
    *          }
    *      }
    *
    *      public static void main(String args[]) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
    *          HelloService helloService=new HelloServiceImpl();
    *          HelloService helloServiceProxy= HelloServiceProxyFactory.getProxyInstance(helloService, HelloService.class);
    *          System.out.println(helloServiceProxy.getClass().getName());
    *          System.out.println(helloServiceProxy.echo("Hello"));
    *      }
    *
    */