代理模式

3.7代理模式

代理模式基本介绍

• 为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象本身访问目标对象，这样的好处是可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。
• 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象
• 代理模式有不用的形式，主要有三种静态模式、动态代理（JDK代理、接口代理）和Cglib代理（可以在内存动态的创建对象，而不需要实现接口，属于动态代理的范畴）

模式角色：

• 目标接口：定义一个被代理对象要实现的功能方法
• 目标对象：也就是被代理的对象，实现目标接口的的方法
• 代理对象：实现目标接口，并且可以扩展目标对象的功能方法

静态代理

• 目标接口

  public interface TargetInterface {
  
      void option();
  }
  

• 目标对象

  public class TargetObject implements TargetInterface {
      @Override
      public void option() {
          System.out.println("I`m a target object to be Proxied");
      }
  }
  

• 代理对象

  public class ProxyObject implements TargetInterface {
  
      private TargetObject targetObject;
  
      //通过构造方法传入被代理对象
      public ProxyObject(TargetObject targetObject) {
          this.targetObject = targetObject;
      }
  
      @Override
      public void option() {
  
          System.out.println("init option");
          targetObject.option();
          System.out.println("end option");
      }
  
      public static void main(String[] args) {
          TargetObject targetObject = new TargetObject();
          ProxyObject proxyObject = new ProxyObject(targetObject);
          proxyObject.option();
      }
  }
  /*
  init option
  I`m a target object to be Proxied
  end option
  */
  

  优点：在不修改目标对象的前提下，能通过代理目标对象功能扩展

  缺点：所有代理对象都要实现目标接口的方法，会产生很多代理类，且一个接口改变，所有的代理类都要发生修改

动态代理

• 代理对象不需要实现接口，但是目标对象要实现接口
• 代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象，实现代理类所在包java.lang.reflect.Proxy
• 动态代理又称JDK代理，接口代理

public class ProxyFactory  {
    //维护一个基类对象
    private Object targetObject;

    //通过构造函数传入
    public ProxyFactory(Object targetObject) {
        this.targetObject = targetObject;
    }

    //给目标对象生成一个代理对象
    public Object getProxyObject(){
        Object target = Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                targetObject.getClass().getInterfaces(),
                new InvocationHandler() {
            //代理实现方法
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("JDK代理开始");
                        //通过反射机制调用目标对象的方法
                        Object invoke = method.invoke(targetObject, args);
                        System.out.println("JDK代理提交，被代理的对象");
                        return invoke;
                    }
                });
        return target;
    }

    public static void main(String[] args) {
        TargetInterface targetObject = new TargetObject();
        TargetInterface proxtTarget=(TargetInterface) new ProxyFactory(targetObject).getProxyObject();
        System.out.println(proxtTarget.getClass());
        proxtTarget.option();
        proxtTarget.del();
    }
}

/*
class com.sun.proxy.$Proxy0
JDK代理开始
I`m a target object to be Proxied
JDK代理提交，被代理的对象
JDK代理开始
to be deleted
JDK代理提交，被代理的对象
*/

动态代理对所有的接口方法实现执行相同的切入操作，比如日志，AOP就是如此实现

Cglib

• 静态代理与JDK代理，都需要目标对象实现接口方法，但是有时候目标对象只是一个单独的对象，并没有任何的接口，这个时候可以使用目标对象子类来实现代理-这就是Cglib代理

• Cglib也叫做子类代理，它是内存中构建一个子类对象从而实现对目标对象功能扩展

• 在AOP编程中如何选择代理模式

  • 目标对象需要实现接口，用JDK代理
  • 目标对象不需要实现接口，用Cglib代理

• Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类

模式角色；

• target

  public class TargetClass {
  
      public void option(){
          System.out.println("没有实现接口");
      }
  }
  

• proxy

  public class CglibProxy implements MethodInterceptor {
  
  
      //维护一个目标对象
      private Object target;
  
      public CglibProxy(Object target) {
          this.target = target;
      }
  
      public Object getProxyInstance(){
          //创建一个工具类
          Enhancer enhancer = new Enhancer();
          //设置工具类
          enhancer.setSuperclass(target.getClass());
          //设置回调函数
          enhancer.setCallback(this);
          //返回子类对象，即代理对象
          return enhancer.create();
      }
  
      /**
       *@Method intercept
       *@Description 重写，调用目标对象的方法
       *@author pandas
       *@create 2020/1/10 15:32
       *@Param [o, method, objects, methodProxy]
       *@return java.lang.Object
       */
      @Override
      public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
          System.out.println("Cglib代理模式开始");
          Object invoke = method.invoke(target, objects);
          System.out.println("Cglib代理模式结束");
          return invoke;
      }
  
      public static void main(String[] args) {
          TargetClass targetClass = new TargetClass();
          TargetClass proxyInstance =(TargetClass) new CglibProxy(targetClass).getProxyInstance();
  
          proxyInstance.option();
      }
  }