代理模式

代理模式是一种比较好理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。
在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。
在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
动态代理(理解) 基于反射机制

1.什么是代理?

代理,在我们日常生活之中就有体现,代购,中介,换ip,商家等等.

比如有一家美国的大学,可以对全世界招生.留学中介(代理 )

留学中介(代理):帮助这家美国的学校招生,中介是学校的代理中介是代替学校完成招生功能
代理特点

中介和代理他们要做的事情是一致的:招生
中介是学校代理,学校是目标
家长————>中介(学校介绍,办理入学手续)—————>美国学校
中介是代理,收取费用

为什么要找中介?
1.中介是专业的,方便.
2.家长现在不能自己去找学校。家长没有能力访问学校.或者美国学校不接收个人来访

买东西都是商家卖, 商家是某个商品的代理, 你个人买东西,肯定不会让你接触到厂家的.

2、使用代理模式的作用

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

实现代理

1)代理类是自己手工实现的,自己创建一个java类,表示代理类
2)同时你所要代理的目标

3、静态代理

特点：1）实现简单2）容易理解。
模拟一个用户购买u盘的行为。
用户是客户端类
商家：代理，代理某个品牌的u盘。
厂家：目标类。
三者的关系：用户（客户端）-—-商家（代理）-—-厂家（目标）
商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘。

3.1、实现步骤：

动态代理 - 图1
实现步骤
1.创建一个接口,定义卖u盘的方法,表示你的厂家和商家做的事情

  1. package com.rango.service;
  2. public interface usbSell {
  3.     /**
  4.      * 定义一个方法 参数 amount:表示一次购买的数量,暂时不用
  5.      * 返回值表示一个u盘的价格
  6.      * @param amount
  7.      * @return
  8.      */
  9.     float sell(int amount);
  10. }

2.创建厂家类,实现1步骤的接口

  1. package com.rango.factory;
  3. import com.rango.service.usbSell;
  4. //目标类:金士顿厂家,不接受用户的单独购买
  5. public class UsbKingFactory implements usbSell {
  6.     /**
  7.      * 定义一个方法 参数 amount:表示一次购买的数量,暂时不用
  8.      * 返回值表示一个u盘的价格
  9.      *
  10.      * @param amount
  11.      * @return
  12.      */
  13.     @Override
  14. //一个128G的U盘是85元.
  15. //    后期根据amount,可以实现不同的价格,例如10000个,单击是80,50000个75
  16.     public float sell(int amount) {
  17.         return 85.0f*amount;
  18.     }
  19. }

3.创建商家,就是代理,也需要实现1步骤中的接口

  1. package com.rango.business;
  3. import com.rango.factory.UsbKingFactory;
  4. import com.rango.service.usbSell;
  7. //淘宝是一个商家,代理金士顿U盘的销售
  8. public class TaoBao implements usbSell {
  9. //      声明 商家代理的厂家具体是谁
  10.     private UsbKingFactory factory =new UsbKingFactory();
  12.     @Override
  13. //    实现销售U盘功能
  14.     public float sell(int amount) {
  15. //        向厂家发送订单,告诉厂家,我买了U盘,厂家发货
  16. //        发送给工厂,我需要的订单,返回报价
  17.         float price = factory.sell(amount);
  18. //        商家需要加价也就是代理要增加价格
  19.         price = price + 25;
  20. //在目标类的方法调用后,你做的其他功能,都是增强的意思
  21.         System.out.println("淘宝再给你返回一个优惠券,或者红包");
  22. //        增加的价格
  23.         return price;
  24.     }
  25. }

4.创建客户端类,调用商家的方法买一个u盘

  1. import com.rango.business.TaoBao;
  3. public class shopMain {
  4.     public static void main(String[] args){
  5. //             创建代理的商家淘宝对象
  6.         TaoBao taoBao = new TaoBao();
  7. //        我只向淘宝买一件产品,得到报价
  8.         float price = taoBao.sell(2);
  9.         System.out.println("购买一件产品.淘宝的报价为: "+price);
  10.     }
  11. }

所以我们再次总结代理类完成的功能:

  1. 目标类中方法的调用

  2. 功能增强

    3.2、静态代理的优缺点

    我们再次总结一下静态代理的优缺点
    优点:

  3. 实现简单

  4. 容易理解

确定:当你的项目中,目标类的代理类很多的时候,有一下的缺点

  1. 当目标类增加了,代理类可能也需要成倍的增加
  2. 当你的接口中功能在增加了,或者修改了,会影响众多的实现类,厂家类,代理都需要修改,影响比较多.

所以我们继续学习动态代理

4、动态代理

使用jdk的反射机制,创建对象的能力,创建的是代理类的的对象.而不用我们创建类文件,不用写java文件
什么叫动态?在程序执行时,调用jdk提供的方法就能创建代理类的对象

4.1、静态代理和动态代理模式的对比

在静态代理中目标类很多时候,可以使用动态代理,避免静态代理的缺点。
动态代理中目标类即使很多,
1）代理类数量可以很少,
2）当你修改了接口中的方法时,不会影响代理类。
动态代理:在程序执行过程中,使用jdk的反射机制,创建代理类对象,并动态的指定要代理目标类。
换句话说:动态代理是一种创建java对象的能力,让你不用创建 TaoBao类就能创建代理类对象,除去了中间商

在java中,要想创建对象
创建类文件,java 文件编译为class —-> 使用构造方法,创建类的对象
动态代理：不要java文件

4.2、动态代理的介绍

动态代理 - 图2

动态代理其实就是jdk运行期间，动态创建class字节码并加载到JVM。

动态代理的实现:

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

jdk动态代理：
1)定义一个接口：

  1. public interface USBsell {
  2.     public int a(int num);
  3.     public int b(int num);
  4.     public void c(int num);
  6. }

2) 写一个接口的实现类：

  1. public class USBfactory implements USBsell{
  2.     @Override
  3.     public int a(int num) {
  4.         return num*10;
  5.     }
  6.     @Override
  7.     public int b(int num) {
  8.         return num*20;
  9.     }
  11.     @Override
  12.     public void c(int num) {
  13.         System.out.println("************"+num);
  14.     }
  15. }

3) 动态代理：

  1.  public static void main(String[] args) {
  3.         USBsell usb = new USBfactory();
  5.         USBsell usbProxy = (USBsell)Proxy.newProxyInstance(usb.getClass().getClassLoader(), usb.getClass().getInterfaces(),
  6.                 (proxy, method, arg) -> {
  7.                     Integer res = (Integer) method.invoke(usb, arg);
  8.                     System.out.println("收个手续费！！！");
  9.                     res = res + 10;
  10.                     return res;
  11.                 }
  12.         );
  14.         System.out.println(usbProxy.a(1));
  15.         System.out.println(usbProxy.b(1));
  16.         usbProxy.c(1);

执行结果：
执行最后一个方法报错，因为这个代理对象执行的方法都会进行方法增强

  1. 收个手续费！！！
  2. 20
  3. 收个手续费！！！
  4. 30
  5. ************1
  6. 收个手续费！！！
  7. Exception in thread "main" java.lang.NullPointerException
  8.     at com.jie.dynamic.MainProxy.lambda$main$0(MainProxy.java:18)
  9.     at com.sun.proxy.$Proxy0.c(Unknown Source)
  10.     at com.jie.dynamic.MainProxy.main(MainProxy.java:25)
  12. Process finished with exit code 1

补充一下类加载器：

一、类加载器是做什么的

1、将Class文件加载到JVM。

2、根据父级优先原则，决定一个类由谁加载。

3、将Class文件解析成JVM认识的结构。

二、类加载器的种类

1、BootstrapClassLoader，顶级类加载器，加载JVM自身需要的类。

2、ExtClassLoader，他负责加载扩展类，如jre/lib/ext或java.ext.dirs目录下的类。

3、AppClassLoader，他负责加载应用类，所有classpath目录下的类都可以被这个类加载器加载。

4、自定义类加载器，如果你要实现自己的类加载器，他的父类加载器都是AppClassLoader。

三、类加载器的继承实现关系

1、BootstrapClassLoader完全是由JVM控制，并不是父也没有子。

2、ExtClassLoader和AppClassLoader是Launcher的内部类。

3、ExtClassLoader和AppClassLoader继承了URLClassLoader。

4、URLClassLoader实现了抽象类ClassLoader。

四、隐式加载和显示加载

1、隐式加载：JVM自动加载类而不是手动编写ClassLoader代码去加载。

2、显式加载：手工编写代码加载类，例如this.getClass.getClassLoader().loadClass()

五、类加载器的三个机制

1、双亲委派：一个类加载器收到加载类的请求首先会找到自己的上一级类去加载，AppClassLoader->ExtClassLoader->BootstrapClassLoader的顺序，谁找到了负责的类谁就去加载。

2、可见性：父类加载器看不到子类加载的内容，子类加载器看得到父类加载的内容。

3、单一性：一个类只会被一个加载器加载一次。

六、加载Class文件的三个阶段

1、找到Class文件并加载字节码到内存。

2、验证字节码、分析Class类数据结构准备相应的内存分配、解析类进行符号表的链接。

3、类中静态属性和初始化赋值，执行静态块语句