《深入浅出Spring》JDK动态代理和CGLIB

猿一一

已于 2022-07-14 00:16:52 修改

阅读量284

点赞数

分类专栏： Spring 文章标签： spring 代理模式 java

于 2022-06-14 00:02:51 首次发布

本文链接：https://blog.csdn.net/ysj_2021/article/details/125269311

版权

静态代理

有一个接口IService，如下：

package com.yuan11.proxy;

/**
 * @title: IService
 * @Author yuan11
 * @Date: 2022/6/13 22:58
 * @Version 1.0
 */
public interface IService {
    void m1();
    void m2();
    void m3();
}

以及实现类：

package com.yuan11.proxy;

/**
 * @title: ServiceA
 * @Author yuan11
 * @Date: 2022/6/13 22:58
 * @Version 1.0
 */
public class ServiceA implements IService {
    @Override
    public void m1() {
        System.out.println("我是ServiceA中的m1方法!");
    }
    @Override
    public void m2() {
        System.out.println("我是ServiceA中的m2方法!");
    }
    @Override
    public void m3() {
        System.out.println("我是ServiceA中的m3方法!");
    }
}

package com.yuan11.proxy;

/**
 * @title: ServiceB
 * @Author yuan11
 * @Date: 2022/6/13 22:58
 * @Version 1.0
 */
public class ServiceB implements IService {
    @Override
    public void m1() {
        System.out.println("我是ServiceB中的m1方法!");
    }

    @Override
    public void m2() {
        System.out.println("我是ServiceB中的m2方法!");
    }

    @Override
    public void m3() {
        System.out.println("我是ServiceB中的m3方法!");
    }
}

调用测试：

package com.yuan11.proxy;

/**
 * @title: ProxyTest
 * @Author yuan11
 * @Date: 2022/6/13 22:59
 * @Version 1.0
 */
public class ProxyTest {
    public static void main(String[] args) {
        m1();
    }
    public static void m1() {
        IService serviceA = new ServiceA();
        IService serviceB = new ServiceB();
        serviceA.m1();
        serviceA.m2();
        serviceA.m3();
        serviceB.m1();
        serviceB.m2();
        serviceB.m3();
    }
}

上面是我们原本的程序，突然领导有个需求：调用IService接口中的任何方法的时候，需要记录方法的耗时。

此时你会怎么做呢？

IService接口有2个实现类ServiceA和ServiceB，我们可以在这两个类的所有方法中加上统计耗时的代码，如果IService接口有几十个实现，是不是要修改很多代码，所有被修改的方法需重新测试？是不是非常痛苦，不过上面这种修改代码的方式倒是可以解决问题，只是增加了很多工作量（编码 & 测试）。

突然有一天，领导又说，要将这些耗时统计发送到监控系统用来做监控报警使用。

此时是不是又要去一个修改上面的代码？又要去测试？此时的系统是难以维护。

还有假如上面这些类都是第三方以jar包的方式提供给我们的，此时这些类都是class文件，此时我们无法去修改源码。

比较好的方式：可以为IService接口创建一个代理类，通过这个代理类来间接访问IService接口的实现类，在这个代理类中去做耗时及发送至监控的代码，代码如下：

package com.yuan11.proxy;

/**
 * @title: ServiceProxy
 * @Author yuan11
 * @Date: 2022/6/13 23:03
 * @Version 1.0
 */
// IService的代理类
public class ServiceProxy implements IService {
    //目标对象，被代理的对象
    private IService target;
    public ServiceProxy(IService target) {
        this.target = target;
    }
    @Override
    public void m1() {
        long starTime = System.nanoTime();
        this.target.m1();
        long endTime = System.nanoTime();
        System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
    }
    @Override
    public void m2() {
        long starTime = System.nanoTime();
        this.target.m1();
        long endTime = System.nanoTime();
        System.out.println(this.target.getClass() + ".m2()方法耗时(纳秒):" + (endTime - starTime));
    }
    @Override
    public void m3() {
        long starTime = System.nanoTime();
        this.target.m1();
        long endTime = System.nanoTime();
        System.out.println(this.target.getClass() + ".m3()方法耗时(纳秒):" + (endTime - starTime));
    }
}

erviceProxy是IService接口的代理类，target为被代理的对象，即实际需要访问的对象，也实现了IService接口，上面的3个方法中加了统计耗时的代码，当我们需要访问IService的其他实现类的时候，可以通过ServiceProxy来间接的进行访问，用法如下：

 public static void serviceProxy() {
   
        IService serviceA = new ServiceProxy(new ServiceA());//@1
        IService serviceB = new ServiceProxy(new ServiceB()); //@2
        serviceA.m1();
        serviceA.m2();
        serviceA.m3();
        serviceB.m1();
        serviceB.m2();
        serviceB.m3();
    }

上面实现中我们没有去修改ServiceA和ServiceB中的方法，只是给IService接口创建了一个代理类，通过代理类去访问目标对象，需要添加的一些共有的功能都放在代理中，当领导有其他需求的时候，我们只需修改ServiceProxy的代码，方便系统的扩展和测试。

假如现在我们需要给系统中所有接口都加上统计耗时的功能，若按照上面的方式，我们需要给每个接口创建一个代理类，此时代码量和测试的工作量也是巨大的，那么我们能不能写一个通用的代理类，来满足上面的功能呢？
`
通用代理的2种实现：

jdk动态代理
cglib代理``

JDK 动态代理

jdk中为实现代理提供了支持，主要用到2个类：

java.lang.reflect.Proxy
java.lang.reflect.InvocationHandler

jdk自带的代理使用上面有个限制，只能为接口创建代理类，如果需要给具体的类创建代理类，需要用后面要说的cglib

java.lang.reflect.Proxy

这是jdk动态代理中主要的一个类，里面有一些静态方法会经常用到，我们来熟悉一下：

getProxyClass方法
为指定的接口创建代理类，返回代理类的Class对象

public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces)

参数说明：

loader：定义代理类的类加载器

interfaces：指定需要实现的接口列表，创建的代理默认会按顺序实现interfaces指定的接口

newProxyInstance方法
创建代理类的实例对象

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

这个方法先为指定的接口创建代理类，然后会生成代理类的一个实例，最后一个参数比较特殊，是InvocationHandler类型的，这个是个借口如下：

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

上面方法会返回一个代理对象，当调用代理对象的任何方法的时候，会就被InvocationHandler接口的invoke方法处理，所以主要代码需要写在invoke方法中，稍后会有案例细说。

isProxy方法
判断指定的类是否是一个代理类

public static boolean isProxyClass(Class<?> cl)

getInvocationHandler方法
获取代理对象的InvocationHandler对象

public static InvocationHandler getInvocationHandler(Object proxy)
        throws IllegalArgumentException

上面几个方法大家熟悉一下，下面我们来看创建代理具体的2种方式。

创建代理：方式一

步骤
1.调用Proxy.getProxyClass方法获取代理类的Class对象
2.使用InvocationHandler接口创建代理类的处理器
3.通过代理类和InvocationHandler创建代理对象
4.上面已经创建好代理对象了，接着我们就可以使用代理对象了

JDK代理创建IService的代理对象

public void m1() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
   
        // 1. 获取接口对应的代理类
        Class<IService> proxyClass = (Class<IService>) Proxy.getProxyClass(IService.class.getClassLoader(), IService.class);
        // 2. 创建代理类的处理器
        InvocationHandler invocationHandler = new InvocationHandler() {
   
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
                System.out.println("我是InvocationHandler，被调用的方法是：" + method.getName());
                return null;
            }
        };
        // 3. 创建代理实例
        IService proxyService = proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);
        // 4. 调用代理的方法
        proxyService.m1();
        proxyService.m2();
        proxyService.m3();
    }

运行结果如下：
在这里插入图片描述

创建代理：方式二

创建代理对象有更简单的方式。

步骤
1.使用InvocationHandler接口创建代理类的处理器
2.使用Proxy类的静态方法newProxyInstance直接创建代理对象
3.使用代理对象

public void m2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
   
        // 1. 创建代理类的处理器
        InvocationHandler invocationHandler = new InvocationHandler() {
   
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
                System.out.println("我是InvocationHandler，被调用的方法是：" + method.getName());
                return null;
            }
        };
        // 2. 创建代理实例
        IService proxyService = (IService) Proxy.newProxyInstance(IService.class.getClassLoader(), new Class[]{
   IService.class}, invocationHandler);
        // 3. 调用代理的方法
        proxyService.m1();
        proxyService.m2();
        proxyService.m3();
    }

运行结果和上例子一样、

栗子：任意接口中的方法耗时统计

下面我们通过jdk动态代理实现一个通用的代理，解决统计所有接口方法耗时的问题。

主要的代码在代理处理器InvocationHandler实现上面，如下：

package com.yuan11.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class CostTimeInvocationHandler implements InvocationHandler {
   
    private Object target;
    public CostTimeInvocationHandler(Object target) {
   
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        long starTime = System.nanoTime();