Spring系列第十五讲 Spring中的Java动态代理技术(上)

超、凢脫俗 2022-12-18 04:57 171阅读 0赞

### Spring系列第十五讲 ###

*  为什么要用代理
 *  jdk动态代理详解
 *   *  java.lang.reflect.Proxy
     *   *  getProxyClass方法
         *  newProxyInstance方法
         *  isProxy方法
         *  getInvocationHandler方法
 *  创建代理：方式一
 *  创建代理：方式二
 *  案例：任意接口中的方法耗时统计
 *  Proxy使用注意

# 为什么要用代理 #

我们先来看一个案例。

有一个接口IService，如下：

package com.javacode2018.lesson001.demo15;
    
    public interface IService {
        
        void m1();
        void m2();
        void m3();
    }

接口有2个实现类ServiceA和ServiceB，如下：

package com.javacode2018.lesson001.demo15;
    
    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.javacode2018.lesson001.demo15;
    
    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.javacode2018.lesson001.demo15;
    
    import org.junit.Test;
    
    public class ProxyTest {
        
        @Test
        public void m1() {
        
            IService serviceA = new ServiceA();
            IService serviceB = new ServiceB();
            serviceA.m1();
            serviceA.m2();
            serviceA.m3();
    
            serviceB.m1();
            serviceB.m2();
            serviceB.m3();
        }
    }

上面的代码很简单，就不解释了，我们运行一下m1()方法，输出：

我是ServiceA中的m1方法!
    我是ServiceA中的m2方法!
    我是ServiceA中的m3方法!
    我是ServiceA中的m1方法!
    我是ServiceA中的m2方法!
    我是ServiceA中的m3方法!

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

此时你会怎么做呢？

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

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

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

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

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

package com.javacode2018.lesson001.demo15;
    
    // 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() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
        }
    
        @Override
        public void m3() {
        
            long starTime = System.nanoTime();
            this.target.m1();
            long endTime = System.nanoTime();
            System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
        }
    }

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

@Test
    public 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();
    }

上面代码重点在于@1和@2，创建的是代理对象ServiceProxy，ServiceProxy构造方法中传入了被代理访问的对象，现在我们访问ServiceA或者ServiceB，都需要经过ServiceProxy，运行输出：

我是ServiceA中的m1方法!
    class com.javacode2018.lesson001.demo15.ServiceA.m1()方法耗时(纳秒):90100
    我是ServiceA中的m1方法!
    class com.javacode2018.lesson001.demo15.ServiceA.m1()方法耗时(纳秒):31600
    我是ServiceA中的m1方法!
    class com.javacode2018.lesson001.demo15.ServiceA.m1()方法耗时(纳秒):25800
    我是ServiceB中的m1方法!
    class com.javacode2018.lesson001.demo15.ServiceB.m1()方法耗时(纳秒):142100
    我是ServiceB中的m1方法!
    class com.javacode2018.lesson001.demo15.ServiceB.m1()方法耗时(纳秒):35000
    我是ServiceB中的m1方法!
    class com.javacode2018.lesson001.demo15.ServiceB.m1()方法耗时(纳秒):32900

上面实现中我们没有去修改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.上面已经创建好代理对象了，接着我们就可以使用代理对象了

案例

先来个接口IService

package com.javacode2018.lesson001.demo16;
    
    public interface IService {
        
        void m1();
        void m2();
        void m3();
    }

创建IService接口的代理对象

@Test
    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();
    }

运行输出

我是InvocationHandler，被调用的方法是：m1
    我是InvocationHandler，被调用的方法是：m2
    我是InvocationHandler，被调用的方法是：m3

# 创建代理：方式二 #

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

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

案例

@Test
    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();
    }

运行输出：

我是InvocationHandler，被调用的方法是：m1
    我是InvocationHandler，被调用的方法是：m2
    我是InvocationHandler，被调用的方法是：m3

# 案例：任意接口中的方法耗时统计 #

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

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

package com.javacode2018.lesson001.demo16;
    
    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();
            Object result = method.invoke(this.target, args);//@1
            long endTime = System.nanoTime();
            System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
            return result;
        }
    
        /**
         * 用来创建targetInterface接口的代理对象
         *
         * @param target          需要被代理的对象
         * @param targetInterface 被代理的接口
         * @param <T>
         * @return
         */
        public static <T> T createProxy(Object target, Class<T> targetInterface) {
        
            if (!targetInterface.isInterface()) {
        
                throw new IllegalStateException("targetInterface必须是接口类型!");
            } else if (!targetInterface.isAssignableFrom(target.getClass())) {
        
                throw new IllegalStateException("target必须是targetInterface接口的实现类!");
            }
            return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new CostTimeInvocationHandler(target));
        }
    }

上面主要是createProxy方法用来创建代理对象，2个参数：

target：目标对象，需要实现targetInterface接口

targetInterface：需要创建代理的接口

invoke方法中通过method.invoke(this.target, args)调用目标方法，然后统计方法的耗时。

测试用例

@Test
    public void costTimeProxy() {
        
        IService serviceA = CostTimeInvocationHandler.createProxy(new ServiceA(), IService.class);
        IService serviceB = CostTimeInvocationHandler.createProxy(new ServiceB(), IService.class);
        serviceA.m1();
        serviceA.m2();
        serviceA.m3();
    
        serviceB.m1();
        serviceB.m2();
        serviceB.m3();
    }

运行输出

我是ServiceA中的m1方法!
    class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):61300
    我是ServiceA中的m2方法!
    class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):22300
    我是ServiceA中的m3方法!
    class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):18700
    我是ServiceB中的m1方法!
    class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):54700
    我是ServiceB中的m2方法!
    class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):27200
    我是ServiceB中的m3方法!
    class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):19800

我们再来的接口，也需要统计耗时的功能，此时我们无需去创建新的代理类即可实现同样的功能，如下：

IUserService接口

package com.javacode2018.lesson001.demo16;
    
    public interface IUserService {
        
        /**
         * 插入用户信息
         * @param name
         */
        void insert(String name);
    }

IUserService接口实现类：

package com.javacode2018.lesson001.demo16;
    
    public class UserService implements IUserService {
        
        @Override
        public void insert(String name) {
        
            System.out.println(String.format("用户[name:%s]插入成功!", name));
        }
    }

测试用例

@Test
    public void userService() {
        
        IUserService userService = CostTimeInvocationHandler.createProxy(new UserService(), IUserService.class);
        userService.insert("路人甲Java");
    }

运行输出：

用户[name:路人甲Java]插入成功!
    class com.javacode2018.lesson001.demo16.UserService.m1()方法耗时(纳秒):193000

上面当我们创建一个新的接口的时候，不需要再去新建一个代理类了，只需要使用CostTimeInvocationHandler.createProxy创建一个新的代理对象就可以了，方便了很多。

# Proxy使用注意 #

1.  jdk中的Proxy只能为接口生成代理类，如果你想给某个类创建代理类，那么Proxy是无能为力的，此时需要我们用到下面要说的cglib了。
2.  Proxy类中提供的几个常用的静态方法大家需要掌握
3.  通过Proxy创建代理对象，当调用代理对象任意方法时候，会被InvocationHandler接口中的invoke方法进行处理，这个接口内容是关键

发表评论取消回复

表情：

评论列表（有 0 条评论，171人围观）

还没有评论，来说两句吧...

相关阅读

相关 Spring AOP中的动态代理技术解析

Spring的aop实现主要应用了JDK动态代理和Cglib动态代理这2种代理。 org.springframework.aop.framework.JdkDy

亦凉/ 2024年03月16日 22:03/ 0 赞/ 56 阅读

相关 Spring5系列(十) | 动态代理底层实现

我们在上面的几篇文章中已经了解了如何使用spring进行aop的开发，本篇文章我们来介绍一下动态代理的底层实现。一. AOP编程概念 AOP: Aspect

小灰灰/ 2023年01月13日 14:56/ 0 赞/ 105 阅读

相关 Spring系列第十七讲深入理解Java注解及Spring对注解的增强（上）

Spring系列第十七讲什么是注解？注解如何使用？定义注解定义注解语法注解中定义参数指定注解的

阳光穿透心脏的1/2处/ 2022年12月21日 06:28/ 0 赞/ 113 阅读

相关 Spring系列第十六讲 Spring中的Java动态代理技术(下)

Spring系列第十六讲什么是cglib cglib组成结构 5个案例来演示cglib常见的用法案例1：拦截所有方法（MethodInt

蔚落/ 2022年12月18日 04:57/ 0 赞/ 177 阅读

相关 Spring系列第十五讲 Spring中的Java动态代理技术(上)

Spring系列第十五讲为什么要用代理 jdk动态代理详解 java.lang.reflect.Proxy getProxy

超、凢脫俗/ 2022年12月18日 04:57/ 0 赞/ 172 阅读

相关 Java Spring静态代理、动态代理

文章目录静态代理动态代理代理类：ProxyInvocation. java 即代理角色接口类： Rent.java 即抽象角

待我称王封你为后i/ 2022年12月04日 05:28/ 0 赞/ 186 阅读

相关 Spring5系列(九) | spring动态代理详解

上篇文章中，我们了解了Spring动态代理的实现和一些细节，但其实主要都是讲的如何使用。今天我们更深一步，简单说说里边的一些实现原理，和切入点表达式的一些其他写法。一.

超、凢脫俗/ 2022年11月18日 10:49/ 0 赞/ 273 阅读

相关 Spring5系列(八) | 静态代理和spring动态代理

从本篇文章开始我们就要开始研究spring的第二大特性AOP了，也就是面向切面编程。在java开发过程中，我们把我们具体要实现的业务方法，可以称之为核心功能，比如注册，登陆，

迈不过友情╰/ 2022年11月18日 02:14/ 0 赞/ 155 阅读

相关 Java基础加强第六讲动态代理技术(上)——动态代理入门

动态代理简单入门动态代理技术在实际开发中用到的非常多，所以有必要详解一下这门技术。这门技术非常难，因此学起来还是比较困难的，但我们不怕困难，定要啃下这块硬骨头。要想理解

刺骨的言语ヽ痛彻心扉/ 2022年09月26日 03:53/ 0 赞/ 208 阅读

相关 spring中的动态代理

一.背景介绍之前介绍了动态代理的两种方式 jdk动态代理:[https://blog.csdn.net/qq\_24516549/article/details/8

不念不忘少年蓝@/ 2022年04月24日 01:50/ 0 赞/ 356 阅读