代理：顾名思义，就是代替别人做别人该做的事。

最最简单的代理模式
public interfact Real{  //这是一个接口
 void run();
}

public class RealImp implements Real{  //这是一个普通类
 public void run(){
  System.out.println("运行了");
 }
}

OK. 正常情况要调用run方法，我们需要new RealImp().run();  或者 Real r = new RealImp(); r.run();
这样简单点就可以理解为是自己在做自己的事情。

但有的时候，也许是为了更便于贴近OO， 就好像一个厂家生产鞋子，但有时销售工作并不是工厂来做，而是由他的代理商完成，而销售的鞋子却是工厂生成的。

简单点就用这个例子来理解

public interface Factory{  //工厂的接口，
 void sale();  //工厂最终都是要销售产品
}

public class ShoesFactory implements Factory{
 private int shoes = 50;
 public void sale(){  //工厂销售了一双鞋子的方法
  shoes--;
  System.out.println("卖出一双鞋，还剩"+shoes+"双");
 }
}

public class ShoesSaler{ //卖鞋的代理商
 private Factory factory;  //具体是哪个厂家的代理
 public ShoesSaler(Factory factory){ this.factory = factory; } //开始有这个代理时就要定下来代理的厂家
 public void sale(){
  factory.sale();  //这里可以看出，这个代理卖的东西并不是自己的，而是鞋厂的产品，这就是代理的最基本概念。
 }
}

 

二.动态代理

有的时候，我们也不知道这个代理商代理的工厂到底是做什么的，不知道代理的工厂需要代理做哪些工作。 对JAVA来说，就是不知道代理的对象类型。 这时需要用到动态代理，

即这个类只知道自己是代理，而不管代理什么，要做什么。仍然是上面的例子

public interface Factory{  //工厂的接口，
 void sale();  //工厂最终都是要销售产品
}

public class ShoesFactory implements Factory{
 private int shoes = 50;
 public void sale(){  //工厂销售了一双鞋子的方法
  shoes--;
  System.out.println("卖出一双鞋，还剩"+shoes+"双");
 }
}

需要两个包。一个是反射的方法，一个是动态代理的接口
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class Saler implements InvocationHandler{ //实现动态代理的接口, 这时的代理，并不能确定要代理什么。暂且只叫Saler
 private Object obj;  //即将代理的不知道的东西或者说是厂家
 
 public Saler(Object obj){
  this.obj = obj;  //建立时可以代理任意的对象（厂商）
 }

 public Object invoke(Object proxy, Method method, Object[] args)  //这个是InvocationHandler接口声明的方法。该方法由动态代理对象自动调用。
   throws Throwable {
  if(method.getName().equals("sale")){
   System.out.println("开始销售");
   method.invoke(obj,args);  //关键
   System.out.println("销售结束");
  }
  return null;
 } 
}

 

至此。已经准备好了一个动态的代理。 那要怎么让他代理不同的厂商呢？

import java.lang.reflect.Proxy;
class demo{
 public static void main(String[] args)
 {
  Factory factory = new ShoesFactory();  //有一个鞋厂要找人代理，实际上可以是任何对象。
  Saler saler = new Saler(factory);  //创建代理，OK。并且让这个代理指定了鞋厂，但真正对于代理来说，传入的只是Object，他并不知道到底这个找他代理

的是干嘛的。动态代理？ 迷糊代理吧。呵呵。下面就需要通过Java的反射机制，让代理了解这个代理的对象是干啥的。
  Factory smartSaler = (Factory)Proxy.newProxyInstance(factory .getClass().getClassLoader(),factory .getClass().getInterfaces(),saler);
  //通过反射出该工厂具体做什么的，包括类与相关接口，并将该信息告知动态的迷糊代理。。这个工作由Proxy来完成，即Proxy可以看作是一个工商局，工商局

告诉了代理商具体细节，并注册了经营范围。这时这个全新的代理，就可以指定出该干的事情。原来是代理的一家工厂。（注意的是，这是转换的只是接口），也就是说代理最多

还是只关注到要干些什么，即卖的产品仍然是工厂的，代理只是知道要卖产品而以。

  smartSaler.sale(); //这时就可以执行代理对象的方法。 原理是什么呢？
  
 
 }
}

  关键就是上面的invoke方法。当代理调用了sale()时，动态机制就开始运作， 该返回的动态代理已经知道了对象的类型信息接口信息， 他便将工作交由动态代

理内部的invoke方法执行，这一切是自动完成的，进行invoke方法后就开始执行我们手动编写的代码。

  上面invoke的方法中可以看出。在调用sale()方法后。 动态代理告知invoke，执行的方法是接口中的sale方法，即传参给invoke的第二个参数，如果该方法有参

数，则传给invoke的第三个参数 obj的数组

  这是再调用method的invoke方法，通知动态代理，这个sale方法的最终执行者是代理的工厂，即原来代理类中的obj对象。
  
  这一系列的工作，说明了建立了动态的代理，既实现InvocationHandler， 可以联想到，动态。。。即自动监听并完成工作，监听到代理执行相关方法后，监听

器就开始运作，调用相应方法invoke， 来寻找判断最终让原厂家执行销售。

这就是代理模式的简单理解。