ドメイン駆動設計（DDD）によるビジネス価値最大化と複雑性への対応

【事例】保険会社の契約管理システム

従来の技術中心設計:
- データベース主導の設計により、契約条件の変更に毎回DBスキーマ変更が必要
- システム間の連携が複雑で、新商品の導入に3ヶ月以上要する

DDD適用後:
- 保険商品と契約プロセスを忠実にモデル化し、変更の局所化を実現
- 新商品の導入期間を3週間に短縮
- ビジネスルールの変更を開発者でなくても設定可能に

// 悪い例: 技術用語とビジネス用語の混在
class TblCust {
    int CustID;
    String CustName;
    boolean IsActive;
}

// 良い例: ユビキタス言語を反映したモデル
class 顧客 {
    顧客ID id;
    氏名 name;
    契約状態 contractStatus; // 「有効」「休止中」「解約済」などビジネス用語で表現
}

// コンテキストマップの概念的表現（擬似コード）
ContextMap eCommerceSystem {
    BoundedContext CatalogContext { 
        type = FEATURE
        responsibilities = "商品情報管理、カタログ表示"
    }
    
    BoundedContext InventoryContext { 
        type = FEATURE
        responsibilities = "在庫管理、倉庫管理"
    }
    
    BoundedContext OrderContext { 
        type = FEATURE
        responsibilities = "注文処理、支払管理"
    }
    
    BoundedContext CustomerContext { 
        type = FEATURE
        responsibilities = "顧客情報管理、認証"
    }
    
    // 関係性の定義
    CatalogContext [P]<->[P] InventoryContext // パートナーシップ
    OrderContext [D]-->[U] InventoryContext // 上流/下流
    CustomerContext [ACL]-->[U] LegacyCRMContext // 腐敗防止層
}

// Javaによるエンティティの実装例
public class 注文 {
    private final 注文ID id;  // 識別子
    private 顧客ID 顧客ID;
    private List<注文明細> 明細一覧;
    private 配送先住所 配送先;
    private 注文状態 状態;

    // コンストラクタ、ビジネスメソッド、検証ロジックなど
    public 注文(注文ID id, 顧客ID 顧客ID, List<注文明細> 明細一覧, 配送先住所 配送先) {
        // 不変条件の検証
        if (明細一覧 == null || 明細一覧.isEmpty()) {
            throw new IllegalArgumentException("注文には少なくとも1つの明細が必要です");
        }
        
        this.id = id;
        this.顧客ID = 顧客ID;
        this.明細一覧 = 明細一覧;
        this.配送先 = 配送先;
        this.状態 = 注文状態.準備中;
    }
    
    // ビジネスメソッド
    public void 出荷() {
        if (状態 != 注文状態.準備中) {
            throw new IllegalStateException("準備中の注文のみ出荷できます");
        }
        状態 = 注文状態.出荷済;
        // ドメインイベントの発行など
    }
    
    // 同一性比較はIDに基づく
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        注文 other = (注文) o;
        return id.equals(other.id);
    }
    
    @Override
    public int hashCode() {
        return id.hashCode();
    }
}

// Kotlinによる値オブジェクトの実装例
data class 金額(val 値: BigDecimal, val 通貨: 通貨単位) {
    init {
        require(値.scale() <= 2) { "金額の小数点以下は2桁までです" }
    }
    
    fun プラス(other: 金額): 金額 {
        require(通貨 == other.通貨) { "異なる通貨間の計算はできません" }
        return 金額(値.add(other.値), 通貨)
    }
    
    fun マイナス(other: 金額): 金額 {
        require(通貨 == other.通貨) { "異なる通貨間の計算はできません" }
        return 金額(値.subtract(other.値), 通貨)
    }
    
    fun 掛ける(係数: BigDecimal): 金額 {
        return 金額(値.multiply(係数).setScale(2, RoundingMode.HALF_UP), 通貨)
    }
    
    fun 消費税込み(税率: BigDecimal): 金額 {
        val 税率係数 = BigDecimal.ONE.add(税率)
        return 掛ける(税率係数)
    }
}

// Kotlinのdata classを使用すると、equals/hashCodeは自動的に実装される

// C#による集約の実装例
public class 注文 // 集約ルート
{
    private readonly HashSet<注文明細> _明細一覧 = new HashSet<注文明細>();
    
    public 注文ID ID { get; private set; }
    public 顧客ID 顧客ID { get; private set; }
    public IReadOnlyCollection<注文明細> 明細一覧 => _明細一覧.ToList().AsReadOnly();
    public 金額 合計金額 => 計算合計金額();
    public 注文状態 状態 { get; private set; }
    
    // 明細を追加（集約ルートを通じての変更）
    public void 明細追加(商品ID 商品ID, int 数量, 金額 単価)
    {
        // ビジネスルールの適用
        if (状態 != 注文状態.作成中)
            throw new DomainException("作成中の注文にのみ明細を追加できます");
            
        var 明細 = new 注文明細(商品ID, 数量, 単価);
        _明細一覧.Add(明細);
    }
    
    // 明細を削除（集約ルートを通じての変更）
    public void 明細削除(商品ID 商品ID)
    {
        if (状態 != 注文状態.作成中)
            throw new DomainException("作成中の注文からのみ明細を削除できます");
            
        var 明細 = _明細一覧.FirstOrDefault(i => i.商品ID == 商品ID);
        if (明細 != null)
            _明細一覧.Remove(明細);
    }
    
    private 金額 計算合計金額()
    {
        // 集約内の一貫性を保証するロジック
        return _明細一覧.Aggregate(
            new 金額(0, 通貨単位.円), 
            (current, item) => current.プラス(item.小計));
    }
}

// 集約内のエンティティ
public class 注文明細 
{
    public 商品ID 商品ID { get; private set; }
    public int 数量 { get; private set; }
    public 金額 単価 { get; private set; }
    public 金額 小計 => 単価.掛ける(数量);
    
    internal 注文明細(商品ID 商品ID, int 数量, 金額 単価)
    {
        if (数量 <= 0)
            throw new DomainException("数量は1以上である必要があります");
            
        this.商品ID = 商品ID;
        this.数量 = 数量;
        this.単価 = 単価;
    }
    
    // 内部変更メソッド（集約ルートからのみアクセス可能）
    internal void 数量変更(int 新数量)
    {
        if (新数量 <= 0)
            throw new DomainException("数量は1以上である必要があります");
            
        this.数量 = 新数量;
    }
}

// TypeScriptによるドメインサービスの実装例
class 為替レートサービス {
  // 外部システムとの連携が必要な操作
  通貨換算(金額: 金額, 目標通貨: 通貨単位): 金額 {
    // レートの取得などの複雑なロジック
    const レート = this.為替レート取得(金額.通貨, 目標通貨);
    const 換算額 = 金額.値 * レート;
    return new 金額(換算額, 目標通貨);
  }
  
  private 為替レート取得(元通貨: 通貨単位, 目標通貨: 通貨単位): number {
    // 外部システムからの取得ロジック
    // ...
  }
}

// 複数の集約を横断する操作
class 注文処理サービス {
  constructor(
    private readonly 注文リポジトリ: 注文リポジトリ,
    private readonly 顧客リポジトリ: 顧客リポジトリ,
    private readonly 在庫リポジトリ: 在庫リポジトリ
  ) {}
  
  注文確定(注文ID: 注文ID): void {
    const 注文 = this.注文リポジトリ.取得(注文ID);
    const 顧客 = this.顧客リポジトリ.取得(注文.顧客ID);
    
    // 在庫の確認
    for (const 明細 of 注文.明細一覧) {
      const 在庫 = this.在庫リポジトリ.商品の在庫取得(明細.商品ID);
      if (!在庫.確認(明細.数量)) {
        throw new Error(`商品${明細.商品ID}の在庫が不足しています`);
      }
    }
    
    // 顧客のクレジット確認
    if (!顧客.クレジット確認(注文.合計金額)) {
      throw new Error('顧客のクレジット限度額を超えています');
    }
    
    // 注文の状態を変更
    注文.確定();
    
    // 在庫の引き当て
    for (const 明細 of 注文.明細一覧) {
      const 在庫 = this.在庫リポジトリ.商品の在庫取得(明細.商品ID);
      在庫.引き当て(明細.数量);
      this.在庫リポジトリ.保存(在庫);
    }
    
    this.注文リポジトリ.保存(注文);
  }
}

# Pythonによるリポジトリインターフェースとその実装
from abc import ABC, abstractmethod
from typing import List, Optional

# リポジトリインターフェース
class 注文リポジトリ(ABC):
    @abstractmethod
    def 保存(self, 注文: 注文) -> None:
        pass
        
    @abstractmethod
    def 取得(self, id: 注文ID) -> Optional[注文]:
        pass
        
    @abstractmethod
    def 顧客の注文取得(self, 顧客ID: 顧客ID) -> List[注文]:
        pass
        
    @abstractmethod
    def 削除(self, id: 注文ID) -> None:
        pass
        
# 実装（例：SQLAlchemyを使用）
class SQLAlchemy注文リポジトリ(注文リポジトリ):
    def __init__(self, session):
        self.session = session
        
    def 保存(self, 注文: 注文) -> None:
        self.session.merge(注文)
        self.session.commit()
        
    def 取得(self, id: 注文ID) -> Optional[注文]:
        return self.session.query(注文).filter(注文.id == id).first()
        
    def 顧客の注文取得(self, 顧客ID: 顧客ID) -> List[注文]:
        return self.session.query(注文).filter(注文.顧客ID == 顧客ID).all()
        
    def 削除(self, id: 注文ID) -> None:
        注文 = self.取得(id)
        if 注文:
            self.session.delete(注文)
            self.session.commit()

# Rubyによるドメインイベントの実装例
class 注文確定イベント
  attr_reader :注文ID, :顧客ID, :合計金額, :発生日時
  
  def initialize(注文ID, 顧客ID, 合計金額)
    @注文ID = 注文ID
    @顧客ID = 顧客ID
    @合計金額 = 合計金額
    @発生日時 = Time.now
  end
end

# イベントの発行と購読
class 注文
  # 注文の確定処理
  def 確定!
    return if @状態 == :確定済
    
    @状態 = :確定済
    @確定日時 = Time.now
    
    # イベントの発行
    イベント = 注文確定イベント.new(self.id, self.顧客ID, self.合計金額)
    DomainEvents.publish(イベント)
  end
end

# イベントハンドラ
class 在庫引当ハンドラ
  def handle(イベント)
    return unless イベント.is_a?(注文確定イベント)
    
    注文 = 注文リポジトリ.取得(イベント.注文ID)
    注文.明細一覧.each do |明細|
      在庫サービス.引当(明細.商品ID, 明細.数量)
    end
  end
end

class 出荷指示ハンドラ
  def handle(イベント)
    return unless イベント.is_a?(注文確定イベント)
    
    出荷サービス.出荷指示作成(イベント.注文ID)
  end
end

// Javaによる仕様パターンの実装例
public interface 仕様<T> {
    boolean isSatisfiedBy(T entity);
}

// 具体的な仕様
public class プレミアム顧客仕様 implements 仕様<顧客> {
    private final BigDecimal 閾値金額;
    
    public プレミアム顧客仕様(BigDecimal 閾値金額) {
        this.閾値金額 = 閾値金額;
    }
    
    @Override
    public boolean isSatisfiedBy(顧客 顧客) {
        return 顧客.過去1年間の購入金額().compareTo(閾値金額) >= 0;
    }
}

// 仕様の組み合わせ
public class And仕様<T> implements 仕様<T> {
    private final 仕様<T> spec1;
    private final 仕様<T> spec2;
    
    public And仕様(仕様<T> spec1, 仕様<T> spec2) {
        this.spec1 = spec1;
        this.spec2 = spec2;
    }
    
    @Override
    public boolean isSatisfiedBy(T entity) {
        return spec1.isSatisfiedBy(entity) && spec2.isSatisfiedBy(entity);
    }
}

// 使用例
仕様<顧客> プレミアム仕様 = new プレミアム顧客仕様(new BigDecimal("100000"));
仕様<顧客> 特典対象仕様 = new And仕様<>(
    プレミアム仕様,
    new 会員登録完了仕様()
);

顧客リスト.stream()
    .filter(特典対象仕様::isSatisfiedBy)
    .forEach(特典サービス::適用);

// TypeScriptによるファクトリーパターンの実装例
class 注文ファクトリー {
  constructor(
    private readonly 注文リポジトリ: 注文リポジトリ,
    private readonly 商品リポジトリ: 商品リポジトリ
  ) {}
  
  新規注文作成(顧客ID: 顧客ID, 明細リスト: {商品ID: 商品ID, 数量: number}[], 配送先: 住所): 注文 {
    // 注文IDの生成
    const 注文ID = this.注文リポジトリ.次のID();
    
    // 明細の構築
    const 注文明細リスト: 注文明細[] = [];
    for (const item of 明細リスト) {
      const 商品 = this.商品リポジトリ.取得(item.商品ID);
      if (!商品) {
        throw new Error(`商品ID ${item.商品ID} は存在しません`);
      }
      
      const 明細 = new 注文明細(item.商品ID, item.数量, 商品.価格);
      注文明細リスト.push(明細);
    }
    
    // 注文オブジェクトの構築
    return new 注文(注文ID, 顧客ID, 注文明細リスト, 配送先);
  }
  
  // 既存注文からの複製作成
  注文複製(元注文ID: 注文ID): 注文 {
    const 元注文 = this.注文リポジトリ.取得(元注文ID);
    if (!元注文) {
      throw new Error(`注文ID ${元注文ID} は存在しません`);
    }
    
    const 注文ID = this.注文リポジトリ.次のID();
    return new 注文(
      注文ID,
      元注文.顧客ID,
      [...元注文.明細一覧], // 明細のコピー
      元注文.配送先
    );
  }
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue
    private OrderId id;
    
    @Embedded
    private CustomerId customerId;
    
    @ElementCollection
    private Set<OrderLineItem> lineItems = new HashSet<>();
    
    @Embedded
    private ShippingAddress shippingAddress;
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    
    // ビジネスロジックを集約内に実装
    public Money calculateTotal() {
        return lineItems.stream()
            .map(OrderLineItem::getSubtotal)
            .reduce(Money.ZERO, Money::add);
    }
    
    public void addItem(Product product, int quantity) {
        // 在庫確認などのビジネスルール適用
        if (product.isDiscontinued()) {
            throw new DomainException("廃止された商品は注文できません");
        }
        
        // 既存の商品なら数量を更新
        Optional<OrderLineItem> existingItem = findLineItemByProductId(product.getId());
        if (existingItem.isPresent()) {
            existingItem.get().increaseQuantity(quantity);
        } else {
            lineItems.add(new OrderLineItem(product.getId(), product.getPrice(), quantity));
        }
    }
    
    public void place() {
        if (lineItems.isEmpty()) {
            throw new DomainException("注文には少なくとも1つの商品が必要です");
        }
        this.status = OrderStatus.PLACED;
        DomainEventPublisher.publish(new OrderPlacedEvent(this.id));
    }
    
    // その他のビジネスメソッド
}

public interface OrderRepository {
    Optional<Order> findById(OrderId orderId);
    void save(Order order);
    List<Order> findByCustomerId(CustomerId customerId);
}

@Repository
public class JpaOrderRepository implements OrderRepository {
    @PersistenceContext
    private EntityManager entityManager;
    
    @Override
    public Optional<Order> findById(OrderId orderId) {
        return Optional.ofNullable(entityManager.find(Order.class, orderId));
    }
    
    @Override
    public void save(Order order) {
        entityManager.persist(order);
    }
    
    @Override
    public List<Order> findByCustomerId(CustomerId customerId) {
        return entityManager.createQuery(
                "SELECT o FROM Order o WHERE o.customerId = :customerId", Order.class)
                .setParameter("customerId", customerId)
                .getResultList();
    }
}

@Service
public class OrderProcessingService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    @Transactional
    public void processOrder(OrderId orderId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new EntityNotFoundException("注文が見つかりません"));
            
        // 在庫確認
        boolean inventoryAvailable = inventoryService.checkAvailability(order);
        if (!inventoryAvailable) {
            throw new DomainException("在庫不足のため注文を処理できません");
        }
        
        // 支払い処理
        PaymentResult result = paymentService.processPayment(order);
        if (result.isSuccessful()) {
            order.markAsPaid();
            orderRepository.save(order);
        } else {
            throw new DomainException("支払い処理に失敗しました: " + result.getFailureReason());
        }
    }
}

class Money {
    private readonly amount: number;
    private readonly currency: string;
    
    private constructor(amount: number, currency: string) {
        this.amount = amount;
        this.currency = currency;
    }
    
    public static yen(amount: number): Money {
        return new Money(amount, "JPY");
    }
    
    public static usd(amount: number): Money {
        return new Money(amount, "USD");
    }
    
    public add(other: Money): Money {
        if (this.currency !== other.currency) {
            throw new Error(`通貨が異なります: ${this.currency} と ${other.currency}`);
        }
        return new Money(this.amount + other.amount, this.currency);
    }
    
    public subtract(other: Money): Money {
        if (this.currency !== other.currency) {
            throw new Error(`通貨が異なります: ${this.currency} と ${other.currency}`);
        }
        return new Money(this.amount - other.amount, this.currency);
    }
    
    public multiply(multiplier: number): Money {
        return new Money(this.amount * multiplier, this.currency);
    }
    
    // 値オブジェクトの等価性
    public equals(other: Money): boolean {
        if (other === null || other === undefined) return false;
        return this.amount === other.amount && this.currency === other.currency;
    }
    
    public toString(): string {
        return `${this.amount} ${this.currency}`;
    }
}