Java 代理模式详解

宋发元2025-03-19 14:42

Java 代理模式详解

下面是一篇详细的教程，介绍 Java 代理模式的基本概念、静态代理和动态代理的实现方式、动态代理的分类、各自的应用场景、优缺点以及如何选择合适的代理方案，并说明 Spring 框架中如何使用这两种代理技术。

1. 什么是代理模式

代理模式是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。简单来说，代理对象包装了真实对象，在调用真实对象的方法前后可以添加额外的处理逻辑，比如日志、权限校验、事务处理等。

应用场景：

  • 远程代理：控制对远程对象的访问，如 RMI 代理。
  • 虚拟代理：延迟加载或按需加载大对象。
  • 安全代理：在访问前进行权限检查。
  • 缓存代理：对请求结果进行缓存。
  • AOP（面向切面编程）：在方法调用前后织入额外逻辑（日志、事务等）。

2. 静态代理

2.1 静态代理概述

静态代理在编译期间就已经确定了代理类，并且代理类和目标类通常都实现相同的接口。代理类内部持有目标对象的引用，并在方法调用时先执行额外逻辑，再调用目标对象的方法。

2.2 静态代理示例

下面是一个简单的静态代理示例，假设有一个 Service 接口及其实现类 RealService，代理类 StaticProxy 在调用目标方法前后增加日志记录：

java 复制代码 
// 定义目标接口
public interface Service {
    void doSomething();
}

// 目标类，实现业务逻辑
public class RealService implements Service {
    @Override
    public void doSomething() {
        System.out.println("RealService: 执行实际业务逻辑...");
    }
}

// 静态代理类，实现相同接口
public class StaticProxy implements Service {
    // 持有目标对象的引用
    private final Service target;

    public StaticProxy(Service target) {
        this.target = target;
    }

    @Override
    public void doSomething() {
        // 前置增强逻辑
        System.out.println("StaticProxy: 前置处理...");
        // 调用目标对象的方法
        target.doSomething();
        // 后置增强逻辑
        System.out.println("StaticProxy: 后置处理...");
    }
}

// 测试静态代理
public class StaticProxyTest {
    public static void main(String[] args) {
        Service realService = new RealService();
        Service proxy = new StaticProxy(realService);
        proxy.doSomething();
    }
}

2.3 静态代理的优缺点

优点：

  • 实现简单，容易理解。
  • 能够在不修改目标类代码的前提下增强功能。

缺点：

  • 每个目标类都需要对应一个代理类，类的数量会迅速增加（类爆炸）。
  • 静态代理在编译期确定，灵活性较低，不适用于大量、动态变化的场景。

3. 动态代理

动态代理在运行时根据需要创建代理对象，代理类不需要在编译期间提前定义，而是通过反射或字节码生成技术动态生成。

3.1 动态代理分类

动态代理主要有两种实现方式：

  1. JDK 动态代理
    • 原理： 利用 Java 反射机制，在运行时生成实现了目标接口的代理类。
    • 限制： 目标类必须实现接口。
    • 实现方式： 使用 java.lang.reflect.Proxy 和 InvocationHandler。
  2. CGLIB 动态代理
    • 原理： 通过字节码操作技术生成目标类的子类，然后重写目标方法。
    • 限制： 不能代理 final 类和 final 方法。
    • 实现方式： 使用 CGLIB 库（底层基于 ASM），在 Spring 中经常使用。

此外，还有一些其他字节码操作库（如 Javassist、ByteBuddy 等），但在日常开发中最常用的是 JDK 动态代理和 CGLIB 动态代理。

3.2 JDK 动态代理示例

当目标类实现了接口时，可以使用 JDK 动态代理。下面是一个示例：

java 复制代码 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定义目标接口
public interface Service {
    void doSomething();
}

// 目标类
public class RealService implements Service {
    @Override
    public void doSomething() {
        System.out.println("RealService: 执行实际业务逻辑...");
    }
}

// 动态代理处理器，实现 InvocationHandler 接口
public class JdkDynamicProxy implements InvocationHandler {
    // 持有目标对象引用
    private final Object target;

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

    // 代理对象调用方法时，会执行此方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强逻辑
        System.out.println("JDK动态代理: 前置处理...");
        // 调用目标方法
        Object result = method.invoke(target, args);
        // 后置增强逻辑
        System.out.println("JDK动态代理: 后置处理...");
        return result;
    }
}

// 测试 JDK 动态代理
public class JdkDynamicProxyTest {
    public static void main(String[] args) {
        // 目标对象
        Service realService = new RealService();
        // 创建动态代理对象
        Service proxy = (Service) Proxy.newProxyInstance(
            realService.getClass().getClassLoader(),
            realService.getClass().getInterfaces(),
            new JdkDynamicProxy(realService)
        );
        // 调用代理对象方法
        proxy.doSomething();
    }
}

优点：

  • 代理类在运行时动态生成，避免了类爆炸问题。
  • 代码更加灵活，可以统一处理增强逻辑。

缺点：

  • 只能代理实现了接口的目标类。
  • 基于反射，可能有一定性能损耗（不过 JDK 1.8 后已经有不少优化）。

3.3 CGLIB 动态代理示例

当目标类没有实现接口时，可以使用 CGLIB 动态代理。下面是一个示例：

java 复制代码 
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

// 目标类（没有实现接口）
public class RealService {
    public void doSomething() {
        System.out.println("RealService: 执行实际业务逻辑...");
    }
}

// CGLIB 代理实现类，实现 MethodInterceptor 接口
public class CglibDynamicProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 前置增强逻辑
        System.out.println("CGLIB动态代理: 前置处理...");
        // 调用目标方法（通过调用父类方法）
        Object result = proxy.invokeSuper(obj, args);
        // 后置增强逻辑
        System.out.println("CGLIB动态代理: 后置处理...");
        return result;
    }
}

// 测试 CGLIB 动态代理
public class CglibDynamicProxyTest {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        // 设置需要代理的目标类
        enhancer.setSuperclass(RealService.class);
        // 设置回调方法
        enhancer.setCallback(new CglibDynamicProxy());
        // 创建代理对象
        RealService proxy = (RealService) enhancer.create();
        // 调用代理对象方法
        proxy.doSomething();
    }
}

优点：

  • 不需要目标类实现接口，可以代理任意普通类。
  • 直接操作字节码，性能较高。

缺点：

  • 不能代理 final 类和 final 方法，因为 CGLIB 通过继承方式生成代理类。
  • 需要引入第三方依赖（CGLIB 库）。

4. 动态代理的应用场景和选择

4.1 动态代理的应用场景

  • 面向切面编程（AOP）： 在方法调用前后织入日志、事务、安全、缓存等额外逻辑。
  • 远程方法调用（RPC）： 动态生成客户端代理，实现调用远程服务的方法。
  • 懒加载（Lazy Loading）： 只有在真正调用方法时才初始化加载目标对象。
  • 权限控制： 在调用方法前进行权限检查，阻止非法调用。

4.2 如何选择代理方式

  • 目标类是否实现接口？
    • 如果实现了接口，优先使用 JDK 动态代理，因为它简单、无需额外依赖。
    • 如果没有实现接口，则使用 CGLIB 动态代理。
  • 是否需要更高的性能？
    • CGLIB 由于直接操作字节码，在某些场景下性能会更好，但大部分情况下性能差异不会太大。
  • 是否存在 final 方法或 final 类？
    • 如果目标类或方法被声明为 final，则不能使用 CGLIB 代理，必须使用 JDK 动态代理（前提是目标类实现了接口）。
  • 代码维护和扩展性：
    • 动态代理能够统一增强逻辑，避免静态代理中类爆炸的问题，适合大量相似逻辑的增强处理。

5. Spring 中的代理使用

Spring 框架广泛使用代理模式来实现 AOP、事务管理、缓存等功能。其代理选择策略主要有以下几点：

5.1 Spring AOP 代理

  • JDK 动态代理：
    • 使用场景： 当目标对象实现了接口时，Spring 默认采用 JDK 动态代理。
    • 特点： 代理对象仅实现目标接口，调用时会先进入 InvocationHandler，然后执行增强逻辑。
    • 示例： 当你在 Spring 中定义 @Transactional 或 @Aspect 切面时，如果目标类实现了接口，Spring AOP 会生成一个 JDK 动态代理对象。
  • CGLIB 代理：
    • 使用场景： 当目标对象没有实现任何接口时，Spring 会自动采用 CGLIB 代理。
    • 特点： 生成目标类的子类来实现代理，但不能对 final 类或 final 方法进行代理。
    • 示例： 如果你在 Spring 中的 Bean 没有实现接口，且配置了切面逻辑，则 Spring AOP 会选择 CGLIB 来创建代理。

5.2 其他 Spring 模块

  • Spring Remoting： 使用代理模式包装远程服务调用。
  • Spring Data/JPA： 也会通过代理来实现懒加载、事务管理等功能。

Spring 的代理选择主要依赖于目标对象的特性以及配置策略，开发者可以通过设置 proxy-target-class（例如在 XML 配置或注解配置中）来强制使用 CGLIB 代理。

6. 总结

在本教程中，我们详细介绍了：

  1. 代理模式 的概念及其在实际开发中的应用场景。

  2. 静态代理

    ：

    • 由开发者在编译期写好的代理类。
    • 优点是实现简单，但缺点是类爆炸和灵活性差。

  3. 动态代理

    ：

    • 运行时生成代理类，主要分为 JDK 动态代理和 CGLIB 动态代理。
    • JDK 动态代理依赖接口，适合接口实现；CGLIB 通过继承实现，适合没有接口的场景，但受限于 final 修饰。

  4. 如何选择

    ：

    • 根据目标类是否实现接口、是否有 final 限制、性能要求等因素选择合适的代理方式。

  5. Spring 中的使用

    ：

    • Spring AOP 默认采用 JDK 动态代理，如果没有接口则回退到 CGLIB 代理。
    • 其他模块（如远程调用、事务管理）也广泛使用代理模式实现功能增强。

理解这些代理模式及其实现原理，不仅能帮助你设计更加解耦和灵活的系统，还能帮助你更深入地理解 Spring 框架的底层实现机制。

相关推荐
心向阳光的天域9 分钟前
黑马跟学.苍穹外卖.Day08
java·spring boot
无名之逆10 分钟前
Hyperlane：Rust 语言打造的 Web 后端框架新标杆
开发语言·前端·网络·网络协议·rust·github·ssl
lsx20240612 分钟前
Ruby 字符串（String）
开发语言
崔婉凝13 分钟前
Ruby语言的工业物联网
开发语言·后端·golang
没明白白40 分钟前
结构型模式之桥接模式：解耦抽象和实现
java·网络·桥接模式
Aomnitrix1 小时前
Qt 实操记录:打造自己的“ QQ 音乐播放器”
开发语言·c++·qt·ui·音视频
Liii4031 小时前
Java学习——数据库查询操作
java·数据库·学习
色楠不哭1 小时前
python包filterpy安装失败ModuleNotFoundError: No module named ‘filterpy‘
开发语言·python
PXM的算法星球1 小时前
Java爬虫抓取B站视频信息
java·windows·爬虫
爱康代码2 小时前
【c语言数组精选代码题】
c语言·开发语言·数据结构
热门推荐
01命令行方式将mysql数据库迁移到达梦数据库（全步骤）02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03DeepSeek各版本说明与优缺点分析04本地部署DeepSeek教程（Mac版本）05如何在WPS和Word/Excel中直接使用DeepSeek功能06本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程07四大AI编程工具组合测评08DeepSeek RAGFlow构建本地知识库系统09DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具10LLM主流框架：Causal Decoder、Prefix Decoder和Encoder-Decoder