Java动态代理详解-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_42549792/article/details/99539885

动态代理的作用是，在不修改源码的基础上对方法增强。在Java中，实现动态代理的方式主要有两种，一种是利用JDK反射机制生成代理（基于接口的动态代理），另外一种是使用cglib代理（基于子类的动态代理），第一种必须要提供接口，而cglib则不需要，可以直接代理类，下面将举例说明两种代理类：

1.基于接口的动态代理

下面这样一个例子，生成生产厂家的代理对象（经销商）

接口类IProducer：有一个销售产品的方法

public interface IProducer {
    void saleProject(float money);
}

实现类Producer(被代理对象)生产厂家：

public class Producer implements IProducer{
    public void saleProject(float money){
        System.out.println("销售产品，拿到钱"+money);
    }
}

消费者Client：

涉及的类：Proxy
创建代理对象：使用Proxy类中的newProxyInstance方法
创建代理对象的要求：被代理类最少实现一个接口，如果没有则不能使用
newProxyInstance方法的参数：

ClassLoader：类加载器，它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器，固定写法
Class[]：字节码数组，它是用于让代理对象和被代理对象有相同方法，固定写法
InvocationHandler：用于提供增强的代码，它是让我们写如何代理。我们一般都是一些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的，例如 new InvocationHandler() ....

public class Client {
    public static void main(String[] args) {
        final Producer producer=new Producer();
        //基于接口的动态代理
        IProducer proxyProducer=(IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                /**
                 * 作用：执行被代理对象的任何接口方法都会经过该方法
                 * 方法参数的含义
                 * @param proxy   代理对象的引用
                 * @param method  当前执行的方法
                 * @param args    当前执行方法所需的参数
                 * @return        和被代理对象方法有相同的返回值
                 * @throws Throwable
                 */
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object rtValue=null;
                        //获取方法所得的参数
                        Float money=(Float) args[0];
                        //判断当前方法是不是销售
                        if ("saleProject".equals(method.getName())){
                            //拦截被代理对象中执行的所有方法
                            rtValue=method.invoke(producer, money*0.8f);
                        }
                        return rtValue;
                    }
                }); 
        //代理商销售产品，售价10000元
        proxyProducer.saleProject(10000f);
    }
}

执行结果：

2.基于子类的动态代理

导入cglib的jar包或者依赖：

 <dependencies>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>
    </dependencies>

生产者Producer:

public class Producer{
    public void saleProject(float money){
        System.out.println("销售产品，拿到钱"+money);
    }
}

消费者Client类：

涉及的类：Enhancer
如何创建代理对象：使用Enhancer类中的create方法
创建代理对象的要求：被代理类不能是最终类
create方法的参数：

Class：字节码，它是用于指定被代理对象的字节码
Callback：用于提供增强的代码，它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。此接口的实现类都是谁用谁写。我们一般写的都是该接口的子接口实现类：MethodInterceptor

public class Client {
    public static void main(String[] args) {
        final Producer producer=new Producer();
        //基于子类的动态代理
        Producer cglibProducer=(Producer)Enhancer.create(producer.getClass(),
                /**
                 * 执行被代理对象的任何方法都会经过该方法
                 * @param proxy
                 * @param method
                 * @param args
                 *    以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
                 * @param methodProxy ：当前执行方法的代理对象
                 * @return
                 * @throws Throwable
                 */
                new MethodInterceptor() {
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                Object rtValue=null;
                Float money=(Float) args[0];
                if ("saleProject".equals(method.getName())){
                    method.invoke(producer, money*0.8f);
                }
                return rtValue;
            }
        });
        cglibProducer.saleProject(10000f);
    }
}

执行结果：