Java 读书笔记 14.7 动态代理

动态代理

这一章的难度加上翻译的水准使得我实在好像是在看天书啊，所以分开写了；

静态代理

首先我们来看看静态代理：

public interface Sell      //说呢，从古至今都有这么一个卖的接口，谁都可以卖东西；
{ 
	void sell(); 
	void ad();
}

public class Vendor implements Sell {        //卖主，小贩实现了他的卖法还有广告；
    public void sell() {
        System.out.println("In sell method");
    }
    public void ad() {
        System.out.println("ad method");
    }
}

 public class BusinessAgent implements Sell {     //代理商也实现卖的接口
   private Vendor mVendor;                        //将卖家聚合到自己类中
   public BusinessAgent(Vendor vendor) {
     mVendor = vendor;
   }
   public void sell() {                           //你调用代理商卖东西，他就去调用小贩去啦；
    mVendor.sell(); 
  }
    public  void  sell(int i)             //代理可以自己决定卖不卖给你
    {
        if (i<10)
        {
            System.out.println("你买的太少，代理不乐意搭理你");
        }
        else
        {
            System.out.println("亲，您需要支付" + (100 * i) + "￥");
            mVendor.sell();
        }
    }
  public void ad() { 
    mVendor.ad(); 
  }
        public  static  void  main(String [] arg)
    {
        BusinessAgent businessAgent = new BusinessAgent(new Vendor());
        businessAgent.sell(10);
    }
}
output：
亲，您需要支付1000￥
In sell method
你买的太少，代理不乐意搭理你

以上就是静态代理的内容了；就好像供货商，代理商之间的关系；卖不卖给你代理是可以决定的；

动态代理

public interface Sell{
        
        void sell(); 
        void ad();
}

public class DynamicProxy implements InvocationHandler {
    private Object obj; //obj为委托类对象
    public DynamicProxy(Object obj) {
        this.obj = obj;
    }
    //通过invoke方法实现了动态的方法和委托类的调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = method.invoke(obj, args);
        System.out.println("after");
        return result;
    }
    public  static  void  main(String [] arg)
    {
        DynamicProxy inter = new DynamicProxy(new Vendor());
        Sell sell = (Sell)   (Proxy.newProxyInstance(Sell.class.getClassLoader(),new  Class[]{Sell.class},inter));
        sell.sell();
        sell.ad();
        //既然是代理，那么我们可以反过来退出来sell这个引用一定是指向一个代理对象的；
        //Proxy.newProxyInstance()生成了一个代理对象
        //我们注意到inter是由 DynamicProxy 实例的一个对象；它就是整个代理对象的处理器了
    }
}

下面的代码改动会使得方法的动态修改变得明朗

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       // System.out.println("before");
        try {
            Class c = Class.forName("Proxy.Sell");
            Method method1 = c.getMethod("sell", null);
            Class c2 = Class.forName("Proxy.Sell");
            Method method2 = c2.getMethod("ad",null);
            if (method.equals(method1)) {
                System.out.println("处理器正在调用sell方法");
            }
            if (method.equals(method2)) {
                System.out.println("处理器正在调用ad方法");
            }
        }catch (Exception e)
        {
            System.out.println(e);
        }
        Object result = method.invoke(obj, args);
       // System.out.println("after");
        return result;
    }
ouput：
处理器正在调用sell方法
In sell method
处理器正在调用ad方法
ad method

还是蛮清楚的吧；

2017-03-05