动态代理讲解（2020.7.16）

动态代理 (2020.7.16)

特点：随用随创建，随用随加载
作用：在不修改源码的基础上对现有的方法进行增强
分类：基于接口的动态代理和基于子类的动态代理
首先我们给一个特定的场景来介绍动态代理，假设有一个电脑生产商producer它要销售电脑，那么就有一个Producer类和sale方法：

public class Producer  {

    public int sale(int money) {
        System.out.println("卖出电脑一台获取利润" + money);
        return money;
    }
}

如果生产厂商卖出一台电脑给消费者，那么就可以获取利润：

  public static void main(String[] args) {
        Producer producer = new Producer();

        producer.sale(1000);
        }

但是现实生活中，我们都知道我们买电脑是不会到电脑生产的厂家去买电脑的，一定是去商城中，也就是电脑的经销商那里去买电脑，现在的要求就是不改变原来生产商的代码的基础上，要进行电脑利润的划分，就是对卖出电脑这个方法进行增强，这里就需要使用我们的动态代理。让用户付的钱一部分给电脑厂商，一部分给经销商。
下面介绍两种动态代理方式以及他们是如何实现的。

Proxy动态代理

它是基于接口的动态代理，是JDK自带的，不需要额外的jar包。它要求被代理对象至少实现一个接口，否则就不能使用此种动态代理的方式。（这里实现一个Iproducer接口，定义了一个厂家的规范）。

         *  基于接口的动态代理：
         *      涉及的类：Proxy
         *      提供者：JDK官方
         *  如何创建代理对象：
         *      使用Proxy类中的newProxyInstance方法
         *  创建代理对象的要求：
         *      被代理类最少实现一个接口，如果没有则不能使用
         *  newProxyInstance方法的参数：
         *      ClassLoader：类加载器
         *          它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
         *      Class[]：字节码数组
         *          它是用于让代理对象和被代理对象有相同方法。固定写法。
         *      InvocationHandler：用于提供增强的代码
         *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
         *          此接口的实现类都是谁用谁写。

其中需要注意的就是被代理对象每个方法的执行都会通过invoke方法，它起到一个拦截器的作用，我们就在invoke方法中对原有方法进行增强。其中的参数的含义分别是：
/
* 作用：执行被代理对象的任何接口方法都会经过该方法
* 方法参数的含义
* @param proxy 代理对象的引用
* @param method 当前执行的方法
* @param args 当前执行方法所需的参数
* @return 和被代理对象方法有相同的返回值
* @throws Throwable
/*
配合下面的代码更好理解，在main函数中模拟一个消费者消费的过程：

public class Client {

    public static void main(String[] args) {
        final Producer producer = new Producer();


       IProducer producer_proxy =  (IProducer)Proxy.newProxyInstance(producer.getClass().getClassLoader(), producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        int resultValue = 0;
                        int money = (int) args[0];
                        if (method.getName().equals("sale")) {
                            resultValue = (int) method.invoke(producer, money/2);
                        }
                        return resultValue;
                    }

                });

       producer_proxy.sale(500);
    }
}

cglib 动态代理

它是基于子类的动态代理，当被代理对象没有实现一个接口的时候，并且不是最终类的时候，就可以使用该种动态代理模式。

     *  基于子类的动态代理：
     *      涉及的类：Enhancer
     *      提供者：第三方cglib库
     *  如何创建代理对象：
     *      使用Enhancer类中的create方法
     *  创建代理对象的要求：
     *      被代理类不能是最终类
     *  create方法的参数：
     *      Class：字节码
     *          它是用于指定被代理对象的字节码。
     *
     *      Callback：用于提供增强的代码
     *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
     *          此接口的实现类都是谁用谁写。
     *          我们一般写的都是该接口的子接口实现类：MethodInterceptor
     */

和基于接口的动态代理一样inctercept方法也是一个拦截器的作用

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

        final Producer producer = new Producer();

        IProducer producer_cglib = (IProducer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                int resultValue = 0;
                int money = (int) objects[0];
                if (method.getName().equals("sale")) {
                    resultValue = (int) method.invoke(producer, money/2);
                }
                return resultValue;
            }
        });

        producer_cglib.sale(1000);
    }

注意事项

• 动态代理代理的是对象，例如上面例子中的producer，增强的是对象中的方法
• 动态代理不是无用的，我们常用的动态代理解决问题有，线程池中的close，因为线程池关闭的时候线程是要回到线程中的不是在底层注销，可以用动态代理的方法来实现。
• Spring中的AOP技术就是通过动态代理来实现的，大大简化代码的书写，不改变我们写的代码的基础上对代码进行增强。