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

1
2
3
4
5
6
7
8

1. 照明を暗くする (lights.dim(50))
2. スクリーンを下ろす (screen.down())
3. プロジェクターを起動する (projector.on())
4. プロジェクターの入力をDVDに設定 (projector.setInput("DVD"))
5. アンプを起動する (amplifier.on())
6. アンプの音量を設定 (amplifier.setVolume(5))
7. DVDプレーヤーを起動する (dvd.on())
8. 映画を再生する (dvd.play(movie))

1

homeTheater.watchMovie("Inception");

1
2
3

Client ----> Facade ----> SubsystemA
                    ----> SubsystemB
                    ----> SubsystemC

 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

// OrderFacade.java
@Service
public class OrderFacade {
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    private final ShippingService shippingService;
    private final NotificationService notificationService;
    
    @Autowired
    public OrderFacade(InventoryService inventoryService, 
                       PaymentService paymentService,
                       ShippingService shippingService,
                       NotificationService notificationService) {
        this.inventoryService = inventoryService;
        this.paymentService = paymentService;
        this.shippingService = shippingService;
        this.notificationService = notificationService;
    }
    
    public OrderResult placeOrder(OrderRequest orderRequest) {
        // 在庫確認
        if (!inventoryService.checkAvailability(orderRequest.getItems())) {
            return OrderResult.outOfStock();
        }
        
        // 在庫予約
        inventoryService.reserveItems(orderRequest.getItems());
        
        // 決済処理
        PaymentResult paymentResult = paymentService.processPayment(
            orderRequest.getPaymentInfo()
        );
        
        if (!paymentResult.isSuccessful()) {
            inventoryService.releaseItems(orderRequest.getItems());
            return OrderResult.paymentFailed();
        }
        
        // 配送手配
        ShippingInfo shippingInfo = shippingService.arrangeShipping(
            orderRequest.getShippingAddress(),
            orderRequest.getItems()
        );
        
        // 確認メール送信
        notificationService.sendOrderConfirmation(
            orderRequest.getCustomerEmail(),
            shippingInfo
        );
        
        return OrderResult.success(shippingInfo);
    }
}

// Controller（クライアント）
@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final OrderFacade orderFacade;
    
    @Autowired
    public OrderController(OrderFacade orderFacade) {
        this.orderFacade = orderFacade;
    }
    
    @PostMapping
    public ResponseEntity<OrderResult> createOrder(@RequestBody OrderRequest request) {
        // Facadeを通じて複雑な処理を簡潔に呼び出す
        OrderResult result = orderFacade.placeOrder(request);
        return ResponseEntity.ok(result);
    }
}

  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
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107

// apiFacade.ts
export class APIFacade {
  private baseUrl: string;
  private defaultHeaders: HeadersInit;

  constructor(config: { baseUrl: string; authToken?: string }) {
    this.baseUrl = config.baseUrl;
    this.defaultHeaders = {
      'Content-Type': 'application/json',
      ...(config.authToken && { Authorization: `Bearer ${config.authToken}` })
    };
  }

  async getUserData(userId: string): Promise<UserData> {
    try {
      const response = await fetch(`${this.baseUrl}/users/${userId}`, {
        headers: this.defaultHeaders
      });
      
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      
      const rawData = await response.json();
      
      // データの変換・正規化
      return this.transformUserData(rawData);
      
    } catch (error) {
      // エラーハンドリング
      console.error('Failed to fetch user data:', error);
      throw new APIError('Failed to fetch user data', error);
    }
  }

  async updateUserProfile(userId: string, updates: Partial<UserData>): Promise<UserData> {
    try {
      const response = await fetch(`${this.baseUrl}/users/${userId}`, {
        method: 'PATCH',
        headers: this.defaultHeaders,
        body: JSON.stringify(updates)
      });
      
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      
      const rawData = await response.json();
      return this.transformUserData(rawData);
      
    } catch (error) {
      console.error('Failed to update user profile:', error);
      throw new APIError('Failed to update user profile', error);
    }
  }

  private transformUserData(rawData: any): UserData {
    // APIレスポンスをアプリケーション内部のデータ構造に変換
    return {
      id: rawData.user_id,
      name: rawData.full_name,
      email: rawData.email_address,
      createdAt: new Date(rawData.created_at)
    };
  }
}

// Reactコンポーネントでの使用
import React, { useEffect, useState } from 'react';

const UserProfile: React.FC<{ userId: string }> = ({ userId }) => {
  const [userData, setUserData] = useState<UserData | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  const apiFacade = new APIFacade({ 
    baseUrl: 'https://api.example.com',
    authToken: 'your-auth-token'
  });

  useEffect(() => {
    const fetchData = async () => {
      try {
        // Facadeを通じた簡潔なAPI呼び出し
        const data = await apiFacade.getUserData(userId);
        setUserData(data);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    };

    fetchData();
  }, [userId]);

  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error}</div>;
  if (!userData) return null;

  return (
    <div>
      <h1>{userData.name}</h1>
      <p>{userData.email}</p>
    </div>
  );
};

 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

// storeFacade.js
import { createStore } from 'vuex';

// サブシステム的な各モジュール
const userModule = {
  state: () => ({ user: null }),
  mutations: {
    setUser(state, user) { state.user = user; }
  },
  actions: {
    async fetchUser({ commit }, userId) {
      const response = await fetch(`/api/users/${userId}`);
      const user = await response.json();
      commit('setUser', user);
    }
  }
};

const cartModule = {
  state: () => ({ items: [] }),
  mutations: {
    addItem(state, item) { state.items.push(item); }
  },
  actions: {
    addToCart({ commit }, item) {
      commit('addItem', item);
    }
  }
};

// Facadeとしてのストア
export const store = createStore({
  modules: {
    user: userModule,
    cart: cartModule
  }
});

// コンポーネントでの使用
export default {
  computed: {
    user() {
      return this.$store.state.user.user;
    }
  },
  methods: {
    async loadUser() {
      // Facadeを通じた簡潔なアクセス
      await this.$store.dispatch('fetchUser', this.userId);
    }
  }
};

 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

// サブシステムクラス群
class CPU {
    public void freeze() {
        System.out.println("CPU: Freezing...");
    }
    
    public void jump(long position) {
        System.out.println("CPU: Jumping to " + position);
    }
    
    public void execute() {
        System.out.println("CPU: Executing...");
    }
}

class Memory {
    public void load(long position, String data) {
        System.out.println("Memory: Loading \"" + data + "\" at " + position);
    }
}

class HardDrive {
    public String read(long lba, int size) {
        System.out.println("HardDrive: Reading " + size + " bytes from sector " + lba);
        return "boot data";
    }
}

// Facadeクラス
class ComputerFacade {
    private final CPU cpu;
    private final Memory memory;
    private final HardDrive hardDrive;
    
    public ComputerFacade() {
        this.cpu = new CPU();
        this.memory = new Memory();
        this.hardDrive = new HardDrive();
    }
    
    // 複雑な起動プロセスを単一メソッドに集約
    public void start() {
        System.out.println("Starting computer...");
        cpu.freeze();
        memory.load(0, hardDrive.read(0, 1024));
        cpu.jump(0);
        cpu.execute();
        System.out.println("Computer started successfully!");
    }
}

// クライアント
public class Main {
    public static void main(String[] args) {
        // Facadeを通じて複雑なプロセスを簡潔に実行
        ComputerFacade computer = new ComputerFacade();
        computer.start();
    }
}

1
2
3
4
5
6
7

Starting computer...
CPU: Freezing...
HardDrive: Reading 1024 bytes from sector 0
Memory: Loading "boot data" at 0
CPU: Jumping to 0
CPU: Executing...
Computer started successfully!

 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

# サブシステムクラス群
class Subsystem1:
    def operation1(self):
        print("Subsystem 1: operation 1")
    
    def operation2(self):
        print("Subsystem 1: operation 2")

class Subsystem2:
    def operation3(self):
        print("Subsystem 2: operation 3")
    
    def operation4(self):
        print("Subsystem 2: operation 4")

class Subsystem3:
    def operation5(self):
        print("Subsystem 3: operation 5")

# Facadeクラス
class Facade:
    def __init__(self):
        self.subsystem1 = Subsystem1()
        self.subsystem2 = Subsystem2()
        self.subsystem3 = Subsystem3()
    
    def example_operation_1(self):
        """複数のサブシステム操作を組み合わせた高レベル操作"""
        print("Facade: Executing example operation 1")
        self.subsystem1.operation1()
        self.subsystem2.operation3()
    
    def example_operation_2(self):
        """別のユースケース向けの高レベル操作"""
        print("Facade: Executing example operation 2")
        self.subsystem1.operation2()
        self.subsystem3.operation5()

# クライアント
if __name__ == "__main__":
    facade = Facade()
    
    # 複雑なサブシステムの操作をFacadeを通じて簡潔に実行
    facade.example_operation_1()
    print()
    facade.example_operation_2()

1
2
3
4
5
6
7

Facade: Executing example operation 1
Subsystem 1: operation 1
Subsystem 2: operation 3

Facade: Executing example operation 2
Subsystem 1: operation 2
Subsystem 3: operation 5

  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
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

// サブシステムクラス群
class DVDPlayer {
  on(): void {
    console.log("DVD Player: Turning on");
  }
  
  play(movie: string): void {
    console.log(`DVD Player: Playing "${movie}"`);
  }
  
  stop(): void {
    console.log("DVD Player: Stopping");
  }
  
  off(): void {
    console.log("DVD Player: Turning off");
  }
}

class Projector {
  on(): void {
    console.log("Projector: Turning on");
  }
  
  setInput(source: string): void {
    console.log(`Projector: Setting input to ${source}`);
  }
  
  wideScreenMode(): void {
    console.log("Projector: Setting to wide screen mode");
  }
  
  off(): void {
    console.log("Projector: Turning off");
  }
}

class Amplifier {
  on(): void {
    console.log("Amplifier: Turning on");
  }
  
  setVolume(level: number): void {
    console.log(`Amplifier: Setting volume to ${level}`);
  }
  
  setSurroundSound(): void {
    console.log("Amplifier: Setting surround sound mode");
  }
  
  off(): void {
    console.log("Amplifier: Turning off");
  }
}

class Lights {
  dim(level: number): void {
    console.log(`Lights: Dimming to ${level}%`);
  }
  
  on(): void {
    console.log("Lights: Turning on to 100%");
  }
}

class Screen {
  down(): void {
    console.log("Screen: Going down");
  }
  
  up(): void {
    console.log("Screen: Going up");
  }
}

// Facadeクラス
class HomeTheaterFacade {
  private dvd: DVDPlayer;
  private projector: Projector;
  private amplifier: Amplifier;
  private lights: Lights;
  private screen: Screen;
  
  constructor(
    dvd: DVDPlayer,
    projector: Projector,
    amplifier: Amplifier,
    lights: Lights,
    screen: Screen
  ) {
    this.dvd = dvd;
    this.projector = projector;
    this.amplifier = amplifier;
    this.lights = lights;
    this.screen = screen;
  }
  
  // 映画鑑賞の開始：複雑な一連の操作を単一メソッドに集約
  watchMovie(movie: string): void {
    console.log("\n=== Getting ready to watch a movie... ===");
    this.lights.dim(10);
    this.screen.down();
    this.projector.on();
    this.projector.wideScreenMode();
    this.projector.setInput("DVD");
    this.amplifier.on();
    this.amplifier.setSurroundSound();
    this.amplifier.setVolume(5);
    this.dvd.on();
    this.dvd.play(movie);
    console.log("=== Enjoy your movie! ===\n");
  }
  
  // 映画鑑賞の終了：片付けの一連の操作
  endMovie(): void {
    console.log("\n=== Shutting down movie theater... ===");
    this.dvd.stop();
    this.dvd.off();
    this.amplifier.off();
    this.projector.off();
    this.screen.up();
    this.lights.on();
    console.log("=== Movie theater is shut down ===\n");
  }
}

// クライアント
function main() {
  // サブシステムの初期化
  const dvd = new DVDPlayer();
  const projector = new Projector();
  const amplifier = new Amplifier();
  const lights = new Lights();
  const screen = new Screen();
  
  // Facadeの作成
  const homeTheater = new HomeTheaterFacade(
    dvd,
    projector,
    amplifier,
    lights,
    screen
  );
  
  // Facadeを通じた簡潔な操作
  homeTheater.watchMovie("Inception");
  
  // 映画終了後
  homeTheater.endMovie();
}

main();

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

=== Getting ready to watch a movie... ===
Lights: Dimming to 10%
Screen: Going down
Projector: Turning on
Projector: Setting to wide screen mode
Projector: Setting input to DVD
Amplifier: Turning on
Amplifier: Setting surround sound mode
Amplifier: Setting volume to 5
DVD Player: Turning on
DVD Player: Playing "Inception"
=== Enjoy your movie! ===

=== Shutting down movie theater... ===
DVD Player: Stopping
DVD Player: Turning off
Amplifier: Turning off
Projector: Turning off
Screen: Going up
Lights: Turning on to 100%
=== Movie theater is shut down ===