java动态代理

动态代理是java反射机制的重要的应用。总结动态代理这一篇也算是对上一篇反射机制的扩展吧。那我们就先从静态代理说起。

静态代理

问题描述
一个品牌衣服工厂，拥有很多方法，如购买布料，购买染料，生产衣服，设计款式等等，现在需要一个对象（代理对象，俗称秘书）代替工厂来完成生产衣服这一工作。而其他的工作也可以由其他的代理对象（秘书）来完成对应的工作，这样就不用工厂自己完成工作了，就如同生活中，老板赋予秘书某种权利，秘书代理老板的某项工作一样。
具体的类
工厂生产衣服的接口

interface ClothFactory{//创建一个生产衣服的工厂的接口，所有品牌的衣服工厂，都必须继承这个接口来生产衣服
 void ProductCloth();//工厂生产衣服的抽象方法
}

工厂的实现类

class NikeClothFactory implements ClothFactory{//创建Nike工厂，此工厂可能还需要实现其他的接口，购买染料，布料等方法的接口
 @Override
 public void ProductCloth() {//Nike工厂生产衣服的方法
  System.out.println("Nike工厂生产一批衣服");//Nike工厂生产衣服的动作
 }
 //此工厂其他方法就不一一列出，比如实现的其它接口的方法：购买染料，布料等
}

代理类
说明：当Nike工厂生产衣服时，Nike工厂不亲自生产，而需要一个代理对象来代替它完成生产衣服的工作，这个代理对象充当秘书的角色，来代理这一个功能（相当于老板赋予秘书一项权利，代替老板完成任务），所以代理类必须也实现对应的接口，但不需要实现Nike工厂所实现的其他接口。

class ProxyFactory implements ClothFactory{//代理类，实现对应的接口（生产衣服的接口）
 ClothFactory cf;//被代理的对象
 public ProxyFactory(ClothFactory cf) {//创建代理类的对象时，实际传入一个被代理类的对象，这就相当于工厂（被代理对象）把自己的权利赋予别人
  this.cf = cf;
 }
 @Override
 public void ProductCloth() {
  System.out.println("代理类开始执行，收代理费$1000");//收取代理所需的劳动费用
  cf.ProductCloth();//执行自己的代理职责
 }
}

主程序

public class TestClothProduct {
 public static void main(String[] args) {
  NikeClothFactory nike = new NikeClothFactory();//创建被代理类的对象
  ProxyFactory proxy = new ProxyFactory(nike);//创建代理类的对象
  proxy.ProductCloth();//代理对象（秘书）开始工作
 }
}

执行结果

静态代理的缺点：每当被代理的对象要求代理对象代替他去完成某项工作时（运行某个方法），代理对象就必须实现对应的接口，并且实现对应的方法，而动态代理的出现，很优雅的就解决了这一问题。

动态代理

问题描述
在这里就不论述怎么让代理对象代替工厂完成生产衣服的工作了，论述同一个问题是乏味的，是没有意义的，这样总结的java知识就失去了灵魂，失去了优雅，大家可以私下偷偷地用动态代理实现上述静态代理的问题。接下来不用动态代理解决某一特定的问题，就是很平常，很通用的问题：代理对象代理被代理对象完成自己所代理的方法（注意这句话的断句：代理对象-代理-被代理对象-完成-代理对象-所代理的方法）
具体的类
接口

interface Subject{
 void action();
}

被代理的类（老板）

class RealSubject implements Subject{//此类希望具有action方法，所以继承了Subject接口，当然，它还可以有其他方法，甚至继承其他接口，这里就不一个个写到类里面了
 public void action() {//方法的实现
  System.out.println("我是被代理的方法，记得要执行我哦！木~~啊~");
 }
}

MyInvocationHandler 类（注意：不是代理类，这个类的实例化对象可以动态的产生代理类，或直接获得代理对象。此类必须实现InvocationHandler接口；产生代理类或代理对象用到Proxy类的静态方法）

class MyInvocationHandler implements InvocationHandler{
 Object obj;//声明被代理的对象，因为所有Object是所有类的根父类，所以被代理的对象被声明为Object
 
 
 public Object blind(Object obj) {//①给被代理的对象实例化，传入被代理的对象
  this.obj = obj;//前面声明的obj引用被代理的对象
  /*
   ②下面这一句返回一个代理类的对象，调用Proxy类的静态方法newProxyInstance()，
   传入参数（被代理对象的类加载器，被代理对象的所有接口，当前对象）-----这里就用到了反射，获得了obj对象的类的信息（类的加载器和实现的接口）
   */
  return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);//返回一个代理对象（秘书）
 }
 //当通过代理对象发起对被重写的方法的调用时，都会转化为对如下的invoke方法的调用
 @Override//实现InvocationHandler接口，所需要实现的方法
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//实现方法
//当通过代理对象发起对代理的方法的调用时，都会转化为invoke方法的调用，而method.invoke(obj, args)才是真正执行的代理方法（秘书代替老板完成工作的实际动作，obj为老板，args是完成被代理的方法所需要的参数），此方法是有返回值的，当被代理的方法有返回值，则此方法返回相应的值，如果被代理方法无返回值，则返回null
  Object returnVal = method.invoke(obj, args);
  return returnVal;
 }
}

主程序

public static void main(String[] args) {
  RealSubject real = new RealSubject();//1.创建被代理类的对象
  MyInvocationHandler handler = new MyInvocationHandler();//2.创建一个实现InvocationHandler接口的类的对象
  Object obj = handler.blind(real);//3.动态地获取real对象（被代理对象）的代理对象,返回值为Object类型
  Subject sub = (Subject)obj;//此时的sub就是代理对象，类型转化为Subject（这就说明sub代理了Subject接口的方法）；如果要代理其他方法，也可以类型转化为其他接口
  //4.用代理类的对象调用方法
  sub.action();//转到对MyInvocationHandler对象的invoke()方法的调用
  /*
  如果上述方法需要传入参数，最终经过底层的实现，
  无论多少参数，都会在代理对象的method.invoke(obj, args)方法的args里
  */
  //再举一例，就是上述静态代理的问题
  NikeClothFactory nike = new NikeClothFactory();//创建被代理类对象
  ClothFactory proxyCloth = (ClothFactory)handler.blind(nike);//获取代理对象invoke方法的
  proxyCloth.ProductCloth();//调用需要被代理的方法
 }

运行结果

以上就是动态代理的基本内容，动态代理的一个重要应用就是AOP（Aspect-Oriented Programming）编程