Java的动态代理(DynamicProxy)

代理的概述

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

代理模式UML图：

为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。

动态代理的使用场景

动态代理的好处是它比较灵活，可以在运行的时候才切入改变类的方法，而不需要预先定义它。

动态代理一般我们比较少去手写，但我们用得其实非常多。

在Spring项目中用的注解，例如依赖注入的@Bean、@Autowired，事务注解@Transactional等都有用到，

换言之就是Srping的AOP（切面编程）。

这种场景的使用是动态代理最佳的落地点，可以非常灵活地在某个类，某个方法，某个代码点上切入我们想要的内容，就是动态代理其中的内容。

静态代理

代理类和被代理类 实现同一个接口

缺点就是一个代理类只能针对一个接口

 package Proxy.staticProxy;

 /**
  * 创建Person接口
  */
 public interface Person {
     // 交钱的方法
     void giveMoney();
 }

package Proxy.staticProxy;

/**
 * 需要代理的对象：
 * 
 * 学生类
 */
public class Student implements Person {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void giveMoney() {

        System.out.println(name + "交保护费50");
    }
}

 package Proxy.staticProxy;

 /**
  * 学生代理类，也实现了Person接口，保存一个学生实体，这样既可以代理学生产生行为
  */
 public class StudentsProxy implements Person {

     //被代理的学生
     Student stu;

     public StudentsProxy(Person stu) {
         //只代理学生对象
         if (stu.getClass() == Student.class) {
             this.stu = (Student) stu;
         }
     }

     //代理上交保护费，调用被代理学生的交保护费行为
     @Override
     public void giveMoney() {
         stu.giveMoney();
     }
 }

 package Proxy.staticProxy;

 public class StaticProxyTest {
     public static void main(String[] args) {

         Person zhangsan = new Student("张三");
         Person moneitor = new StudentsProxy(zhangsan);
         moneitor.giveMoney();
         /**
          * 运行结果：
          *
          * 张三交保护费50
          */
     }
 }

动态代理

动态代理分为两种 jdk 和 cglib

jdk

jdk 代理主要用到了

接口InvocationHandler 此接口只有一个方法（代码如下）

InvocationHandler的实现类可以理解成具体的代理实现

类Proxy

生成代理的具体的操作类，可以为一个or多个接口动态的实现代理类

缺点 就是被代理的类必须是接口的实现类（依赖于接口）,

如果某些类没有实现接口 则不能用jdk代理

 package Proxy.DynamicProxy.JDKProxy;

 /**
  * 目标接口
  */
 public interface UserManager {

     public void addUser(String name ,String password);
     public void detUser(String name);
 }

 package Proxy.DynamicProxy.JDKProxy;

 public class UserManagerImpl implements UserManager {
     @Override
     public void addUser(String id, String password) {
         System.out.println("调用了UserManagerImpl.addUser()方法");
     }

     @Override
     public void detUser(String id) {
         System.out.println("调用了UserManagerImpl.detUser()的方法");
     }
 }

 package Proxy.DynamicProxy.JDKProxy;

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;

 /**
  * JDK动态代理类
  */
 public class JDKDynamicProxy implements InvocationHandler {
     //需要代理的目标对象
     private Object targetObject;

     public Object newProxy(Object targetObject) {
         //将目标对象传入进行代理
         this.targetObject = targetObject;
         //将代理对象返回 //其中有三个参数
         return Proxy.newProxyInstance(
                 targetObject.getClass().getClassLoader(),
                 targetObject.getClass().getInterfaces(),
                 this);
     }

     // invoke 测试方法
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

         // 代理前 ：逻辑处理的方法(函数)
         checkPopedom();
         Object reflect = null;
         // 调用invoke()
         reflect = method.invoke(targetObject, args);
         // 代理后：
         isOK();
         return reflect;
     }

     private void isOK() {
         System.out.println("权限通过：isOK()");
     }

     private void checkPopedom() {
         System.out.println("检查权限：checkPopedom()");
     }

 }

 package Proxy.DynamicProxy.JDKProxy;

 /**
  * 测试类
  *
  */
 public class JDKDynamicProxyTest {
     public static void main(String[] args) {

         JDKDynamicProxy jdkDynamicProxy = new JDKDynamicProxy();
         //JDK动态代理对象传入一个需要代理的对象 然后用需要代理的对象接收就OK啦
         UserManager userManagerJDK = (UserManager) jdkDynamicProxy.newProxy(new UserManagerImpl());
         userManagerJDK.addUser("tom","root");
         userManagerJDK.addUser("jeck","root");
         /**
          * 运行结果：
          * 检查权限：checkPopedom()
          * 调用了UserManagerImpl.addUser方法
          * 权限通过：isOK()
          * 检查权限：checkPopedom()
          * 调用了UserManagerImpl.addUser方法
          * 权限通过：isOK()
          */
     }
 }

cglib

原理是针对target类 生成一个子类 覆盖方法实现增强

缺点 基于继承 无法代理final类(final类无法被继承，如String)

需要的jar包 ：asm-3.3.1，cglib-2.2.jar ps:jar包版本不同可能会报错

详细情况请看：www.cnblogs.com/cruze/p/3865180.html#lable1

参看文献：

https://shifulong.iteye.com/blog/2166770

https://www.cnblogs.com/gonjan-blog/p/6685611.html

http://blog.jobbole.com/104433/

https://baike.baidu.com/item/动态代理类/5087985?fr=aladdin