TypeScriptで複数依存関係を持つクラスの管理方法とベストプラクティス

class ServiceB {
  doSomething() {
    console.log("ServiceB: Doing something");
  }
}

class ServiceA {
  private serviceB: ServiceB;

  constructor(serviceB: ServiceB) {
    this.serviceB = serviceB;
  }

  execute() {
    this.serviceB.doSomething();
  }
}

// 依存関係を注入
const serviceB = new ServiceB();
const serviceA = new ServiceA(serviceB);
serviceA.execute(); // "ServiceB: Doing something"

interface ILogger {
  log(message: string): void;
}

class ConsoleLogger implements ILogger {
  log(message: string): void {
    console.log(`ConsoleLogger: ${message}`);
  }
}

class FileLogger implements ILogger {
  log(message: string): void {
    // ファイルにログを書き込む処理（簡略化）
    console.log(`FileLogger: ${message}`);
  }
}

class Application {
  private logger: ILogger;

  constructor(logger: ILogger) {
    this.logger = logger;
  }

  run() {
    this.logger.log("Application is running.");
  }
}

// 実装の切り替え
const consoleLogger = new ConsoleLogger();
const app1 = new Application(consoleLogger);
app1.run(); // "ConsoleLogger: Application is running."

const fileLogger = new FileLogger();
const app2 = new Application(fileLogger);
app2.run(); // "FileLogger: Application is running."

import "reflect-metadata";
import { Container, injectable, inject } from "inversify";

// インターフェース
interface IWeapon {
  attack(): void;
}

// 具体的な実装
@injectable()
class Sword implements IWeapon {
  attack() {
    console.log("Swinging the sword!");
  }
}

@injectable()
class Warrior {
  private weapon: IWeapon;

  constructor(@inject("IWeapon") weapon: IWeapon) {
    this.weapon = weapon;
  }

  fight() {
    this.weapon.attack();
  }
}

// DIコンテナを設定
const container = new Container();
container.bind<IWeapon>("IWeapon").to(Sword);
container.bind<Warrior>(Warrior).toSelf();

// 依存関係を解決してインスタンスを生成
const warrior = container.get(Warrior);
warrior.fight(); // "Swinging the sword!"

import { container, injectable } from "tsyringe";

@injectable()
class ServiceA {
  log() {
    console.log("ServiceA is running");
  }
}

@injectable()
class ServiceB {
  constructor(private serviceA: ServiceA) {}

  execute() {
    this.serviceA.log();
  }
}

const serviceB = container.resolve(ServiceB);
serviceB.execute(); // "ServiceA is running"

class Logger {
  private static instance: Logger;

  private constructor() {}  // プライベートコンストラクタ

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

  log(message: string): void {
    console.log(`Log: ${message}`);
  }
}

// Loggerのインスタンスを取得
const logger1 = Logger.getInstance();
const logger2 = Logger.getInstance();

logger1.log("First log");  // "Log: First log"
logger2.log("Second log"); // "Log: Second log"

// logger1とlogger2は同じインスタンス
console.log(logger1 === logger2); // true

interface Database {
  connect(): void;
}

class MySQLDatabase implements Database {
  connect() {
    console.log("Connected to MySQL");
  }
}

class MongoDatabase implements Database {
  connect() {
    console.log("Connected to MongoDB");
  }
}

class DatabaseFactory {
  static createDatabase(type: string): Database {
    if (type === "mysql") {
      return new MySQLDatabase();
    } else if (type === "mongo") {
      return new MongoDatabase();
    } else {
      throw new Error("Unknown database type");
    }
  }
}

// データベースインスタンスをファクトリで作成
const db = DatabaseFactory.createDatabase("mysql");
db.connect(); // "Connected to MySQL"

// 支払いインターフェース
interface PaymentService {
  processPayment(amount: number): void;
}

// 具体的な支払い実装 (クレジットカード)
class CreditCardPaymentService implements PaymentService {
  processPayment(amount: number): void {
    console.log(`Processing credit card payment of ${amount}`);
  }
}

// 配送インターフェース
interface ShippingService {
  shipItem(item: string): void;
}

// 具体的な配送実装 (通常配送)
class StandardShippingService implements ShippingService {
  shipItem(item: string): void {
    console.log(`Shipping item via standard delivery: ${item}`);
  }
}

// 注文サービス
class OrderService {
  private paymentService: PaymentService;
  private shippingService: ShippingService;

  constructor(paymentService: PaymentService, shippingService: ShippingService) {
    this.paymentService = paymentService;
    this.shippingService = shippingService;
  }

  placeOrder(item: string, amount: number) {
    this.paymentService.processPayment(amount);
    this.shippingService.shipItem(item);
    console.log("Order placed successfully.");
  }
}

import { Container } from "inversify";

// DIコンテナの初期化
const container = new Container();

// コンテナに依存関係をバインド
container.bind<PaymentService>("PaymentService").to(CreditCardPaymentService);
container.bind<ShippingService>("ShippingService").to(StandardShippingService);
container.bind<OrderService>(OrderService).toSelf();

// 依存関係を解決して注文サービスを実行
const orderService = container.get(OrderService);
orderService.placeOrder("Laptop", 1500); // 出力: クレジットカード支払い、通常配送

// 新しい支払い方法の追加 (PayPal)
class PayPalPaymentService implements PaymentService {
  processPayment(amount: number): void {
    console.log(`Processing PayPal payment of ${amount}`);
  }
}

// DIコンテナの依存関係を再バインド
container.rebind<PaymentService>("PaymentService").to(PayPalPaymentService);
const updatedOrderService = container.get(OrderService);
updatedOrderService.placeOrder("Smartphone", 800); // 出力: PayPal支払い、通常配送

// モックを使った依存関係の注入 (テスト用)
class MockPaymentService implements PaymentService {
  processPayment(amount: number): void {
    console.log(`Mock payment processed for ${amount}`);
  }
}

class MockShippingService implements ShippingService {
  shipItem(item: string): void {
    console.log(`Mock shipping for item: ${item}`);
  }
}

// テスト時にモックを注入
const mockOrderService = new OrderService(new MockPaymentService(), new MockShippingService());
mockOrderService.placeOrder("TestItem", 0); // 出力: モック支払い、モック配送

// 依存関係のモッククラス
class MockPaymentService implements PaymentService {
  processPayment(amount: number): void {
    console.log(`MockPaymentService: Pretending to process payment of ${amount}`);
  }
}

class MockShippingService implements ShippingService {
  shipItem(item: string): void {
    console.log(`MockShippingService: Pretending to ship item: ${item}`);
  }
}

// モックを使ったOrderServiceのテスト
const mockPaymentService = new MockPaymentService();
const mockShippingService = new MockShippingService();
const orderService = new OrderService(mockPaymentService, mockShippingService);

// テスト実行
orderService.placeOrder("TestItem", 100);
// 出力:
// MockPaymentService: Pretending to process payment of 100
// MockShippingService: Pretending to ship item: TestItem
// Order placed successfully.

import { jest } from '@jest/globals';

// Jestでのモック作成
const mockPaymentService = {
  processPayment: jest.fn(),
};

const mockShippingService = {
  shipItem: jest.fn(),
};

// OrderServiceのテスト
test('should place order successfully', () => {
  const orderService = new OrderService(mockPaymentService, mockShippingService);
  orderService.placeOrder('TestItem', 100);

  // モックメソッドが正しく呼ばれたか確認
  expect(mockPaymentService.processPayment).toHaveBeenCalledWith(100);
  expect(mockShippingService.shipItem).toHaveBeenCalledWith('TestItem');
});

// 支払い失敗のシナリオをテスト
mockPaymentService.processPayment.mockImplementation(() => {
  throw new Error("Payment failed");
});

test('should handle payment failure', () => {
  const orderService = new OrderService(mockPaymentService, mockShippingService);

  expect(() => {
    orderService.placeOrder('TestItem', 100);
  }).toThrow("Payment failed");
});

class HeavyService {
  constructor() {
    console.log("HeavyService is being created...");
  }

  performTask() {
    console.log("HeavyService is performing a task.");
  }
}

class OrderService {
  private heavyService?: HeavyService;

  // HeavyServiceを遅延ロード
  getHeavyService(): HeavyService {
    if (!this.heavyService) {
      this.heavyService = new HeavyService();
    }
    return this.heavyService;
  }

  processOrder() {
    console.log("Order is being processed.");
    // HeavyServiceが必要になった時にのみインスタンス化
    this.getHeavyService().performTask();
  }
}

// 使用例
const orderService = new OrderService();
orderService.processOrder(); // HeavyServiceが必要になる時点で初めてインスタンス化

class CachedPaymentService implements PaymentService {
  private cache: Record<string, number> = {};

  processPayment(amount: number): void {
    if (this.cache[amount]) {
      console.log(`Payment of ${amount} retrieved from cache.`);
    } else {
      // 実際の支払い処理を行う代わりにキャッシュに保存
      this.cache[amount] = amount;
      console.log(`Payment of ${amount} processed and cached.`);
    }
  }
}

// 依存関係を利用した注文処理
const paymentService = new CachedPaymentService();
const orderService = new OrderService(paymentService, new StandardShippingService());

orderService.placeOrder("Tablet", 500); // 支払い処理が行われ、キャッシュされる
orderService.placeOrder("Tablet", 500); // キャッシュから支払い情報が取得される

// DIコンテナで異なる支払い方法を切り替え
container.rebind<PaymentService>("PaymentService").to(PayPalPaymentService);