结构型设计模式深度解析：代理模式（Proxy）实战

本文还有配套的精品资源，点击获取

简介：代理模式作为结构型设计模式的重要组成部分，主要用于通过代理对象控制对目标对象的访问。其常见用途包括远程代理、虚拟代理、安全代理和智能引用等。本内容系统讲解了代理模式的核心角色（目标对象、代理对象和客户端）、实现方式（静态代理与动态代理）以及在Java中的具体实现机制。同时，结合实际应用场景，如权限控制、日志记录、缓存策略等，展示了代理模式在软件架构设计中的灵活性与扩展性。通过学习，开发者可掌握如何在不修改原有对象的前提下，增强系统功能并提升安全性。

1. 代理模式概述与分类

代理模式是一种常用的结构型设计模式，其核心在于为对象访问提供间接控制机制，从而实现对访问过程的增强与管理。该模式通过引入“代理”角色，使得客户端在调用真实对象时，能够在不修改原有逻辑的前提下增加额外功能，例如权限控制、远程通信、延迟加载等。

代理模式广泛应用于现代软件架构中，尤其在分布式系统、AOP（面向切面编程）、RPC调用、安全控制等领域具有重要地位。根据不同的使用场景，代理模式可分为多种类型，如远程代理、虚拟代理、安全代理和智能引用代理等。每种类型都针对特定问题域提供了高效的解决方案，为后续章节中代理模式的具体实现和应用奠定了理论基础。

2. 代理模式核心角色解析（RealSubject/Proxy/Client）

代理模式的核心在于其三个关键角色的协作： RealSubject（真实主题） 、 Proxy（代理类） 和 Client（客户端） 。这三者共同构成了代理机制的基础结构，决定了代理如何实现对真实对象的封装、控制和调用。理解这三者之间的职责划分与交互逻辑，是掌握代理模式原理的关键所在。

2.1 代理模式中的三大核心角色

代理模式通过将对真实对象的访问控制权交给代理对象，实现了对访问流程的增强、延迟加载、权限控制等功能。理解每个角色的定义和职责，有助于我们更深入地分析其在实际开发中的应用场景。

2.1.1 RealSubject（真实主题）的作用

RealSubject 是代理模式中真正执行业务逻辑的对象。它是代理所要封装和控制的目标对象，负责完成具体的功能实现。

职责分析：

• 提供核心业务方法 ：RealSubject 是功能实现的最终执行者。
• 不处理代理逻辑 ：它不关心调用的来源、权限、缓存等额外控制逻辑。
• 与代理保持接口一致 ：为了方便代理类统一调用，RealSubject 通常需要实现某个接口或继承某个抽象类。

示例代码：

public class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk(filename); // 模拟耗时加载
    }

    @Override
    public void display() {
        System.out.println("Displaying " + filename);
    }

    private void loadFromDisk(String filename) {
        System.out.println("Loading " + filename + " from disk...");
    }
}

代码逻辑分析：

• RealImage 实现了 Image 接口。
• display() 方法是核心业务逻辑。
• loadFromDisk() 模拟了资源加载，体现其作为真实主题的职责。

参数说明：

• filename ：图片文件名，用于模拟资源路径。

2.1.2 Proxy（代理类）的功能与职责

Proxy 是代理模式的核心控制层，它封装了对 RealSubject 的访问，负责在调用前后插入额外逻辑，如权限校验、日志记录、缓存控制等。

职责分析：

• 封装 RealSubject 对象 ：代理类持有 RealSubject 的引用。
• 控制访问流程 ：在调用前后添加逻辑，如验证、缓存、计时等。
• 接口一致性 ：代理类与 RealSubject 实现相同的接口，保证客户端调用一致性。

示例代码：

public class ProxyImage implements Image {
    private RealImage realImage;
    private String filename;

    public ProxyImage(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename); // 延迟加载
        }
        realImage.display();
    }
}

代码逻辑分析：

• ProxyImage 实现了 Image 接口。
• display() 方法中加入了延迟加载逻辑。
• 只有在真正需要时才创建 RealImage 实例。

参数说明：

• filename ：图片文件名，用于构建真实对象。

2.1.3 Client（客户端）的调用流程

Client 是代理模式的调用者，它不关心具体的实现是真实对象还是代理对象，只通过统一的接口进行调用。

调用流程：

1. 客户端通过接口调用代理对象。
2. 代理对象根据需求决定是否创建真实对象。
3. 代理对象将调用转发给真实对象，并在前后插入增强逻辑。

示例代码：

public class Client {
    public static void main(String[] args) {
        Image image1 = new ProxyImage("photo1.jpg");
        Image image2 = new ProxyImage("photo2.jpg");

        // 第一次调用时加载
        image1.display();
        // 第二次调用时已缓存
        image1.display();

        // 不同代理对象互不影响
        image2.display();
    }
}

代码逻辑分析：

• 客户端通过 ProxyImage 构造两个代理对象。
• 第一次调用 display() 时触发真实对象的创建。
• 第二次调用时已存在对象，跳过加载过程。
• 每个代理对象维护自己的真实对象实例。

参数说明：

• photo1.jpg 、 photo2.jpg ：图片资源路径，用于模拟不同的访问请求。

2.2 角色之间的协作关系

三大角色之间的协作关系构成了代理模式的运行机制。理解这些协作流程，有助于我们构建更复杂的代理结构，如动态代理、远程代理等。

2.2.1 代理对象如何封装真实对象

代理对象通常通过组合的方式持有真实对象的引用，而不是继承。这样做的优势在于：

• 接口一致性 ：代理与真实对象实现相同接口，客户端无感知。
• 职责分离 ：代理负责控制，真实对象负责执行。
• 可扩展性高 ：可以轻松替换不同的代理逻辑。

协作流程图（Mermaid 表示）：

sequenceDiagram
    participant Client
    participant Proxy
    participant RealSubject

    Client->>Proxy: 调用 display()
    Proxy->>RealSubject: 判断是否已创建
    Proxy->>RealSubject: 创建 RealSubject 实例
    Proxy->>RealSubject: 调用 display()
    RealSubject-->>Proxy: 返回结果
    Proxy-->>Client: 返回显示结果

2.2.2 调用过程的控制与增强

代理对象在调用真实对象前后，可以插入任意增强逻辑，例如：

• 日志记录 ：记录调用时间、参数、结果。
• 权限校验 ：判断用户是否有权限调用。
• 缓存机制 ：避免重复调用，提高性能。
• 异常处理 ：统一捕获并处理异常。

示例：增强型代理类

public class LoggingProxyImage implements Image {
    private RealImage realImage;
    private String filename;

    public LoggingProxyImage(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        System.out.println("Before displaying image: " + filename);
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
        System.out.println("After displaying image: " + filename);
    }
}

代码逻辑分析：

• 在调用前后打印日志信息。
• 保留了代理模式的延迟加载特性。
• 提供了更丰富的调用上下文信息。

2.3 核心角色的UML类图表示

通过 UML 类图，我们可以更清晰地理解代理模式的结构关系。

2.3.1 类图结构分析

classDiagram
    class Subject {
        <<interface>>
        +display()
    }

    class RealSubject {
        +display()
    }

    class Proxy {
        -realSubject: RealSubject
        +display()
    }

    Subject <|-- RealSubject
    Subject <|-- Proxy
    Proxy --> RealSubject

图解说明：

• Subject 是公共接口。
• RealSubject 是接口的具体实现。
• Proxy 也实现 Subject 接口，并持有 RealSubject 实例。
• 客户端通过 Subject 接口调用，无法感知具体是哪个实现类。

2.3.2 实现方式的差异对比

特性	静态代理	动态代理
代理类生成方式	手动编写	运行时生成
接口绑定	静态绑定	动态绑定
可扩展性	差	好
维护成本	高	低
性能	高	略低

表格说明：

• 代理类生成方式 ：静态代理需手动编写每个代理类；动态代理由 JVM 在运行时自动生成。
• 接口绑定 ：静态代理必须提前绑定接口；动态代理可动态适配任意接口。
• 可扩展性 ：动态代理支持多个接口，适合大规模系统。
• 维护成本 ：动态代理减少重复代码，降低维护成本。
• 性能 ：动态代理因反射机制略慢于静态代理。

小结

本章深入解析了代理模式的三大核心角色（RealSubject、Proxy、Client），并通过代码示例和 UML 图展示了它们的职责划分与协作流程。同时，我们还通过增强型代理类和 UML 类图展示了代理模式的扩展性和结构设计。这些内容为后续章节中深入探讨静态代理、动态代理、远程代理等高级应用打下了坚实的基础。

3. 静态代理实现方式详解

静态代理是一种在编译期就确定代理类结构的代理实现方式。它依赖于接口和实现类的绑定关系，通过手动编写代理类来实现对目标对象的增强。虽然实现方式较为基础，但在一些小型项目或对性能要求较高的场景中，静态代理依然具有实用价值。

3.1 静态代理的基本原理

静态代理的实现依赖于接口与实现类之间的绑定关系，并在编译期生成代理类。它通过封装目标对象，在调用前后添加增强逻辑，从而实现对方法的控制和扩展。

3.1.1 编译期生成代理类

静态代理的代理类是在编译阶段就已经确定并生成的。这意味着代理类的源码必须由开发者手动编写，并在编译时与真实类一起被编译为字节码文件。这种方式与动态代理（运行时生成代理类）形成鲜明对比。

例如，当我们有一个接口 Service 和其实现类 ServiceImpl ，我们可以手动编写一个代理类 ServiceProxy ，它也实现 Service 接口，并在内部持有 ServiceImpl 的实例。

public interface Service {
    void doSomething();
}

public class ServiceImpl implements Service {
    @Override
    public void doSomething() {
        System.out.println("执行实际业务逻辑");
    }
}

public class ServiceProxy implements Service {
    private Service realService;

    public ServiceProxy(Service realService) {
        this.realService = realService;
    }

    @Override
    public void doSomething() {
        System.out.println("调用前增强逻辑");
        realService.doSomething();
        System.out.println("调用后增强逻辑");
    }
}

在这个例子中， ServiceProxy 就是一个典型的静态代理类。它在编译时就已经存在，并通过构造函数接收真实对象的引用，从而在方法调用前后插入增强逻辑。

3.1.2 接口和实现类的绑定关系

静态代理的一个重要特性是： 代理类必须实现与真实类相同的接口 。这是实现代理逻辑的基础，因为客户端在调用时并不关心是调用真实类还是代理类，只要它们实现相同的接口即可。

这种接口与实现类的绑定关系，使得代理类能够无缝地替代真实类，同时也限制了静态代理的灵活性。如果接口发生变化，代理类也必须相应地修改，这在大型系统中容易造成维护困难。

3.2 静态代理的代码实现

静态代理的实现主要包括三个步骤：定义接口与真实类、编写代理类、调用代理对象。下面我们通过一个完整的示例来展示静态代理的实现过程。

3.2.1 定义接口与真实类

我们先定义一个简单的接口 UserService ，用于用户信息的操作。

public interface UserService {
    void addUser(String username);
    void deleteUser(int userId);
}

接下来是该接口的实现类 UserServiceImpl ：

public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        System.out.println("添加用户：" + username);
    }

    @Override
    public void deleteUser(int userId) {
        System.out.println("删除用户ID：" + userId);
    }
}

3.2.2 编写代理类并实现增强逻辑

现在我们编写代理类 UserServiceProxy ，它将对 UserServiceImpl 进行增强，比如添加日志记录、权限检查等功能。

public class UserServiceProxy implements UserService {
    private UserService realUserService;

    public UserServiceProxy(UserService realUserService) {
        this.realUserService = realUserService;
    }

    @Override
    public void addUser(String username) {
        log("开始添加用户");
        realUserService.addUser(username);
        log("用户添加完成");
    }

    @Override
    public void deleteUser(int userId) {
        log("开始删除用户");
        realUserService.deleteUser(userId);
        log("用户删除完成");
    }

    private void log(String message) {
        System.out.println("[日志记录] " + message);
    }
}

在这个代理类中，我们通过 log 方法添加了日志记录功能。无论调用哪个方法，都会在方法执行前后输出日志信息。

客户端调用示例

public class Client {
    public static void main(String[] args) {
        UserService realService = new UserServiceImpl();
        UserService proxy = new UserServiceProxy(realService);

        proxy.addUser("Tom");
        proxy.deleteUser(1001);
    }
}

执行结果：

[日志记录] 开始添加用户
添加用户：Tom
[日志记录] 用户添加完成
[日志记录] 开始删除用户
删除用户ID：1001
[日志记录] 用户删除完成

代码逻辑分析

• UserService 接口定义了两个操作方法。
• UserServiceImpl 是接口的实现类，负责实际的业务逻辑。
• UserServiceProxy 是代理类，持有 UserService 接口的引用，并在方法调用前后插入增强逻辑。
• 客户端通过代理对象调用方法，从而实现了对真实对象的增强控制。

3.3 静态代理的优缺点分析

静态代理作为一种基础的代理实现方式，具有其实用性，但也存在明显的局限性。下面我们从优缺点两个方面进行深入分析。

3.3.1 优点：实现简单、易于理解

实现简单

静态代理无需依赖任何第三方库或框架，完全通过手动编码实现。开发者只需定义接口、实现类和代理类即可完成代理逻辑的构建。

易于理解

由于代理类是显式编写的，逻辑清晰，便于调试和维护。对于初学者而言，静态代理是一种非常好的入门方式，有助于理解代理模式的基本思想。

性能较高

静态代理在编译期就已经生成代理类，运行时无需动态生成类或进行反射调用，因此在性能上通常优于动态代理。

3.3.2 缺点：扩展性差、代码冗余

扩展性差

每个接口都需要对应一个代理类。如果系统中存在多个接口，就需要编写多个代理类，这会显著增加代码量。同时，当接口方法发生变化时，代理类也需要同步修改，维护成本较高。

代码冗余

代理类的结构高度相似，往往只是在方法前后添加增强逻辑。这种重复性代码不仅浪费开发时间，也增加了出错的概率。

不适合大型项目

在大型项目中，接口数量庞大，手动维护代理类会变得非常困难。此外，静态代理无法实现对没有接口的类进行代理，这进一步限制了其应用范围。

对比维度	静态代理	动态代理
是否需要手动编写代理类	是	否
支持无接口类代理	否	是（如CGLIB）
扩展性	差	好
可维护性	低	高
性能	高	中等

3.4 静态代理在实际项目中的应用场景

虽然静态代理存在诸多限制，但在一些特定场景中仍然具有实用价值。

3.4.1 小型项目或快速原型开发

在功能较少、接口数量有限的小型项目中，静态代理可以快速实现功能增强，且无需引入复杂的框架。

3.4.2 日志记录与性能监控

静态代理适合用于添加统一的日志记录、方法耗时统计等通用逻辑。例如，在服务层方法调用前后插入日志输出或性能计时代码。

3.4.3 权限校验的初步实现

在某些安全要求不高的系统中，可以通过静态代理实现在调用前进行权限判断。例如，在访问敏感接口前进行用户身份校验。

3.4.4 与Spring AOP结合使用

虽然Spring AOP默认使用动态代理，但开发者仍然可以通过自定义静态代理类，结合Spring IOC容器实现更细粒度的控制。

3.4.5 教学与示例演示

静态代理结构清晰、逻辑简单，非常适合教学或示例演示，帮助开发者理解代理模式的核心思想。

总结与延伸

静态代理作为代理模式的基础实现方式，虽然在扩展性和灵活性上存在不足，但其结构清晰、易于理解，适合小型项目或特定场景下的使用。随着项目规模的扩大和功能需求的增加，静态代理的局限性逐渐显现，这就促使我们转向更为灵活的 动态代理 机制。

在下一章中，我们将深入探讨 Java 动态代理的实现原理，包括基于反射的 InvocationHandler 和 CGLIB 字节码增强技术，并通过实际案例展示其在现代 Java 项目中的应用价值。

4. 动态代理（Java反射/CGLIB）原理与实战

动态代理技术是 Java 领域中实现面向切面编程（AOP）和功能增强的重要机制之一。它允许我们在不修改原始类的情况下，对方法调用进行拦截、增强或控制。与静态代理相比，动态代理具备更强的灵活性和扩展性，尤其适用于需要为多个类、多个方法统一添加增强逻辑的场景。本章将从 Java 原生反射代理和 CGLIB 代理两个角度，深入剖析其原理，并结合实战案例展示其应用场景。

4.1 Java动态代理机制概述

Java 原生的动态代理机制基于 反射（Reflection） 和 InvocationHandler 接口实现，其核心思想是在运行时动态生成代理类，并通过接口绑定目标对象的方法调用。这种机制特别适用于接口驱动的开发模型，例如 Spring AOP 的底层实现就广泛使用了该机制。

4.1.1 基于反射的InvocationHandler机制

InvocationHandler 是 Java 动态代理的核心接口，它定义了一个 invoke 方法，用于拦截目标对象的方法调用并添加增强逻辑。其方法签名如下：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable;

• proxy ：生成的代理对象。
• method ：被调用的目标方法。
• args ：方法参数。

在实际使用中，我们需要自定义一个类实现 InvocationHandler 接口，并在 invoke 方法中定义增强逻辑。然后通过 Proxy 类的 newProxyInstance 方法动态生成代理对象。

示例：实现一个简单的日志记录代理

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

interface Service {
    void execute();
}

class RealService implements Service {
    public void execute() {
        System.out.println("Executing real service.");
    }
}

class LoggingHandler implements InvocationHandler {
    private Object target;

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

    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;
    }
}

public class Main {
    public static void main(String[] args) {
        Service realService = new RealService();

        // 创建代理对象
        Service proxyService = (Service) Proxy.newProxyInstance(
            realService.getClass().getClassLoader(),
            realService.getClass().getInterfaces(),
            new LoggingHandler(realService)
        );

        proxyService.execute();  // 调用代理对象
    }
}

执行结果：

Before method: execute
Executing real service.
After method: execute

逐行分析：

• 第 2~5 行定义了一个 Service 接口和 RealService 实现类。
• 第 6~15 行定义了 LoggingHandler ，实现了 InvocationHandler 接口。
• 第 17~28 行创建代理对象并调用其方法。
• Proxy.newProxyInstance() 是核心方法，它接收类加载器、接口数组和 InvocationHandler 实例，动态生成代理类。

参数说明：

参数名	类型	说明
loader	ClassLoader	目标类的类加载器
interfaces	Class<?>[]	目标类实现的接口数组
h	InvocationHandler	自定义的增强逻辑处理器

4.1.2 Proxy类的使用方法

Proxy 类是 Java 提供的用于生成代理对象的工具类，其核心方法是 newProxyInstance() 。使用时需注意以下几点：

1. 必须基于接口生成代理类 ：Java 动态代理仅支持接口代理，无法对没有实现接口的类进行代理。
2. 生成的代理类是运行时动态创建的 ：代理类在运行时生成，不会出现在源码中。
3. 代理对象继承自 Proxy 类并实现目标接口 ：代理类内部通过 InvocationHandler 调用目标方法。

示例：查看代理类的类名

Service proxyService = (Service) Proxy.newProxyInstance(...);
System.out.println(proxyService.getClass().getName());

输出示例：

com.sun.proxy.$Proxy0

4.2 CGLIB动态代理实现原理

CGLIB（Code Generation Library）是一个强大的字节码生成库，它可以在运行时动态生成子类来实现代理功能。与 Java 原生动态代理不同，CGLIB 不依赖接口，而是通过继承目标类的方式生成代理类，因此适用于没有接口定义的类。

4.2.1 基于字节码操作的代理生成

CGLIB 使用 ASM 字节码框架动态修改类的字节码，生成目标类的子类（代理类），并重写其方法。其核心组件包括：

• Enhancer ：用于创建代理对象。
• MethodInterceptor ：定义拦截逻辑。
• MethodProxy ：用于调用原始方法。

示例：CGLIB 实现日志记录代理

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

class RealService {
    public void execute() {
        System.out.println("Executing real service.");
    }
}

class CglibInterceptor implements MethodInterceptor {
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = proxy.invokeSuper(obj, args);  // 调用父类方法
        System.out.println("After method: " + method.getName());
        return result;
    }
}

public class CglibMain {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(RealService.class);  // 设置父类
        enhancer.setCallback(new CglibInterceptor());  // 设置拦截器

        RealService proxyService = (RealService) enhancer.create();  // 创建代理对象
        proxyService.execute();  // 调用代理方法
    }
}

执行结果：

Before method: execute
Executing real service.
After method: execute

逐行分析：

• 第 1~7 行定义了一个没有接口的 RealService 类。
• 第 8~15 行定义了 CglibInterceptor ，实现 MethodInterceptor 接口。
• 第 16~24 行通过 Enhancer 构建代理对象并调用方法。
• proxy.invokeSuper(obj, args) 是调用父类方法的核心方式。

参数说明：

参数名	类型	说明
obj	Object	代理对象
method	Method	被拦截的方法
args	Object[]	方法参数
proxy	MethodProxy	用于调用父类方法

4.2.2 与Java动态代理的对比分析

特性	Java 动态代理	CGLIB
是否依赖接口	是	否
实现代理方式	接口代理	子类代理
性能	高（JDK 1.8 后优化）	略低（需生成子类）
适用场景	接口驱动项目	没有接口的类
依赖库	JDK 自带	第三方库（需引入 cglib 或 asm）

流程图说明：

graph TD
    A[客户端调用] --> B{目标类是否有接口}
    B -->|有| C[Java动态代理]
    B -->|无| D[CGLIB代理]
    C --> E[Proxy.newProxyInstance]
    D --> F[Enhancer.create]
    E --> G[调用InvocationHandler]
    F --> H[调用MethodInterceptor]
    G --> I[执行目标方法]
    H --> I

4.3 动态代理的实战应用

动态代理在实际开发中应用广泛，常见于日志记录、权限控制、事务管理等非业务逻辑的统一处理。以下两个实战案例将展示其在项目中的具体用途。

4.3.1 日志记录功能的动态增强

在大型系统中，我们通常需要对关键方法进行日志记录，以便排查问题。使用动态代理可以避免在每个方法中手动添加日志代码。

示例：统一日志记录代理

public class LoggingProxy implements InvocationHandler {
    private Object target;

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

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = method.invoke(target, args);
        long endTime = System.currentTimeMillis();
        System.out.println("Method " + method.getName() + " took " + (endTime - startTime) + "ms");
        return result;
    }
}

使用方式：

Service service = (Service) Proxy.newProxyInstance(..., new LoggingProxy(realService));
service.execute();  // 自动记录执行时间

4.3.2 权限控制的统一处理

在 Web 应用中，我们可以使用动态代理实现统一的权限验证逻辑。

示例：基于角色的权限拦截

public class AuthProxy implements InvocationHandler {
    private Object target;
    private String role;

    public AuthProxy(Object target, String role) {
        this.target = target;
        this.role = role;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.isAnnotationPresent(RequiresRole.class)) {
            RequiresRole annotation = method.getAnnotation(RequiresRole.class);
            if (!annotation.value().equals(role)) {
                throw new IllegalAccessException("No permission to invoke " + method.getName());
            }
        }
        return method.invoke(target, args);
    }
}

定义注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequiresRole {
    String value();
}

使用注解控制权限：

class AdminService {
    @RequiresRole("admin")
    public void deleteData() {
        System.out.println("Data deleted.");
    }
}

4.4 动态代理的性能与局限性

虽然动态代理提供了强大的功能扩展能力，但也存在一些性能和使用上的限制。

性能分析

代理方式	初始化耗时	调用耗时	适用场景
Java 动态代理	中等	低（JDK 优化）	接口代理
CGLIB	高（需生成子类）	中等	无接口类

一般而言，Java 原生代理的调用性能优于 CGLIB，但 CGLIB 更加灵活。

局限性

1. Java 动态代理依赖接口 ：无法对没有实现接口的类进行代理。
2. CGLIB 无法代理 final 类和 final 方法 ：因为其依赖继承机制。
3. 代理逻辑需统一处理 ：不适合针对特定方法做精细控制，除非结合注解等手段。

示例：CGLIB 无法代理 final 方法

class FinalService {
    public final void doSomething() {
        System.out.println("Final method");
    }
}

// 使用 CGLIB 代理时，doSomething() 方法不会被拦截

建议： 在 Spring 等框架中，若目标类实现了接口，则优先使用 JDK 动态代理，否则使用 CGLIB。

本章从 Java 原生反射代理和 CGLIB 代理两个角度，系统性地讲解了动态代理的实现原理、代码示例、应用场景和性能对比。通过本章内容，开发者可以深入理解动态代理机制，并在实际项目中灵活运用，实现非侵入式的功能增强。

5. 远程代理实现原理与应用

在分布式系统架构中，服务的调用往往跨越不同的物理节点，远程代理（Remote Proxy）正是为了解决这种跨网络访问而设计的。远程代理的核心作用是隐藏远程调用的复杂性，使得客户端在调用远程服务时如同调用本地对象一般。本章将深入剖析远程代理的基本原理、通信机制及其在实际项目中的典型应用，包括微服务中的远程调用、跨网络访问控制等。

5.1 远程代理的基本概念

5.1.1 分布式系统中的代理需求

在分布式系统中，服务通常部署在不同的物理节点上。为了实现服务之间的通信，客户端需要通过网络访问远程服务。然而，网络通信本身存在延迟、不可靠性等问题，直接暴露这些细节会增加系统的复杂度。

远程代理模式正是为了解决这一问题而设计的。它在客户端和服务端之间引入一个中介对象，即代理对象，负责处理远程调用的底层细节，如网络连接、数据序列化、异常处理等，使得客户端可以以透明的方式调用远程服务。

5.1.2 RMI（远程方法调用）机制简介

Java 提供了内置的远程方法调用（Remote Method Invocation, RMI）机制，是远程代理模式的一个典型实现。RMI 允许一个 Java 虚拟机上的对象调用另一个 JVM 上的对象方法，如同本地方法调用一样。

RMI 的核心组件包括：

• 远程接口（Remote Interface） ：定义了客户端可以调用的方法。
• 远程实现类（Remote Implementation） ：实现远程接口的具体业务逻辑。
• RMI 注册表（RMI Registry） ：用于注册远程对象，供客户端查找。
• 代理对象（Stub） ：客户端调用远程方法时，实际上是调用了本地的代理对象（Stub），由它负责与远程服务通信。

示例：RMI 基本实现

// 1. 定义远程接口
public interface HelloService extends Remote {
    String sayHello(String name) throws RemoteException;
}

// 2. 实现远程服务
public class HelloServiceImpl extends UnicastRemoteObject implements HelloService {
    protected HelloServiceImpl() throws RemoteException {
        super();
    }

    @Override
    public String sayHello(String name) throws RemoteException {
        return "Hello, " + name;
    }
}

// 3. 启动 RMI 服务
public class RMIServer {
    public static void main(String[] args) {
        try {
            HelloService service = new HelloServiceImpl();
            Naming.rebind("rmi://localhost:1099/HelloService", service);
            System.out.println("服务已注册");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 4. 客户端调用
public class RMIClient {
    public static void main(String[] args) {
        try {
            HelloService service = (HelloService) Naming.lookup("rmi://localhost:1099/HelloService");
            System.out.println(service.sayHello("Alice"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码逻辑分析：

• HelloService 是一个远程接口，继承自 Remote 接口，所有方法必须抛出 RemoteException 。
• HelloServiceImpl 实现了该接口，并继承 UnicastRemoteObject ，表示该对象可以在网络中被远程访问。
• 服务端使用 Naming.rebind() 将服务注册到 RMI 注册表中。
• 客户端通过 Naming.lookup() 获取远程服务的代理对象，调用其方法时实际上是在远程执行。

5.2 远程代理的通信机制

5.2.1 客户端与服务端的交互流程

远程代理的通信流程主要包括以下几个步骤：

1. 客户端请求调用 ：客户端调用代理对象的方法。
2. 参数序列化 ：代理对象将方法名和参数进行序列化。
3. 网络传输 ：将序列化后的数据通过网络发送到服务端。
4. 服务端反序列化与执行 ：服务端接收请求，反序列化并调用真实服务。
5. 结果返回 ：服务端将执行结果返回给客户端代理，代理再将结果返回给客户端。

5.2.2 网络传输与序列化机制

远程调用的核心在于 序列化 与 网络通信 。Java RMI 默认使用 Java 原生序列化，但其性能较差，因此在实际项目中常使用更高效的序列化方式，如 JSON、Protocol Buffers、Thrift、Hessian 等。

序列化方式	优点	缺点	使用场景
Java 原生序列化	简单易用	性能差、可读性差	简单 RMI 应用
JSON（Jackson/Gson）	可读性强，跨语言	性能略差	REST API
Protocol Buffers	高性能、跨语言	需要定义 IDL	微服务通信
Hessian	二进制、跨语言	Java 为主	Dubbo 框架
Thrift	高性能、支持多种语言	配置复杂	大型分布式系统

示例：使用 Hessian 实现远程调用

// 1. 定义接口
public interface HelloService {
    String sayHello(String name);
}

// 2. 实现服务
public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

// 3. 启动 Hessian 服务
public class HessianServer {
    public static void main(String[] args) throws Exception {
        BasicServer server = new BasicServer();
        server.setPort(8080);
        server.publish("/hello", new HelloServiceImpl());
        System.out.println("Hessian 服务已启动");
    }
}

// 4. 客户端调用
public class HessianClient {
    public static void main(String[] args) {
        HessianProxyFactory factory = new HessianProxyFactory();
        try {
            HelloService proxy = (HelloService) factory.create(HelloService.class, "http://localhost:8080/hello");
            System.out.println(proxy.sayHello("Bob"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码逻辑分析：

• HelloService 是一个普通接口，无需继承 Remote 。
• HessianServer 使用 BasicServer 启动 HTTP 服务，并发布服务对象。
• 客户端使用 HessianProxyFactory 创建代理对象，通过 HTTP 调用远程服务。

5.3 远程代理的实际应用

5.3.1 微服务架构中的远程调用

在微服务架构中，各个服务之间通过远程调用进行通信，远程代理模式广泛应用于服务间调用、负载均衡、熔断降级等场景。以 Dubbo、Spring Cloud Feign 为代表的框架，底层都使用了远程代理技术。

示例：Dubbo 中的远程调用流程

graph TD
    A[客户端] --> B[代理对象]
    B --> C[网络通信层]
    C --> D[注册中心]
    D --> E[服务提供者]
    E --> F[执行业务逻辑]
    F --> G[返回结果]
    G --> H[反序列化]
    H --> I[返回给客户端]

流程说明：

1. 客户端调用接口方法，实际上是调用代理对象。
2. 代理对象将方法名、参数等封装为请求体。
3. 请求通过网络发送到服务提供者。
4. 服务提供者反序列化请求，调用真实服务。
5. 返回结果序列化后返回给客户端代理，再返回给客户端。

5.3.2 使用代理实现跨网络访问控制

在分布式系统中，远程代理还可以用于实现访问控制、日志记录、性能监控等功能。通过代理对象统一处理请求，可以在调用前后插入增强逻辑。

示例：远程调用日志记录代理

public class LoggingProxy implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用方法: " + method.getName() + ", 参数: " + Arrays.toString(args));
        long startTime = System.currentTimeMillis();
        Object result = method.invoke(target, args);
        long duration = System.currentTimeMillis() - startTime;
        System.out.println("方法执行耗时: " + duration + "ms");
        return result;
    }

    public static <T> T createProxy(T target) {
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new LoggingProxy(target)
        );
    }
}

// 使用方式
HelloService proxy = LoggingProxy.createProxy(new HelloServiceImpl());
System.out.println(proxy.sayHello("Proxy"));

代码逻辑分析：

• LoggingProxy 实现 InvocationHandler 接口，在 invoke() 方法中添加了日志记录和性能监控。
• 使用 Proxy.newProxyInstance() 动态生成代理对象。
• 客户端调用 proxy.sayHello() 时，会先输出调用日志，再执行真实方法，最后输出耗时信息。

本章深入探讨了远程代理的核心原理、通信机制及其在分布式系统中的应用。远程代理通过封装远程调用的复杂性，提升了系统的可维护性与可扩展性，是构建高性能、高可用分布式系统的关键技术之一。后续章节将继续探讨虚拟代理、安全代理等不同类型的代理模式及其优化策略。

6. 虚拟代理优化策略与实战

虚拟代理（Virtual Proxy）作为代理模式的一种典型应用，主要通过 延迟加载 （Lazy Loading）机制，解决资源密集型对象在初始化时带来的性能问题。它通过在客户端真正需要访问对象时才创建实际对象，从而有效减少系统启动时的开销，提升整体性能与响应速度。

在本章中，我们将深入剖析虚拟代理的核心思想，结合图像加载、数据库连接等典型应用场景，探讨其在大型系统中的优化策略，并通过具体代码示例展示其实现方式。

6.1 虚拟代理的核心思想

虚拟代理的核心思想是 延迟加载 ，即在实际对象被访问之前，代理对象仅作为占位符存在。只有当客户端真正调用其功能时，代理才会触发实际对象的创建与执行。

6.1.1 惰性加载机制的引入

惰性加载（Lazy Initialization）是一种常见的性能优化策略，其核心思想是 按需加载 资源，而非在系统启动时一次性加载所有内容。这种机制在以下场景中尤为有效：

• 图像加载：在网页或桌面应用中，图片资源可能非常大，提前加载会影响用户体验；
• 数据库连接：频繁创建连接会消耗大量系统资源；
• 大型对象实例化：如配置文件解析、复杂模型初始化等。

优点：
- 减少初始资源消耗；
- 提升系统响应速度；
- 降低内存占用。

缺点：
- 第一次访问时会有延迟；
- 增加代码复杂度；
- 需要考虑线程安全问题。

6.1.2 提升系统性能的典型场景

以图像加载为例，虚拟代理可以用于构建一个图像预览系统。在用户第一次点击图片时才真正加载完整图像，而在预览时显示一个占位符或缩略图。

典型流程如下：

graph TD
    A[客户端请求图像] --> B{代理中是否存在真实图像对象？}
    B -->|是| C[调用真实图像的显示方法]
    B -->|否| D[创建真实图像对象]
    D --> E[加载完整图像资源]
    E --> F[显示图像]

这种机制在Web前端、图像编辑软件、在线文档查看器中均有广泛应用。

6.2 虚拟代理的实现方式

虚拟代理的实现方式主要围绕 代理类的构造逻辑 和 真实对象的加载时机 展开。下面通过一个图像加载的示例，展示其具体实现过程。

6.2.1 缓存代理对象的创建时机

在实现虚拟代理时，代理类应包含一个指向真实对象的引用，并在首次调用方法时才真正初始化该对象。

关键点：
- 代理类应与真实类实现相同接口；
- 代理类在构造时不创建真实对象；
- 代理类在方法调用时判断是否需要加载真实对象。

6.2.2 图像加载中的虚拟代理示例

1. 定义图像接口

public interface Image {
    void display();
}

2. 实现真实图像类

public class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk(filename); // 模拟加载耗时操作
    }

    private void loadFromDisk(String filename) {
        System.out.println("Loading image: " + filename);
        try {
            Thread.sleep(1000); // 模拟IO延迟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void display() {
        System.out.println("Displaying image: " + filename);
    }
}

3. 创建虚拟代理类

public class VirtualImageProxy implements Image {
    private Image realImage;
    private String filename;

    public VirtualImageProxy(String filename) {
        this.filename = filename;
        // 不在此处加载真实图像
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename); // 首次调用时加载
        }
        realImage.display();
    }
}

4. 客户端调用示例

public class Client {
    public static void main(String[] args) {
        Image image = new VirtualImageProxy("big_image.jpg");
        System.out.println("Proxy created, image not loaded yet.");
        image.display(); // 第一次调用，触发加载
        image.display(); // 第二次调用，直接显示
    }
}

输出结果：

Proxy created, image not loaded yet.
Loading image: big_image.jpg
Displaying image: big_image.jpg
Displaying image: big_image.jpg

代码逻辑分析：

• VirtualImageProxy 在构造时不创建 RealImage 实例，仅保存文件名；
• display() 方法在第一次调用时才创建真实对象；
• 后续调用复用已创建的对象，避免重复加载；
• 有效减少初始化阶段的资源占用。

6.3 虚拟代理在大型系统中的优化策略

在大型系统中，虚拟代理不仅用于图像加载，还广泛应用于数据库连接、缓存管理、服务调用等领域。下面我们将重点讨论其在 数据库连接管理 和 高并发资源控制 中的应用。

6.3.1 数据库连接的虚拟代理管理

数据库连接是典型的资源密集型操作。频繁打开和关闭连接会导致性能下降。通过虚拟代理，可以实现连接的延迟加载和复用。

1. 接口定义

public interface DatabaseConnection {
    void connect();
    void query(String sql);
}

2. 真实连接类

public class RealDatabaseConnection implements DatabaseConnection {
    private String url;

    public RealDatabaseConnection(String url) {
        this.url = url;
    }

    @Override
    public void connect() {
        System.out.println("Connecting to database: " + url);
        // 模拟连接耗时
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void query(String sql) {
        System.out.println("Executing SQL: " + sql);
    }
}

3. 虚拟代理类

public class LazyDatabaseConnectionProxy implements DatabaseConnection {
    private DatabaseConnection realConnection;
    private String url;

    public LazyDatabaseConnectionProxy(String url) {
        this.url = url;
    }

    @Override
    public void connect() {
        if (realConnection == null) {
            realConnection = new RealDatabaseConnection(url);
        }
        realConnection.connect();
    }

    @Override
    public void query(String sql) {
        connect(); // 自动连接
        realConnection.query(sql);
    }
}

4. 客户端调用示例

public class Client {
    public static void main(String[] args) {
        DatabaseConnection conn = new LazyDatabaseConnectionProxy("jdbc:mysql://localhost:3306/mydb");
        System.out.println("Proxy created, connection not established yet.");
        conn.query("SELECT * FROM users");
        conn.query("SELECT COUNT(*) FROM orders");
    }
}

输出结果：

Proxy created, connection not established yet.
Connecting to database: jdbc:mysql://localhost:3306/mydb
Executing SQL: SELECT * FROM users
Executing SQL: SELECT COUNT(*) FROM orders

参数说明与优化建议：

• 使用虚拟代理可避免连接过早创建，节省资源；
• 可结合连接池进一步优化，避免重复创建；
• 适用于频繁访问但不总是需要连接的场景（如后台任务、定时任务）；

6.3.2 高并发场景下的资源控制

在高并发系统中，如电商秒杀、支付系统等，资源访问需要严格控制。虚拟代理可用于实现 资源访问的限流与延迟初始化 。

优化策略：

• 虚拟代理 + 限流策略 ：在代理层限制同时创建真实对象的数量；
• 懒加载 + 缓存机制 ：避免重复加载相同资源；
• 线程安全控制 ：使用双重检查锁定（Double-Checked Locking）确保单例初始化安全。

线程安全的虚拟代理示例：

public class ThreadSafeProxy implements Image {
    private volatile Image realImage;
    private String filename;

    public ThreadSafeProxy(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        if (realImage == null) {
            synchronized (this) {
                if (realImage == null) {
                    realImage = new RealImage(filename);
                }
            }
        }
        realImage.display();
    }
}

优化分析：

• 使用 volatile 关键字确保多线程可见性；
• 使用双重检查锁定避免重复初始化；
• 适用于高并发下的资源延迟加载场景；
• 可与线程池、异步加载结合使用，进一步提升性能。

总结与延伸

虚拟代理通过延迟加载机制，有效优化了系统资源的使用效率。在图像加载、数据库连接、远程服务调用等场景中具有广泛的应用价值。其核心在于 控制真实对象的创建时机 ，从而实现性能与资源使用的平衡。

在实际项目中，可以将虚拟代理与其他设计模式（如工厂模式、单例模式、缓存模式）结合使用，形成更强大的资源管理策略。此外，结合现代并发编程模型（如Java的CompletableFuture、Reactive Streams），可以实现更高效的异步虚拟代理机制，满足高并发系统的性能需求。

思考题：
- 虚拟代理在Spring框架中是如何体现的？
- 如何将虚拟代理与缓存策略结合，进一步优化资源访问？
- 在微服务架构中，虚拟代理是否可以用于服务调用的延迟初始化？

这些问题将在后续章节中进一步探讨。

7. 安全代理权限控制实现

7.1 安全代理的基本作用

安全代理（Security Proxy）是代理模式在权限控制场景中的一种典型应用。它主要用于在访问真实对象之前进行权限验证，确保只有具备相应权限的用户才能执行特定操作。

在现代Web应用中，安全代理通常作为统一的访问控制入口，负责拦截用户请求并验证其身份与权限。例如，在Spring框架中，通过AOP与代理机制实现权限控制，使得所有对敏感资源的访问都必须经过代理层的权限校验。

安全代理的核心作用包括：

• 访问控制 ：限制特定用户或角色对资源的访问权限。
• 权限验证 ：根据用户身份动态判断是否允许执行某个操作。
• 操作审计 ：记录用户的访问行为，便于后续日志追踪与安全分析。

7.2 安全代理的实现方法

7.2.1 基于角色的权限拦截逻辑

在实际开发中，权限控制通常基于角色（Role）来实现。每个用户被赋予一个或多个角色，每个角色对应一组权限。安全代理通过拦截用户的请求，在调用目标方法前检查用户是否具备相应权限。

以下是一个基于Java的简单权限拦截代理示例：

// 定义服务接口
public interface OrderService {
    void placeOrder(String userId);
}

// 真实服务类
public class OrderServiceImpl implements OrderService {
    @Override
    public void placeOrder(String userId) {
        System.out.println("订单已提交，用户ID：" + userId);
    }
}

// 安全代理类
public class SecurityProxy implements OrderService {
    private OrderService realOrderService;
    private String currentUserRole;

    public SecurityProxy(OrderService realOrderService, String currentUserRole) {
        this.realOrderService = realOrderService;
        this.currentUserRole = currentUserRole;
    }

    @Override
    public void placeOrder(String userId) {
        if ("ADMIN".equals(currentUserRole) || userId.equals("user123")) {
            realOrderService.placeOrder(userId);
        } else {
            throw new SecurityException("用户没有权限提交订单");
        }
    }
}

// 客户端调用
public class Client {
    public static void main(String[] args) {
        OrderService realService = new OrderServiceImpl();
        // 模拟不同角色访问
        OrderService proxyAdmin = new SecurityProxy(realService, "ADMIN");
        OrderService proxyUser = new SecurityProxy(realService, "USER");

        proxyAdmin.placeOrder("user456");  // 允许访问
        proxyUser.placeOrder("user456");   // 抛出异常
    }
}

代码说明：
- SecurityProxy 是安全代理类，封装了对 OrderServiceImpl 的访问。
- 在 placeOrder 方法中，先判断当前用户角色是否具备权限，再决定是否调用真实对象。
- 示例中模拟了管理员和普通用户的访问行为，体现了权限控制的核心逻辑。

7.2.2 结合Spring Security实现安全代理

在实际企业级应用中，权限控制通常借助Spring Security框架来实现。Spring Security利用AOP和动态代理机制，自动对请求进行拦截并验证权限。

以下是Spring Security中使用安全代理的基本配置示例：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")    // 管理员路径
                .antMatchers("/user/**").hasAnyRole("ADMIN", "USER") // 用户路径
                .anyRequest().authenticated()
            .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
            .logout()
                .permitAll();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

配置说明：
- 通过 antMatchers() 设置不同路径的访问权限。
- 使用 hasRole() 指定所需角色，如 /admin/** 只允许管理员访问。
- 登录与登出页面允许所有用户访问，其他路径必须认证后才能访问。
- PasswordEncoder 用于密码加密，增强系统安全性。

Spring Security通过内部的代理机制，自动在请求到达Controller之前进行权限验证，实现了高度灵活和可扩展的安全控制。

7.3 安全代理在Web应用中的应用

7.3.1 控制页面访问权限

在Web应用中，安全代理可用于控制用户对特定页面的访问。例如，在Spring Boot项目中，结合Thymeleaf模板引擎，可以动态控制页面中某些元素的可见性：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>用户中心</title>
</head>
<body>
    <h1>欢迎访问用户中心</h1>

    <div sec:authorize="hasRole('ADMIN')">
        <p>管理员专属功能：系统设置</p>
    </div>

    <div sec:authorize="hasRole('USER')">
        <p>普通用户功能：查看订单</p>
    </div>
</body>
</html>

说明：
- sec:authorize 是Spring Security的Thymeleaf扩展属性，用于根据用户角色控制页面元素的显示。
- 页面根据用户角色动态渲染不同的内容，增强了用户体验与安全性。

7.3.2 接口级别的权限验证机制

除了页面级别的权限控制，接口级别的权限验证同样重要。在RESTful API中，通常使用注解方式进行权限控制，例如Spring Security提供的 @PreAuthorize 和 @Secured 注解：

@RestController
@RequestMapping("/api/orders")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @GetMapping("/{id}")
    @PreAuthorize("hasRole('ADMIN') or #id == authentication.principal.username")
    public ResponseEntity<Order> getOrder(@PathVariable String id) {
        Order order = orderService.getOrderById(id);
        return ResponseEntity.ok(order);
    }

    @PostMapping
    @Secured("ROLE_ADMIN")
    public ResponseEntity<Void> createOrder(@RequestBody Order order) {
        orderService.createOrder(order);
        return ResponseEntity.ok().build();
    }
}

说明：
- @PreAuthorize 支持SpEL表达式，可以根据参数值进行动态权限判断。
- @Secured 直接指定角色，限制只有特定角色才能访问该接口。
- 这些注解由Spring AOP代理机制实现，确保了接口调用前的安全性校验。

通过接口级别的权限控制，可以实现细粒度的权限管理，确保系统中不同角色只能访问其授权范围内的资源。

本文还有配套的精品资源，点击获取

简介：代理模式作为结构型设计模式的重要组成部分，主要用于通过代理对象控制对目标对象的访问。其常见用途包括远程代理、虚拟代理、安全代理和智能引用等。本内容系统讲解了代理模式的核心角色（目标对象、代理对象和客户端）、实现方式（静态代理与动态代理）以及在Java中的具体实现机制。同时，结合实际应用场景，如权限控制、日志记录、缓存策略等，展示了代理模式在软件架构设计中的灵活性与扩展性。通过学习，开发者可掌握如何在不修改原有对象的前提下，增强系统功能并提升安全性。

本文还有配套的精品资源，点击获取