Proxyパターン 調査ドキュメント

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

      +-------------+
      |   Subject   |<-------------------+
      +-------------+                    |
      | +request()  |                    |
      +-------------+                    |
          /   \                          |
         /     \                         |
+---------------+          +-------------------+
|  RealSubject  |          |      Proxy        |
+---------------+          +-------------------+
| +request()    |          | +request()        |
+---------------+          | -realSubject      |
                           +-------------------+
                                    |
                                    | (holds reference)
                                    v
                           [RealSubject instance]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

from abc import ABC, abstractmethod

# Subject Interface
class Image(ABC):
    @abstractmethod
    def display(self):
        pass

# RealSubject
class RealImage(Image):
    def __init__(self, filename):
        self.filename = filename
        self._load_from_disk()
    
    def _load_from_disk(self):
        print(f"Loading image from disk: {self.filename}")
        # 実際には重い処理（ファイルI/O、デコードなど）
        self.image_data = f"Image data of {self.filename}"
    
    def display(self):
        print(f"Displaying {self.filename}")

# Proxy
class ProxyImage(Image):
    def __init__(self, filename):
        self.filename = filename
        self._real_image = None  # 遅延初期化のため、最初はNone
    
    def display(self):
        # 必要になるまでRealImageを生成しない（遅延初期化）
        if self._real_image is None:
            self._real_image = RealImage(self.filename)
        self._real_image.display()

# 使用例
if __name__ == "__main__":
    # プロキシを作成（この時点では画像は読み込まれない）
    image1 = ProxyImage("photo1.jpg")
    image2 = ProxyImage("photo2.jpg")
    
    print("--- 画像を表示（初回） ---")
    image1.display()  # この時点で初めて読み込まれる
    
    print("\n--- 画像を再表示 ---")
    image1.display()  # 既に読み込み済みなので再読み込みしない
    
    print("\n--- 別の画像を表示 ---")
    image2.display()  # この時点で読み込まれる

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

--- 画像を表示（初回） ---
Loading image from disk: photo1.jpg
Displaying photo1.jpg

--- 画像を再表示 ---
Displaying photo1.jpg

--- 別の画像を表示 ---
Loading image from disk: photo2.jpg
Displaying photo2.jpg

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# Subject Interface
class SecretDocument(ABC):
    @abstractmethod
    def view(self):
        pass

# RealSubject
class ConfidentialDocument(SecretDocument):
    def __init__(self, content):
        self.content = content
    
    def view(self):
        print(f"機密情報: {self.content}")

# Protection Proxy
class DocumentProtectionProxy(SecretDocument):
    def __init__(self, document, user_role):
        self.document = document
        self.user_role = user_role
    
    def view(self):
        if self.user_role in ["admin", "manager"]:
            print(f"アクセス許可: {self.user_role}")
            self.document.view()
        else:
            print(f"アクセス拒否: {self.user_role}には閲覧権限がありません")

# 使用例
if __name__ == "__main__":
    real_doc = ConfidentialDocument("トップシークレット情報")
    
    # 管理者としてアクセス
    admin_proxy = DocumentProtectionProxy(real_doc, "admin")
    admin_proxy.view()
    
    # 一般ユーザーとしてアクセス
    guest_proxy = DocumentProtectionProxy(real_doc, "guest")
    guest_proxy.view()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# Subject Interface
class DataService(ABC):
    @abstractmethod
    def fetch_data(self, key):
        pass

# RealSubject
class DatabaseService(DataService):
    def fetch_data(self, key):
        print(f"データベースから取得: {key}")
        # 実際には重いDB操作
        return f"Data for {key}"

# Cache Proxy
class CachingProxy(DataService):
    def __init__(self):
        self._real_service = DatabaseService()
        self._cache = {}
    
    def fetch_data(self, key):
        if key in self._cache:
            print(f"キャッシュから取得: {key}")
            return self._cache[key]
        
        # キャッシュになければ実サービスから取得
        result = self._real_service.fetch_data(key)
        self._cache[key] = result
        return result

# 使用例
if __name__ == "__main__":
    service = CachingProxy()
    
    print("--- 1回目の取得 ---")
    data1 = service.fetch_data("user:1")
    
    print("\n--- 2回目の取得（同じキー） ---")
    data2 = service.fetch_data("user:1")  # キャッシュから取得
    
    print("\n--- 別のキーを取得 ---")
    data3 = service.fetch_data("user:2")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// Subject Interface
interface Image {
    void display();
}

// RealSubject
class RealImage implements Image {
    private String filename;
    
    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk();
    }
    
    private void loadFromDisk() {
        System.out.println("Loading image from disk: " + filename);
        // 実際には重い処理
    }
    
    @Override
    public void display() {
        System.out.println("Displaying " + filename);
    }
}

// Proxy
class ProxyImage implements Image {
    private String filename;
    private RealImage realImage;
    
    public ProxyImage(String filename) {
        this.filename = filename;
    }
    
    @Override
    public void display() {
        // 遅延初期化
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

// 使用例
public class ProxyPatternDemo {
    public static void main(String[] args) {
        Image image1 = new ProxyImage("photo1.jpg");
        Image image2 = new ProxyImage("photo2.jpg");
        
        System.out.println("--- 画像を表示（初回） ---");
        image1.display();  // この時点で読み込まれる
        
        System.out.println("\n--- 画像を再表示 ---");
        image1.display();  // 再読み込みしない
        
        System.out.println("\n--- 別の画像を表示 ---");
        image2.display();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// Subject Interface
interface Service {
    void doWork();
}

// RealSubject
class RealService implements Service {
    @Override
    public void doWork() {
        System.out.println("RealServiceで作業を実行中...");
    }
}

// Smart Proxy (Logging)
class LoggingProxy implements Service {
    private RealService realService;
    
    public LoggingProxy() {
        this.realService = new RealService();
    }
    
    @Override
    public void doWork() {
        logBefore();
        realService.doWork();
        logAfter();
    }
    
    private void logBefore() {
        System.out.println("[LOG] 作業開始: " + 
            java.time.LocalDateTime.now());
    }
    
    private void logAfter() {
        System.out.println("[LOG] 作業完了: " + 
            java.time.LocalDateTime.now());
    }
}

// 使用例
public class SmartProxyDemo {
    public static void main(String[] args) {
        Service service = new LoggingProxy();
        service.doWork();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

// Subject Interface
interface Document {
  read(): string;
  write(content: string): void;
}

// RealSubject
class ConfidentialDocument implements Document {
  private content: string;

  constructor(content: string) {
    this.content = content;
  }

  read(): string {
    return this.content;
  }

  write(content: string): void {
    this.content = content;
    console.log("文書が更新されました");
  }
}

// Protection Proxy
class DocumentProxy implements Document {
  private document: ConfidentialDocument;
  private userRole: string;

  constructor(document: ConfidentialDocument, userRole: string) {
    this.document = document;
    this.userRole = userRole;
  }

  read(): string {
    if (["admin", "editor", "viewer"].includes(this.userRole)) {
      console.log(`アクセス許可: ${this.userRole}が読み取り`);
      return this.document.read();
    }
    throw new Error("アクセス拒否: 読み取り権限がありません");
  }

  write(content: string): void {
    if (this.userRole === "admin" || this.userRole === "editor") {
      console.log(`アクセス許可: ${this.userRole}が書き込み`);
      this.document.write(content);
    } else {
      throw new Error("アクセス拒否: 書き込み権限がありません");
    }
  }
}

// 使用例
const realDoc = new ConfidentialDocument("機密情報");

// 管理者としてアクセス
const adminProxy = new DocumentProxy(realDoc, "admin");
console.log(adminProxy.read());
adminProxy.write("更新された機密情報");

// 閲覧者としてアクセス
const viewerProxy = new DocumentProxy(realDoc, "viewer");
console.log(viewerProxy.read());
try {
  viewerProxy.write("これは失敗する");
} catch (e) {
  console.error(e.message);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// 実オブジェクト
const api = {
  getData(id: number): string {
    console.log(`APIからデータ取得: ID ${id}`);
    return `Data ${id}`;
  },
  
  getSecret(): string {
    return "classified";
  }
};

// Proxyハンドラー（ロギングとアクセス制御）
const handler: ProxyHandler<typeof api> = {
  get(target, prop, receiver) {
    console.log(`[Proxy] メソッド呼び出し: ${String(prop)}`);
    
    // 機密メソッドへのアクセス制御
    if (prop === "getSecret") {
      throw new Error("アクセス拒否: 機密情報にアクセスできません");
    }
    
    return Reflect.get(target, prop, receiver);
  }
};

// Proxyの作成
const proxyApi = new Proxy(api, handler);

// 使用例
console.log(proxyApi.getData(123));  // 成功

try {
  console.log(proxyApi.getSecret());  // エラー
} catch (e) {
  console.error(e.message);
}

1
2
3
4
5

class ImageProxy:
    def display(self):
        if self._real_image is None:
            self._real_image = RealImage()  # 必要になるまで生成しない
        self._real_image.display()

1
2
3
4
5
6

class BoldDecorator:
    def __init__(self, text):
        self._text = text
    
    def render(self):
        return f"<b>{self._text.render()}</b>"  # 機能を追加

1
2
3
4
5
6
7
8

class SubjectInterface:
    def request(self): pass

class RealSubject(SubjectInterface):
    def request(self): ...

class Proxy(SubjectInterface):  # 同じインターフェース
    def request(self): ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class OldInterface:
    def old_method(self): ...

class NewInterface:
    def new_method(self): pass

class Adapter(NewInterface):  # 新しいインターフェース
    def __init__(self, old_obj):
        self.old_obj = old_obj
    
    def new_method(self):
        return self.old_obj.old_method()  # 変換

1
2
3
4
5

class DatabaseProxy:
    def query(self, sql):
        # 認証チェック
        if self.check_permission():
            return self._real_db.query(sql)

1
2
3
4
5
6
7

class OrderFacade:
    def place_order(self, order):
        # 複数のサブシステムを調整
        self.inventory.check_stock(order)
        self.payment.process(order)
        self.shipping.schedule(order)
        self.notification.send_confirmation(order)