Proxyパターン

# はじめに
GoFデザインパターンの一つで構造に関するパターンである
**Proxyパターン**について見ていきます.

# Proxyパターンとは
Proxy(代理人)パターンは,オブジェクトへアクセスする際に
**代理のオブジェクト**を使うようなデザインパターンです.

代理のオブジェクトを用意することで,元のオブジェクトへリクエストが
行く前後にアクションを起こすことができます.

# Proxyパターンのメリット
Proxyパターンのメリットは以下のようなものが挙げられます.
- アクセスの制限
- メモリの節約
- 透過性

# Proxyパターンの構造
この内容については、[Proxyパターンとは｜GoFデザインパターンの解説](https://cs-techblog.com/technical/proxy-pattern/#:~:text=Proxy%E3%83%91%E3%82%BF%E3%83%BC%E3%83%B3%E3%81%A8%E3%81%AF%E3%80%81%E3%81%82%E3%82%8B,%E7%9B%AE%E7%9A%84%E3%81%A8%E3%81%97%E3%81%A6%E4%BD%BF%E3%82%8F%E3%82%8C%E3%81%BE%E3%81%99%E3%80%82)で
以下のように説明されています.

> - Subject：本来のオブジェクトのインターフェースを定義します
> - RealSubject：Subjectの実装クラスで、実際の処理を行います
> - Proxy：RealSubjectへのアクセスを制御する代理クラスです

# Proxyパターンの実装(適用前)
オンラインショップのショッピングカートのシステムで,
商品を注文に追加する方法を考えます.

考えるべきことは以下となります.
- 顧客が商品を注文する
- それぞれの商品には値段がある
- 各商品の注文数を保持する

これらを踏まえて,存在するオブジェクトとして
Customer, Order, Item, Productを用意します.

このとき,クラス図をシンプルな以下の構造で考えます.

#### クラス図
![スクリーンショット 2025-01-08 002824.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3586226/de29e915-b58e-aeb5-7914-cacd9ac4d04e.png)

これは,Customerが0個以上のOrderをして,
それぞれのProductを何個OrderしたかをItemが保持するというものです．

このクラス図に,新しいアイテムをオーダーに追加する方法を考えると,
OrderクラスにaddItemメソッドを追加するのが自然に考えられます.
![スクリーンショット 2025-01-08 010255.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3586226/aaccee7f-fbf2-72fd-371c-bb2270de60e7.png)



## データベースへの拡張
オンラインで扱うシステムにおいてデータベースは不可欠です.

このとき,それぞれのオブジェクトがデータベースに保存されているデータだとします.

データベースに保存されているものを取り出すためにIdを指定する必要があります.

そのため,上記のクラス図にidを追加したのが以下のクラス図となります.


#### id追加後のクラス図
![スクリーンショット 2025-01-08 004606.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3586226/5b5f29a7-67f7-d4fc-9142-2040601f8290.png)

ここで,skuはStock Keeping Unit(在庫管理コード)です.

上記のクラス図のポイントは以下の通りになります
- 特定のカスタマからのオーダーを探すため,そのカスタマID(cusid)を持つ
オーダーをすべて探す
- 特定のオーダーに登録されているアイテムを探すため,オーダーID(orderId)を持つ
アイテムをすべて探す
- アイテムを指定してその商品を参照するためskuを使う

データベースを用いて,アイテムをオーダーに追加する場合もデータベースへ拡張する前と
ほとんど同じ機能を要するメソッドを追加することで実現できます.

異なる点は,ソースコードにデータベースを使う処理を書かなければいけない点です.

### 問題点
しかし,このプログラムには問題があります.

それは,データベースを使う処理を書くことによって,
**ソフトウェア開発における原則**を破る可能性がある点です.

例えば,アイテムとオーダーにおいて,SQL文やデータベース接続といった処理は必要ないので
`単一責任の原則`を破っていることになります.

その他にも,(コードの構造にもよりますが)`依存関係逆転の原則`など様々な
ソフトウェア開発における原則を破ってしまう場合があります.

このようなソフトウェアでは問題が発生してしまったときに困ります.

この不具合を解決するためにProxyパターンを適用してみます.

# Proxyパターンの実装(適用後)
ProxyパターンをProductクラスに適用した場合のクラス図は以下のようになります.

#### クラス図
![スクリーンショット 2025-01-08 130313.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3586226/166a5295-2206-e067-10b3-7241a55a5569.png)

それぞれのオブジェクトをProxyパターンの構造に当てはめると以下のようになります.
- **Subject**
Productオブジェクトが当てはまり,Productクラスをインタフェースに変えて
Proxyパターンを使えるようにしています.

- **RealSubject**
ProductImplementationオブジェクトが当てはまり,インタフェースです.
Proxyがこのインスタンスを作成するなどの実際の処理を行うクラスです.

- **Proxy**
Product DB Proxyオブジェクトが当てはまり,ProductImplementationへの
制御を行います.

このパターンを踏まえてオーダーに商品を追加するコードを実装すると
以下のようになります.
(AIを参考にして作ったものです.)

#### ソースコード
```java:Customer.java
public class Customer {
    private String cusId;
    private String name;

    public Customer(String cusId, String name) {
        this.cusId = cusId;
        this.name = name;
    }

    public String getCusId() {
        return cusId;
    }

    public String getName() {
        return name;
    }
}
```

```java:Order.java
class Order {
    private String orderId;
    private List<Item> items = new ArrayList<>();
    private Customer customer;

    public Order(String orderId, Customer customer) {
        this.orderId = orderId;
        this.customer = customer;
    }

    public void addItem(String sku, int quantity) {
        items.add(new Item(orderId, sku, quantity));
    }

    public String getOrderId() {
        return orderId;
    }

    public List<Item> getItems() {
        return items;
    }

    public Customer getCustomer() {
        return customer;
    }
}
```

```java:Item.java
public class Item {
    private String orderId;
    private int quantity;
    private Product product;

    public Item(String orderId, String sku, int quantity) {
        this.orderId = orderId;
        this.product = new ProductProxy(sku);
        this.quantity = quantity;
    }

    public String getOrderId() {
        return orderId;
    }

    public Product getProduct() {
        return product;
    }

    public int getQuantity() {
        return quantity;
    }
}
```

```java:Product.java
public interface Product {
    String getSku();
    String getName();
    double getPrice();
}
```

```java:ProductImplementation.java
public class ProductImplementation implements Product {
    private String sku;
    private String name;
    private double price;

    public ProductImplementation(String sku, String name, double price) {
        this.sku = sku;
        this.name = name;
        this.price = price;
        System.out.println("Loading product from DB: " + name + " (SKU: " + sku + ")");
    }

    @Override
    public String getSku() {
        return data.getSku();
    }

    @Override
    public String getName() {
        return data.getName();
    }

    @Override
    public double getPrice() {
        return data.getPrice();
    }
}
```

```java:ProductProxy.java
public class ProductProxy implements Product {
    private ProductImplementation productImplementation;
    private String sku;

    public ProductProxy(String sku) {
        this.sku = sku;
    }

    private void loadProductIfNeeded() {
        if (productImplementation == null) {
            productImplementation = DB.loadProduct(sku)
        }
    }

    @Override
    public String getSku() {
        return sku;
    }

    @Override
    public String getName() {
        loadProductIfNeeded();
        return productImplementation.getName();
    }

    @Override
    public double getPrice() {
        loadProductIfNeeded();
        return productImplementation.getPrice();
    }
}
```

```java:DB.java
public cladd DB{
    public ProductImplementation loadProduct(String sku){
    // 商品データの獲得処理
    }
}
```

```java:Main.java
public class Main {
    public static void main(String[] args) {
        // カスタマーを作成
        Customer customer = new Customer("CUS001", "John Doe");
        
        // 注文を作成
        Order order = new Order("ORD001", customer);
        
        // 商品を注文に追加（この時点ではデータは読み込まれない）
        order.addItem("SKU001", 2);
        order.addItem("SKU002", 1);
        
        // 商品情報にアクセスした時点で初めてDBから読み込まれる
        System.out.println("Order ID: " + order.getOrderId());
        System.out.println("Customer ID: " + order.getCustomer().getCusId());
        for (Item item : order.getItems()) {
            System.out.println(
                "Order ID: " + item.getOrderId() + 
                ", SKU: " + item.getProduct().getSku() + 
                ", Product: " + item.getProduct().getName() + 
                ", Price: " + item.getProduct().getPrice() + 
                ", Quantity: " + item.getQuantity()
            );
        }
    }
}
```

全体のクラス図は以下のようになります.
#### クラス図
![スクリーンショット 2025-01-09 001757.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3586226/0bec9bcc-8ef2-b979-7d38-50901239f87f.png)

### 問題点の解決・メリット
ソースコードとクラス図を参考に問題点が解決されていることやメリットを確認します.

#### 単一責任の原則
各クラスに注目すると,CutomerやOrder,ItemといったクラスにおいてSQL文やデータベース接続といった処理を書く必要がなくなりました.

これにより,それぞれのクラスの役割(責任)はただ一つに絞ることができました.

また,DBに関する処理はDBファイルを追加することで凝集性が向上します.

#### パフォーマンスの最適化
OrderクラスにItemを追加することを考えます.

そのとき用いるメソッドは以下のようなaddItemメソッドです.
```java:OrderクラスへのItem追加
public void addItem(String sku, int quantity) {
    items.add(new Item(orderId, sku, quantity));  // この時点でProxyのみ作成
}
```
このメソッドを使用して,OrderクラスにItemを追加した段階では,Proxyオブジェクトを
作っただけとなっています.

つまり,**実際にデータベースへのアクセス**は行っていないことになります.

データベースへのアクセスは,DBクラスのloadProductメソッドを使用して
初めて行われます.

これにより,**メモリ使用量の削減や不要なDBアクセス**を回避することができ,
必要なときにだけDBにアクセスします.

#### アクセス制御の管理
Proxyクラスにアクセスロジックを集中させることで,
**アクセス制御の管理**を容易に行うことができます.

キャッシュ機能など,新たな機能実装時もキャッシュの管理をProxyに担当させることで,
**アクセス制御に関するロジックを一つにまとめる**ことができます.

#### インタフェースの共有
Proxyは実際のオブジェクトと同じインターフェースを実装することで,
**透過的なアクセス**を実現します.

呼び出し側のコードは自分が直接ProductImplementationを使用していると
考えています.

しかし,実際には,呼び出し側とProductImplementationの間にProxyが存在し,
データベースアクセスやネットワーク通信などの処理を代理で行っています.

このとき,呼び出し側はこれらの複雑な処理の存在を意識する必要がありません.

Proxyが複雑な処理を隠蔽することで,システムを変更する際に呼び出し側のコードを
変更する必要がなくなります.

### Proxyパターンの問題点
このソースコード,実は問題があります.

それは,ProductImplementationを作る必要がないという点です.

...ProductProxyはProductImplementationが返すデータを既に持っています.

つまり,**ProductImplementationはリソースを無駄遣い**しており,
不必要なオブジェクト生成をしていることになります.

**このような問題がなぜ発生したのか?**

それは,Proxyパターンの構造に従ってソースコードを書いたからです.

このように,Proxyパターンは取り扱いが難しく,うまくいくことはなかなかありません.

したがって,「アジャイルソフトウェア開発の奥義」によると

まずは**Fecadeパターン**から用いることがオススメとされています.

# 最後に
Proxyパターンを適用するのは難しく,実用的に扱うことはないのかなと思いました.

とはいえ,デザインパターンが**どのような意図**で設計されているのかを理解することが
デザインパターンを学ぶ上で大事だと思っています.
(今回でいうと,データベースによる責任が誰のものかわからない)

そのため,引き続き様々なデザインパターンを学んでいきたいと思います.

# 参考
[アジャイルソフトウェア開発の奥義](https://www.amazon.co.jp/%E3%82%A2%E3%82%B8%E3%83%A3%E3%82%A4%E3%83%AB%E3%82%BD%E3%83%95%E3%83%88%E3%82%A6%E3%82%A7%E3%82%A2%E9%96%8B%E7%99%BA%E3%81%AE%E5%A5%A5%E7%BE%A9-%E7%AC%AC2%E7%89%88-%E3%82%AA%E3%83%96%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88%E6%8C%87%E5%90%91%E9%96%8B%E7%99%BA%E3%81%AE%E7%A5%9E%E9%AB%84%E3%81%A8%E5%8C%A0%E3%81%AE%E6%8A%80-%E3%83%AD%E3%83%90%E3%83%BC%E3%83%88%E3%83%BBC%E3%83%BB%E3%83%9E%E3%83%BC%E3%83%81%E3%83%B3/dp/4797347783)

https://cs-techblog.com/technical/proxy-pattern/#:~:text=Proxy%E3%83%91%E3%82%BF%E3%83%BC%E3%83%B3%E3%81%A8%E3%81%AF%E3%80%81%E3%81%82%E3%82%8B,%E7%9B%AE%E7%9A%84%E3%81%A8%E3%81%97%E3%81%A6%E4%BD%BF%E3%82%8F%E3%82%8C%E3%81%BE%E3%81%99%E3%80%82