readme

  1. 代理模式：
  2. 真实对象：被代理的对象
  3. 代理对象：就是代理对象
  4. 代理模式：代理对象代理真实对象，达到增强真实对象功能目的
  6. 实现方式：
  7. 动态代理：
  8. 1、代理对象和真实对象实现相同的接口
  9. 2、代理对象 = Proxy.newProxyInstance()
  10. 3、使用代理对象调用方法
  11. 4、增强方法
  13. 增强方式：
  14. 1、增强参数列表
  15. 2、增强返回值类型
  16. 3、增强方法体逻辑

demo-代理商+原厂卖手机

接口

  1. package com.example.newyear.proxy;
  3. public interface SalePhone {
  4.     public String sale(double maney);
  6.     public void show();
  7. }

真实类

  1. package com.example.newyear.proxy;
  3. /**
  4.  * 真实类
  5.  */
  7. public class lenovo implements SalePhone{
  8.     @Override
  9.     public String sale(double maney) {
  10.         System.out.println("花了"+maney+"买了一台电脑");
  11.         return "lenove pc";
  12.     }
  14.     @Override
  15.     public void show() {
  16.         System.out.println("展示电脑....原价8000");
  17.     }
  18. }

代理测试类

  1. package com.example.newyear.proxy;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. /**
  8.  * 代理测试类
  9.  */
  10. public class Proxytest {
  12.     public static void main(String[] args) {
  13.         //创建真实对象
  14.         lenovo lno = new lenovo();
  16.         //动态代理增强lno对象  底层：反射一个实现相同接口的类，这个新类的方法里面包含了对旧类方法的引用，使用这个新类实例化一个对象
  17.         // 这个方法会返回一个代理对象
  18.         // 固定写法  传入lno对象的类加载器和所有接口
  19.         /**
  20.          * 三个参数：
  21.          *      1、类加载器：真实对象.getClass().getClassLoader()
  22.          *      2、接口数组：真实对象.getClass().getInterfaces()  保证代理对象和真实对象实现了相同的接口
  23.          *      3、处理器：new InvocationHandler() 核心业务的处理
  24.          *
  25.          * 因为代理对象和真实对象都是实现SalePhone接口，所以可以直接强转，方便阅读
  26.          */
  27.         SalePhone proxy_lno = (SalePhone) Proxy.newProxyInstance(lno.getClass().getClassLoader(), lno.getClass().getInterfaces(), new InvocationHandler() {
  28.             /**
  29.              *  代理逻辑里面写的方法：代理对象调用的所有方法都会触发该方法执行
  30.              * @param proxy ：代理对象，就是上面的proxy_lno
  31.              * @param method : 代理对象调用哪个方法，就会把哪个方法通过反射封装成对象传入
  32.              * @param args ：代理对象调用的方法时，传递的实际参数
  33.              * @return
  34.              * @throws Throwable
  35.              */
  36.             @Override
  37.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  38. //                System.out.println("代理逻辑中的方法执行了");
  39. //                System.out.println(method.getName());
  40. //                System.out.println(args[0]);
  41.                 //代理对象只是增强真实对象的，因此这里面需要使用真实对象调用方法进行执行 而方法已经通过虚拟对象传入method中了
  42.                 //方法被真实对象执行
  43. //                Object obj = method.invoke(lno, args);
  44.                 //使用真实对象调用方法执行后，返回的结果，这里return是给到代理对象，所以下面的pc=obj
  45. //                return obj;
  47.                 //上面那部分需要好好理解，可以把注释去掉，运行进行理解，但是记得注释下面这部分
  49.                 //案例：比如供应商（代理对象），代理卖联想的电脑，卖出价格是进价的1.1
  50. //                判断是否是sale方法,如果不是sale方法，就不会触发
  51.                 if (method.getName().equals("sale")){
  52.                     //增强参数
  53.                     double maney = (double) args[0];
  54.                     maney = maney*1.1;
  55.                     //增强方法体
  56.                     System.out.println("客户");
  57.                     Object obj = method.invoke(lno, maney);
  58.                     System.out.println("客户血赚");
  59.                     //增强返回值
  60.                     return "因为"+obj+"送了鼠标";
  61.                 }else {
  62.                     Object obj = method.invoke(lno, args);
  63.                     return obj;
  64.                 }
  66.             }
  67.         });
  69.         //使用代理对象调用真实类中的方法
  70.         String pc = proxy_lno.sale(8000);
  71.         System.out.println(pc);
  73. //        proxy_lno.show();
  74.     }
  75. }

通过代理，可以对真实对象进行增强，输出了更多的内容
image.png