SOLID原則 — 変更に強いコードを書くための5つの指針

// ❌ SRP違反: 3種類のアクターの関心事が1クラスに同居している
class ReportService {
  // 集計ルール —— 経理部門の要望で変わる
  generate(orders: Order[]): Report {
    const total = orders.reduce((sum, o) => sum + o.amount, 0);
    return { total, count: orders.length, createdAt: new Date() };
  }
 
  // 出力フォーマット —— デザイン変更の要望で変わる
  formatAsHtml(report: Report): string {
    return `<h1>売上レポート</h1><p>合計: ${report.total}円</p>`;
  }
 
  // 保存処理 —— インフラ構成の変更で変わる
  async save(report: Report): Promise<void> {
    await db.reports.insert(report);
  }
}

// ⭕ 変更理由（アクター）ごとに分割する
class ReportGenerator {
  generate(orders: Order[]): Report {
    const total = orders.reduce((sum, o) => sum + o.amount, 0);
    return { total, count: orders.length, createdAt: new Date() };
  }
}
 
class ReportHtmlFormatter {
  format(report: Report): string {
    return `<h1>売上レポート</h1><p>合計: ${report.total}円</p>`;
  }
}
 
class ReportRepository {
  async save(report: Report): Promise<void> {
    await db.reports.insert(report);
  }
}

// ❌ OCP違反: ランクが増えるたびに、この関数を修正することになる
function calcDiscount(price: number, memberRank: string): number {
  if (memberRank === 'gold') {
    return price * 0.1;
  } else if (memberRank === 'silver') {
    return price * 0.05;
  } else {
    return 0;
  }
}

// ⭕ 抽象を定義し、バリエーションを実装の追加で表現する
interface DiscountPolicy {
  calc(price: number): number;
}
 
class GoldDiscount implements DiscountPolicy {
  calc(price: number): number {
    return price * 0.1;
  }
}
 
class SilverDiscount implements DiscountPolicy {
  calc(price: number): number {
    return price * 0.05;
  }
}
 
class NoDiscount implements DiscountPolicy {
  calc(): number {
    return 0;
  }
}
 
// 利用側は抽象にしか依存しない
function calcDiscount(price: number, policy: DiscountPolicy): number {
  return policy.calc(price);
}

// ❌ LSP違反: 「Birdはflyできる」という契約をPenguinが破っている
class Bird {
  fly(): void {
    console.log('飛んだ');
  }
}
 
class Penguin extends Bird {
  fly(): void {
    throw new Error('ペンギンは飛べません');
  }
}
 
function letBirdsFly(birds: Bird[]): void {
  for (const bird of birds) {
    bird.fly(); // Penguinが混ざっていると実行時に例外で落ちる
  }
}

// ⭕ 「飛べる」を別の抽象として分離し、飛べるものだけが実装する
interface Flyable {
  fly(): void;
}
 
class Sparrow implements Flyable {
  fly(): void {
    console.log('飛んだ');
  }
}
 
class Penguin {
  swim(): void {
    console.log('泳いだ');
  }
}
 
function letBirdsFly(birds: Flyable[]): void {
  for (const bird of birds) {
    bird.fly(); // Flyableを実装した型しか渡せないので、実行時に落ちない
  }
}

// ❌ ISP違反: 「多機能な1つのインターフェース」を全員に強制している
interface MultiFunctionDevice {
  print(doc: Document): void;
  scan(): Document;
  fax(doc: Document, to: string): void;
}
 
// 印刷しかできない安価なプリンタも、この巨大な契約を結ばされる
class SimplePrinter implements MultiFunctionDevice {
  print(doc: Document): void {
    console.log('印刷しました');
  }
  scan(): Document {
    throw new Error('スキャン機能はありません'); // 空実装 or 例外になる
  }
  fax(): void {
    throw new Error('FAX機能はありません');
  }
}

// ⭕ 利用者の関心ごとにインターフェースを分ける
interface Printer {
  print(doc: Document): void;
}
 
interface Scanner {
  scan(): Document;
}
 
interface Fax {
  fax(doc: Document, to: string): void;
}
 
// 印刷専用機はPrinterだけ実装すればよい
class SimplePrinter implements Printer {
  print(doc: Document): void {
    console.log('印刷しました');
  }
}
 
// 複合機は複数のインターフェースを実装する
class MultiFunctionPrinter implements Printer, Scanner, Fax {
  print(doc: Document): void { /* ... 印刷処理 */ }
  scan(): Document { /* ... スキャン処理 */ }
  fax(doc: Document, to: string): void { /* ... FAX送信処理 */ }
}
 
// 印刷だけしたい利用側は、Printerにだけ依存する
function printReport(printer: Printer, report: Document): void {
  printer.print(report);
}

// ❌ DIP違反: ビジネスロジックが具体的な技術（MySQL）に依存している
import { MySqlOrderTable } from './infra/mysql-order-table';
 
class OrderService {
  private orderTable = new MySqlOrderTable(); // 具体クラスを直接生成
 
  async placeOrder(order: Order): Promise<void> {
    if (order.items.length === 0) {
      throw new Error('商品が選択されていません');
    }
    await this.orderTable.insert(order);
  }
}

// ⭕ 上位が「必要とする抽象」を定義する
interface OrderRepository {
  insert(order: Order): Promise<void>;
}
 
class OrderService {
  // 具体クラスではなく抽象を受け取る（コンストラクタインジェクション）
  constructor(private readonly orderRepo: OrderRepository) {}
 
  async placeOrder(order: Order): Promise<void> {
    if (order.items.length === 0) {
      throw new Error('商品が選択されていません');
    }
    await this.orderRepo.insert(order);
  }
}
 
// 下位モジュールが抽象を実装する
class MySqlOrderRepository implements OrderRepository {
  async insert(order: Order): Promise<void> {
    // MySQLへの保存処理
  }
}
 
// 組み立ては外側（エントリポイントやDIコンテナ）で行う
const orderService = new OrderService(new MySqlOrderRepository());