当前位置： 首页 > news >正文

静态代理和JDK动态代理以及CGLIB动态代理

news 来源：原创 2024/11/27 21:36:08

代理模式是一种比较好的理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

静态代理

对目标对象（被代理对象）的每个方法都是手动增强的，一旦接口新增了方法，目标对象和代理对象都要进行修改，并且麻烦，需要对每个目标类都单独写一个代理类。

上面我们是从实现和应用角度来说的静态代理，从 JVM 层面来说， 静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的class 文件。

静态代理实现步骤:

  1. 定义一个接口及其实现类；

  2. 创建一个代理类同样实现这个接口

  3. 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

  4. 定义接口

package com.jxz.ProxyPattern.staticProxcy;


public interface SmsService {
    String send(String s);
}
  1. 实现接口
package com.jxz.ProxyPattern.staticProxcy;

public class SmsServiceImpl implements SmsService{
    @Override
    public String send(String s) {
        System.out.println("send message:"+s);
        return s;
    }
}
  1. 创建代理类并同样实现接口
package com.jxz.ProxyPattern.staticProxcy;
// 增强一样的方法，所以实现了接口，要达到相同的结果不实现也可以
// 需要对每个目标类（被代理类）都实现一个代理类
public class SmsServiceProxy implements SmsService{
    private final SmsService master;
    public SmsServiceProxy(SmsService smsService){
        // 将被代理的类传入进来
        master=smsService;
    }

    @Override
    public String send(String s) {
        System.out.println("before send");
        master.send(s);
        System.out.println("after send");
        return null;
    }

}
  1. 实际使用
package com.jxz.ProxyPattern.staticProxcy;

public class Main {
    public static void main(String[] args) {
        // 还是要创建被代理类
        SmsServiceImpl smsService = new SmsServiceImpl();
        // 将被代理类对象注入到代理类中，需要对每个目标类都写一个代理类
        SmsServiceProxy smsServiceProxy = new SmsServiceProxy(smsService);
        smsServiceProxy.send("I'm jiangxuzhao");
    }
}

输出结果：

before send
send message:I'm jiangxuzhao
after send

动态代理

从JVM层面来看，动态代理是在类运行时动态生成类字节码，并加载到JVM中。

JDK动态代理

JDK动态代理中InvocationHandler接口和Proxy类中的newProxyInstance方法是核心。

Proxy类中的静态方法newProxyInstance用来生成代理对象。

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h) {
        Objects.requireNonNull(h);

        @SuppressWarnings("removal")
        final Class<?> caller = System.getSecurityManager() == null
                                    ? null
                                    : Reflection.getCallerClass();

        /*
         * Look up or generate the designated proxy class and its constructor.
         */
        Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);

        return newProxyInstance(caller, cons, h);
    }

需要传入三个参数：

ClassLoader loader： 被代理类加载器，可以传入 target.getClass().getClassLoader()

interfaces：被代理类实现的接口，可以传入 target.getClass().getInterfaces()

InvocationHandler h： 实现InvocationHandler接口的对象，里面会通过重写invoke方法完成我们自定义的逻辑

InvocationHandler接口需要被一个我们自定义的类实现，并且实现其中的invoke方法，最终当我们的代理对象调用它的一个方法的时候，这个方法的调用就会被拦截转发到我们InvocationHandler接口实现类的invoke方法上。

public interface InvocationHandler {
  // 被实现类转发到这个方法上来，通常是利用反射增强原生对象的方法
   public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
  /*
  @CallerSensitive
    public static Object invokeDefault(Object proxy, Method method, Object... args)
            throws Throwable {
        Objects.requireNonNull(proxy);
        Objects.requireNonNull(method);
        return Proxy.invokeDefault(proxy, method, args, Reflection.getCallerClass());
    }
   */
}

invoke方法有三个参数：

  1. Object proxy：动态生成的代理类，不需要我们改动

  2. Method method：与目标类调用的方法相对应，可以通过Object result=method.invoke(target,args)反射调用实现增强

  3. Object[] args：调用传入的参数，可以通过Object result=method.invoke(target,args)反射调用实现增强

其中的流程为：

  1. 通过Proxy类中的静态方法newProxyInstance生成代理对象，其中传入了实现InvocationHandler接口的自定义类

  2. 实现InvocationHandler接口的自定义类需要重写invoke方法，并且由于是有参构造传入了原生对象（类似静态代理），可以在自定义类中通过反射method.invoke调用原生对象方法，达到功能增强。

  3. 后续只需要用这个代理对象去调用原先目标对象的方法就可以了，在外层调用方式不变的情况下，实现了功能的增强

JDK动态代理使用放在具体的例子中来看：

  1. 定义我们原先需要被增强的接口及其实现类

  2. 实现InvocationHandler接口的自定义类并且重写invoke方法，可以在自定义类中通过反射method.invoke调用原生对象方法，达到功能增强。

  3. 通过Proxy类中的静态方法newProxyInstance生成代理对象，其中传入了第二步实现了InvocationHandler接口的自定义类

  4. （这里可以用一个工厂类将 通过Proxy类中的静态方法newProxyInstance生成代理对象 的逻辑进行包装，并将代理对象返回）

  5. 生成的代理对象类型和接口类型相同，可以调用接口中声明的方法，但是效果已经被增强了

  6. 定义接口

package com.jxz.ProxyPattern.dynamicProxy.jdk;


public interface SmsService {
    String send(String s);
}
  1. 原生类实现接口
package com.jxz.ProxyPattern.dynamicProxy.jdk;

public class SmsServiceImpl implements SmsService {
    @Override
    public String send(String s) {
        System.out.println("send message:"+s);
        return s;
    }
}
  1. 实现InvocationHandler接口的自定义类并且重写invoke方法
package com.jxz.ProxyPattern.dynamicProxy.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class JXZInvocationHandler implements InvocationHandler {
    private final Object target; // 被代理类
    public JXZInvocationHandler(Object target){
        this.target=target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 实现方法增强
        System.out.println("before method:"+method.getName());
        Object result=method.invoke(target,args);
        System.out.println("after method:"+method.getName());
        return result;
    }
}
  1. 实现工厂类获取代理对象的
package com.jxz.ProxyPattern.dynamicProxy.jdk;

import com.jxz.ProxyPattern.staticProxcy.SmsService;

import java.lang.reflect.Proxy;

// 创建代理类工厂
public class JDKProxyFactory {
    // get方法中参数传入原先未被增强的对象,返回代理对象
    public static Object getProxy(Object target){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), //  被代理类的加载器
                target.getClass().getInterfaces(), // 被代理类实现的接口
                new JXZInvocationHandler(target) // 自定义实现`InvocationHandler接口`的对象
        );
    }
}
  1. 进行调用
package com.jxz.ProxyPattern.dynamicProxy.jdk;

public class Main {
    public static void main(String[] args) {
        // 从工厂中取出代理对象
        SmsService proxy = (SmsService)JDKProxyFactory.getProxy(new SmsServiceImpl());
        proxy.send("I'm jiangdazhao");
    }
}

输出结果：

before method:send
send message:I'm jiangdazhao
after method:send

CGLIB动态代理

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。

为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

CGLIB(Code Generation Library是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB，例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。

需要自定义一个类实现MethodInterceptor接口并且实现其中的intercept方法

package net.sf.cglib.proxy;

import java.lang.reflect.Method;

public interface MethodInterceptor extends Callback {
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable;
}

intercept方法三个参数：

  1. Object o：被代理的对象（需要被增强）
  2. Method method： 被拦截的方法（需要被增强）
  3. Object[] objects： 方法入参
  4. MethodProxy methodProxy：用于调用原始方法

CGLIB动态代理使用放在具体的例子中来看：

  1. 不同于JDK 动态代理不需要额外的依赖。CGLIB(Code Generation Library) 实际是属于一个开源项目，需要手动添加相关依赖。

  2. 只需要定义需要被增强的类，不需要接口

  3. 实现MethodInterceptor接口的自定义类并且重写intercept方法，intercept方法用于拦截且增强被代理类的方法，和JDK动态代理中的invoke方法类似。

  4. 通过创建动态代理增强类Enhancer和调用create()方法生成代理类

  5. （这里可以用一个工厂类将 通过动态代理增强类Enhancer和调用create()方法生成代理类 的逻辑进行包装，并将代理对象返回）

  6. 生成的代理对象类型和原来的类类型相同，可以调用原来类中的方法，但是效果已经被增强了

  7. 添加依赖

<dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>3.3.0</version>
 </dependency>
  1. 定义需要被增强的类
package com.jxz.ProxyPattern.dynamicProxy.cglib;

public class WeakService {
    public String send(String s){
        System.out.println("send msg:"+s);
        return s;
    }
}
  1. 实现MethodInterceptor接口的自定义类并且重写intercept方法
package com.jxz.ProxyPattern.dynamicProxy.cglib;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

// 自定义类实现MethodInterceptor接口
public class JXZMethodInterceptor implements MethodInterceptor {

    /**
     * 1. `Object o`：被代理的对象（需要被增强）
     * 2. `Method method`： 被拦截的方法（需要被增强）
     * 3. `Object[] objects`： 方法入参
     * 4. `MethodProxy methodProxy`：用于调用原始方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before send:"+method.getName());
        // 进行方法增强,`Method method`： 被拦截的方法（需要被增强）没有用在这一句上
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("after send:"+method.getName());
        return result;
    }
}
  1. 工厂类将 通过动态代理增强类Enhancer和调用create()方法生成代理类 的逻辑进行包装，并将代理对象返回
package com.jxz.ProxyPattern.dynamicProxy.cglib;

import net.sf.cglib.proxy.Enhancer;

//代理类工厂
public class CGLIBProxyFactory {
    // 返回代理对象
    public static Object getProxy(Object target){
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(target.getClass().getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(target.getClass());
        // 设置方法拦截器
        enhancer.setCallback(new JXZMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}
  1. 进行调用
package com.jxz.ProxyPattern.dynamicProxy.cglib;

public class Main {
    public static void main(String[] args) {
        WeakService weakService = (WeakService)CGLIBProxyFactory.getProxy(new WeakService());
        weakService.send("I'm jiangdazhao");
    }
}

其中在运行的过程中碰到jdk 19版本过高导致反射不可用的问题，在VM options中添加

--add-opens java.base/java.lang=ALL-UNNAMED

输出结果：

before send:send
send msg:I'm jiangdazhao
after send:send

JDK 动态代理和 CGLIB 动态代理对比

  1. JDK 动态代理只能只能代理实现了接口的类，而 CGLIB 可以代理未实现任何接口的类。另外，CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为final 类型的类和方法。
  2. 就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

静态代理和动态代理的对比

  1. 灵活性：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！
  2. JVM 层面：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到JVM 中的。

相关文章：

  • 网站品牌建设/seo首页排名优化
  • 网站换空间会影响排名吗/朋友圈营销
  • 学完html的收获感受/郑州seo公司排名
  • 用腾讯云服务器做网站/千锋教育前端学费多少
  • 商丘做网站sqlongliqi/查询收录
  • wordpress php7 兼容/精准营销推广
  • 【信息系统项目管理师】论文写作心得整理篇
  • 85.机器翻译与数据集
  • 【p2p】初识Safire 基于 libnice 的 World wide parment system
  • （小甲鱼python）函数笔记合集四 函数(IV)总结 函数中参数的作用域 局部作用域 全局作用域 global语句 嵌套函数 nonlocal语句等详解
  • pytorch【Conv2d参数介绍】
  • 初学者C语言练习题-入门
  • 跨境电商必知：这7种实用的保留策略，可以有效减少客户流失
  • 激光雷达对植被冠层结构和SIF同时探测展望
  • 代码随想录算法训练营第七天 | 454.四数相加II ，383. 赎金信 ，15. 三数之和，18. 四数之和
  • Go map 实现原理
  • 致 Tapdata 开源贡献者：聊聊 2022 年的进展和新一年的共建计划
  • Node.js+Vue.js全栈开发王者荣耀手机端官网和管理后台(二) || 后台及接口完结篇