夯实spring(十五):java动态代理与CGLIB代理

青旅半醒 2024-03-24 19:31 74阅读 0赞

spring中用到代理的很多，比如上篇文章中的lookup-method和replaced-method，以及后面要学的aop、spring中的事务、spring中解析@configuration注解等等，这些都是依靠代理来实现的，所以现在来把代理学一下。

#### 1，为什么要用代理 ####

看一个案例

public interface Service {
        
        void m1();
        void m2();
    }

public class Service1 implements Service {
        
        @Override
        public void m1() {
        
            System.out.println("我是Service1中的m1方法!");
        }
        @Override
        public void m2() {
        
            System.out.println("我是Service1中的m2方法!");
        }
    }

public class Service2 implements Service{
        
        @Override
        public void m1() {
        
            System.out.println("我是Service2中的m1方法!");
        }
        @Override
        public void m2() {
        
            System.out.println("我是Service2中的m2方法!");
        }
    
    }

测试输出

public class Main {
        
        public static void main(String[] args) {
        
            Service1 service1 = new Service1();
            service1.m1();
            service1.m2();
    
            Service2 service2 = new Service2();
            service2.m1();
            service2.m2();
            
        }
    }

我是Service1中的m1方法!
    我是Service1中的m2方法!
    我是Service2中的m1方法!
    我是Service2中的m2方法!

上面的代码很简单。现在我们**需要调用IService接口中的任何方法的时候，需要记录方法的耗时**。

> Service接口有2个实现类Service1和Service2，我们可以在这两个类的所有方法中加上统计耗时的代码，但是如果Service接口有几十个实现，是不是要修改很多代码，所有被修改的方法需重新测试？是不是非常麻烦，不过上面这种修改代码的方式倒是可以解决问题，只是增加了很多工作量（编码 & 测试）
> 
> 但是突然有一天需求又改了。 此时是不是又要去一个修改上面的代码？又要去测试？此时的系统是难以维护。  
> 还有假如上面这些类都是第三方以jar包的方式提供给我们的，此时这些类都是class文件，此时我们无法去修改源码。

我们可以为Service接口创建一个代理类，通过这个代理类来间接访问IService接口的实现类，在这个代理类中去做耗时及或其他需求的代码。

public class ServiceProxy implements Service{
        
        //被代理的对象
        private Service target;
    
        public ServiceProxy(Service 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.m2();
            long endTime = System.nanoTime();
            System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
        }
    }

此时测试输出

public class Main {
        
        public static void main(String[] args) {
        
            Service1 service1 = new Service1();
            Service2 service2 = new Service2();
            Service proxy1 = new ServiceProxy(service1);
            Service proxy2 = new ServiceProxy(service2);
            
            proxy1.m1();
            proxy1.m2();
            
            proxy2.m1();
            proxy2.m2();
    
        }
    }

我是Service1中的m1方法!
    class com.chen.netty.ss.Service1.m1()方法耗时(纳秒):284900
    我是Service1中的m2方法!
    class com.chen.netty.ss.Service1.m1()方法耗时(纳秒):43200
    我是Service2中的m1方法!
    class com.chen.netty.ss.Service2.m1()方法耗时(纳秒):31000
    我是Service2中的m2方法!
    class com.chen.netty.ss.Service2.m1()方法耗时(纳秒):20000

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

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

#### 2，jdk动态代理详解 ####

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

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

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

使用方式：

public class JdkProxy {
        
        public static void main(String[] args) {
        
            // 1. 创建代理类的处理器,执行被代理类的方法都会经过这个方法
            InvocationHandler proxyHandler = new InvocationHandler() {
        
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
                    System.out.println("InvocationHandler#invoke:"+method.getName());
                    return null;
                }
            };
    
            // 2. 创建代理实例，注意
            Service proxyService = (Service) Proxy.newProxyInstance(Service.class.getClassLoader(), new Class[]{
        Service.class}, proxyHandler);
    
            //3. 调用代理的方法
            proxyService.m1();
            proxyService.m2();
    
        }
    }

InvocationHandler#invoke:m1
    InvocationHandler#invoke:m2

//newProxyInstance参数说明
    	ClassLoader loader  类加载器
    	Class<?>[] interfaces  需要代理的接口数组，你需要给哪些接口创建代理
    	InvocationHandler h  代理处理器，即你需要怎么实现代理
        public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)

现在为上面的使用jdk动态代理创建代理

public class computeTimeInvocationHandler implements InvocationHandler {
        
    
        private Object target;
    
        public computeTimeInvocationHandler(Object target) {
        
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            long starTime = System.nanoTime();
            Object invoke = method.invoke(target, args);
            long endTime = System.nanoTime();
             System.out.println(this.target.getClass() + method.getName() +"方法耗时(纳秒):" + (endTime - starTime));
            return invoke;
        }
    
        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 computeTimeInvocationHandler(target));
        }
    }

public class Main {
        
        public static void main(String[] args) {
        
            Service1 service1 = new Service1();
            Service proxy = computeTimeInvocationHandler.createProxy(service1, Service.class);
            proxy.m1();
            proxy.m2();
    
        }
    }

我是Service1中的m1方法!
    class com.chen.netty.ss.Service1m1方法耗时(纳秒):191900
    我是Service1中的m2方法!
    class com.chen.netty.ss.Service1m2方法耗时(纳秒):30900

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

public class Main {
        
        public static void main(String[] args) {
        
            Service2 service2 = new Service2();
            Service proxy = computeTimeInvocationHandler.createProxy(service2, Service.class);
            proxy.m1();
            proxy.m2();
    
        }
    }

我是Service2中的m1方法!
    class com.chen.netty.ss.Service2m1方法耗时(纳秒):158300
    我是Service2中的m2方法!
    class com.chen.netty.ss.Service2m2方法耗时(纳秒):31100

小结：

>  *  jdk中的Proxy只能为接口生成代理类，如果你想给某个类创建代理类，那么Proxy是不可以的，此时需要用到cglib了。
>  *  通过Proxy创建代理对象，当调用代理对象任意方法时候，会被InvocationHandler接口中的invoke方法进行处理，这个接口方法内容是最重要的。

#### 3，cglib代理 ####

jdk动态代理只能为接口创建代理，使用上有局限性。实际的场景中我们的类不一定有接口，此时如果我们想为普通的类也实现代理功能，我们就需要用到cglib来实现了。

cglib是一个强大、高性能的字节码生成库，它用于在运行时扩展Java类和实现接口；本质上它是通过动态的生成一个子类去覆盖所要代理的类（非final修饰的类和方法）。Enhancer可能是CGLIB中最常用的一个类，和jdk中的Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（包括从Object中继承的toString和hashCode方法）。Enhancer不能够拦截final方法，例如Object.getClass()方法，这是由于Java final方法语义决定的。同样，Enhancer也不能对final类进行代理操作。

spring已将第三方cglib jar包中所有的类集成到springjar包中，我们可以在spring依赖中直接使用。

使用：

public interface Service {
        
        void m1();
        void m2();
    }

public class CglibMain {
        
        public static void main(String[] args) {
        
            //使用Enhancer来给某个类创建代理类，步骤
            //1.创建Enhancer对象
            Enhancer enhancer = new Enhancer();
            //2.通过setSuperclass来设置父类型，即需要给哪个类创建代理类
            enhancer.setSuperclass(Service1.class);
            /*3.设置回调，需实现org.springframework.cglib.proxy.Callback接口，
            此处我们使用的是org.springframework.cglib.proxy.MethodInterceptor，也是一个接口，实现了Callback接口，
            当调用代理对象的任何方法的时候，都会被MethodInterceptor接口的invoke方法处理*/
            enhancer.setCallback(new MethodInterceptor() {
        
                /**
                 * 代理对象方法拦截器
                 * @param o 代理对象
                 * @param method 被代理的类的方法，即Service1中的方法
                 * @param objects 调用方法传递的参数
                 * @param methodProxy 方法代理对象
                 * @return
                 * @throws Throwable
                 */
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        
                    System.out.println("调用方法:" + method);
                    //可以调用MethodProxy的invokeSuper调用被代理类的方法
                    Object result = methodProxy.invokeSuper(o, objects);
                    //Object result = method.invoke(o,objects);
                    return result;
                }
            });
            //4.获取代理对象,调用enhancer.create方法获取代理对象，这个方法返回的是Object类型的，所以需要强转一下
            Service1 proxy = (Service1) enhancer.create();
            //5.调用代理对象的方法
            proxy.m1();
            proxy.m2();
        }
    }

> Object result = methodProxy.invokeSuper(o,objects);可以调用被代理类，也就是Service1类中的具体的方法，意思可以看出是调用父类，实际对某个类创建代理，cglib底层通过修改字节码的方式为Service1类创建了一个子类。

调用方法:public void com.chen.netty.ss.Service1.m1()
    我是Service1中的m1方法!
    调用方法:public void com.chen.netty.ss.Service1.m2()
    我是Service1中的m2方法!

> 从输出中可以看出Service1中的2个方法都被MethodInterceptor中的invoke拦截处理了。

总结：

>  *  Java动态代理只能够对接口进行代理，不能对普通的类进行代理（因为所有生成的代理类的父类为Proxy，Java类继承机制不允许多重继承）；CGLIB能够代理普通类；
>  *  Java动态代理使用Java原生的反射API进行操作，在生成类上比较高效；CGLIB使用ASM框架直接对字节码进行操作，在类的执行过程中比较高效

发表评论取消回复

表情：

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

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

相关阅读

相关夯实spring(十五):java动态代理与CGLIB代理

spring中用到代理的很多，比如上篇文章中的lookup-method和replaced-method，以及后面要学的aop、spring中的事务、spring中解析@con

青旅半醒/ 2024年03月24日 19:31/ 0 赞/ 75 阅读

相关 cglib动态代理(cglib动态代理实现原理)

关于java动态代理和cglib动态代理的区别 JDK动态代理要求被代理的类必须实现一个接口，而CGLIB代理不要求被代理类实现某个接口，CGLIG代理则是给代理类生成一

- 日理万妓/ 2023年09月26日 13:50/ 0 赞/ 268 阅读

相关 JDK动态代理与CGLIB动态代理

JDK动态代理和CGLIB动态代理是SpringAOP非常重要的两个概念，SpringAOP是通过生成目标对象的代理类来实现对目标对象的增强，在说JDK的动态代理之前我们先来回

你的名字/ 2023年06月27日 05:44/ 0 赞/ 38 阅读

相关 Spring——Cglib动态代理

CGLIB动态代理 CGLIB（Code Generation Library）是一个高性能开源的代码生成包，采用非常底层的字节码技术，对指定的目标类生成一个子类，并对子

╰+哭是因爲堅強的太久メ/ 2022年11月30日 04:17/ 0 赞/ 205 阅读

相关 java动态代理——CGLIB

1.使用场景：JDK中所要进行动态代理的类必须要实现一个接口，也就是说只能对该类所实现接口中定义的方法进行代理，这在实际编程中具有一定的局限性，而且使用反射的效率也并不是很高。

忘是亡心i/ 2022年06月02日 10:08/ 0 赞/ 254 阅读

相关 JDK动态代理与Cglib动态代理

一、前言 `AOP`(Aspect Oriented Programming)，即`面向切面编程`，最主要的思想就是纵向重复，横向抽取。要想实现AOP，其底层实现是使用了

旧城等待，/ 2022年05月30日 09:27/ 0 赞/ 346 阅读

相关静态代理，动态代理，CGLIB动态代理

静态代理，动态代理，CGLIB动态代理概述静态代理动态代理原理分析 CGLIB代理原理分析 JDK和CGL

清疚/ 2022年02月01日 08:29/ 0 赞/ 486 阅读

相关动态代理（CGLIB 动态代理）

动态代理：代理类在程序运行时被创建，这种代理方式称为动态代理动态代理实现有两种方式，JDK 动态代理和 CGlib 动态代理，本文介绍 CGlib 动态代理 CGLib

﹏ヽ暗。殇╰゛Y/ 2022年02月01日 08:21/ 0 赞/ 422 阅读

相关动态代理基本使用（JDK动态代理与CGLib 动态代理）

JDK 动态代理使用反射机制在方法执行过程中动态地添加功能 Java 实现动态代理主要涉及以下几个类： java.lang.reflect.Proxy: 这是生成

小咪咪/ 2021年10月19日 02:00/ 0 赞/ 448 阅读

相关 Java动态代理与CGLIB动态代理实现原理

动态代理的实现原理什么是代理模式静态代理静态代理的不足 JDK动态代理 JDK动态代理小结 CGLIB动态代理

川长思鸟来/ 2021年09月23日 00:22/ 0 赞/ 425 阅读