代理模式（英語：proxy pattern），是程式設計中的一種設計模式。所謂的代理者是指一個類別可以作為其它東西的介面。代理者可以作任何東西的介面：網路連接、記憶體中的大物件、檔案或其它昂貴或無法複製的資源。
概述
编辑著名的代理模式例子為參照計數（英語：reference counting）指標物件。當一個複雜物件的多份副本須存在時，代理模式可以結合享元模式以減少記憶體用量。典型作法是建立一個複雜物件及多個代理者，每個代理者會參照到原本的複雜物件。而作用在代理者的運算會轉送到原本物件。一旦所有的代理者都不存在時，複雜物件會被移除。
结构
编辑
在上面的UML类图中，Proxy类实现了Subject接口，使它充当Subject对象的代替者。它维护一个引用（realSubject）至被代替的对象（RealSubject），使其可以转发给它（realSubject.operation()）。
序列图展示了运行时交互：The Client对象通过合作于Proxy对象，来控制到RealSubject对象的访问。在这个例子中，Proxy转发请求至RealSubject，它办理这个请求。
示例
编辑C++
编辑下面是C++的例子：
import std;
using std::string;
using std::unique_ptr;
// Subject Interface
class Image {
public:
virtual void display() const = 0;
virtual ~Image() = default;
};
// Real Subject (expensive to load)
class RealImage : public Image {
private:
string filename;
public:
explicit RealImage(const string& file):
filename{file} {
loadFromDisk();
}
void display() const override {
std::println("Displaying image: {}", filename);
}
private:
void loadFromDisk() const {
std::println("Loading image from disk: {}", filename);
}
};
// Proxy (controls access to RealImage)
class ProxyImage : public Image {
private:
string filename;
mutable unique_ptr<RealImage> realImage; // lazily created
public:
explicit ProxyImage(const string& file):
filename{file} {}
void display() const override {
if (!realImage) {
std::println("(Proxy) Loading image on demand...");
realImage = std::make_unique<RealImage>(filename);
}
realImage->display();
}
};
// Client code
int main() {
Image* img = new ProxyImage("photo.png");
// First display (should load)
img->display();
// Second display (should use cached image)
img->display();
delete img;
return 0;
}
Java
编辑以下Java範例解釋惰性載入模式中的“虛擬代理”方法。ProxyImage 類別用來存取遠端方法。
import java.util.*;
interface Image {
public void displayImage();
}
//on System A
class RealImage implements Image {
private String filename;
public RealImage(String filename) {
this.filename = filename;
loadImageFromDisk();
}
private void loadImageFromDisk() {
System.out.println("Loading " + filename);
}
public void displayImage() {
System.out.println("Displaying " + filename);
}
}
//on System B
class ProxyImage implements Image {
private String filename;
private Image image;
public ProxyImage(String filename) {
this.filename = filename;
}
public void displayImage() {
if(image == null)
image = new RealImage(filename);
image.displayImage();
}
}
class ProxyExample {
public static void main(String[] args) {
Image image1 = new ProxyImage("HiRes_10MB_Photo1");
Image image2 = new ProxyImage("HiRes_10MB_Photo2");
image1.displayImage(); // loading necessary
image2.displayImage(); // loading necessary
}
}
程式的輸出為：
Loading HiRes_10MB_Photo1
Displaying HiRes_10MB_Photo1
Loading HiRes_10MB_Photo2
Displaying HiRes_10MB_Photo2
C#
编辑C#的例子：
using System;
namespace Proxy {
interface IImage {
void Display();
}
class RealImage : IImage {
public RealImage(string fileName) {
FileName = fileName;
LoadFromFile();
}
private void LoadFromFile() {
Console.WriteLine("Loading " + FileName);
}
public String FileName { get; private set; }
public void Display() {
Console.WriteLine("Displaying " + FileName);
}
}
class ProxyImage : IImage {
public ProxyImage(string fileName) {
FileName = fileName;
}
public String FileName { get; private set; }
private IImage image;
public void Display() {
if (image == null)
image = new RealImage(FileName);
image.Display();
}
}
class Program {
static void Main(string[] args) {
IImage image = new ProxyImage("HiRes_Image");
for (int i = 0; i < 10; i++)
image.Display();
}
}
}
程式的輸出為：
Loading HiRes_Image
Displaying HiRes_Image
Displaying HiRes_Image
Displaying HiRes_Image
Displaying HiRes_Image
Displaying HiRes_Image
Displaying HiRes_Image
Displaying HiRes_Image
Displaying HiRes_Image
Displaying HiRes_Image
Displaying HiRes_Image
Python
编辑from abc import ABC, abstractmethod
import functools
class Image(ABC):
@abstractmethod
def display(self): pass
@functools.lru_cache(maxsize=2)
class RealImage(Image):
def __init__(self, filename):
self.filename = filename
self.load_from_disk()
def load_from_disk(self):
print("Loading ", self.filename)
def display(self):
print("Displaying ", self.filename)
class ProxyImage(Image):
def __init__(self, filename):
self.filename = filename
def display(self):
RealImage(self.filename).display()
def example():
image1 = ProxyImage("HiRes_Photo1")
image2 = ProxyImage("HiRes_Photo2")
image3 = ProxyImage("HiRes_Photo3")
image1.display()
image2.display()
image3.display()
image3.display()
image2.display()
image1.display()
这里的标准库functools的lru_cache缓存采用了最少最近使用（LRU）缓存替换算法，缓存的最大大小maxsize的缺省值为128，如果设置其为None，这个缓存就等同于没有大小限制的cache缓存，这里为了演示替换效果而将其设置为很小的2。下面其执行：
>>> example()
Loading HiRes_Photo1
Displaying HiRes_Photo1
Loading HiRes_Photo2
Displaying HiRes_Photo2
Loading HiRes_Photo3
Displaying HiRes_Photo3
Displaying HiRes_Photo3
Displaying HiRes_Photo2
Loading HiRes_Photo1
Displaying HiRes_Photo1
另見
编辑引用
编辑- ^ The Proxy design pattern - Structure and Collaboration. w3sDesign.com. [2017-08-12].
外部連結
编辑- Java 中的代理模式
- UML 和 LePUS3 （一種形式塑模語言）中的代理模式
- 以代理模式掌控大局
- PerfectJPattern 開源計劃（页面存档备份，存于互联网档案馆），提供 Java 中代理模式的元件實作。
