设计模式——结构型_代理模式（静态，jdk，cglib）

• 静态代理
• JDK动态代理（接口代理）
• Cglib动态代理（子类代理）

---

1. 概述

代理模式提供了对目标对象另外的访问方式：通过代理对象访问目标对象

这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能

这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法

---

2. 情景

• 抽象接口（租房：Rent接口）
• 真实角色（比如房东小张：Host类实现Rent接口）
• 代理角色（代理真实角色，比如中介，负责帮小张卖方：Proxy类实现Rent接口，同时拥有Host类这个成员属性，它可以调用小张实现的方法，并且增加自己的方法在里面）
• 客户（买房人：比如测试类，直接new 真实角色，并把真实角色传入new 代理角色中）

---

3. 静态代理

• 租房接口

//抽象接口：租房
public interface Rent {
   public void rent();
}

• 房东类

//真实角色: 房东
public class Host implements Rent{
   public void rent() {
       System.out.println("房屋出租");
  }
}

• 代理类

//代理角色：中介
public class Proxy implements Rent {

   private Host host;
   public Proxy() { }
   public Proxy(Host host) {
       this.host = host;
  }

   //租房
   public void rent(){
       seeHouse();
       host.rent();
       fare();
  }
   //看房
   public void seeHouse(){
       System.out.println("带房客看房");
  }
   //收中介费
   public void fare(){
       System.out.println("收中介费");
  }
}

• 客户端调用

//客户类，一般客户都会去找代理！
public class Client {
   public static void main(String[] args) {
       //房东要租房
       Host host = new Host();
       //中介帮助房东
       Proxy proxy = new Proxy(host);

       //你去找中介！
       proxy.rent();
  }
}

优点：

• 没有改变房东的代码，通过构造了新实现类中介，增强了房东的功能。对房东类进行了扩展。

缺点：

• 把代码写死了
• 代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护

---

4. JDK动态代理（接口代理）

• 利用JDK的API（ java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler ）实现
• 实现方法：
  • 新建 代理类 implements InvocationHandler（把要代理的抽象接口作为属性传入）
  • 重写invoke()方法
  • 对该接口调用静态类Proxy.newProxyInstance()方法返回代理对象

//抽象角色：租房
public interface Rent {
   public void rent();
}

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
   public void rent() {
       System.out.println("房屋出租");
  }
}

public class ProxyInvocationHandler implements InvocationHandler {
   private Rent rent;

   public void setRent(Rent rent) {
       this.rent = rent;
  }

   //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
   public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),
               rent.getClass().getInterfaces(),this);
  }

   // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
   // 处理代理实例上的方法调用并返回结果
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       seeHouse();
       //核心：本质利用反射实现！
       Object result = method.invoke(rent, args);
       fare();
       return result;
  }

   //看房
   public void seeHouse(){
       System.out.println("带房客看房");
  }
   //收中介费
   public void fare(){
       System.out.println("收中介费");
  }

}

//租客
public class Client {

   public static void main(String[] args) {
       //真实角色
       Host host = new Host();
       //代理实例的调用处理程序
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       pih.setRent(host); //将真实角色放置进去！
       Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
       proxy.rent();
  }

}

总结：

• 优点：相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度
• 缺点：无法摆脱仅支持interface代理的桎梏，代理的对象Host()必须实现Rent接口

---

5. Cglib动态代理（子类代理）

• 如果代理的目标对象没有实现接口，则不能用jdk动态代理，这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做：Cglib代理
• Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展
• 实现方法
  • 需要引入cglib的jar文件，但是Spring的核心包中已经包括了Cglib功能,所以直接引入spring-core-3.2.5.jar即可
  • 利用ASM开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理

//真实角色: 房东，房东要出租房子
public class Host {
   public void rent() {
       System.out.println("房屋出租");
  }
}

public class ProxyFactory implements MethodInterceptor{
   
    private Object target;    //需要代理的类

    public ProxyFactory(Object target) {    //构造器传参，传入代理类
        this.target = target;
    }

    public Object getInstance() {    //固定代码
        Enhancer enhancer = new Enhancer();    //工具类
        enhancer.setSuperclass(this.target.getClass());    //设置父类
        enhancer.setCallback(this);    //设置回调函数
        return enhancer.create();    //创建子类（代理对象）
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        this.seeHouse();
        Object returnValue = method.invoke(target, args);    //执行目标对象的方法
        this.fare();
        return returnValue;
    }

   //看房
   public void seeHouse(){
       System.out.println("带房客看房");
  }
   //收中介费
   public void fare(){
       System.out.println("收中介费");
  }

}

//租客
public class Client {

   public static void main(String[] args) {
       //真实角色
       Host host = new Host();
       //代理实例的调用处理程序
       Host proxy = (Host)new ProxyFactory(host).getInstance();
       proxy.rent();    //执行方法
  }

}

• CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高
• 但是CGLIB创建代理对象时长比JDK多得多
• 所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些
• 同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理

---

6. 总结

• JDK与Cglib
  • JDK代理的对象需要 implements 接口
  • CGLib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法（继承），因此不能对声明为final的方法进行代理
• Spring在选择用JDK还是CGLib的依据
  • 当Bean实现接口时，Spring就会用JDK的动态代理
  • 当Bean没有实现接口时，Spring使用CGLib来实现
  • 可以强制使用CGLib（在Spring配置中加入<aop:aspectj-autoproxy proxy-target-class=“true”/>）
• 性能对比
  • CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用Java反射效率要高。
  • 在JDK1.6、JDK1.7、JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLib代理效率，只有当进行大量调用的时候，JDK1.6和JDK1.7比CGLib代理效率低一点，但是到JDK1.8的时候，JDK代理效率高于CGLib代理
  • cglib创建对象时候的时间远远大于jdk（大约8倍），但cglib创建的对象实际运行性能远远优于jdk（大约10倍），cglib更适合单例对象

---

Reference

https://www.cnblogs.com/wenxiangchen/p/12689713.html

https://www.cnblogs.com/daniels/p/8242592.html

https://www.cnblogs.com/leeego-123/p/10995975.html

https://blog.csdn.net/xlgen157387/article/details/82497594