Scattered Instantiation

Description

What does it look like?

• Classes are instantiated using new directly and repeatedly throughout the codebase
• Hard to track which classes are used where, leading to unclear dependencies
• Instantiation logic is scattered, making management difficult

Why is it a problem?

• Results in a fragile design that is hard to modify or replace with new implementations
• Difficult to unit test (hard to inject mocks)
• Object creation logic is often copy-pasted in multiple places
• Instance management becomes tangled like spaghetti code

Bad Example of the Anti-pattern

TypeScript

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

class UserService {
  private logger: Logger;

  constructor() {
    this.logger = new Logger(); // 毎回 new!!
  }

  createUser(name: string) {
    this.logger.log(`ユーザー作成: ${name}`);
  }
}

PHP

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

class UserService {
  private Logger $logger;

  public function __construct() {
    $this->logger = new Logger(); // 毎回 new!!
  }

  public function createUser(string $name): void {
    $this->logger->log("ユーザー作成: {$name}");
  }
}

Python

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

class UserService:
    def __init__(self):
        self.logger = Logger()  # 毎回 new!!

    def create_user(self, name: str):
        self.logger.log(f"ユーザー作成: {name}")

Issues:

• Logger is instantiated directly inside UserService
• Other services may also repeat new Logger(), leading to duplication
• Difficult to reuse the logger logic as a shared component

Refactoring by Pattern

Design patterns that can address this

Pattern	Overview	Main Refactoring Approach
Factory Method	Delegate object creation to a subclass	Make instantiation logic extensible
Abstract Factory	Group related objects into a factory	Abstract creation logic for easy switching
Builder	Clarify complex creation steps	Separate construction steps for clarity
Singleton	Restrict to a single instance and reuse it	Useful for shared global state