java动态代理详细介绍

最新推荐文章于 2025-03-18 22:45:31 发布
最新推荐文章于 2025-03-18 22:45:31 发布
阅读量1k 收藏 19
点赞数 31
分类专栏： spring boot java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_47874230/article/details/145200147
版权

java动态代理详细介绍

1.动态代理概述

        动态代理（Dynamic Proxy）是指在运行时动态地生成代理对象的技术，通常用于为目标对象提供额外的功能，比如日志、事务管理、权限控制等。与静态代理不同，静态代理在编译时已经确定代理类，而动态代理则是在程序运行时动态生成代理类，能够有效减轻代码的重复性。

动态代理的主要作用：

  • 增强功能：可以为目标对象添加附加功能（例如日志记录、性能统计、安全控制等）。
  • 解耦：使得业务逻辑和增强功能分离，增加代码的可维护性。
  • 灵活性：代理类可以在运行时动态生成，不需要手动创建。

什么叫运行期动态创建？听起来好像很复杂。所谓动态代理，是和静态相对应的。我们来看静态代码怎么写：

  1. 定义接口
public interface Hello {
    void morning(String name);
}
  1. 编写实现类
public class HelloImpl implements Hello {
    public void morning(String name) {
        System.out.println("Good morning, " + name);
    }
}
  1. 创建实例，转型为接口并调用
Hello hello = new HelloImpl();
hello.morning("Bob");

        这种方式就是我们通常编写代码的方式。
        还有一种方式是动态代码，我们仍然先定义了接口Hello，但是我们并不去编写实现类，而是直接通过JDK提供的一个Proxy.newProxyInstance()创建了一个Hello接口对象。
        这种没有实现类但是在运行期动态创建了一个接口对象的方式，我们称为动态代码。JDK提供的动态创建接口对象的方式，就叫动态代理。
一个最简单的动态代理实现如下：

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

public class Main {
    public static void main(String[] args) {
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method);
                if (method.getName().equals("morning")) {
                    System.out.println("Good morning, " + args[0]);
                }
                return null;
            }
        };
        Hello hello = (Hello) Proxy.newProxyInstance(
            Hello.class.getClassLoader(), // 传入ClassLoader
            new Class[] { Hello.class }, // 传入要实现的接口
            handler); // 传入处理调用方法的InvocationHandler
        hello.morning("Bob");
    }
}

interface Hello {
    void morning(String name);
}

在运行期动态创建一个interface实例的方法如下：

  1. 定义一个InvocationHandler实例，它负责实现接口的方法调用；
  2. 通过Proxy.newProxyInstance()创建interface实例，它需要3个参数：
    1. 使用的ClassLoader，通常就是接口类的ClassLoader；
    2. 需要实现的接口数组，至少需要传入一个接口进去；
    3. 用来处理接口方法调用的InvocationHandler实例。
  3. 将返回的Object强制转型为接口。

动态代理实际上是JVM在运行期动态创建class字节码并加载的过程，把上面的动态代理改写为静态实现类大概就是下面Java中的动态代理的实现。

2.Java中的动态代理

Java 提供了两种方式来实现动态代理：

  1. JDK 动态代理（基于接口）
  2. CGLIB 动态代理（基于继承）

2.1 JDK 动态代理

JDK 动态代理是通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来实现的。使用 JDK 动态代理时，代理对象需要实现至少一个接口。代理对象会在运行时根据接口生成。
主要类和接口：

  • java.lang.reflect.Proxy：用于创建代理实例。
  • java.lang.reflect.InvocationHandler：处理被代理对象方法调用的接口。

JDK 动态代理示例

2.1.1 定义接口

public interface UserService {
    void addUser(String userName);
    void deleteUser(String userName);
}

2.1.2 定义接口实现类

public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String userName) {
        System.out.println("User " + userName + " added.");
    }

    @Override
    public void deleteUser(String userName) {
        System.out.println("User " + userName + " deleted.");
    }
}

2.1.3 创建 InvocationHandler 实现类

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

public class UserServiceInvocationHandler implements InvocationHandler {
    private Object target;

    public UserServiceInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Method " + method.getName() + " is invoked with arguments: " + args[0]);
        
        // 调用目标对象的方法
        Object result = method.invoke(target, args);
        
        System.out.println("Method " + method.getName() + " executed.");
        
        return result;
    }
}

2.1.4 创建代理对象并测试

import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args) {
        // 创建目标对象
        UserService userService = new UserServiceImpl();

        // 创建 InvocationHandler
        UserServiceInvocationHandler handler = new UserServiceInvocationHandler(userService);

        // 创建代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                handler);

        // 调用代理对象的方法
        proxy.addUser("John");
        proxy.deleteUser("John");
    }
}

解释：

  1. 目标对象：UserServiceImpl ，它实现了 UserService 接口，实际的业务逻辑类。
  2. InvocationHandler：UserServiceInvocationHandler 是对目标对象的代理处理类。它会拦截对目标对象方法的调用，在方法执行前后添加自己的逻辑。
  3. 代理对象：通过 Proxy.newProxyInstance 动态创建的代理对象。该代理对象会通过 InvocationHandler 来执行方法。
  4. 方法执行：通过代理对象调用目标对象的方法时，实际上是由 InvocationHandler 来处理，代理对象在方法调用前后可以执行额外的操作。

2.2 CGLIB 动态代理

        CGLIB 动态代理通过字节码技术，在运行时生成一个目标类的子类，并重写其中的方法。CGLIB 代理不要求目标类实现接口，因此它适用于没有接口的类。
主要类：

  • net.sf.cglib.proxy.Enhancer：用于创建代理类。
  • net.sf.cglib.proxy.MethodInterceptor：用于拦截目标对象的方法调用。
    CGLIB 动态代理示例
    引入依赖
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.12</version> <!-- 你可以根据需要选择其他版本 -->
        </dependency>

2.2.1 定义目标类

public class UserService {
    public void addUser(String userName) {
        System.out.println("User " + userName + " added.");
    }

    public void deleteUser(String userName) {
        System.out.println("User " + userName + " deleted.");
    }
}

2.2.2 创建 MethodInterceptor 实现类

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

import java.lang.reflect.Method;

public class UserServiceInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Method " + method.getName() + " is invoked with arguments: " + args[0]);
        
        // 调用目标对象的方法
        Object result = proxy.invokeSuper(obj, args);
        
        System.out.println("Method " + method.getName() + " executed.");
        
        return result;
    }
}

2.2.3 创建代理对象并测试

import net.sf.cglib.proxy.Enhancer;

public class ProxyTest {
    public static void main(String[] args) {
        // 创建目标对象
        UserService userService = new UserService();

        // 创建 MethodInterceptor
        UserServiceInterceptor interceptor = new UserServiceInterceptor();

        // 创建 CGLIB 代理对象
        UserService proxy = (UserService) Enhancer.create(UserService.class, interceptor);

        // 调用代理对象的方法
        proxy.addUser("John");
        proxy.deleteUser("John");
    }
}

解释：

  1. 目标对象：UserService 类，定义了业务方法。
  2. MethodInterceptor：UserServiceInterceptor 实现了 MethodInterceptor 接口，用于在方法执行前后添加自定义逻辑。
  3. 代理对象：Enhancer.create 创建了 UserService 类的代理对象，代理对象会通过 MethodInterceptor 来处理方法调用。

2.3 主要区别

特性JDK 动态代理CGLIB 动态代理
代理对象类型必须是接口类型生成目标类的子类
适用场景适用于目标类实现了接口的情况适用于目标类没有实现接口的情况
性能相比 CGLIB 更快，且不需要依赖第三方库生成子类，性能相对较慢，且需要依赖 CGLIB 库
使用限制只能代理接口类型可以代理任何类（不需要接口）
生成的代理类动态生成实现接口的类动态生成目标类的子类
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
Java动态代理
itmyhome的专栏
09-26 1914
代理模式： 代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。 代理的实现分为 静态代理：代理类是在编译时就实现好的，也就是说Java编译完成后代理类是一个实际的class文件 动态代理：代理类是在运行时生成的，也就是说Java编译完之后并没有实际的class文件，而
Java的动态代理
qq_33708803的博客
03-31 368
Java提供了动态代理,,即程序运行时动态创建代理类的.class. 来看一下动态代理： JDK动态代理中包含一个类和一个接口： InvocationHandler接口： 代表代理对象关联的处理代码 public interface InvocationHandler { public Object invoke(Object proxy,Method method,O
Java 代理模式详解
最新发布
宋发元
03-18 939
代理模式是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。简单来说，代理对象包装了真实对象，在调用真实对象的方法前后可以添加额外的处理逻辑，比如日志、权限校验、事务处理等。远程代理：控制对远程对象的访问，如 RMI 代理。虚拟代理：延迟加载或按需加载大对象。安全代理：在访问前进行权限检查。缓存代理：对请求结果进行缓存。AOP（面向切面编程）：在方法调用前后织入额外逻辑（日志、事务等）。静态代理在编译期间就已经确定了代理类，并且代理类和目标类通常都实现相同的接口。
java的动态代理
weixin_42595206的博客
06-07 211
java动态代理
java动态代理
热门推荐
飞！！！的博客
12-28 5万+
前段时间去学习了一下RPC原理，其中提到了动态代理。特意去学习了一下，为了防止以后忘记，写下这篇博客做个记录，有不对的地方欢迎指正。 java中的常见的动态代理如Spring AOP。关于动态代理首先需要了解代理模式，根据代理类的创建时间又可以分为静态代理和动态代理。 1、代理模式 代理模式是常见的设计模式之一，Java我们通常通过new一个对象然后调用其对应的方法来访问我们需要的服务。代理模式则...
Java 动态代理详解（学习资料）
06-17
这里不再详细介绍 CGLIB 的具体实现，因为它相比 JDK 动态代理更为复杂，需要额外的库支持。总结Java 动态代理为我们提供了在运行时创建代理对象的能力，减少了代码的冗余，提高了代码的灵活性。JDK 动态代理适用于...
Java动态代理语法Proxy类原理详解
08-19
本文将详细介绍Java动态代理语法Proxy类原理的实现机制和示例代码。 一、Proxy类原理 Proxy类是Java动态代理语法的核心类，它提供了一个静态方法newProxyInstance，该方法可以动态创建代理对象。newProxyInstance...
Java设计模式——代理设计模式（静态代理和动态代理）
04-15
下面我们将详细介绍静态代理的实现方式： 1. **定义接口**：首先，我们需要定义一个业务接口，这个接口会定义真实对象需要实现的方法，例如`Service`接口： ```java public interface Service { void ...
Java简单实现动态代理模式过程解析
08-18
主要介绍了Java动态代理模式简单案例代码,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java中的动态代理
xingfuyisheng的专栏
10-30 1180
Java中的动态代理
动态代理----------------架构师的必备武器
Caesar Home
02-21 340
代理模式 为其他对象提供一个代理以控制对某个对象的访问。代理类主要负责为委托了（真实对象）预处理消息、过滤消息、传递消息给委托类，代理类不现实具体服务，而是利用委托类来完成服务，并将执行结果封装处理。 其实就是代理类为被代理类预处理消息、过滤消息并在此之后将消息转发给被代理类，之后还能进行消息的后置处理。代理类和被代理类通常会存在关联关系(即上面提到的持有的被带离对象的引用)，代理类本身不实现...
Java 动态代理详解
小旋锋 的博客
12-21 2836
博客原文：http://laijianfeng.org/2018/12/Java-动态代理详解/ 动态代理在Java中有着广泛的应用，比如Spring AOP、Hibernate数据查询、测试框架的后端mock、RPC远程调用、Java注解对象获取、日志、用户鉴权、全局性异常处理、性能监控，甚至事务处理等。 本文主要介绍Java中两种常见的动态代理方式：JDK原生动态代理和CGLIB动态代理。...
java中的动态代理
记录开发日常笔记
04-26 1345
1、动态代理流程图 在运行状态中，需要代理的地方，根据 Subject 和 RealSubject，动态地创建一个 Proxy，用完之后，就会销毁，这样就可以避免了 Proxy 角色的 class 在系统中冗杂的问题了。 动态代理步骤： 获取 RealSubject 上的所有接口列表； 确定要生成的代理类的类名，默认为：com.sun.proxy.$ProxyXXXX； 根据需要实现的接口信息，在代码中动态创建 该 Proxy 类的字节码； 将对应的字节码转换为对应的 class 对象； 创建 Invo
Java动态代理详解
一个喜欢诗和远方的程序媛
06-19 657
JDK动态代理：适用于实现了接口的类，通过InvocationHandler处理代理逻辑。CGLIB动态代理：适用于没有实现接口的类，通过继承实现代理，使用MethodInterceptor处理代理逻辑。性能更优。动态代理在AOP（面向切面编程）、拦截器、权限控制、事务管理等领域有广泛应用，提供了灵活的方式来在运行时增强对象行为。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值