Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-r1-0528· DeepSeekHugging Face LMArena Human Preference 140K

java动态代理讲解

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-30b-a3b’s answer.
  1. User

    java动态代理讲解

  2. DeepSeek Assistant

    Java 动态代理详解

    动态代理是 Java 中一种运行时动态生成代理对象的技术,无需手动编写代理类。它基于接口实现,通过反射机制在运行时创建代理类,常用于 AOP(面向切面编程)、日志记录、事务管理等场景。


    核心组件

    1. java.lang.reflect.Proxy
      主类,提供创建动态代理的静态方法:

      static Object newProxyInstance(ClassLoader loader, 
                                     Class<?>[] interfaces, 
                                     InvocationHandler h)
      
    2. java.lang.reflect.InvocationHandler
      接口,实现代理逻辑:

      Object invoke(Object proxy, Method method, Object[] args)
      

    实现步骤

    1. 定义接口

      public interface UserService {
          void addUser(String name);
          void deleteUser(String id);
      }
      
    2. 实现真实对象

      public class UserServiceImpl implements UserService {
          @Override
          public void addUser(String name) {
              System.out.println("添加用户: " + name);
          }
          
          @Override
          public void deleteUser(String id) {
              System.out.println("删除用户: " + id);
          }
      }
      
    3. 实现 InvocationHandler

      public class LogHandler implements InvocationHandler {
          private final Object target; // 真实对象
          
          public LogHandler(Object target) {
              this.target = target;
          }
          
          @Override
          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
              System.out.println("[日志] 调用方法: " + method.getName());
              Object result = method.invoke(target, args); // 调用真实对象的方法
              System.out.println("[日志] 方法执行完毕");
              return result;
          }
      }
      
    4. 创建动态代理

      public class Main {
          public static void main(String[] args) {
              // 1. 创建真实对象
              UserService realService = new UserServiceImpl();
              
              // 2. 创建调用处理器
              InvocationHandler handler = new LogHandler(realService);
              
              // 3. 动态生成代理对象
              UserService proxy = (UserService) Proxy.newProxyInstance(
                  realService.getClass().getClassLoader(), // 类加载器
                  realService.getClass().getInterfaces(),   // 实现的接口
                  handler                                  // 调用处理器
              );
              
              // 4. 通过代理对象调用方法
              proxy.addUser("张三"); 
              proxy.deleteUser("1001");
          }
      }
      

    输出结果

    [日志] 调用方法: addUser
    添加用户: 张三
    [日志] 方法执行完毕
    [日志] 调用方法: deleteUser
    删除用户: 1001
    [日志] 方法执行完毕
    

    关键特性

    1. 基于接口
      被代理对象必须实现至少一个接口(JDK 动态代理的限制)。

    2. 运行时生成
      代理类在运行时动态生成,可通过 System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true") 保存生成的代理类到文件(文件名如 $Proxy0.class)。

    3. 统一拦截
      所有方法调用均通过 InvocationHandler.invoke() 转发,便于统一处理横切关注点(如日志、事务)。


    动态代理 vs 静态代理

    特性动态代理静态代理
    实现方式运行时自动生成代理类手动编写代理类
    代码量少(复用逻辑)多(每个代理类需单独编写)
    维护性高(修改 InvocationHandler 即可)低(需修改每个代理类)
    接口要求必须基于接口可不依赖接口

    典型应用场景

    1. Spring AOP
      基于动态代理实现方法拦截和增强。
    2. RPC 框架
      动态生成远程服务调用的客户端代理。
    3. 事务管理
      在方法调用前后自动开启/提交事务。
    4. 权限校验
      统一拦截方法进行权限检查。

    注意事项

    1. 只能代理接口方法
      非接口方法(如 Object 中的 toString())不会被代理(除非在接口中声明)。

    2. 性能开销
      反射调用比直接调用略慢(现代 JVM 已优化,影响较小)。

    3. 绕过代理
      目标对象内部方法相互调用时,this.xxx() 不会触发代理逻辑(需通过 AOP 上下文获取代理对象)。


    扩展:CGLIB 代理

    若需代理无接口的类,可使用 CGLIB 库(基于字节码生成):

    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(TargetClass.class);
    enhancer.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) {
            // 增强逻辑
            return proxy.invokeSuper(obj, args);
        }
    });
    TargetClass proxy = (TargetClass) enhancer.create();
    

    总结

    Java 动态代理通过 Proxy + InvocationHandler 在运行时动态创建代理对象,实现了解耦和逻辑复用,是 AOP 和框架设计的核心基础。掌握其原理能更好地理解 Spring 等框架的工作机制。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.