代理模式

大白菜小南
118 阅读11分钟

定义

代理模式（Proxy Pattern）是一种结构型设计模式，它定义了一种为其他对象提供一种代理以控制对这个对象的访问的方式。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

具体来说，代理模式为其他对象创建一个代理对象，以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介的作用，客户端并不直接访问目标对象，而是通过代理对象间接地访问。这样做的好处包括保护目标对象、增强目标对象的功能、实现客户端和目标对象之间的解耦等。

代理模式的主要角色包括：

代理对象（Proxy）：代理对象在客户端和目标对象之间起到中介的作用，它持有目标对象的引用，并控制对目标对象的访问。代理对象通常会在调用目标对象的方法前后添加一些额外的操作，如权限检查、日志记录、事务处理等。

目标对象（Real Subject）：目标对象是代理对象所代表的实际对象，是客户端最终要访问的对象。客户端通过代理对象间接地访问目标对象，而不是直接引用目标对象。

客户端（Client）：客户端是代理模式的发起者，它通过代理对象来间接访问目标对象。客户端并不知道代理对象和目标对象之间的具体实现细节，它只关心代理对象提供的接口。

代理模式可以分为静态代理和动态代理两种：

静态代理：静态代理是由程序员在编写代码时手动创建的代理类。代理类与目标类在代码层面上有明确的关联，代理类的实现依赖于目标类的具体实现。静态代理的优点是实现简单，缺点是当目标类接口发生变化时，代理类也需要相应地进行修改，增加了维护成本。

动态代理：动态代理是在运行时动态生成的代理类。它不需要程序员手动编写代理类的代码，而是由运行时环境（如JVM）根据目标类的接口动态生成代理类的字节码，并通过反射机制加载到JVM中。动态代理的优点是实现灵活，可以适应目标类接口的变化，缺点是相对于静态代理来说，会有一定的性能开销。

在Java等面向对象的编程语言中，动态代理通常通过反射机制和代理框架（如JDK自带的动态代理、Cglib等）来实现。动态代理的实现方式比静态代理更加灵活和强大，因此在实际开发中得到了广泛的应用。

类定义

在TypeScript中，代理模式的类定义示例可以通过静态代理或动态代理来实现。由于TypeScript本身不直接支持像Java那样的动态代理机制（如通过java.lang.reflect.Proxy类），我们通常通过高阶函数、装饰器或类继承来模拟动态代理的行为。不过，为了保持简单，这里我先给出一个静态代理的示例。

静态代理示例：

typescript // 目标接口 interface Image { display(): void; }

// 目标对象 class RealImage implements Image { private filename: string;

constructor(filename: string) {
    this.filename = filename;
    console.log('Loading ' + this.filename);
}

display(): void {
    console.log('Displaying ' + this.filename);
}

}

// 代理类 class ProxyImage implements Image { private realImage: RealImage | null; private filename: string;

constructor(filename: string) {
    this.realImage = null;
    this.filename = filename;
}

display(): void {
    if (this.realImage === null) {
        this.realImage = new RealImage(this.filename);
    }
    this.realImage.display();
}

// 可以添加其他控制逻辑，如缓存、延迟加载等

}

// 客户端代码 function showImage(image: Image) { image.display(); }

const proxy = new ProxyImage('test.png'); showImage(proxy); // 输出：Loading test.png 和 Displaying test.png

在这个示例中，RealImage是目标对象，它实现了Image接口。ProxyImage是代理类，它也实现了Image接口，并在其display方法中封装了对RealImage实例的访问。代理类可以在调用目标对象的display方法之前或之后添加额外的逻辑，比如在这个例子中，代理类实现了懒加载功能，即只有在真正需要显示图片时才创建RealImage实例。

对于动态代理，在TypeScript中通常需要使用装饰器（Decorators）或高阶函数等高级特性来模拟。然而，由于装饰器目前在TypeScript中还是实验性功能，并且它们主要用于类和类成员的元数据注解，而不是直接用于创建代理对象，因此在这里不深入讨论。如果你需要动态代理的功能，可以考虑使用现有的库，如ts-proxy，或者通过高阶函数等方式自行实现。

注意：上述示例中的“动态代理”和Java等语言中的动态代理在概念上有所不同。在TypeScript中，我们通常通过编程技巧来模拟动态代理的行为，而不是直接依赖语言或框架提供的动态代理机制。

场景

代理模式在前端开发中有多种应用场景，主要围绕对象访问控制、功能增强、数据预处理和后处理等方面。以下是一些具体的应用场景：

数据加载与缓存：

在前端应用中，经常需要从后端API加载数据。使用代理模式，可以创建一个代理对象来封装数据加载逻辑，包括缓存机制。这样，当需要相同数据时，可以直接从缓存中获取，而无需再次发送请求到服务器，从而提高应用性能。

权限控制：

在需要权限验证的场景中，可以使用代理模式来控制对特定资源的访问。代理对象会检查用户的权限，并根据权限决定是否允许访问目标对象。这在单页应用（SPA）中尤为常见，例如，在路由守卫中使用代理来验证用户是否有权访问某个页面或路由。

数据转换与格式化：

代理模式可以用于在数据从后端传输到前端时进行转换和格式化。例如，后端可能返回的是JSON格式的日期字符串，而前端需要将其转换为JavaScript的Date对象。代理对象可以在数据到达前端之前进行这种转换，使得前端代码可以更加简洁和易于维护。

网络请求的封装：

在进行网络请求时，可以使用代理模式来封装请求逻辑，包括错误处理、重试机制、请求拦截等。代理对象会接收客户端的请求，并发送到服务器。同时，它还会处理服务器的响应，并在返回给客户端之前进行必要的处理。

事件监听与处理：

在前端应用中，经常需要监听和处理DOM事件。使用代理模式，可以创建一个代理对象来封装事件监听逻辑，包括事件的添加、移除和回调函数的执行。这样可以使得事件处理更加集中和模块化，也便于管理和维护。

远程对象访问：

在使用WebSockets或WebSocket-like技术（如RPC）时，可以使用代理模式来实现对远程对象的透明访问。代理对象会作为客户端和目标远程对象之间的中介，负责处理网络通信和序列化/反序列化等任务。

性能优化：

代理模式还可以用于性能优化。例如，在懒加载或按需加载的场景中，可以使用代理对象来延迟实际对象的创建和初始化，直到真正需要时才进行。这可以减少应用的初始加载时间，提高用户体验。

需要注意的是，虽然代理模式在前端开发中有多种应用场景，但并非所有情况都适合使用代理模式。在决定使用代理模式之前，需要仔细分析具体需求，并考虑是否有其他更合适的设计模式或解决方案。同时，也需要注意代理模式可能带来的额外复杂性和性能开销。

案例

代理模式（Proxy Pattern）在JavaScript中是一种常用的设计模式，它允许你创建一个对象的代理，以控制对这个对象的访问。在JavaScript中，由于其动态性和原型继承的特性，实现代理模式相对直接。以下是一些使用JavaScript实现代理模式的案例：

  1. 缓存代理

缓存代理可以缓存对目标对象的访问结果，以提高性能。当再次请求相同的数据时，可以直接从缓存中获取，而无需再次执行可能耗时的操作。

javascript function createCacheProxy(target) { const cache = {};

return new Proxy(target, {
    get(target, propKey, receiver) {
        if (propKey in cache) {
            return cache[propKey];
        }

        const result = Reflect.get(target, propKey, receiver);
        cache[propKey] = result;
        return result;
    }
});

}

const data = { expensiveCalculation() { console.log('Performing expensive calculation...'); return 'Result'; } };

const cachedData = createCacheProxy(data);

console.log(cachedData.expensiveCalculation()); // 执行并缓存 console.log(cachedData.expensiveCalculation()); // 从缓存中获取 2. 访问控制代理

访问控制代理可以限制对目标对象的某些属性的访问。例如，你可能只想允许读取某些属性，而不允许修改它们。

javascript function createAccessProxy(target) { return new Proxy(target, { get(target, propKey, receiver) { if (propKey.startsWith('')) { throw new Error('Private properties are not accessible.'); } return Reflect.get(target, propKey, receiver); }, set(target, propKey, value, receiver) { if (propKey.startsWith('')) { throw new Error('Private properties cannot be set.'); } return Reflect.set(target, propKey, value, receiver); } }); }

const person = { _name: 'John Doe', age: 30 };

const proxyPerson = createAccessProxy(person);

console.log(proxyPerson.age); // 30 proxyPerson.age = 31; console.log(proxyPerson.age); // 31

try { console.log(proxyPerson._name); // 抛出错误 } catch (e) { console.error(e.message); }

try { proxyPerson._name = 'Jane Doe'; // 抛出错误 } catch (e) { console.error(e.message); } 3. 日志代理

日志代理可以在访问目标对象时记录日志，这对于调试和监控非常有用。

javascript function createLogProxy(target) { return new Proxy(target, { get(target, propKey, receiver) { console.log(Accessing ${propKey}); return Reflect.get(target, propKey, receiver); }, set(target, propKey, value, receiver) { console.log(Setting ${propKey} to ${value}); return Reflect.set(target, propKey, value, receiver); } }); }

const obj = { a: 1, b: 2 };

const proxyObj = createLogProxy(obj);

console.log(proxyObj.a); // Accessing a proxyObj.b = 3; // Setting b to 3

这些案例展示了代理模式在JavaScript中的多种用途，包括缓存、访问控制和日志记录。通过代理，你可以在不修改原始对象的情况下，为其添加额外的行为和功能。

代理模式的优缺点

代理模式（Proxy Pattern）是一种常用的设计模式，它主要用于为其他对象提供一种代理以控制对这个对象的访问。在代理模式中，会创建一个具有现有对象相同接口的代理对象，以便在代理对象中插入额外的操作。这种设计模式在软件开发中有很多应用场景，比如远程代理、虚拟代理、安全代理、智能引用等。以下是代理模式的一些主要优缺点：

优点

增强原有对象的功能： 代理可以在客户端和目标对象之间起到中介的作用，可以在不修改目标对象的前提下，增加额外的功能。

控制访问： 可以基于客户端的权限、请求的内容等，决定是否将请求转发给目标对象，从而控制对目标对象的访问。

减少创建对象的开销： 对于开销较大的对象，可以通过代理来间接创建，仅在真正需要时才创建目标对象，降低资源消耗。

实现延迟加载： 当目标对象较大或加载成本较高时，可以使用代理来延迟加载目标对象，提高程序的性能。

保护目标对象： 在客户端和目标对象之间设置一道屏障，防止外部对目标对象的直接访问，从而保护目标对象。

隐藏实现细节： 通过代理隐藏目标对象的实现细节，只提供接口给客户端，降低系统的耦合度。

缺点

增加系统复杂性： 在系统中引入代理模式会增加额外的类，增加系统的复杂性和理解难度。

性能开销： 客户端通过代理访问目标对象时，会增加一层调用，可能会带来一定的性能开销。

透明性问题： 如果代理对象需要完全模拟目标对象的行为，那么需要确保代理对象和目标对象具有相同的接口，这可能会增加实现的复杂性。

错误处理： 在代理中可能需要处理额外的逻辑，如权限验证、日志记录等，这可能会增加错误处理的复杂性。

综上所述，代理模式在软件开发中具有广泛的应用价值，但同时也需要注意其可能带来的缺点和复杂性。在实际应用中，应根据具体需求选择合适的代理实现方式，并权衡其优缺点。

avatar
文章
阅读
粉丝