【代理设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

简介

代理模式（Proxy Pattern）是一种结构型设计模式，用一个类来代理另一个类或几个类的功能。
在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
延迟初始化（虚拟代理）。如果你有一个偶尔使用的重量级服务对象，一直保持该对象运行会消耗系统资源时，可使用代理模式。
访问控制（保护代理）。如果你只希望特定客户端使用服务对象，这里的对象可以是操作系统中非常重要的部分，而客户端则是各种已启动的程序 （包括恶意程序）， 此时可使用代理模式。
作用

• 为其他对象提供一种代理访问的方式。
  
• 避免直接访问可能带来的问题，通过接口和代理来实现高扩展。
  

实现步骤

• 定义一个基础接口，约定一些方法。
  
• 建立原始类，实现接口方法。
  
• 再建立代理类，也实现基础接口。代理类调用原始类来实现功能。
  

UML

 
Java代码

代理接口类

1. // Image.java 定义一个接口供代理和实际调用来使用
2. public interface Image {
3.   void display();
4. }

复制代码

功能代理类

1. // ProxyImage.java 代理类也实现了基础接口
2. public class ProxyImage implements Image {
4.   private RealImage realImage;
5.   private String fileName;
7.   public ProxyImage(String fileName) {
8.     this.fileName = fileName;
9.   }
11.   @Override
12.   public void display() {
13.     System.out.println("ProxyImage::display() " + fileName);
14.     if (realImage == null) {
15.       realImage = new RealImage(fileName);
16.     }
17.     // 代理类调用真实类的方法
18.     realImage.display();
19.   }
20. }

复制代码

真实功能类

1. // RealImage.java 真实类也实现基础代理接口
2. public class RealImage implements Image {
4.   private String fileName;
6.   public RealImage(String fileName) {
7.     // 在初始化时执行内部逻辑
8.     this.fileName = fileName;
9.     loadFromDisk(fileName);
10.   }
12.   @Override
13.   public void display() {
14.     System.out.println("RealImage::display() " + fileName);
15.   }
17.   // 这个方法只是内部使用
18.   private void loadFromDisk(String fileName) {
19.     System.out.println("RealImage::loadFromDisk()  " + fileName);
20.   }
21. }

复制代码

测试调用

1.   /**
2.    * 代理模式就是用一个类来代理另一个类或几个类的功能，以便隔绝外部客户和内部真实类
3.    * 这样真实类和调用方之间有一个代理屏障，保证了安全
4.    * 同时真实的类如果初始化过，就不再初始化，提升了性能
5.    */
7.     // 声明代理类来执行真实类的能力
8.     Image image = new ProxyImage("001.jpg");
10.     // 代理类执行真实类的能力
11.     image.display();
13.     // 再调用一次，不会重复实例化
14.     image.display();

复制代码

Go代码

代理接口类

1. // Image.go 定义一个接口供代理和实际调用来使用
2. type Image interface {
3.   Init(fileName string)
4.   Display()
5. }

复制代码

功能代理类

1. // ProxyImage.go 代理类也实现了基础接口
2. type ProxyImage struct {
3.   fileName string
4.   // 直接聚合真实类
5.   // realImage RealImage
6.   // 聚合接口
7.   realImage Image
8. }
10. // 设置文件名称
11. func (p *ProxyImage) SetFileName(fileName string) {
12.   p.fileName = fileName
13. }
15. func (p *ProxyImage) Display() {
16.   fmt.Println("ProxyImage::Display() " + p.fileName)
17.   if p.realImage == nil {
18.     p.realImage = &RealImage{}
19.     p.realImage.Init(p.fileName)
20.   }
21.   // 代理类调用真实类的方法
22.   p.realImage.Display()
23. }

复制代码

真实功能类

1. // RealImage.go 真实类也实现基础代理接口
2. type RealImage struct {
3.   fileName string
4. }
6. // 在初始化时执行内部逻辑
7. func (r *RealImage) Init(fileName string) {
8.   r.fileName = fileName
9.   r.LoadFromDisk(fileName)
10. }
12. func (r *RealImage) Display() {
13.   fmt.Println("RealImage::Display() " + r.fileName)
14. }
16. // 这个方法只是内部使用
17. func (r *RealImage) LoadFromDisk(fileName string) {
18.   fmt.Println("RealImage::LoadFromDisk()  " + fileName)
19. }

复制代码

测试调用

1. func main() {
2.   fmt.Println("test start:")
3.   /**
4.    * 代理模式就是用一个类来代理另一个类或几个类的功能，以便隔绝外部客户和内部真实类
5.    * 这样真实类和调用方之间有一个代理屏障，保证了安全
6.    * 同时真实的类如果初始化过，就不再初始化，提升了性能
7.    */
9.   // 声明代理类来执行真实类的能力
10.   var image = &src.ProxyImage{}
11.   image.SetFileName("001.jpg")
13.   // 代理类执行真实类的能力
14.   image.Display()
16.   // 再调用一次，真实类不会重复实例化
17.   image.Display()
18. }

复制代码

C代码简版

1. // simple_proxy.c
2. #include <stdio.h>
4. // 代理模式就是用一个类来代理另一个类或几个类的功能，以便隔绝外部客户和内部真实类
6. // 定义接口
7. typedef struct Interface
8. {
9.     void (*method)(struct Interface *interface);
10. } Interface;
12. // 实现接口的具体类
13. typedef struct Concrete
14. {
15.     void (*method)(struct Concrete *interface);
16. } Concrete;
18. void real_method(struct Concrete *interface)
19. {
20.     printf("调用真实方法 real_method.\n");
21. }
23. // 代理类，继承接口，聚合具体类实例
24. typedef struct Proxy
25. {
26.     struct Interface *real_subject;
27. } Proxy;
29. // 代理类方法实现，通过聚合的具体类实例来调用具体类的方法
30. void proxy_method(struct Interface *interface)
31. {
32.     struct Proxy *p = (struct Proxy *)interface;
33.     p->real_subject->method((struct Interface *)p);
34. }
36. int main()
37. {
38.     // 创建具体类实例
39.     struct Concrete real_subject = {
40.         .method = &real_method,
41.     };
43.     // 创建代理类实例并聚合具体类实例
44.     struct Proxy proxy_instance = {
45.         .real_subject = (struct Interface *)&real_subject,
46.     };
48.     // 将代理类的方法指针指向代理类的方法实现
49.     struct Interface proxy_interface = {
50.         .method = &proxy_method,
51.     };
53.     // 通过代理类的接口调用具体类方法
54.     proxy_interface.method((struct Interface *)&proxy_instance);
56.     return 0;
57. }

复制代码

更多语言版本

不同语言实现设计模式：https://github.com/microwind/design-pattern

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！