代理设计模式

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《代理设计模式》，文章讲解的知识点主要包括，如果你对文章方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

在我之前的博客中，我探索了各种处理对象创建机制的创作设计模式。现在，是时候深入研究结构设计模式，它重点关注如何组合对象和类以形成更大的结构，同时保持它们的灵活性和高效性。让我们从代理设计模式开始

javascript 中的代理设计模式

代理设计模式是一种结构设计模式，它提供一个对象代表另一个对象。它充当控制对真实对象的访问的中介，添加附加行为，例如延迟初始化、日志记录、访问控制或缓存，而无需更改原始对象的代码。

在 javascript 中，代理是 proxy 对象提供的内置功能，允许您为属性访问、赋值、函数调用等基本操作定义自定义行为。

我们什么时候需要代理模式？

代理模式在以下情况下特别有用：

• 延迟初始化：您希望延迟创建资源密集型对象，直到需要它为止。
• 访问控制：您需要控制对对象的访问，例如限制未经授权的访问或根据条件限制操作。
• 日志记录：您想要记录对象上的操作（例如，属性访问或方法调用）。
• 缓存：您想要缓存昂贵操作的结果以避免冗余计算。

代理模式的组成部分

1. 主题： 定义真实对象和代理的公共操作的接口。
2. realsubject： 执行实际工作的实际对象。
3. 代理： 控制对 realsubject 的访问的中介。

类比：

想象一下，您有一幅大画想要向客人展示，但需要花费很多时间才能从储藏室中取出它（因为它很重并且需要时间来搬运）。您决定使用这幅画的小明信片图像，在他们等待实际画作被获取时快速向他们展示，而不是每次都等待。

在这个比喻中：

• 大画是真实的物体（就像需要时间加载的图像）。
• 明信片是代理（一种轻量级替代品，直到真实对象准备好为止）。
• 一旦真正的画作准备好，您就可以向客人展示实际的画作。

现实世界的类比：

将房地产经纪人视为代理人。当你想买房子时，你不会立即参观每栋房子（加载实物）。相反，房地产经纪人（代理人）首先向您展示照片和描述。只有当你准备购买时（即，当你调用display()时），代理才会安排看房（加载实物）。

真实示例：图像加载（虚拟代理）

让我们使用 web 应用程序中的图像加载示例，我们希望延迟图像的加载，直到用户请求它（延迟加载）。代理可以充当占位符，直到加载真实图像。

以下是如何在 javascript 中实现代理设计模式。

示例：图像加载代理

// step 1: the real object
class realimage {
  constructor(filename) {
    this.filename = filename;
    this.loadimagefromdisk();
  }

  loadimagefromdisk() {
    console.log(`loading ${this.filename} from disk...`);
  }

  display() {
    console.log(`displaying ${this.filename}`);
  }
}

// step 2: the proxy object
class proxyimage {
  constructor(filename) {
    this.realimage = null; // no real image yet
    this.filename = filename;
  }

  display() {
    if (this.realimage === null) {
      // load the real image only when needed
      this.realimage = new realimage(this.filename);
    }
    this.realimage.display(); // display the real image
  }
}

// step 3: using the proxy to display the image
const image = new proxyimage("photo.jpg");
image.display(); // loads and displays the image
image.display(); // just displays the image (already loaded)

说明：

1)。真实图像：

• realimage类代表实际图像。
• 它以文件名作为输入，并模拟从磁盘加载图像的耗时过程（由 loadimagefromdisk 方法显示）。
• 加载后，将使用显示方法来显示图像。

2）。代理图像：

• proxyimage类充当realimage的替代品。它不会立即加载真实图像。
• 它包含对真实图像的引用（但最初它是空的，因为真实图像尚未加载）。
• 当您在代理上调用显示方法时，它会检查真实图像是否已加载。如果没有，它会先加载，然后显示。

3）。用法：

• 当我们创建 proxyimage 实例时，实际图像尚未加载（因为它是资源密集型的）。
• 第一次调用 display 时，代理加载图像（使用 realimage 类），然后显示它。
• 第二次调用display时，真实图片已经加载完毕，所以只显示图片，不再加载。

内置proxy对象

es6 代理由一个代理构造函数组成，该构造函数接受目标和处理程序作为参数

const proxy = new proxy(target, handler)

这里，target代表应用代理的对象，而handler是一个特殊的对象，定义了代理的行为。

处理程序对象包含一系列具有预定义名称的可选方法，称为陷阱方法（例如 apply、get、set 和 has），当对代理实例执行相应操作时，这些方法会自动调用。

让我们通过使用内置代理实现计算器来理解这一点

// Step 1: Define the Calculator class with prototype methods
class Calculator {
  constructor() {
    this.result = 0;
  }

  // Prototype method to add numbers
  add(a, b) {
    this.result = a + b;
    return this.result;
  }

  // Prototype method to subtract numbers
  subtract(a, b) {
    this.result = a - b;
    return this.result;
  }

  // Prototype method to multiply numbers
  multiply(a, b) {
    this.result = a * b;
    return this.result;
  }

  // Prototype method to divide numbers
  divide(a, b) {
    if (b === 0) throw new Error("Division by zero is not allowed.");
    this.result = a / b;
    return this.result;
  }
}

// Step 2: Create a proxy handler to intercept operations
const handler = {
  // Intercept 'get' operations to ensure access to prototype methods
  get(target, prop, receiver) {
    if (prop in target) {
      console.log(`Accessing property: ${prop}`);
      return Reflect.get(target, prop, receiver); // Access property safely
    } else {
      throw new Error(`Property "${prop}" does not exist.`);
    }
  },

  // Intercept 'set' operations to prevent mutation
  set(target, prop, value) {
    throw new Error(`Cannot modify property "${prop}". The calculator is immutable.`);
  }
};

// Step 3: Create a proxy instance that inherits the Calculator prototype
const calculator = new Calculator(); // Original calculator object
const proxiedCalculator = new Proxy(calculator, handler); // Proxy wrapping the calculator

// Step 4: Use the proxy instance
try {
  console.log(proxiedCalculator.add(5, 3)); // Output: 8
  console.log(proxiedCalculator.multiply(4, 2)); // Output: 8
  console.log(proxiedCalculator.divide(10, 2)); // Output: 5

  // Attempt to access prototype directly through proxy
  console.log(proxiedCalculator.__proto__ === Calculator.prototype); // Output: true

  // Attempt to modify a property (should throw an error)
  proxiedCalculator.result = 100; // Error: Cannot modify property "result".
} catch (error) {
  console.error(error.message); // Output: Cannot modify property "result". The calculator is immutable.
}

使用代理的最佳部分是：

• 代理对象继承了原calculator类的原型。
• 通过代理设置的陷阱来避免突变。

代码说明

1)。 原型继承：

• 代理不会干扰 **calculator ** 类的原始原型。
• 通过检查 proxiedcalculator.proto === calculator.prototype 来确认这一点。结果将是true。

2）。 处理 getoperations：

• get 陷阱拦截代理对象上的属性访问。
• 我们使用 reflect.get 安全地访问原始对象的属性和方法。

3）。 防止突变：

每当尝试修改目标对象上的任何属性时，设置陷阱都会引发错误。这确保了不变性。

4)。 通过代理使用原型方法：

代理允许访问加、减、乘、除等方法，所有这些方法都在原始对象的原型上定义。

这里要观察的要点是：

• 保留原型继承：代理保留对所有原型方法的访问，使其行为类似于原始计算器。
• 防止突变： 设置陷阱可确保计算器对象的内部状态不会被意外更改。
• 安全访问属性和方法： get 陷阱确保仅访问有效的属性，从而提高鲁棒性。

如果您已经做到了这一步，请不要忘记点赞❤️，并在下面发表评论以提出任何问题或想法。您的反馈对我来说至关重要，我很乐意听到您的来信！

以上就是《代理设计模式》的详细内容，更多关于的资料请关注golang学习网公众号！