Adapterパターン（デザインパターン）調査レポート

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

// レガシー決済システム
OldPaymentSystem.makeOldPayment(amount, currency)

// 新システムのインターフェース
PaymentProcessor.process(amount, currency)

// Adapterで橋渡し
LegacyPaymentAdapter implements PaymentProcessor {
  process(amount, currency) {
    oldSystem.makeOldPayment(amount, currency)
  }
}

1

Adapter extends Adaptee implements Target

 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

// Target（期待されるインターフェース）
interface Print {
    void printWeak();
    void printStrong();
}

// Adaptee（既存クラス）
class Banner {
    void showWithParen() {
        System.out.println("(Banner)");
    }
    void showWithAster() {
        System.out.println("*Banner*");
    }
}

// Adapter（継承型）
class PrintBanner extends Banner implements Print {
    public void printWeak() {
        showWithParen();  // 既存メソッドを利用
    }
    public void printStrong() {
        showWithAster();  // 既存メソッドを利用
    }
}

1
2
3

Adapter implements Target {
    private Adaptee adaptee;
}

 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

// Target（期待されるインターフェース）
interface Print {
    void printWeak();
    void printStrong();
}

// Adaptee（既存クラス）
class Banner {
    void showWithParen() {
        System.out.println("(Banner)");
    }
    void showWithAster() {
        System.out.println("*Banner*");
    }
}

// Adapter（委譲型）
class PrintBanner implements Print {
    private Banner banner;  // Adapteeを保持
    
    public PrintBanner(String string) {
        this.banner = new Banner(string);
    }
    
    public void printWeak() {
        banner.showWithParen();  // 委譲
    }
    public void printStrong() {
        banner.showWithAster();  // 委譲
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package OldClass;

sub old_method {
    print "Old method called\n";
}

package Adapter;
our @ISA = qw(OldClass);  # 継承

sub new {
    my $class = shift;
    return bless {}, $class;
}

sub new_method {
    my $self = shift;
    $self->old_method();  # 継承したメソッドを呼び出し
}

# 使用例
package main;
my $adapter = Adapter->new();
$adapter->new_method();  # "Old method called"

 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

package OldClass;

sub new {
    my $class = shift;
    return bless {}, $class;
}

sub old_method {
    print "Old method called\n";
}

package Adapter;

sub new {
    my ($class, $adaptee) = @_;
    return bless { adaptee => $adaptee }, $class;
}

sub new_method {
    my $self = shift;
    $self->{adaptee}->old_method();  # 委譲
}

# 使用例
package main;
my $old_obj = OldClass->new();
my $adapter = Adapter->new($old_obj);
$adapter->new_method();  # "Old method called"

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

# Class::Adapterを使用した実装例
use Class::Adapter;

package MyAdapter;
use base 'Class::Adapter';

sub new {
    my $class = shift;
    my $object = MyLegacyClass->new(@_);
    return $class->SUPER::new($object);
}

# 必要に応じてメソッドをオーバーライド
sub adapted_method {
    my $self = shift;
    return $self->_OBJECT_->legacy_method(@_);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Adaptee（既存クラス）
class LegacyPaymentSystem:
    def make_old_payment(self, amount, currency):
        print(f"レガシーシステムで決済: {amount} {currency}")
        return f"OLD_TX_{amount}"

# Target（期待されるインターフェース）
class PaymentProcessor:
    def process(self, amount: float, currency: str) -> str:
        pass

# Adapter（委譲型）
class LegacyPaymentAdapter(PaymentProcessor):
    def __init__(self, legacy_system: LegacyPaymentSystem):
        self.legacy_system = legacy_system
    
    def process(self, amount: float, currency: str) -> str:
        return self.legacy_system.make_old_payment(amount, currency)

# 使用例
legacy = LegacyPaymentSystem()
adapter = LegacyPaymentAdapter(legacy)
adapter.process(1000, "JPY")  # "レガシーシステムで決済: 1000 JPY"

 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

// Adaptee（既存クラス）
class OldLogger {
    logOldFormat(message: string): void {
        console.log(`[OLD] ${message}`);
    }
}

// Target（期待されるインターフェース）
interface Logger {
    log(message: string, level: string): void;
}

// Adapter（委譲型）
class LoggerAdapter implements Logger {
    private oldLogger: OldLogger;
    
    constructor(oldLogger: OldLogger) {
        this.oldLogger = oldLogger;
    }
    
    log(message: string, level: string = 'INFO'): void {
        this.oldLogger.logOldFormat(`[${level}] ${message}`);
    }
}

// 使用例
const oldLogger = new OldLogger();
const adapter = new LoggerAdapter(oldLogger);
adapter.log('Hello', 'INFO');  // "[OLD] [INFO] Hello"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Adaptee（既存の日本の家電）
class JapaneseAppliance:
    def use_100v(self):
        return "100Vで動作中"

# Target（アメリカの電源規格）
class AmericanOutlet:
    def provide_120v(self):
        pass

# Adapter（電圧変換アダプター）
class VoltageAdapter(AmericanOutlet):
    def __init__(self, japanese_appliance: JapaneseAppliance):
        self.appliance = japanese_appliance
    
    def provide_120v(self):
        # 実際は電圧変換処理が入る（ここでは簡略化）
        result = self.appliance.use_100v()
        return f"{result} → 120Vに変換して供給"

# 使用例
appliance = JapaneseAppliance()
adapter = VoltageAdapter(appliance)
print(adapter.provide_120v())  # "100Vで動作中 → 120Vに変換して供給"

 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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

from abc import ABC, abstractmethod
from typing import Dict

# Target（統一決済インターフェース）
class PaymentProcessor(ABC):
    @abstractmethod
    def process_payment(self, amount: float, currency: str) -> Dict:
        pass

# Adaptee 1（PayPay API）
class PayPayAPI:
    def execute_paypay_transaction(self, yen_amount: int):
        print(f"PayPay決済: {yen_amount}円")
        return {"status": "success", "transaction_id": f"PP_{yen_amount}"}

# Adaptee 2（Stripe API）
class StripeAPI:
    def charge(self, amount_cents: int, currency_code: str):
        print(f"Stripe決済: {amount_cents/100} {currency_code}")
        return {"id": f"stripe_{amount_cents}", "status": "succeeded"}

# Adaptee 3（楽天ペイ API）
class RakutenPayAPI:
    def make_payment(self, payment_data: Dict):
        amount = payment_data["amount"]
        print(f"楽天ペイ決済: {amount}円")
        return {"result": "OK", "ref": f"RP_{amount}"}

# Adapter 1（PayPay用）
class PayPayAdapter(PaymentProcessor):
    def __init__(self, paypay_api: PayPayAPI):
        self.api = paypay_api
    
    def process_payment(self, amount: float, currency: str) -> Dict:
        if currency != "JPY":
            raise ValueError("PayPayは円のみ対応")
        result = self.api.execute_paypay_transaction(int(amount))
        return {
            "success": result["status"] == "success",
            "transaction_id": result["transaction_id"],
            "provider": "PayPay"
        }

# Adapter 2（Stripe用）
class StripeAdapter(PaymentProcessor):
    def __init__(self, stripe_api: StripeAPI):
        self.api = stripe_api
    
    def process_payment(self, amount: float, currency: str) -> Dict:
        amount_cents = int(amount * 100)
        result = self.api.charge(amount_cents, currency)
        return {
            "success": result["status"] == "succeeded",
            "transaction_id": result["id"],
            "provider": "Stripe"
        }

# Adapter 3（楽天ペイ用）
class RakutenPayAdapter(PaymentProcessor):
    def __init__(self, rakuten_api: RakutenPayAPI):
        self.api = rakuten_api
    
    def process_payment(self, amount: float, currency: str) -> Dict:
        if currency != "JPY":
            raise ValueError("楽天ペイは円のみ対応")
        payment_data = {"amount": int(amount), "currency": "JPY"}
        result = self.api.make_payment(payment_data)
        return {
            "success": result["result"] == "OK",
            "transaction_id": result["ref"],
            "provider": "RakutenPay"
        }

# 使用例
def process_order(processor: PaymentProcessor, amount: float, currency: str):
    result = processor.process_payment(amount, currency)
    if result["success"]:
        print(f"✓ 決済成功 [{result['provider']}]: {result['transaction_id']}")
    else:
        print(f"✗ 決済失敗 [{result['provider']}]")

# 各決済システムの使用
paypay = PayPayAdapter(PayPayAPI())
stripe = StripeAdapter(StripeAPI())
rakuten = RakutenPayAdapter(RakutenPayAPI())

process_order(paypay, 1000, "JPY")   # PayPay決済
process_order(stripe, 50.00, "USD")  # Stripe決済
process_order(rakuten, 3000, "JPY")  # 楽天ペイ決済

1
2
3
4
5
6

PayPay決済: 1000円
✓ 決済成功 [PayPay]: PP_1000
Stripe決済: 50.0 USD
✓ 決済成功 [Stripe]: stripe_5000
楽天ペイ決済: 3000円
✓ 決済成功 [RakutenPay]: RP_3000

 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
69
70
71
72
73
74
75
76
77
78
79
80
81
82

#!/usr/bin/env perl
use strict;
use warnings;
use v5.10;

# Adaptee（レガシーデータベースライブラリ）
package LegacyDB;

sub new {
    my ($class, $config) = @_;
    return bless { config => $config }, $class;
}

sub db_connect {
    my $self = shift;
    say "レガシーDB接続: " . $self->{config};
    return 1;
}

sub exec_query {
    my ($self, $sql) = @_;
    say "レガシーSQL実行: $sql";
    return ["row1", "row2", "row3"];
}

sub db_close {
    my $self = shift;
    say "レガシーDB切断";
}

# Target（現代的なデータベースインターフェース）
package DatabaseInterface;

sub connect { die "Not implemented" }
sub execute { die "Not implemented" }
sub disconnect { die "Not implemented" }

# Adapter（委譲型）
package LegacyDBAdapter;
use parent 'DatabaseInterface';

sub new {
    my ($class, $legacy_db) = @_;
    return bless { db => $legacy_db }, $class;
}

sub connect {
    my $self = shift;
    $self->{db}->db_connect();
    say "[Adapter] 接続完了";
}

sub execute {
    my ($self, $query) = @_;
    say "[Adapter] クエリ実行: $query";
    my $results = $self->{db}->exec_query($query);
    # 結果を現代的な形式に変換
    return { rows => $results, count => scalar @$results };
}

sub disconnect {
    my $self = shift;
    $self->{db}->db_close();
    say "[Adapter] 切断完了";
}

# 使用例
package main;

sub process_database {
    my $db = shift;
    $db->connect();
    my $result = $db->execute("SELECT * FROM users");
    say "取得件数: " . $result->{count};
    $db->disconnect();
}

# レガシーDBをアダプター経由で使用
my $legacy = LegacyDB->new("legacy_config.conf");
my $adapter = LegacyDBAdapter->new($legacy);

process_database($adapter);

1
2
3
4
5
6
7

レガシーDB接続: legacy_config.conf
[Adapter] 接続完了
[Adapter] クエリ実行: SELECT * FROM users
レガシーSQL実行: SELECT * FROM users
取得件数: 3
レガシーDB切断
[Adapter] 切断完了