北京动力节点-王鹤-动态代理.pdf

动态代理（理解）： 基于反射机制。

掌握的程度

  1. 什么是动态代理 ？
    使用jdk的反射机制，创建对象的能力， 创建的是代理类的对象。 而不用你创建类文件。不用写java文件。
    动态：在程序执行时，调用jdk提供的方法才能创建代理类的对象。
    jdk动态代理，必须有接口，目标类必须实现接口， 没有接口时，需要使用cglib动态代理
    2. 知道动态代理能做什么 ？
    可以在不改变原来目标方法功能的前提下， 可以在代理中增强自己的功能代码。
    程序开发中的意思。
    比如：你所在的项目中，有一个功能是其他人（公司的其它部门，其它小组的人）写好的，你可以使用。
    GoNong.class , GoNong gn = new GoNong(), gn.print();
    你发现这个功能，现在还缺点， 不能完全满足我项目的需要。 我需要在gn.print()执行后，需要自己在增加代码。
    用代理实现 gn.print（）调用时， 增加自己代码， 而不用去改原来的 GoNong文件。
    后面会讲 mybatis ，spring

1、代理

代购， 中介，换ip，商家等等
比如有一家美国的大学， 可以对全世界招生。 留学中介（代理）
留学中介（代理）： 帮助这家美国的学校招生， 中介是学校的代理， 中介是代替学校完成招生功能。

  1.      代理特点：<br />       1. 中介和代理他们要做的事情是一致的：  招生。  <br />       2. 中介是学校代理， 学校是目标。<br />       3. 家长---中介（学校介绍，办入学手续）----美国学校。<br />       4. 中介是代理，不能白干活，需要收取费用。<br />       5. 代理不让你访问到目标。
  3.      为什么要找中介 ？  <br />       1. 中介是专业的， 方便<br />       2. 家长现在不能自己去找学校。 家长没有能力访问学校。 或者美国学校不接收个人来访。<br />     <br />         买东西都是商家卖， 商家是某个商品的代理， 你个人买东西， 肯定不会让你接触到厂家的。

2、在开发中也会有这样的情况， 你有a类， 本来是调用c类的方法， 完成某个功能。 但是c不让a调用。

  1. a -----不能调用 c的方法。<br />    在a 和 c 直接 创建一个 b 代理，    c让b访问。  <br />    a --访问b---访问c<br />    实际的例子： 登录，注册有验证码， 验证码是手机短信。<br />    中国移动， 联通能发短信。  <br />    中国移动， 联通能有子公司，或者关联公司，他们面向社会提供短信的发送功能<br />    张三项目发送短信----子公司，或者关联公司-----中国移动， 联通

3、使用代理模式的作用

1.功能增强： 在你原有的功能上，增加了额外的功能。 新增加的功能，叫做功能增强。
2.控制访问： 代理类不让你访问目标，例如商家不让用户访问厂家。

4、实现代理的方式

1. 静态代理 ：

1） 代理类是自己手工实现的，自己创建一个java类，表示代理类。
2） 同时你所要代理的目标类是确定的。
特点：
1）实现简单
2）容易理解。
缺点：
当你的项目中，目标类和代理类很多时候，有以下的缺点：
1）当目标类增加了， 代理类可能也需要成倍的增加。 代理类数量过多。
2） 当你的接口中功能增加了， 或者修改了，会影响众多的实现类，厂家类，代理都需要修改，影响比较多。

1.1 模拟一个用户购买u盘的行为：

  1.  用户是客户端类<br />     商家：代理，代理某个品牌的u盘。<br />     厂家：目标类。<br />     三者的关系： 用户（客户端）---商家（代理）---厂家（目标）<br />     商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘。
  3.   实现步骤：<br />   1. 创建一个接口，定义卖u盘的方法， 表示你的厂家和商家做的事情。<br />   2. 创建厂家类，实现1步骤的接口<br />   3. 创建商家，就是代理，也需要实现1步骤中的接口。<br />   4. 创建客户端类，调用商家的方法买一个u盘。
  5.                       代理类完成的功能：  <br />    1. 目标类中方法的调用<br />    2. 功能增强

静态代理， 代理类是手工创建的， 代理的目标类是固定的。

  1. package com.bjpowernode.factory;
  3. import com.bjpowernode.service.UsbSell;
  5. //目标类： 金士顿厂家, 不接受用户的单独购买。
  6. public class UsbKingFactory implements UsbSell {
  7.     @Override
  8.     public float sell(int amount) {
  9.         System.out.println("目标类中的方法调用 , UsbKingFactory 中的sell ");
  10.         //一个128G的u盘是 85元。
  11.         //后期根据amount ，可以实现不同的价格，例如10000个，单击是80， 50000个75
  12.         return 85.0f;
  13.     }
  14. }
  1. package com.bjpowernode.service;
  3. // 表示功能的，厂家，商家都要完成的功能
  4. public interface UsbSell {
  6.     //定义方法 参数 amount:表示一次购买的数量，暂时不用
  7.     //返回值表示一个u盘的价格。
  8.     float sell(int amount);
  10.     //可以多个其它的方法
  11.     //void print();
  12. }
  1. package com.bjpowernode.shangjian;
  3. import com.bjpowernode.factory.UsbKingFactory;
  4. import com.bjpowernode.service.UsbSell;
  6. //taobao是一个商家，代理金士顿u盘的销售。
  7. public class TaoBao implements UsbSell {
  9.     //声明 商家代理的厂家具体是谁
  10.     private UsbKingFactory factory = new UsbKingFactory();
  12.     @Override
  13.     //实现销售u盘功能
  14.     public float sell(int amount) {
  16.         //向厂家发送订单，告诉厂家，我买了u盘，厂家发货
  17.         float price = factory.sell(amount); //厂家的价格。
  18.         //商家 需要加价， 也就是代理要增加价格。
  19.         price = price + 25; //增强功能，代理类在完成目标类方法调用后，增强了功能。
  20.         //在目标类的方法调用后，你做的其它功能，都是增强的意思。
  21.         System.out.println("淘宝商家，给你返一个优惠券，或者红包");
  23.         //增加的价格
  24.         return price;
  25.     }
  26. }
  1. package com.bjpowernode.shangjian;
  3. import com.bjpowernode.factory.UsbKingFactory;
  4. import com.bjpowernode.service.UsbSell;
  6. public class WeiShang implements UsbSell {
  7.     //代理的是 金士顿，定义目标厂家类
  8.     private UsbKingFactory factory = new UsbKingFactory();
  9.     @Override
  10.     public float sell(int amount) {
  11.         //调用目标方法
  12.         float price = factory.sell(amount);
  13.         //只增加1元
  14.         price = price + 1;
  15.         return price;
  16.     }
  17. }
  1. package com.bjpowernode;
  3. import com.bjpowernode.shangjian.TaoBao;
  4. import com.bjpowernode.shangjian.WeiShang;
  6. public class ShopMain {
  8.     public static void main(String[] args) {
  9.         //创建代理的商家taobao对象
  10. //        TaoBao taoBao = new TaoBao();
  11. //        通过代理类，实现购买u盘，增加了优惠券，红包等等
  12. //        float price = taoBao.sell(1);
  13. //        System.out.println("通过淘宝的商家，购买u盘单价："+price);
  16.         WeiShang weiShang = new WeiShang();
  17.         //通过代理类，实现购买u盘，增加了优惠券，红包等等
  18.         float price = weiShang.sell(1);
  19.         System.out.println("通过微商购买的价格："+ price);
  21.     }
  22. }

2. 动态代理

  • 在静态代理中目标类很多时候，可以使用动态代理，避免静态代理的缺点。 

    1.      动态代理中目标类即使很多， <br />1）代理类数量可以很少，<br />2）当你修改了接口中的方法时，不会影响代理类。<br />   <br />          动态代理： 在程序执行过程中，使用jdk的反射机制，创建代理类对象， 并动态的指定要代理目标类。<br />          换句话说： 动态代理是一种创建java对象的能力，让你不用创建TaoBao类，就能创建代理类对象。

  • 在java中，要想创建对象：

    1.       1.创建类文件， java文件编译为class<br />               2.使用构造方法，创建类的对象。<br />                动态代理的实现： <br />1. jdk动态代理（理解）： 使用java反射包中的类和接口实现动态代理的功能。<br />                             反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy.<br />                    2. cglib动态代理（了解）: cglib是第三方的工具库， 创建代理对象。<br />                           cglib的原理是继承， cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法，                              实现功能的修改。<br />                           因为cglib是继承，重写方法，所以要求目标类不能是final的， 方法也不能是final的。<br />                           cglib的要求目标类比较宽松， 只要能继承就可以了。cglib在很多的框架中使用，  比如 mybatis                             ，spring框架中都有使用。<br />

    5、jdk动态代理：

    1. 反射， Method类，表示方法。类中的方法。 通过Method可以执行某个方法。
      2. jdk动态代理的实现
      反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy.

      1)InvocationHandler 接口（调用处理器）：就一个方法invoke（）
      invoke（）:表示代理对象要执行的功能代码。你的代理类要完成的功能就写在invoke()方法中。

方法原型：

  1. public Object invoke(Object proxy, Method method, Object[] args)
  1.                   参数： <br />Object proxy:jdk创建的代理对象，无需赋值。<br />                            Method method:目标类中的方法，jdk提供method对象的<br />                            Object[] args：目标类中方法的参数， jdk提供的。<br />                             InvocationHandler 接口：表示你的代理要干什么。
  3.     代理类完成的功能：<br />         1. 调用目标方法，执行目标方法的功能<br />         2. 功能增强，在目标方法调用时，增加功能。<br />       <br />              怎么用： <br />1.创建类实现接口InvocationHandler<br />                             2.重写invoke（）方法， 把原来静态代理中代理类要完成的功能，写在这。<br />       <br />               2）Method类：表示方法的， 确切的说就是目标类中的方法。<br />                          作用：通过Method可以执行某个目标类的方法，Method.invoke();<br />                           method.invoke(目标对象，方法的参数)<br />                           Object ret = method.invoke(service2, "李四");
  1.   说明： method.invoke（）就是用来执行目标方法的，等同于静态代理中的

//向厂家发送订单，告诉厂家，我买了u盘，厂家发货 float price = factory.sell(amount); //厂家的价格。

  1.            3）Proxy类：核心的对象，创建代理对象。之前创建对象都是 new 类的构造方法()<br />                         现在我们是使用Proxy类的方法，代替new的使用。  <br />                       方法： 静态方法 newProxyInstance()  <br />                       作用是： 创建代理对象， 等同于静态代理中的TaoBao taoBao = new TaoBao();<br />                         参数：<br />                            1. ClassLoader loader 类加载器，负责向内存中加载对象的。 使用反射获取对象的ClassLoader<br />                             类a , a.getCalss().getClassLoader(),  目标对象的类加载器<br />                            2. Class<?>[] interfaces： 接口， 目标对象实现的接口，也是反射获取的。<br />3. InvocationHandler h : 我们自己写的，代理类要完成的功能。  <br />                          返回值：就是代理对象                    
  1. public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
  1. package com.bjpowernode.factory;
  3. import com.bjpowernode.service.UsbSell;
  5. //目标类
  6. public class UsbKingFactory implements UsbSell {
  7.     @Override
  8.     public float sell(int amount) {
  9.         //目标方法
  10.         System.out.println("目标类中，执行sell目标方法");
  11.         return 85.0f;
  12.     }
  14.     @Override
  15.     public void print() {
  17.     }
  18. }
  1. package com.bjpowernode.handler;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  6. //必须实现InvocationHandler接口，完成代理类要做的功能（1.调用目标方法，2.功能增强）
  7. public class MySellHandler implements InvocationHandler {
  9.     private Object target = null;
  11.     //动态代理：目标对象是活动的，不是固定的，需要传入进来。
  12.     //传入是谁，就给谁创建代理。
  13.     public MySellHandler(Object target) {
  14.         //给目标对象赋值
  15.         this.target = target;
  16.     }
  18.     @Override
  19.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  21.         Object res  = null;
  22.         //向厂家发送订单，告诉厂家，我买了u盘，厂家发货
  23.         //float price = factory.sell(amount); //厂家的价格。
  24.         res =  method.invoke(target,args); //执行目标方法
  28.         //商家 需要加价， 也就是代理要增加价格。
  29.         //price = price + 25; //增强功能，代理类在完成目标类方法调用后，增强了功能。
  30.         if( res != null ){
  31.             Float price = (Float)res;
  32.             price = price + 25;
  33.             res = price;
  34.         }
  36.         //在目标类的方法调用后，你做的其它功能，都是增强的意思。
  37.         System.out.println("淘宝商家，给你返一个优惠券，或者红包");
  38.         //记录数据库
  40.         //增加的价格
  41.         return res;
  43.     }
  44. }
  1. package com.bjpowernode.service;
  3. //目标接口
  4. public interface UsbSell {
  6.     float sell(int amount);
  8.     void print();
  9. }
  1. package com.bjpowernode;
  3. import com.bjpowernode.factory.UsbKingFactory;
  4. import com.bjpowernode.handler.MySellHandler;
  5. import com.bjpowernode.service.UsbSell;
  7. import java.lang.reflect.InvocationHandler;
  8. import java.lang.reflect.Proxy;
  10. public class MainShop {
  12.     public static void main(String[] args) {
  13.         //创建代理对象，使用Proxy
  14.         //1. 创建目标对象
  15.         // UsbKingFacotry  factory = new UsbKingFactory();
  16.         UsbSell factory = new UsbKingFactory();
  17.         //2.创建InvocationHandler对象
  18.         InvocationHandler handler = new MySellHandler(factory);
  20.         //3.创建代理对象
  21.         UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
  22.                 factory.getClass().getInterfaces(),
  23.                 handler);
  25.         //com.sun.proxy.$Proxy0 : 这是jdk动态代理创建的对象类型。
  26.         System.out.println("proxy:"+proxy.getClass().getName());
  27.         //4.通过代理执行方法
  28.         float price = proxy.sell(1);
  29.         System.out.println("通过动态代理对象，调用方法："+price);
  30.     }
  31. }

6、实现动态代理的步骤：

  1.         1. 创建接口，定义目标类要完成的功能<br />            2. 创建目标类实现接口<br />            3. 创建InvocationHandler接口的实现类，在invoke方法中完成代理类的功能<br />                  1）调用目标方法<br />                  2）增强功能<br />           4.使用Proxy类的静态方法，创建代理对象。 并把返回值转为接口类型。

image.png

  1. package com.bjpowernode.handler;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  6. public class MyInvocationHandler implements InvocationHandler {
  8.     private Object target = null;
  10.     public MyInvocationHandler(Object target) {
  11.         this.target = target;
  12.     }
  14.     @Override
  15.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  17.         //我在项目中记录数据库，
  18.         //调用目标方法， 执行print()得到 2
  19.         Object res = method.invoke(target,args); //2
  20.         //需要乘以 2的结果
  21.         if( res != null){
  22.             Integer num = (Integer)res;
  23.             res = num * 2;
  24.         }
  26.         return res;
  27.     }
  28. }
  1. package com.bjpowernode.service;
  3. public class GoNeng implements HelloService {
  4.     @Override
  5.     public int print(String name) {
  6.         System.out.println("其它人写好的个功能方法");
  7.         return 2;
  8.     }
  9. }
  1. package com.bjpowernode.service;
  3. public interface HelloService {
  5.     //打印报告， 报表
  6.     int print(String name);
  7. }
  1. package com.bjpowernode;
  3. import com.bjpowernode.handler.MyInvocationHandler;
  4. import com.bjpowernode.service.GoNeng;
  5. import com.bjpowernode.service.HelloService;
  7. import java.lang.reflect.InvocationHandler;
  8. import java.lang.reflect.Proxy;
  10. public class MyApp {
  12.     public static void main(String[] args) {
  13.        // GoNeng gn = new GoNeng();
  14.         //int num = gn.print("销售");
  15.        // System.out.println("num="+num);
  17.         GoNeng goNeng = new GoNeng();
  18.         InvocationHandler handler = new MyInvocationHandler(goNeng);
  20.         System.out.println("goNeng.getClass().getInterfaces()="+goNeng.getClass().getInterfaces()[0].getName());
  21.         HelloService proxy = (HelloService) Proxy.newProxyInstance( goNeng.getClass().getClassLoader(),
  22.                 goNeng.getClass().getInterfaces(),handler);
  24.         int num = proxy.print("市场");
  25.         System.out.println("我们期望的 num ==" + num);
  27.     }
  28. }