🧩 Singleton Pattern

✅ Intent

• Ensure that classes like Logger or Config are instantiated only once and reused globally
• Provide centralized control and access to shared state across the application

✅ Motivation

• Ideal for cases where "the same instance should be used everywhere"
• Helps unify log formatting and centralize configuration management

✅ When to Use

• When building utilities like logging, configuration, caching, or DB connections that require a shared, single state

✅ Code Example

TypeScript

class Config {
  private static instance: Config;
  private debugMode: boolean;

  private constructor() {
    this.debugMode = process.env.DEBUG_MODE === "true";
  }

  static getInstance(): Config {
    if (!Config.instance) {
      Config.instance = new Config();
    }
    return Config.instance;
  }

  isDebug(): boolean {
    return this.debugMode;
  }
}

class Logger {
  private static instance: Logger;

  private constructor() {}

  static getInstance(): Logger {
    if (!Logger.instance) {
      Logger.instance = new Logger();
    }
    return Logger.instance;
  }

  log(message: string) {
    console.log(`[LOG] ${message}`);
  }

  debug(message: string) {
    if (Config.getInstance().isDebug()) {
      console.log(`[DEBUG] ${message}`);
    }
  }
}

// 利用例
class OrderService {
  createOrder(orderId: string) {
    const logger = Logger.getInstance();
    logger.log(`注文作成: ${orderId}`);
    logger.debug(`注文詳細: ${orderId}`);
  }
}

PHP

<?php

class Config {
  private static ?Config $instance = null;
  private bool $debugMode;

  private function __construct() {
    $this->debugMode = getenv("DEBUG_MODE") === "true";
  }

  public static function getInstance(): Config {
    if (self::$instance === null) {
      self::$instance = new Config();
    }
    return self::$instance;
  }

  public function isDebug(): bool {
    return $this->debugMode;
  }
}

class Logger {
  private static ?Logger $instance = null;

  private function __construct() {}

  public static function getInstance(): Logger {
    if (self::$instance === null) {
      self::$instance = new Logger();
    }
    return self::$instance;
  }

  public function log(string $message): void {
    echo "[LOG] {$message}\n";
  }

  public function debug(string $message): void {
    if (Config::getInstance()->isDebug()) {
      echo "[DEBUG] {$message}\n";
    }
  }
}

class OrderService {
  public function createOrder(string $orderId): void {
    $logger = Logger::getInstance();
    $logger->log("注文作成: {$orderId}");
    $logger->debug("注文詳細: {$orderId}");
  }
}

Python

import os

class Config:
    _instance = None

    def __init__(self):
        self.debug_mode = os.environ.get("DEBUG_MODE") == "true"

    @classmethod
    def get_instance(cls):
        if cls._instance is None:
            cls._instance = Config()
        return cls._instance

    def is_debug(self):
        return self.debug_mode

class Logger:
    _instance = None

    def __init__(self):
        pass

    @classmethod
    def get_instance(cls):
        if cls._instance is None:
            cls._instance = Logger()
        return cls._instance

    def log(self, message: str):
        print(f"[LOG] {message}")

    def debug(self, message: str):
        if Config.get_instance().is_debug():
            print(f"[DEBUG] {message}")

class OrderService:
    def create_order(self, order_id: str):
        logger = Logger.get_instance()
        logger.log(f"注文作成: {order_id}")
        logger.debug(f"注文詳細: {order_id}")

✅ Explanation

This code uses the Singleton pattern to ensure that Config and Logger are instantiated only once across the application.
The Singleton pattern guarantees a single instance and provides global access to it throughout the codebase.

1. Overview of the Singleton Pattern

• Singleton: A class that ensures a single instance and exposes a global access point

  • In this example: Config and Logger

• Client: Uses the singleton instance

  • In this example: OrderService

2. Key Classes and Their Roles

• Config

  • A singleton class that manages application settings
  • Uses environment variable DEBUG_MODE to determine if debug mode is enabled

• Logger

  • A singleton class that provides logging functionality
  • Outputs debug logs only when debug mode is enabled

• OrderService

  • A client class that logs order creation via the shared Logger instance

3. UML Class Diagram

4. Benefits of the Singleton Pattern

• Unique Instance: Guarantees exactly one instance throughout the application
• Global Access: The instance can be accessed from anywhere using getInstance
• Resource Saving: Enables lazy initialization to avoid unnecessary object creation

warning

• Testing Difficulty: Global state can make unit testing harder due to tight coupling and lack of dependency injection
• Risk of Overuse: Overusing Singletons can lead to tightly coupled code and reduced maintainability

This pattern is highly effective when managing shared resources like configuration or logging across an entire application.
However, careful and deliberate use is recommended to avoid the pitfalls of global state and tight coupling.