一、代理模式基本概念

定义

1、模式说明

代理模式结构

proxy代理对象:（1）实现与具体的目标对象一样的接口，这样就可以使用代理来代替具体的目标对象（2）保存一个指向具体目标对象的引用，可以在需要的时候调用具体的目标对象，可以控制对具体目标对象的访问，并可能负责创建和删除它
Subject目标接口：定义代理和具体目标对象的接口，这样就可以在任何使用具体目标对象的地方使用代理对象
RealSubject具体的目标对象：真正实现目标接口要求的功能。

2、代理运行过程

3、代理功能

• 代理模式是通过创建一个代理对象，用这个代理对象去代表真实的对象，客户端得到这个代理对象过后，对客户端没有什么影响，就跟得到了真实对象一样来使用。
• 当客户端操作这个代理对象的时候，实际上功能最终还是会由真实的对象来完成，只不过是通过代理操作的，也就是客户端操作代理，代理操作真正的对象。

代理其实就是中转的意思，用代理对象去完成真实对象的动作。但是因为是中转，可以利用代理完成很多对客户端透明的东西，比如权限验证等。因此代理的作用可以归纳为：把一些共有的逻辑抽象到代理类中，由代理来完成，可以大大简化代码的。

4、代理分类

• 静态代理：（虚代理、保护代理、远程代理和智能指引等等）
• 动态代理：jdk动态代理、cglib动态代理

二、静态代理示例

1、创建需要代理的接口对象及其实现类

public interface Target {
 String execute();
}
public class TargetImpl implements Target {
 public String execute() {
     System.err.println("TargetImpl execute！");
     return "targetImpl";
 }
}

2、创建代理对象

public class StaticProxy implements Target {
 /**
  * 需要被代理的目标接口
  */
 private  Target target;

 public StaticProxy(Target target) {
     this.target = target;
 }

 public String execute() {
     //代理类进行代理方法操作（相当于中转，但是同时可以添加很多的东西，比如日志、权限等等）
     System.err.println("perProcess");
     String result = this.target.execute();
     System.out.println("postProcess");
     return result;
 }
}

3、测试

public class StaticProxyTest {
 public static void main(String[] args) {
     Target target=new TargetImpl();
     StaticProxy proxy=new StaticProxy(target);
     //代理类进行代理处理
     String execute = proxy.execute();
     System.err.println(execute);
 }
}

结果：

postProcess
perProcess
TargetImpl execute！
targetImpl

三、动态代理

静态代理具有一个明显的缺点就是如果Subject接口发生变化，那么代理类和具体的目标实现都要变化，不是很灵活。而动态代理如其名，能动态的适应变化，应用更加广泛。

1、jdk动态代理

• Java对代理模式提供了内建的支持，在java.lang.reflect包下面，提供了一个Proxy的类和一个InvocationHandler的接口。
• Java的动态代理目前只能代理接口，基本的实现是依靠Java的反射机制和动态生成class的技术，来动态生成被代理的接口的实现对象。
• 使用jdk动态代理的步骤：

（1）通过实现InvocationHandler接口来自定义自己的InvocationHandler;
（2）通过Proxy.getProxyClass获得动态代理类
（3）通过代理对象调用目标方法

public class JdkProxyInvocation implements InvocationHandler {

 private Object target;

 public JdkProxyInvocation(Object target) {
     this.target = target;
 }

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     System.out.println("========before==========");
     Object result = method.invoke(target,args);
     System.out.println("========after===========");
     return result;
 }
}

public class JdkProxy<T> {
  /**
   * 要被代理的对象
   */
  private Class<T> target;
  /**
   * 具体处理逻辑的invoke
   */
  private InvocationHandler invocationHandler;

  public JdkProxy(Class<T> target, InvocationHandler invocationHandler) {
      this.target = target;
      this.invocationHandler = invocationHandler;

  }

  public T getProxyObject() {
      return (T) Proxy.newProxyInstance(target.getClassLoader(), 
target.getInterfaces() , invocationHandler);
  }
}

public class JdkProxyTest {
  public static void main(String[] args) {
      Target target = new TargetImpl();
      JdkProxyInvocation jdkProxyInvocation = new JdkProxyInvocation(target);
      //获取代理对象
      Target proxy = (Target) new JdkProxy(target.getClass(), jdkProxyInvocation)
              .getProxyObject();
      proxy.execute();
  }
}

如果想深入可以看这篇分析源码的博客：深度剖析 JDK 动态代理机制

2、cglib代理

CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。

public class CglibProxy implements MethodInterceptor {
  //单例模式
  private static CglibProxy instance = new CglibProxy();
  public static CglibProxy getInstance(){
      return instance;
  }

  /**
   * 创建代理对象
   * @param cls 要代理的类
   * @param <T>
   * @return
   */
  public <T> T getProxy(Class<T> cls){
      return (T) Enhancer.create(cls, this);
  }

  public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
      System.out.println(">>>>MethodInterceptor start...");
      Object result = methodProxy.invokeSuper(obj,args);
      System.out.println(">>>>MethodInterceptor ending...");
      return result;
  }
}

public class CglibTarget {
  public String execute() {
      String message = "-----------test------------";
      System.out.println(message);
      return message;
  }
}

public class CglibTest {
  public static void main(String[] args) {
      CglibTarget proxy = CglibProxy.getInstance().getProxy(CglibTarget.class);
      proxy.execute();
  }
}