🧩 Facade Pattern

✅ Intent

• Provide a simple, unified interface to a complex subsystem
• Hide internal logic behind a clean and task-oriented entry point

✅ Motivation

• Simplify client responsibilities by exposing only what’s necessary
• Help decouple client code from subsystem changes

✅ When to Use

• When a task involves multiple steps across services
• To provide a gateway for frameworks or module groups
• To simplify complex workflows for reuse and clarity

✅ Code Example

TypeScript

class AuthService {
  authenticate(userId: string): boolean {
    console.log(`ユーザー認証: ${userId}`);
    return true;
  }
}

class UserProfileService {
  load(userId: string): object {
    console.log(`プロフィール取得: ${userId}`);
    return { name: "Hiroshi", id: userId };
  }
}

class AuditService {
  log(action: string) {
    console.log(`[監査ログ] ${action}`);
  }
}

// Facade
class UserProfileFacade {
  private auth = new AuthService();
  private profile = new UserProfileService();
  private audit = new AuditService();

  show(userId: string) {
    if (this.auth.authenticate(userId)) {
      const profile = this.profile.load(userId);
      console.log(profile);
      this.audit.log("プロフィール表示");
    }
  }
}

// 利用例
const facade = new UserProfileFacade();
facade.show("user-123");

PHP

<?php

class AuthService {
  public function authenticate(string $userId): bool {
    echo "ユーザー認証: {$userId}\n";
    return true;
  }
}

class UserProfileService {
  public function load(string $userId): array {
    echo "プロフィール取得: {$userId}\n";
    return ["name" => "Hiroshi", "id" => $userId];
  }
}

class AuditService {
  public function log(string $action): void {
    echo "[監査ログ] {$action}\n";
  }
}

// Facade
class UserProfileFacade {
  private AuthService $auth;
  private UserProfileService $profile;
  private AuditService $audit;

  public function __construct() {
    $this->auth = new AuthService();
    $this->profile = new UserProfileService();
    $this->audit = new AuditService();
  }

  public function show(string $userId): void {
    if ($this->auth->authenticate($userId)) {
      $profile = $this->profile->load($userId);
      print_r($profile);
      $this->audit->log("プロフィール表示");
    }
  }
}

// 利用例
$facade = new UserProfileFacade();
$facade->show("user-123");

Python

class AuthService:
    def authenticate(self, user_id: str) -> bool:
        print(f"ユーザー認証: {user_id}")
        return True

class UserProfileService:
    def load(self, user_id: str) -> dict:
        print(f"プロフィール取得: {user_id}")
        return {"name": "Hiroshi", "id": user_id}

class AuditService:
    def log(self, action: str):
        print(f"[監査ログ] {action}")

# Facade
class UserProfileFacade:
    def __init__(self):
        self.auth = AuthService()
        self.profile = UserProfileService()
        self.audit = AuditService()

    def show(self, user_id: str):
        if self.auth.authenticate(user_id):
            profile = self.profile.load(user_id)
            print(profile)
            self.audit.log("プロフィール表示")

# 利用例
facade = UserProfileFacade()
facade.show("user-123")

✅ Explanation

This example applies the Facade pattern to unify three distinct subsystems — AuthService, UserProfileService, and AuditService — under a simple interface.

The UserProfileFacade class consolidates these into a single show(userId) call that handles authentication, profile retrieval, and audit logging.

1. Facade Pattern Overview

• Subsystem Classes: Provide individual pieces of logic

  • In this example: AuthService, UserProfileService, AuditService

• Facade: Simplifies access to the subsystems through a unified interface

  • Here: UserProfileFacade

• Client: Uses the facade to complete a complex task via a single call

  • Here: facade.show("user-123")

2. Key Classes and Roles

• AuthService

  • Authenticates the user

• UserProfileService

  • Fetches user profile information

• AuditService

  • Logs the profile access action

• UserProfileFacade

  • Encapsulates the entire workflow into a single show() method

• Client Code

  • Calls only UserProfileFacade.show() instead of dealing with each subsystem separately

3. UML Class Diagram

4. Benefits of the Facade Pattern

• Simplified Interface: Reduces the learning curve and usage complexity
• Decoupling: Hides internal subsystem logic from the client
• Improved Maintainability: Internal changes are absorbed by the facade, not the client

This design is especially helpful when internal complexity needs to be hidden to promote reuse and cleaner interfaces.
It enhances both usability and maintainability by preventing business logic from leaking into calling code.