オブジェクト指向のアンチパターンから脱却!データと処理を分離してバグを減らす設計設計

オブジェクト指向のアンチパターンを見直しデータと処理を分離する設計 アーキテクチャ

オブジェクト指向では、「データと、それを操作する処理をひとまとめにする」という考え方が基本になります。
これは適切に使えば、関連する責務を近くに置き、変更の影響範囲を局所化できる有効な設計です。
しかし、クラスを作ること自体が目的になると、状況は一変します。
状態を大量に抱えたオブジェクト同士が複雑に呼び出し合い、継承や隠れた副作用によって、たった一つの変更が思わぬ箇所のバグを引き起こす構造になりがちです。

特に問題なのは、現実世界の「もの」をそのままクラスへ写し取ろうとする発想です。
実際の業務では、データの保存形式と、そのデータに対して行う判断・変換・検証は、必ずしも同じ変更理由を持ちません。
それにもかかわらず、すべての処理をデータを保持するオブジェクトへ集約すると、責務が肥大化し、テストも再利用も難しくなります。
反対に、データと処理を適切に分離できれば、処理は入力と出力の関係として捉えやすくなり、状態変更の範囲や依存関係を明確にできます。

もちろん、分離すれば常に正解というわけではありません。
過度に細かい関数や型を増やせば、かえって全体像が見えにくくなるため、凝集度や変更頻度、データの所有権を基準に設計を判断する必要があります。
本記事では、オブジェクト指向で起こりやすいアンチパターンを整理し、データと処理をどの境界で分けるべきかを、具体的な設計例とともに解説します。
コードを動かすだけでなく、バグが生まれにくい構造をどう作るか。
そこから見直していきましょう。

  1. オブジェクト指向のアンチパターンがバグを増やす理由
    1. クラス設計で起こりやすい代表的な問題
    2. 状態と副作用が見えにくいコードの危険性
  2. データと処理を分離する設計が注目される背景
    1. 変更に強いソフトウェアが求められている
    2. テストしやすさと保守性への関心が高まっている
    3. 関数型プログラミングとデータ中心の考え方
    4. データベースや外部サービスとの境界が複雑になっている
  3. オブジェクト指向ですべてを表現することの限界
    1. 現実世界のモデルとソフトウェアのモデルは一致しない
    2. データ変換や集計処理はオブジェクト化しにくい
    3. 継承による分類は変更に弱くなりやすい
    4. オブジェクトの同一性が常に必要とは限らない
    5. オブジェクト指向を適用する範囲を見極める
  4. データと処理を分離する基本原則
    1. データの責務と処理の責務を明確に分ける
    2. 状態変更を減らして依存関係を単純化する
  5. 関数型プログラミングの考え方を設計に取り入れる
    1. 純粋関数で業務ロジックを表現する
    2. 不変データで予期しないバグを防ぐ
  6. データと処理の分離を実装へ落とし込む方法
    1. データ転送オブジェクトとドメインロジックを使い分ける
    2. サービス層へ処理を集約するときの注意点
    3. データベース設計とアプリケーションロジックの境界を決める
  7. データと処理を分離した設計のテスト効果
    1. 純粋な処理を単体テストするメリット
    2. モックに頼りすぎないテスト設計を考える
  8. データと処理の分離で失敗しないための注意点
    1. 分離しすぎによる過剰設計を避ける
    2. 変更理由と凝集度から適切な境界を判断する
  9. オブジェクト指向のアンチパターンから脱却しバグを減らす設計へ

オブジェクト指向のアンチパターンがバグを増やす理由

複雑に絡み合ったオブジェクト指向のクラス構造

オブジェクト指向は、データと処理をオブジェクトにまとめ、複雑なソフトウェアを整理するための強力な考え方です。
関連する状態と操作を近くに配置できるため、適切に設計されたクラスは、コードの意図を読み取りやすくし、変更の影響範囲も限定できます。
しかし、クラスを作ることや、すべての処理をオブジェクトのメソッドにすること自体が目的になると、設計上の利点は失われます。

典型的な問題は、現実世界の概念をそのままクラスへ写し取ろうとすることです。
現実の「注文」「会員」「商品」といった名詞を見つけ、それぞれをクラスにするだけでは、ソフトウェアとして適切な責務分担にはなりません。
データの保存、入力値の検証、料金の計算、外部サービスとの通信、画面表示までを一つのクラスへ集めれば、そのクラスは複数の理由で変更されることになります。

この状態が続くと、クラスの内部構造を理解しなければ、わずかな修正さえ安全に行えなくなります。
あるメソッドの変更が別のメソッドの前提条件を壊し、その影響がさらに別のオブジェクトへ伝播するためです。
問題が発生した場所と、原因となった変更箇所が一致しないことも珍しくありません。
結果として、デバッグに時間がかかり、テストケースも増え、開発速度が徐々に低下します。

重要なのは、オブジェクト指向そのものを否定することではありません。
問題は、データの所有と処理の実行を無条件に同じ場所へ置くことです。
どの処理がどのデータに依存し、どの範囲を変更するのかを明確にできれば、クラスを使う設計でも、関数を中心とした設計でも、バグの発生しにくい構造を作れます。

クラス設計で起こりやすい代表的な問題

クラス設計で起こりやすい代表的な問題の一つが、責務の過剰な集中です。
最初は単純なデータ保持用クラスとして作ったクラスに、入力検証、計算、永続化、ログ出力、通知処理などが少しずつ追加されていくケースです。
追加される処理は一見すると関連しているように見えますが、実際には異なる変更理由を持っています。

例えば、データベースの仕様変更は永続化処理に影響します。
一方、割引ルールの変更は料金計算に影響し、ログの形式変更は監視や運用上の都合によるものです。
これらを同じクラスに集めると、一つの変更理由がクラス全体の再確認を要求します。
クラスの行数が多いことだけが問題なのではありません。
異なる責務が同じ変更単位に押し込まれていることが本質的な問題です。

もう一つの代表例が、継承階層の複雑化です。
共通処理を再利用する目的で基底クラスを作り、個別の違いをサブクラスで上書きする設計は、条件が明確な場合には有効です。
しかし、サブクラスが基底クラスの内部状態や呼び出し順序に強く依存すると、基底クラスの変更がすべてのサブクラスへ波及します。
メソッドをオーバーライドした結果、基底クラスが想定する不変条件を破壊することもあります。

さらに、便利な共通クラスを作りすぎる問題もあります。
複数の機能から呼び出されるユーティリティクラスへ処理を集約すると、依存関係を減らせたように感じます。
しかし、実際には多くの機能が一つのクラスへ依存するため、そのクラスは変更に弱い共有部品になります。
名前が抽象的で、どの機能のための処理なのか分からないクラスは、責務が拡散している可能性があります。

設計を確認する際は、クラス名やメソッド数だけを見るのでは不十分です。
次のような問いが有効です。

  • このクラスは、どのような理由で変更されるのか
  • このメソッドは、クラスが保持するデータに本当に強く依存しているのか
  • このクラスを単独でテストするために、何個の外部オブジェクトが必要なのか
  • 内部の呼び出し順序や状態を知らなければ、正しく利用できない設計になっていないか

これらの問いに明確に答えられない場合、クラスの責務やデータの所有範囲を見直す余地があります。

状態と副作用が見えにくいコードの危険性

バグを難しくする最大の要因の一つが、状態の変化をコードから追跡しにくいことです。
状態とは、オブジェクトが保持している値や、データベース、ファイル、キャッシュなどに保存されている情報を指します。
メソッドを呼び出すだけで内部状態が変わる設計では、同じメソッドに同じ引数を渡しても、呼び出す前の状態によって結果が変わる可能性があります。

このような処理は、単体テストでも扱いにくくなります。
テストの前に特定のメソッドを呼び、内部状態を初期化し、さらに別の処理を実行しておかなければならない場合、テストは本来確認したいロジック以外の準備に依存します。
テスト同士が共有状態を持っていれば、実行順序によって結果が変わることもあります。
単独では成功するテストが、全体で実行すると失敗する現象です。

副作用にも注意が必要です。
副作用とは、関数やメソッドが戻り値を返す以外に、外部の状態を変更したり、外部へ影響を与えたりすることです。
データベースへの書き込み、ファイルの更新、メール送信、ログ出力、グローバル変数の変更などが該当します。
副作用自体が悪いわけではありません。
現実のアプリケーションでは、どこかで外部状態を変更する必要があります。
問題は、計算処理の中に副作用が埋め込まれ、その存在が呼び出し側から見えなくなることです。

例えば、料金を計算するだけに見えるメソッドが、内部で会員情報を更新し、ポイントを付与し、通知まで送っていたとします。
そのメソッドを画面表示のために呼び出しただけでも、データ更新や通知が実行されるかもしれません。
名前から予測できない処理が実行される設計は、利用者にとって危険です。
呼び出し側が必要とするのは計算結果だけなのに、メソッドの内部では複数の責務が一度に実行されているためです。

対策として、まず計算と外部状態の変更を分ける方法があります。
入力されたデータから結果を導く処理は、可能な限り外部環境に依存しない形にします。
そのうえで、データベースへの保存や通知といった副作用は、処理の流れが明確な別の層で実行します。
こうすると、計算ロジックは入力と出力の関係としてテストでき、外部サービスとの連携は連携部分に限定して検証できます。

また、状態を変更するメソッドと、状態を読み取るだけのメソッドを区別することも重要です。
命名によって意図を明示し、読み取り処理の中でデータを書き換えないという規約を設けるだけでも、予期しない動作は減らせます。
設計の目的は、状態を完全になくすことではありません。
状態がどこで生成され、どこで変更され、どこで利用されるのかを追跡可能にすることです。

オブジェクト指向のアンチパターンから脱却する第一歩は、クラスの数を減らすことでも、関数型プログラミングへ全面的に移行することでもありません。
データ、計算、外部への作用を分け、それぞれの変更理由と依存関係を見える形にすることです。
コードを読んだときに状態の流れを説明できるか。
変更したときに、どの範囲をテストすべきか判断できるか。
この二つを基準に設計を見直すと、バグの原因を早い段階で発見しやすくなります。

データと処理を分離する設計が注目される背景

データと処理を分けて整理したソフトウェア設計図

ソフトウェア開発では、機能を追加するよりも、既存の機能を壊さずに変更することのほうが難しい場面があります。
開発初期は小さなクラスや少数のモジュールで実装できていた処理も、利用者や要件が増えるにつれて、データベース、外部API、認証、ログ、キャッシュなどと接続されます。
すると、一つの処理を変更しただけなのに、複数の層やクラスへ影響が広がることがあります。

このような複雑化に対する設計上のアプローチとして、データと処理を分離する考え方が注目されています。
ここでいう分離は、データを入れるクラスを作り、処理を別のクラスへ機械的に移動することではありません。
重要なのは、データがどのような形で表現され、処理が何を入力として受け取り、どのような結果を返すのかを明確にすることです。
さらに、データベースへの保存や外部サービスへの通信といった副作用を、計算や判断のロジックから切り離します。

変更に強いソフトウェアが求められている

データと処理の分離が注目される第一の理由は、ソフトウェアに求められる変更の頻度が高まっていることです。
市場や業務ルールが変われば、料金計算、権限判定、検索条件、通知ルールなども変更されます。
しかも、変更の内容はあらかじめすべて予測できません。
設計時に将来の要件を完全に見通すことは不可能です。

このとき、データを保持するオブジェクトが多くの処理を抱えていると、変更の影響範囲を特定しにくくなります。
料金ルールを修正しただけなのに、注文状態の更新やデータベースへの保存まで確認しなければならない場合、開発者はコード全体の実行経路を追跡する必要があります。
ロジックが独立していれば、料金計算の変更は計算処理とそのテストを中心に確認できます。

設計において重要なのは、変更理由の異なるものを同じ単位へ閉じ込めないことです。
画面仕様、保存形式、業務ルール、外部サービスの仕様は、それぞれ別の理由で変わります。
これらを一つのクラスやメソッドへ集約すると、変更のたびに広い範囲を再検証する必要が生じます。
反対に、変更理由に応じて処理を分割できれば、修正範囲とテスト範囲を限定しやすくなります。

テストしやすさと保守性への関心が高まっている

第二の理由は、テスト自動化の重要性が増していることです。
継続的インテグレーションや継続的デリバリーを実現するには、コードを変更するたびに、一定の時間で信頼性のあるテストを実行できなければなりません。
しかし、処理がデータベースやネットワーク、時刻、乱数などに直接依存していると、テストの準備が複雑になります。

例えば、単純な割引額の計算を確認したいだけなのに、テストのためにデータベースへ会員情報を登録し、外部サービスの応答を用意し、特定の時刻を再現しなければならない設計では、計算ロジックの検証に多くのコストがかかります。
外部環境が停止しているだけで、ロジックとは無関係のテストが失敗する可能性もあります。

そこで、入力データから結果を計算する処理と、データを取得・保存する処理を分けます。
計算部分が外部環境に依存しなければ、通常の値、境界値、異常値を直接渡して、結果を確認できます。
テストの準備が小さくなるだけでなく、失敗したときに原因を絞り込みやすくなります。

もちろん、外部サービスとの連携もテストしなければなりません。
ただし、すべての処理を同じテスト方法で確認する必要はありません。
純粋な計算や判断は高速な単体テストで確認し、データベースやAPIとの接続は結合テストや契約テストで検証するというように、責務に応じてテストを分けることが合理的です。

関数型プログラミングとデータ中心の考え方

第三の理由として、関数型プログラミングの考え方が広く知られるようになったことも挙げられます。
関数型プログラミングでは、入力から出力を導く処理を重視し、処理の途中で外部の状態を変更することをできるだけ避けます。
すべてのアプリケーションを関数型言語で書く必要はありませんが、状態や副作用を管理する考え方は、オブジェクト指向の設計にも応用できます。

同じ入力に対して同じ結果を返す処理は、理解とテストが容易です。
一方、内部状態や外部環境によって結果が変わる処理は、呼び出しの前提条件を把握しなければなりません。
状態を完全になくすことは現実的ではありませんが、状態に依存する部分を限定し、依存しない処理を増やすことは可能です。

たとえば、注文データから合計金額を算出する処理、商品の一覧から在庫不足の商品を抽出する処理、入力された権限情報から操作の可否を判断する処理などは、外部環境から切り離しやすい領域です。
これらをデータベースアクセスや画面表示と同じクラスへ置く必要はありません。
データを受け取り、結果を返す処理として表現できれば、再利用性と検証可能性が高まります。

ただし、データと処理の分離を関数の分割数で評価してはいけません。
関数を細かく分けすぎれば、処理の流れを追うために多くのファイルを行き来することになります。
分離の目的は、コードを細切れにすることではなく、依存関係と変更の境界を明確にすることです。

データベースや外部サービスとの境界が複雑になっている

現代のWebアプリケーションでは、アプリケーション内部のロジックだけで処理が完結するとは限りません。
リレーショナルデータベース、キャッシュ、メッセージキュー、決済サービス、認証基盤など、複数の外部要素と連携します。
それぞれの仕様や障害条件を、業務ロジックへ直接持ち込むと、コードの複雑性は急速に高まります。

データベースのテーブル構造は、アプリケーションが扱う業務上の概念と完全に一致するとは限りません。
正規化された複数のテーブルからデータを取得し、それをアプリケーションが扱いやすい形へ変換する必要がある場合もあります。
この変換処理を業務ルールと同じ場所へ置くと、保存形式の変更がロジックへ波及します。

そのため、データベースから取得したデータ、アプリケーション内部で扱うデータ、外部APIへ送信するデータを、必要に応じて別の表現として扱います。
すべてを別の型にすることが正解ではありませんが、異なる目的のデータを同じ構造として無理に共有しないことが重要です。
保存形式と業務上の意味を分けることで、データベースの都合が処理全体を支配する状況を避けられます。

この境界を設計する際は、次の点を確認すると判断しやすくなります。

  • そのデータ形式は、データベースの都合で決まっているのか、業務上の意味で決まっているのか
  • 処理は外部サービスの応答形式を直接参照していないか
  • 外部サービスを別の実装へ置き換えた場合、業務ロジックまで変更する必要があるか
  • データの変換処理と業務上の判断が同じメソッドに混在していないか

これらを確認すると、どこまでをデータの責務とし、どこからを処理の責務とするかが見えやすくなります。

データと処理を分離する設計が注目されている背景には、オブジェクト指向への反動だけではなく、変更の頻度、テストの自動化、外部サービスとの連携、状態管理の難しさといった、現在のソフトウェア開発が抱える現実的な課題があります。
目指すべきなのは、データを単純な入れ物にして処理を無制限に外へ追い出すことではありません。
どの処理がどのデータに依存し、どこで状態を変更し、どこから先が外部環境なのかを説明できる構造です。

オブジェクト指向、関数型プログラミング、データ中心設計は、互いに排他的な選択肢ではありません。
必要な場所ではオブジェクトに責務を持たせ、独立させやすい計算は関数として表現し、外部との境界は明確に分ける。
このように複数の考え方を組み合わせることで、実装の自由度を保ちながら、バグの原因を追跡しやすい設計へ近づけます。

オブジェクト指向ですべてを表現することの限界

複雑化したオブジェクト指向モデルと依存関係の図

オブジェクト指向は、複雑なソフトウェアを構造化するための有力な方法です。
データと、それに関係する操作をオブジェクトへまとめれば、変更箇所を局所化しやすくなります。
アクセス制御やポリモーフィズムを利用して、実装の詳細を隠すこともできます。
実際、多くの業務システムやWebアプリケーションは、オブジェクト指向の考え方を基盤として発展してきました。

一方で、現実に存在するものをすべてオブジェクトとして表現すれば、設計が分かりやすくなるわけではありません。
ソフトウェアが扱うのは、現実の物体だけではないからです。
大量のレコード、時系列データ、変換処理、集計結果、通信メッセージ、設定値、イベントなど、振る舞いよりも構造や流れが重要なデータも数多く存在します。
これらを無理に状態を持つオブジェクトへ変換すると、かえって処理の関係が見えにくくなります。

現実世界のモデルとソフトウェアのモデルは一致しない

オブジェクト指向の設計では、現実世界の概念を分析し、名詞をクラス、動詞をメソッドとして表現する考え方がよく使われます。
この方法は、対象となる業務を理解するきっかけとしては有効です。
しかし、現実の概念をそのままクラスへ変換するだけでは、実装上の責務は決まりません。

たとえば、「注文」という概念には、注文番号、購入者、商品、金額、配送先、状態などの情報があります。
しかし、注文に対して実行される処理は一種類ではありません。
合計金額の計算、在庫の確保、支払いの確認、キャンセル可能期間の判定、配送状況の更新、売上集計など、異なる目的を持つ処理が関係します。
これらをすべて注文クラスへ追加すると、注文クラスは業務全体の窓口になり、次第に巨大化します。

さらに、同じデータが複数の視点から利用されることもあります。
注文データは、顧客向け画面では購入履歴として表示され、倉庫では出荷指示として利用され、経理では売上情報として集計されます。
それぞれが必要とするデータの形や処理は異なります。
単一の注文オブジェクトにすべての視点を集約すると、利用者ごとの要求が一つのクラスに混在します。

現実世界では一つのものとして扱われている対象でも、ソフトウェアでは複数のデータ構造や処理単位に分けたほうが合理的な場合があります。
モデルは現実の完全な複製ではなく、特定の目的のための抽象化です。
この前提を忘れると、「現実に存在するからクラスにする」という形式的な設計に陥ります。

データ変換や集計処理はオブジェクト化しにくい

アプリケーションには、状態を保持する主体だけでなく、データを変換したり集計したりする処理が数多くあります。
複数のレコードを条件で絞り込み、並べ替え、グループ化し、別の形式へ変換する処理です。
これらは、特定のオブジェクトが所有する振る舞いというより、入力データ全体に対する操作として捉えたほうが自然なことがあります。

例えば、一定期間の売上データから部門別の集計結果を作る処理を考えてみます。
集計の対象となるデータは、注文、商品、顧客、日時など複数の情報から構成されます。
集計処理を注文オブジェクトに持たせるのか、商品オブジェクトに持たせるのか、それとも顧客オブジェクトに持たせるのかは、一意に決まりません。
無理にどれかのクラスへ配置すると、クラスの責務が不自然に広がる可能性があります。

このような処理は、入力と出力を明確にした独立した処理として表現できます。
どのデータを受け取り、どの条件で計算し、どの結果を返すのかが分かれば、特定のオブジェクトの内部状態に依存する必要はありません。
もちろん、実装上はクラスのメソッドとして定義しても構いません。
重要なのは、クラスに置いたという事実ではなく、不要な状態や依存関係を持ち込んでいないことです。

オブジェクト指向では、処理の所属先を必ず決めようとする傾向があります。
しかし、処理によっては「誰のメソッドか」を考えるよりも、「どの入力からどの出力を作るか」を考えたほうが設計しやすい場合があります。
特に、集計、変換、検証、検索条件の組み立てといった処理では、この視点が有効です。

継承による分類は変更に弱くなりやすい

オブジェクト指向の代表的な機能である継承も、すべての問題を解決するわけではありません。
継承を使うと、共通処理を基底クラスへまとめ、差分をサブクラスに記述できます。
型の互換性を保ちながら、複数の実装を扱える点は便利です。

しかし、継承関係は強い結合を生みます。
サブクラスは基底クラスのメソッドや状態、初期化の手順に依存するため、基底クラスの変更がサブクラスへ影響します。
基底クラスへ新しい前提条件を追加した場合、既存のサブクラスがその条件を満たせなくなることもあります。
見た目には共通している処理でも、将来の変更理由が異なるなら、同じ継承階層へ入れるべきとは限りません。

また、分類は時間とともに変化します。
最初は「通常会員」と「特別会員」の二種類だったものが、契約プラン、地域、キャンペーン、利用状況などの組み合わせによって振る舞いを変えるようになると、サブクラスの数が急増します。
条件の組み合わせを継承で表現しようとすると、クラス爆発が起きます。

この場合は、データとして条件を保持し、処理側でルールを評価するほうが柔軟な場合があります。
あるいは、継承ではなく委譲や合成を使い、料金計算、権限判定、通知方式などの変化しやすい要素を独立した処理として差し替えられるようにします。
分類を固定するより、変化するルールをデータや小さな処理へ分けるほうが、変更への対応力を高められます。

オブジェクトの同一性が常に必要とは限らない

オブジェクト指向では、オブジェクトの同一性やライフサイクルを重視します。
どのオブジェクトがどの状態を持ち、いつ生成され、誰が変更するのかを管理することは、業務システムにおいて重要です。
しかし、すべてのデータに長期間維持される同一性が必要なわけではありません。

画面表示用に作られたデータ、検索結果、APIのレスポンス、計算途中の値などは、処理のために一時的に存在するだけです。
これらに複雑なメソッドや状態管理を持たせると、単純なデータの受け渡しが難しくなります。
データの内容が重要であり、どのインスタンスであるかが重要でない場合、値として扱うほうが自然なこともあります。

ここで注意したいのは、単純なデータ構造を使うことが、直ちに設計の劣化を意味するわけではない点です。
データ構造に業務ルールを無制限に詰め込む必要はありませんが、目的に応じてデータを素直に表現し、処理を別の境界へ置くことには明確な利点があります。
データの流れが分かりやすくなり、変換や検証の責務も切り分けやすくなります。

オブジェクト指向を適用する範囲を見極める

オブジェクト指向の限界を理解する目的は、クラスやメソッドを排除することではありません。
重要なのは、オブジェクトとして管理する価値があるものと、データや処理として扱ったほうが明快なものを区別することです。

オブジェクトとして扱う効果が高いのは、状態の整合性を維持する必要があり、その状態に対する操作も明確に関係している場合です。
例えば、複雑な不変条件を持つ集約や、外部リソースのライフサイクルを管理するコンポーネントでは、状態と操作をまとめる意味があります。
一方で、単純な変換、集計、検証、検索結果の整形などは、独立した処理やデータ構造として設計したほうが理解しやすい傾向があります。

判断に迷ったときは、次の観点から考えると整理しやすくなります。

  • その処理は特定のオブジェクトの状態に強く依存しているか
  • 処理を実行すると、データや外部環境が変更されるか
  • 同じ処理を異なるデータ形式や利用者から再利用する可能性があるか
  • そのクラスは一つの変更理由に対応しているか
  • 継承ではなく、データと処理の組み合わせで表現できないか

オブジェクト指向は、設計上の選択肢の一つです。
すべてをオブジェクトで表現しようとすると、現実世界の分類に引きずられ、データの流れや処理の依存関係が隠れることがあります。
反対に、データと処理を必要な境界で分離すれば、オブジェクト指向の利点を残しながら、集計や変換のような処理も自然に表現できます。

最終的に目指すべきなのは、特定のパラダイムを純粋に適用することではありません。
コードを読んだ人が、データの形、処理の責務、状態の変更箇所、外部環境との接点を追跡できる構造です。
オブジェクト指向の限界を知ることは、その手法を捨てることではなく、適用すべき範囲を正確に見極めるための前提になります。

データと処理を分離する基本原則

データ構造と処理ロジックを分離した設計のイメージ

データと処理を分離する設計では、単にクラスを複数へ分割するだけでは不十分です。
重要なのは、データが担う役割と、データに対して実行する処理の役割を整理し、それぞれの依存関係を明確にすることです。
データは状態や事実を表し、処理はそのデータを入力として、計算・判断・変換などの結果を導きます。
さらに、データベースへの保存や外部APIへの送信といった副作用は、これらとは別の境界で管理します。

この考え方を採用すると、コードの各部分が何を担当しているのかを説明しやすくなります。
反対に、データ保持、業務ルール、画面表示、永続化を一つのクラスへ集約すると、クラスの内部に複数の変更理由が入り込みます。
見た目には関連する処理であっても、実際には異なるタイミングや異なる担当者によって変更されるものがあります。
責務を分ける目的は、コードを細かくすることではなく、変更の単位とテストの単位を整えることです。

データの責務と処理の責務を明確に分ける

まず、データの責務を明確にします。
データの責務とは、値を保持し、必要な形式を保証し、他の処理へ受け渡せる状態を維持することです。
例えば、注文データであれば、注文番号、明細、顧客識別子、注文日時などを保持します。
値の型や必須項目、最低限の形式を保証することも、データ側の責務に含められます。

一方、処理の責務は、データを利用して業務上の判断や計算を行うことです。
割引額を計算する、利用可能なクーポンを判定する、在庫不足の商品を抽出する、入力された値を別の形式へ変換するといった処理が該当します。
これらは、データを保持することとは異なる責務です。
データがどのような形式で保存されているかと、どのようなルールで判断されるかは、別々に変更される可能性があります。

ここで注意したいのは、データを完全に無機質な入れ物にすればよいわけではないことです。
データ自身が必ず満たすべき制約や、不正な状態を防ぐための処理は、データの近くに置いたほうが自然な場合があります。
例えば、金額が負数にならないことや、識別子が空文字にならないことは、データの整合性に関する制約です。
一方、複数のデータを比較して割引条件を判断する処理は、データ単体の責務とは分けたほうがよいでしょう。

判断の基準は、その処理が何に依存しているかです。
一つの値の形式や不変条件だけを守る処理なら、データの構築時に検証する意味があります。
複数のデータや外部情報、時間、設定値に依存する処理なら、独立したサービスや関数として表現するほうが、依存関係を整理しやすくなります。

処理を分離すると、同じデータを異なる目的で利用しやすくなります。
例えば、注文データを画面表示用に整形する処理と、売上集計用に変換する処理は、同じ注文というデータを扱っていても目的が異なります。
これらを注文クラスのメソッドとして無制限に追加するのではなく、それぞれの用途に応じた処理として分ければ、画面仕様の変更が集計ロジックへ影響することを防げます。

また、データの形式と業務上の意味も区別する必要があります。
データベースの行やAPIのレスポンスを、そのままアプリケーション全体へ渡す設計では、外部形式に依存する範囲が広がります。
外部データを内部で扱う形式へ変換する境界を設ければ、データベースやAPIの仕様変更が業務ロジックへ直接波及することを抑えられます。

状態変更を減らして依存関係を単純化する

次に重要なのが、状態変更を必要最小限に抑えることです。
状態変更とは、オブジェクトの内部値を書き換えることだけではありません。
データベースへの更新、キャッシュの変更、ファイルへの書き込み、グローバルな設定の変更など、後続の処理へ影響を残す操作も状態変更に含まれます。

状態変更が多いコードでは、処理の結果を引数と戻り値だけから判断できません。
呼び出し前の状態、途中で実行されたメソッド、共有されているオブジェクトの内容などを確認する必要があります。
これは、プログラムの実行経路を複雑にする大きな要因です。
同じ入力を与えても、過去に何が実行されたかによって結果が変わるなら、テストやデバッグは難しくなります。

対策として、まず読み取り処理と書き込み処理を分けます。
読み取り処理は、可能な限りデータを変更せず、現在の状態から結果を返すようにします。
書き込み処理は、どのデータをどの条件で変更するのかを明示し、処理の流れの中で限定的に実行します。
読み取りのつもりで呼び出したメソッドが、内部でデータベースを更新したり通知を送ったりしないことが重要です。

次に、計算処理を外部状態から切り離します。
入力されたデータから結果を求めるだけの処理であれば、外部サービスや現在時刻を直接参照しない形にできます。
時刻や設定値が必要な場合も、処理の内部で取得するのではなく、呼び出し側から渡す設計にすると、依存関係が明確になります。
テスト時には固定した値を渡せるため、境界条件も確認しやすくなります。

ただし、状態変更を完全になくす必要はありません。
注文を確定したり、在庫を減らしたり、決済を実行したりするには、どこかで外部状態を変更しなければなりません。
重要なのは、副作用を隠さず、発生する場所を限定することです。
計算と判断を行う処理、副作用を実行する処理、処理の順序を管理する処理を分けることで、全体の流れを追跡しやすくなります。

状態変更を減らすための実践的な観点は、次のとおりです。

  • 一つの処理が複数の共有オブジェクトを変更していないか確認する
  • 戻り値を返すだけで済む処理が、内部状態を書き換えていないか確認する
  • データベースや外部APIへのアクセスを業務ロジックから切り離す
  • 同じデータを複数の場所で変更せず、変更の責任者を決める
  • 処理の前提となる時刻や設定値を、隠れた依存関係にしない

これらを実践すると、処理の依存関係が単純になります。
ある処理が必要とする入力、返す結果、実行する副作用が明確になるためです。
単体テストでは入力と出力を中心に確認でき、結合テストでは外部との接続部分に集中できます。
さらに、バグが発生したときも、どの状態変更が原因だったのかを追跡しやすくなります。

データと処理の分離は、データを単なる構造体にして、すべてのロジックを外部へ追い出す設計ではありません。
データの整合性を守る責務はデータの近くに置き、複数のデータを扱う業務ルールは独立した処理として整理し、外部への副作用は境界へ集約します。
この三つを区別することで、責務の所在が明確になります。

設計を見直す際は、クラスや関数の数ではなく、変更理由と状態の流れに注目することが大切です。
その処理は何に依存しているのか。
実行後に何が変化するのか。
別の処理から安全に再利用できるのか。
これらの問いに答えられる構造を目指せば、オブジェクト指向の利点を活かしながら、依存関係を抑え、バグの原因を追跡しやすいコードへ近づけます。

関数型プログラミングの考え方を設計に取り入れる

入力と出力が明確な関数型プログラミングのイメージ

関数型プログラミングは、処理を関数の組み合わせとして捉え、状態変更や副作用をできるだけ制御する考え方です。
関数型言語を採用しなければ利用できない技法ではありません。
オブジェクト指向言語や手続き型言語でも、入力と出力の関係を明確にし、共有状態への依存を減らすことで、その考え方を設計へ取り入れられます。

特に有効なのは、業務ロジックと外部環境との接続を分けることです。
データベースから値を取得する処理、APIへリクエストを送る処理、現在時刻を取得する処理などは、プログラムの外部と関係するため、結果が環境によって変わります。
一方、取得済みのデータを使って金額を計算したり、条件に応じて判定したりする処理は、外部環境から切り離しやすい領域です。

この二つを同じメソッドへ詰め込むと、ロジックの正しさと外部接続の成否を同時に検証しなければなりません。
関数型プログラミングの考え方を取り入れる場合は、まず外部からデータを受け取る処理と、受け取ったデータを変換・判断する処理を分けます。
これだけでも、コードの予測可能性とテストのしやすさは大きく変わります。

純粋関数で業務ロジックを表現する

純粋関数とは、同じ入力に対して常に同じ出力を返し、関数の外部に目に見えない変更を与えない関数です。
実行するたびにグローバル変数を更新したり、データベースへ書き込んだり、現在時刻を直接参照したりしません。
入力と出力の関係が明確なため、処理の振る舞いを理解しやすく、単体テストでも扱いやすい特徴があります。

業務ロジックには、純粋関数として表現しやすい処理が多くあります。
例えば、商品の価格と割引条件から最終金額を求める処理、利用者の権限一覧から操作可能か判定する処理、注文データから配送対象を抽出する処理などです。
これらの処理に必要な情報を引数として渡せば、関数の内部からデータベースや外部サービスを参照する必要はありません。

純粋関数として設計する際は、隠れた入力に注意が必要です。
現在時刻、乱数、環境変数、グローバル設定、共有キャッシュなどを関数内部から直接参照すると、見た目の引数だけでは結果を説明できなくなります。
例えば「有効期限内か」を判定する処理が現在時刻を内部で取得している場合、同じデータを渡しても実行時刻によって結果が変わります。
現在時刻を引数として渡せば、判定ロジックそのものは純粋な処理として扱えます。

外部との接続が必要な場合は、純粋関数と副作用を持つ処理を組み合わせます。
最初に外部から必要なデータを取得し、そのデータを純粋関数へ渡して結果を計算します。
必要であれば、計算結果を別の処理へ渡して保存や通知を実行します。
重要なのは、純粋関数だけでアプリケーション全体を構成することではなく、副作用のある処理を、予測しやすいロジックから隔離することです。

この分離には、テスト以外の利点もあります。
業務ルールを画面、バッチ処理、API、管理画面など複数の入口から再利用しやすくなります。
入力データの形式を合わせれば、同じ判断ロジックを異なる実行経路から呼び出せるためです。
また、外部サービスを別の実装へ置き換える場合も、純粋な業務ロジックを変更せずに済む可能性が高まります。

ただし、純粋関数という言葉を厳格に適用しすぎる必要はありません。
実際のアプリケーションでは、どこかでデータを保存し、通信し、状態を更新します。
大切なのは、どの関数が外部環境へ影響を与えるのかを明示し、業務ロジックがその詳細に直接依存しない構造を作ることです。

不変データで予期しないバグを防ぐ

不変データとは、一度作成した後に内容を書き換えないデータです。
値を変更したい場合は、既存のデータを直接更新するのではなく、変更後の新しいデータを生成します。
すべてのデータを完全に不変にすることは、言語やアプリケーションの性質によって難しい場合がありますが、共有されるデータを不用意に変更しないという方針は、多くの設計で有効です。

可変データが問題になるのは、同じデータを複数の処理が参照しているときです。
ある処理が配列やオブジェクトの内容を書き換えると、別の処理は、その変更を意図せず受ける可能性があります。
呼び出し側は読み取りだけを期待していたのに、渡したデータが変更されていることもあります。
このようなバグは、変更を実行した場所と、問題が表面化した場所が離れるため、原因の特定が困難です。

不変データを基本にすると、データを受け取った処理が元の値を変更していないことを保証しやすくなります。
処理ごとの入力が独立するため、実行順序による影響も減ります。
並列処理や非同期処理でも、共有データを変更する競合が起こりにくくなります。
複数の処理が同じデータを参照していても、誰かが途中で値を書き換える可能性を考えずに済むからです。

ただし、不変データにはコストもあります。
大きなデータを毎回複製すると、メモリ使用量や処理時間が増える可能性があります。
言語によっては、効率的な構造共有を利用して、変更されていない部分を再利用できます。
設計時には、不変性による安全性と、実行時のコストをバランスさせる必要があります。

実務では、すべてのデータを同じ厳密さで扱うのではなく、共有範囲と変更頻度に注目すると判断しやすくなります。
複数の層へ渡されるデータ、キャッシュされるデータ、非同期処理で利用されるデータは、特に不用意な変更を避ける価値が高い領域です。
一方、関数内部だけで短時間利用される一時的なデータは、性能や可読性を考慮して局所的な変更を許容できる場合もあります。

不変データを導入するときは、次のようなルールが役立ちます。

  • 共有されるデータは、原則として読み取り専用で扱う
  • データを変更する処理は、入力と出力を明確に分ける
  • 変更後の値を返す処理と、元の値を書き換える処理を混在させない
  • 可変なコレクションを外部へ公開せず、必要に応じてコピーや読み取り専用の形式で渡す
  • 状態を変更する必要がある場合は、変更の責任者を一つの場所に限定する

関数型プログラミングの考え方を取り入れる目的は、関数型言語の文法を再現することではありません。
入力と出力の関係を明らかにし、隠れた依存関係を減らし、状態変更の範囲を制御することです。
純粋関数によって業務ルールを独立させ、不変データによって処理同士の干渉を減らせば、コードは予測しやすくなります。

オブジェクト指向の設計でも、状態を持つオブジェクトが必要な場面はあります。
しかし、すべての処理を可変なオブジェクトのメソッドとして実行する必要はありません。
状態を管理する部分と、状態に依存しない計算や判断を分けることで、両方の利点を活かせます。
どのデータが変わり、どの処理が外部へ作用し、どのロジックが入力だけで結果を決められるのか。
この境界を意識することが、予期しないバグを減らす設計につながります。

データと処理の分離を実装へ落とし込む方法

データ処理の流れを分離して整理したコード構成

データと処理を分離する考え方を実際のコードへ反映するには、責務の境界を具体的に決める必要があります。
単に「データ用クラス」と「処理用クラス」を作るだけでは、クラス間の依存関係が増え、別の形で複雑化する可能性があります。
重要なのは、どのデータをどの層で扱い、どの処理がどの形式のデータを受け取り、どこで外部環境と接続するのかを整理することです。

一般的なWebアプリケーションでは、画面やAPIから入力を受け取り、入力を内部のデータ形式へ変換し、業務ルールを適用したうえで、必要に応じてデータベースへ保存します。
この一連の流れを一つのクラスやメソッドに詰め込むと、入力形式、業務ロジック、永続化処理が強く結合します。
まずは処理の流れを分解し、それぞれの責務を別の境界へ置くことが出発点です。

データ転送オブジェクトとドメインロジックを使い分ける

データ転送オブジェクト、いわゆるDTOは、層と層の間でデータを受け渡すための構造です。
APIのリクエストやレスポンス、画面表示用のデータ、外部サービスとの通信内容などを表現するために利用します。
DTOの主な役割は、データを決められた形式で運ぶことであり、複雑な業務ルールを実行することではありません。

例えば、APIから受け取る注文登録データには、商品識別子、数量、配送先などが含まれます。
この入力形式は、クライアントとの通信契約によって決まります。
一方、アプリケーション内部で業務ロジックが必要とするデータは、入力DTOと完全に一致するとは限りません。
入力値の検証や形式変換を行った後、内部で扱いやすいデータへ変換する場合があります。

この変換を省略し、APIのDTOをそのまま業務ロジックやデータベース処理へ渡すと、外部の形式が内部全体へ広がります。
APIの項目名を変更しただけで、業務ロジックやデータベースアクセスまで修正が必要になるかもしれません。
DTOを境界として利用すれば、外部との契約と内部の都合を分離できます。

ただし、すべての場面でDTOを大量に作る必要はありません。
データ構造が単純で、外部形式と内部形式が長期的に一致すると判断できる場合は、同じ型を共有する設計も選択肢になります。
DTOを導入する目的は、クラス数を増やすことではありません。
異なる変更理由を持つデータを、無条件に同じ構造へ結び付けないことです。

ドメインロジックは、業務上のルールや判断を担当します。
料金計算、利用可否の判定、状態遷移の条件、在庫数の検証などが該当します。
これらは、画面やAPIの都合ではなく、業務上の意味によって変化します。
そのため、DTOの定義やデータベースのテーブル構造へ直接依存させないほうが、変更に強い設計になります。

DTOとドメインロジックの間には、必要に応じて変換処理を置きます。
入力DTOを内部のデータへ変換し、ドメインロジックで判断し、その結果をレスポンスDTOへ変換するという流れです。
変換処理が増えすぎると冗長に感じられますが、外部の都合と業務上の意味を切り分けるための明確なコストでもあります。
重要なのは、すべてのデータに変換層を追加することではなく、変更の可能性と依存の影響範囲を考慮して境界を設けることです。

サービス層へ処理を集約するときの注意点

サービス層は、複数の処理を組み合わせて一つのユースケースを実行する場所として利用できます。
例えば、注文を受け付ける処理では、入力の確認、在庫の確認、料金の計算、注文の保存、通知の送信などを順番に実行する必要があります。
これらの処理を、APIのコントローラーやデータベース用クラスに直接記述すると、入口や保存処理が業務ロジックを抱えることになります。

サービス層を設けることで、ユースケースの流れを一つの場所で表現できます。
どの処理をどの順番で実行するのか、どの条件で失敗するのか、どの結果を返すのかが明確になります。
コントローラーは入力の受け取りと結果の返却に集中し、データアクセス層は保存や取得に集中できます。

しかし、サービス層へ処理を集約しすぎると、今度は巨大なサービスクラスが生まれます。
複数のユースケースに関係する処理を一つのサービスへ追加し続けると、サービス層が業務ロジック、データ変換、トランザクション管理、ログ出力、通知処理のすべてを担当する状態になります。
これは、以前の巨大なドメインオブジェクトと本質的には同じ問題です。

サービス層には、ユースケースの調整役としての責務を持たせると整理しやすくなります。
具体的な計算や判定は独立した処理へ委譲し、データベースへのアクセスはリポジトリなどの境界へ委譲します。
サービス自身がすべてを実行するのではなく、必要な処理を組み合わせ、処理全体の流れを管理する役割です。

サービス層を設計するときは、次の観点が役立ちます。

  • 一つのサービスが複数の異なるユースケースを担当していないか確認する
  • 計算や判定をサービス内部に直接書き込みすぎていないか確認する
  • データベースの具体的なAPIやSQLがサービスへ漏れていないか確認する
  • 外部通知やログ出力が、業務上の処理と不必要に密結合していないか確認する
  • サービスを単独でテストするために、過剰なモックや環境準備が必要になっていないか確認する

また、トランザクションの境界もサービス層で検討します。
複数のデータを一貫した状態で更新する必要がある場合、ユースケース全体を一つのトランザクションとして扱うことがあります。
ただし、外部APIへの通信まで同じトランザクションで完全に管理できるとは限りません。
データベースの更新と外部通知を単純に一続きの処理として考えると、片方だけ成功した場合の復旧が難しくなります。
外部連携がある場合は、再試行、冪等性、イベント記録なども含めて設計する必要があります。

データベース設計とアプリケーションロジックの境界を決める

データベースは、アプリケーションのデータを永続化する重要な構成要素です。
しかし、データベースのテーブル構造と、アプリケーションが扱う業務上のモデルは、常に同じ形になるわけではありません。
テーブルは検索効率、正規化、整合性制約、既存システムとの互換性などを考慮して設計されます。
一方、アプリケーション側のデータは、業務ルールやユースケースに合わせて扱いやすい形が求められます。

この違いを無視して、データベースの行をそのままアプリケーション全体へ渡す設計にすると、保存形式への依存が強まります。
テーブルの分割やカラム名の変更が、画面や業務ロジックへ波及する可能性があります。
逆に、アプリケーションのオブジェクトをそのまま永続化しようとすると、オブジェクトの継承や内部状態が、データベースの構造に引きずられることがあります。

境界を設ける場合は、データアクセスを担当する層で、データベースの形式と内部の形式を変換します。
取得処理では、テーブルやクエリの結果をアプリケーションが扱うデータへ変換し、保存処理では、内部データをデータベースへ格納できる形式へ変換します。
これにより、SQLやORMの仕様が業務ロジックへ直接漏れることを防げます。

ただし、すべてのSQLやデータベース操作を隠せばよいわけではありません。
複雑な集計や検索条件は、データベース側で実行したほうが効率的な場合があります。
大量のデータをアプリケーションへ読み込んでから集計するより、データベースのインデックスや集約機能を利用したほうが合理的なケースもあります。

ここで重要なのは、処理をどこで実行するかを、業務上の意味と性能の両面から判断することです。
データベースに任せる処理は、検索や集計の都合だけでなく、データの整合性を守る役割を持つ場合があります。
一方、複数の外部情報や複雑な業務ルールを組み合わせる処理は、アプリケーション側で実行したほうがテストしやすく、変更にも対応しやすいことがあります。

境界を決める際には、次の点を確認するとよいでしょう。

  • その処理は保存形式に依存しているのか、業務ルールに依存しているのか
  • データベースの変更が、アプリケーションのどの範囲へ影響する設計になっているか
  • 大量データの検索や集計を、適切な場所で実行しているか
  • ORMのエンティティを、業務ロジックの中心へ直接持ち込んでいないか
  • データの整合性を、アプリケーションだけでなくデータベース側でも保証すべきか

データと処理の分離を実装する際は、DTO、サービス層、データアクセス層を形式的に導入することが目的ではありません。
DTOは外部とのデータ形式を隔離するため、サービス層はユースケースの流れを管理するため、データアクセス層は永続化の詳細を閉じ込めるために使います。
それぞれの役割を理解しないまま層だけを増やすと、単に処理が分散して追跡しにくくなります。

最終的には、どの層が何を知ってよいのかを明確にすることが重要です。
外部入力の形式、業務ルール、データベースの構造、通信の詳細をすべての層が知る必要はありません。
変更されやすい詳細を境界の外側へ置き、安定した業務ロジックを内側へ保つ設計にすると、仕様変更の影響を抑えやすくなります。
データの流れと処理の責務を図やコードで説明できる状態こそ、分離が適切に実装されている目安です。

データと処理を分離した設計のテスト効果

分離された処理を単体テストするプログラミング画面

データと処理を分離すると、テストの対象と方法を整理しやすくなります。
アプリケーションの処理を一つの大きなメソッドへ集約している場合、テストはデータベース、外部API、認証情報、時刻、設定値など、複数の環境を準備しなければなりません。
テストが失敗したときも、業務ロジックの誤りなのか、外部サービスとの接続失敗なのか、テストデータの準備ミスなのかを判断しにくくなります。

一方、データを受け取り、結果を返す処理と、データの取得・保存を行う処理を分けておけば、検証の単位を小さくできます。
計算や判断は単体テストで高速に確認し、データベースや外部APIとの接続は結合テストで確認するというように、責務に応じてテストを分担できます。
これは単にテスト数を増やすための設計ではありません。
失敗したときに原因を絞り込み、変更の安全性を効率よく確認するための設計です。

純粋な処理を単体テストするメリット

純粋な処理とは、外部環境や共有状態に依存せず、入力から出力を導く処理です。
例えば、商品の価格、割引条件、税率から請求額を計算する処理や、利用者の権限一覧から実行可能な操作を判定する処理は、必要な情報を引数として渡せば、データベースやネットワークに接続せず検証できます。

このような処理を単体テストにすると、テストの準備が少なくなります。
データベースを起動したり、外部サービスの応答を用意したりする必要がないため、テストは短時間で実行できます。
また、入力と期待する出力の対応が明確になるため、テストケースの意図も読み取りやすくなります。
正常系だけでなく、境界値や異常値も追加しやすい点が重要です。

料金計算であれば、割引が適用される境界、無料になる条件、最小金額、端数処理などを確認できます。
権限判定であれば、権限が存在しない場合、複数の権限がある場合、期限切れの場合などを独立して検証できます。
外部環境を必要とする設計では、これらのケースを確認するだけでも、大量の準備データや複雑なセットアップが必要になることがあります。

純粋な処理は、テストが失敗したときの原因も明確です。
入力値と期待値を比較して失敗しているなら、ロジックやテストケースを調べればよいでしょう。
データベースの状態やネットワークの障害が関係しないため、問題の切り分けが容易です。
これは開発者の作業時間を削減するだけでなく、修正に対する心理的な負担も小さくします。

さらに、純粋な処理は再利用しやすい特徴があります。
API、バッチ処理、管理画面など、異なる入口から同じ業務ルールを利用できます。
入口ごとに似たロジックを複製する必要がなくなり、テストも共通化できます。
ただし、再利用のために抽象化を進めすぎると、かえってコードの意図が分かりにくくなるため、実際に複数の箇所で必要な処理を中心に分離することが重要です。

単体テストでは、次のような観点を意識すると効果的です。

  • 通常の入力に対して期待した結果が返るか
  • 最小値や最大値などの境界条件で正しく動作するか
  • 空のデータや不完全なデータを適切に扱えるか
  • 不正な状態を検出し、適切なエラーや結果を返すか
  • 同じ入力に対して、実行するたびに同じ結果を返すか

これらを確認することで、処理の仕様をテストコードに反映できます。
テストは単なるバグ検出の手段ではなく、ロジックが満たすべき契約を明文化する役割も持ちます。

モックに頼りすぎないテスト設計を考える

データと処理を分離すると、外部依存をモックへ置き換えやすくなります。
モックとは、データベースや外部APIなどの実際の依存先を、テスト用の代替オブジェクトへ置き換える仕組みです。
特定の応答を返すモックを用意すれば、外部サービスが存在しない環境でも、呼び出し側の処理を検証できます。

モックは便利ですが、使いすぎるとテストの信頼性が低下します。
テスト対象がどのメソッドを何回呼び出したかだけを検証している場合、実際のデータの流れや結果を十分に確認できないことがあります。
実装の内部構造に合わせてモックを設定すると、処理の結果は変わっていないのに、内部の呼び出し方を変更しただけでテストが大量に失敗することもあります。

例えば、データ取得用のメソッドが一回呼ばれることを厳密に検証しているテストは、キャッシュを導入しただけで失敗するかもしれません。
しかし、テストで本当に確認したいのが「対象のデータを取得し、正しい業務結果を返すこと」であれば、呼び出し回数は本質ではない可能性があります。
テストは実装の手順ではなく、外部から見える振る舞いを中心に記述したほうが、変更に強くなります。

モックに頼りすぎると、実際の依存先との不一致も見逃します。
モックが常に理想的な応答を返すよう設定されていても、本番のAPIが異なる形式のデータを返したり、データベースの制約で保存に失敗したりする可能性があります。
そのため、外部依存をモックした単体テストだけで、システム全体の信頼性を保証することはできません。

テストの種類を分けることが重要です。
業務ロジックは、できるだけ外部依存なしの単体テストで確認します。
データベースとの保存・取得は、実際のデータベースやテスト用の同等環境を使った結合テストで確認します。
外部APIとの通信は、実際の契約に沿った応答を検証する契約テストや、限定的な統合テストで確認します。

モックを使うべきなのは、外部サービスの障害や特定の異常応答を再現したい場合、実行に時間や費用がかかる処理を隔離したい場合、テスト環境では利用できない依存先を代替したい場合などです。
一方、単純なデータ変換や計算処理までモックで置き換える必要はありません。
外部依存の境界を明確にし、その境界の内側では実際のデータを使って検証するほうが、テストの価値を保ちやすくなります。

テスト設計では、次のようなバランスを意識するとよいでしょう。

  • 純粋な業務ロジックは、モックなしの単体テストを中心にする
  • 外部サービスとの契約やデータ形式は、統合テストや契約テストで確認する
  • モックの呼び出し回数よりも、処理結果や外部から見える振る舞いを優先する
  • テストデータは、実際に起こり得る境界条件や異常条件を含める
  • テストが実装変更に過敏に反応する場合は、検証対象が適切か見直す

また、テストの実行速度も設計上の重要な要素です。
開発者が頻繁に実行する単体テストは、短時間で結果が返る必要があります。
時間のかかる結合テストや外部サービスを利用するテストは、必要なタイミングで実行できるよう分けて管理します。
すべてのテストを同じ環境と同じ頻度で実行するより、テストの目的に応じて層を分けるほうが、品質と開発速度を両立しやすくなります。

データと処理を分離した設計では、テストが処理の責務を映し出します。
入力と出力だけで検証できる部分、外部状態を確認する部分、両者の連携を確認する部分を区別できるためです。
モックは境界を越えないための道具として使い、業務ロジックの正しさを隠すための道具にはしないことが大切です。
テストが実装の詳細ではなく、データの流れと期待する結果を表現できていれば、コードを変更しても壊れにくく、バグの原因も追跡しやすい構造になります。

データと処理の分離で失敗しないための注意点

過度な分離による複雑化を防ぐソフトウェア設計の図

データと処理を分離すると、責務や依存関係を整理しやすくなります。
しかし、分離そのものを目的にすると、別の問題が発生します。
クラスや関数、変換処理、インターフェースを必要以上に増やすと、コードは細かく分割される一方で、処理全体の流れが見えにくくなります。
設計の品質は、分割した数では決まりません。
変更の影響を抑え、意図を読み取りやすくし、適切な範囲でテストできるかが重要です。

分離には、必ず理解コストが伴います。
ある処理を確認するために複数のファイルを行き来しなければならない場合、責務が分かれていても、開発者は全体の関係を頭の中で再構成しなければなりません。
データの変換を何層も経由し、最終的にどこで業務ルールが実行されているのか分からない状態になれば、分離の利点は失われます。

分離しすぎによる過剰設計を避ける

過剰設計とは、将来必要になるかもしれない変更を先回りし、現時点では不要な抽象化や分割を導入することです。
例えば、まだ一種類しかないデータベース接続に複数の抽象層を設けたり、単純な変換処理のために専用クラスをいくつも作ったりするケースが該当します。
将来の差し替え可能性を高めたつもりでも、実際には実装と抽象の両方を保守する負担が増えます。

特に注意したいのが、形式的なレイヤーの増加です。
コントローラー、サービス、ユースケース、ファクトリー、リポジトリ、マッパーなどをすべての処理に適用すると、設計の統一感は得られるかもしれません。
しかし、単純な読み取り処理まで多くの層を経由させると、データがどのように流れているのかを理解するためのコード量が増えます。
層を設けること自体に価値があるのか、その層がどの変更や依存を隔離しているのかを確認する必要があります。

抽象化も同様です。
インターフェースは、実装の差し替えや依存関係の制御に役立ちますが、実装が一つしかなく、将来も差し替える理由がない場合は、単なる間接参照になる可能性があります。
テストのためだけにすべてのクラスへインターフェースを追加するのも、必ずしも適切ではありません。
外部依存の境界や、実際に複数の実装が存在する箇所へ絞って導入するほうが、設計の意図を保ちやすくなります。

過剰設計を避けるためには、分離の効果を具体的に説明できるかを確認します。

  • この分離によって、どの変更の影響範囲が小さくなるのか
  • この抽象化によって、どの依存関係を隠せるのか
  • 分離後のコードは、分離前よりもテストしやすくなっているか
  • 処理の流れを追うために、必要以上のファイルを読む必要がないか
  • 現在の要件に対して、追加した構造の維持コストが見合っているか

これらに明確な答えがない場合、その分離は目的ではなく手段になっている可能性があります。
将来変更されるかもしれないという理由だけで抽象化を増やすより、変更が実際に発生した時点で、必要な境界を追加するほうが合理的な場合もあります。
最初から完璧な構造を作るのではなく、変更の実績を観察しながら設計を進化させる姿勢です。

また、分離した処理を小さな関数へ分割しすぎることにも注意が必要です。
一つの関数が数行であっても、意味のある処理単位として名前が付いているなら可読性に貢献します。
しかし、単なる代入や一回しか使わない単純な式まで別関数にすると、抽象化のための名前が処理内容より増えることがあります。
関数の名前が処理の意図を明確にするのか、それとも実装を迂回しているだけなのかを見極めることが重要です。

変更理由と凝集度から適切な境界を判断する

適切な境界を決める際は、変更理由と凝集度を基準にします。
変更理由とは、そのコードがどのような要求や環境の変化によって修正されるのかという観点です。
画面デザインの変更、データベースの変更、業務ルールの変更、外部APIの仕様変更は、それぞれ異なる理由で発生します。
異なる理由で変更される処理を同じクラスへ集めると、一つの変更が無関係な処理へ影響しやすくなります。

凝集度とは、モジュールやクラスの内部にある要素が、どれだけ同じ目的やデータに関係しているかを示す考え方です。
高い凝集度を持つクラスでは、内部のメソッドやデータが一つの目的に集中しています。
低い凝集度のクラスでは、名前は一つでも、実際には複数の機能や関心事が混在しています。

例えば、会員情報を保持し、会員の利用資格を判定する処理は、一定の関連性を持つかもしれません。
一方、会員情報を保存する処理、メールを送信する処理、売上を集計する処理まで同じクラスへ含めると、関連性は弱くなります。
これらは会員データを利用するという共通点があるだけで、目的や変更理由は異なるからです。

ただし、凝集度を高めるために、関連する処理を無条件に分割してはいけません。
処理同士が常に一緒に変更され、同じデータを扱い、同じ利用目的を持つなら、同じモジュールに置いたほうが理解しやすい場合があります。
判断の基準は、理論上分割できるかではなく、実際の変更や利用のまとまりです。

境界を検討するときは、まず変更の履歴や開発中の会話に注目します。
過去に同じ機能の変更で毎回同じファイルを修正しているなら、それらの処理には強い関連性がある可能性があります。
反対に、同じクラスで頻繁に別々の箇所を修正し、互いに関係のないテストが失敗するなら、責務の分割を検討できます。
コードの見た目だけでなく、実際の変更パターンを設計判断に利用することが重要です。

実装上は、次のような手順で境界を見直すと進めやすくなります。

  1. 対象となるクラスや処理が担当している機能を列挙します
  2. 各機能がどのデータに依存し、どの理由で変更されるかを整理します
  3. 同じ理由で変更される処理や、強く関連するデータをグループ化します
  4. 外部環境への依存や副作用を、業務ロジックから分離できるか検討します
  5. 分割後の各単位を、個別に説明・テストできるか確認します

この手順を踏むと、単なるメソッド数やファイル数ではなく、変更のまとまりに基づいて設計できます。
特に、データベースの形式、APIの入出力形式、業務ルール、画面表示用の変換は、変更理由が異なりやすい領域です。
これらを同じ処理へ置かず、必要な範囲で境界を設けると、保守の負担を抑えられます。

また、既存コードを一度に全面改修する必要はありません。
バグが多い箇所や変更頻度が高い箇所から、データ取得、計算、保存の責務を少しずつ分けます。
変更前後でテストを追加し、振る舞いを維持できていることを確認しながら進めるのが安全です。
設計改善の目的は、理想的な構造を作ることではなく、今後の変更や検証を容易にすることだからです。

データと処理の分離で失敗しないためには、分けることとまとめることの両方を検討する必要があります。
分離すべきなのは、異なる変更理由を持ち、依存関係や副作用を隔離する価値がある責務です。
まとめるべきなのは、同じ目的を持ち、同じデータに強く関係し、ほぼ一緒に変更される処理です。

最終的に判断したいのは、設計が美しいかどうかだけではありません。
仕様変更の影響範囲を予測できるか、処理の責務を説明できるか、必要なテストを適切な単位で書けるかという点です。
分離の量ではなく、変更と依存関係の見通しやすさを基準にすることが、過剰設計を避けながらバグを減らすための実践的な原則です。

オブジェクト指向のアンチパターンから脱却しバグを減らす設計へ

データと処理を分離して整理されたソフトウェア設計のイメージ

オブジェクト指向は、データと処理をまとめ、責務を持つオブジェクトとしてソフトウェアを構成するための有力な設計手法です。
適切に使えば、複雑な状態を管理し、変更の影響を局所化し、実装の詳細を隠せます。
しかし、すべてのデータと処理をオブジェクトへ詰め込むことが、常に良い設計につながるわけではありません。
クラスを作ること自体が目的になると、責務の集中、継承階層の複雑化、隠れた状態変更、外部依存の拡散といった問題が発生します。

特に注意が必要なのは、一つのクラスが複数の変更理由を持つ状態です。
データベースの仕様変更、業務ルールの変更、画面表示の変更、外部APIの変更が、同じクラスを修正する理由になっていないでしょうか。
もしそうであれば、そのクラスはデータ保持、業務ロジック、データ変換、永続化、通知などの責務を抱えすぎている可能性があります。
行数の多さだけで判断するのではなく、どのような理由で変更されるのかを確認することが重要です。

ここまで見てきたように、データと処理を分離する目的は、オブジェクト指向を否定することではありません。
データがどのような状態を表し、処理がどのような入力から結果を導き、どの場所で外部状態を変更するのかを明確にすることです。
状態を保持する必要があるオブジェクトは適切に利用し、入力と出力の関係が明確な計算や判断は、独立した処理として表現します。
データベースや外部APIとの接続は境界へ集約し、業務ロジックが保存形式や通信形式に直接依存しない構造を目指します。

実際に既存コードを改善する場合は、最初からすべてを作り直す必要はありません。
大規模なリファクタリングは、変更範囲が広くなり、別の不具合を生む危険もあります。
まずは、変更頻度が高い箇所、バグが繰り返し発生する箇所、テストが書きにくい箇所を特定します。
そのうえで、次のような手順で段階的に整理します。

  1. 対象のクラスが保持しているデータと、実行している処理を列挙します
  2. 各処理がどのデータや外部環境に依存しているかを確認します
  3. 計算や判断など、外部環境から切り離せる処理を抽出します
  4. データベースやAPIへのアクセスを、明確な境界へ移動します
  5. 入力と出力を確認するテストを追加し、変更後の振る舞いを保証します
  6. 変更理由が異なる処理が同じクラスに残っていないか再評価します

このとき、クラスや関数の数を増やすことを目標にしてはいけません。
分離によって、どの変更の影響範囲が小さくなったのか、どのテストが書きやすくなったのかを確認します。
分離した結果、処理の流れが複雑になったり、単純な処理を追うために多くのファイルを確認する必要が生じたりするなら、境界が細かすぎる可能性があります。

関数型プログラミングの考え方も、設計改善に役立ちます。
同じ入力に対して同じ結果を返す純粋な処理を増やし、共有状態の変更を減らすことで、コードの予測可能性が高まります。
データベースへの書き込みや外部サービスへの通信をなくす必要はありませんが、それらの副作用を限定し、どこで発生するのかを明確にします。
不変データを基本にすれば、ある処理が別の処理の入力を意図せず書き換える問題も減らせます。

テスト設計も、データと処理の分離によって改善できます。
計算や判定は、外部環境を必要としない単体テストで高速に検証します。
データベースや外部APIとの連携は、結合テストや契約テストで確認します。
モックは便利な道具ですが、呼び出し回数や内部手順だけを検証するために使いすぎると、実際の振る舞いを見失います。
テストでは、実装の詳細よりも、入力に対して期待した結果が得られるか、外部との契約が守られているかを重視するべきです。

一方で、データと処理の分離にも限界があります。
すべてのデータをDTOへ変換し、すべてのクラスにインターフェースを追加し、すべての処理を独立したサービスへ移動すればよいわけではありません。
分離には、コードを理解するための間接参照と、変換処理を維持するコストが発生します。
現在の要件や実際の変更頻度に対して、そのコストを払う価値があるのかを判断しなければなりません。

設計を評価する際は、次の問いを定期的に確認するとよいでしょう。

  • このクラスやモジュールは、どのような理由で変更されるのか
  • 処理の入力、出力、副作用を明確に説明できるか
  • データベースや外部APIの都合が、業務ロジックへ漏れていないか
  • 状態を変更する場所と、その責任者が明確になっているか
  • 重要な業務ルールを、外部環境なしでテストできるか
  • 分離によって可読性や保守性が本当に向上しているか

これらの問いに答えられるコードは、必ずしも特定の設計パターンへ従っている必要はありません。
オブジェクト指向、関数型プログラミング、手続き型の処理、データベース側の集計などを、問題に応じて組み合わせればよいのです。
設計手法の名前を守ることより、データの流れ、責務の境界、状態の変化を追跡できることのほうが重要です。

バグを減らす設計とは、複雑さを消す設計ではなく、複雑さが存在する場所を明確にする設計です。
データと処理を適切に分ければ、業務ロジックの変更、保存形式の変更、外部サービスの変更を互いに隔離しやすくなります。
純粋な処理を増やし、状態変更を限定し、テストの単位を整理すれば、問題が発生したときの原因も追跡しやすくなります。

オブジェクト指向のアンチパターンから脱却する第一歩は、クラスを減らすことでも、別のパラダイムへ全面的に移行することでもありません。
今あるコードについて、どのデータが変化し、どの処理がそのデータを利用し、どこで外部へ作用しているのかを観察することです。
そこから不要な結合と隠れた副作用を一つずつ取り除いていけば、変更に強く、テストしやすく、長期的に保守できる設計へ近づけます。

コメント

タイトルとURLをコピーしました