探秘代理设计模式的多维实现：C/Java/JS/Go/Python/TS的演绎

后端

2023-11-06 07:47:25

代理设计模式：赋予对象交互灵活性与控制

什么是代理设计模式？

代理设计模式是一种结构型设计模式，在客户端和对象之间引入一层代理对象。代理对象负责控制对真实对象的访问，同时提供额外的功能或增强。它旨在提高系统的灵活性、可扩展性和安全性。

代理设计模式的分类

代理设计模式有几种常见分类：

保护代理： 限制对真实对象的访问，仅允许经过授权的客户端进行访问。
缓冲代理： 缓存真实对象的状态，提高访问性能。
虚拟代理： 延迟真实对象的初始化，直到真正需要时才创建，从而优化资源分配。

代理设计模式的应用

代理设计模式在软件开发中有着广泛的应用：

数据隔离： 代理对象将真实对象与客户端隔离开来，保护真实对象不受客户端直接影响。
访问控制： 代理对象控制对真实对象的访问，确保只有经过授权的客户端才能进行操作。
延迟加载： 代理对象延迟初始化真实对象，避免不必要的资源消耗。
并发控制： 代理对象控制对真实对象的并发访问，防止数据不一致。

如何实现代理设计模式？

以下是使用 C++、Java、JavaScript、Go、Python 和 TypeScript 实现代理设计模式的示例代码：

C++ 代码：

struct ISubject {
    virtual void request() = 0;
};

struct RealSubject : ISubject {
    void request() override {
        std::cout << "RealSubject: Handling request.\n";
    }
};

struct Proxy : ISubject {
    RealSubject* real_subject;
    Proxy(RealSubject* real_subject) : real_subject(real_subject) {}

    void request() override {
        std::cout << "Proxy: Pre-processing.\n";
        real_subject->request();
        std::cout << "Proxy: Post-processing.\n";
    }
};

int main() {
    ISubject* subject = new Proxy(new RealSubject);
    subject->request();
    delete subject;
    return 0;
}

Java 代码：

interface ISubject {
    void request();
}

class RealSubject implements ISubject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

class Proxy implements ISubject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        System.out.println("Proxy: Pre-processing.");
        realSubject.request();
        System.out.println("Proxy: Post-processing.");
    }
}

public class Main {
    public static void main(String[] args) {
        ISubject subject = new Proxy(new RealSubject());
        subject.request();
    }
}

JavaScript 代码：

const ISubject = {
    request: function() {
        throw new Error("Not implemented");
    }
};

const RealSubject = function() {
    this.request = function() {
        console.log("RealSubject: Handling request.");
    };
};

const Proxy = function(realSubject) {
    this.realSubject = realSubject;

    this.request = function() {
        console.log("Proxy: Pre-processing.");
        this.realSubject.request();
        console.log("Proxy: Post-processing.");
    };
};

const subject = new Proxy(new RealSubject);
subject.request();

Go 代码：

type ISubject interface {
    request()
}

type RealSubject struct{}

func (r *RealSubject) request() {
    fmt.Println("RealSubject: Handling request.")
}

type Proxy struct {
    realSubject *RealSubject
}

func (p *Proxy) request() {
    fmt.Println("Proxy: Pre-processing.")
    p.realSubject.request()
    fmt.Println("Proxy: Post-processing.")
}

func main() {
    subject := &Proxy{
        realSubject: &RealSubject{},
    }
    subject.request()
}

Python 代码：

class ISubject:
    def request(self):
        pass

class RealSubject(ISubject):
    def request(self):
        print("RealSubject: Handling request.")

class Proxy(ISubject):
    def __init__(self, real_subject):
        self.real_subject = real_subject

    def request(self):
        print("Proxy: Pre-processing.")
        self.real_subject.request()
        print("Proxy: Post-processing.")

def main():
    subject = Proxy(RealSubject())
    subject.request()

if __name__ == "__main__":
    main()

TypeScript 代码：

interface ISubject {
    request(): void;
}

class RealSubject implements ISubject {
    request() {
        console.log("RealSubject: Handling request.");
    }
}

class Proxy implements ISubject {
    private realSubject: RealSubject;

    constructor(realSubject: RealSubject) {
        this.realSubject = realSubject;
    }

    request() {
        console.log("Proxy: Pre-processing.");
        this.realSubject.request();
        console.log("Proxy: Post-processing.");
    }
}

const subject = new Proxy(new RealSubject());
subject.request();