PHP開発の罠!Enumのアンチパターンを回避して仕様変更に強いアプリケーションを作る方法

PHP Enumのアンチパターンを回避し仕様変更に強いアプリケーション設計を考えるイメージ プログラミング言語

PHP 8.1以降で利用できるEnumは、状態や区分を型安全に表現できる便利な機能です。
文字列や整数のマジックナンバーを置き換えられるため、「これで仕様変更にも強いコードを書ける」と考えがちです。
しかし、Enumを導入しただけで設計が堅牢になるわけではありません。
むしろ、使い方を誤ると、仕様変更のたびに複数箇所の修正が必要になり、条件分岐や依存関係が増殖する原因にもなります。

特に注意したいのが、Enumにビジネスルールを詰め込みすぎる設計と、Enumの値そのものをアプリケーション全体の都合に合わせて利用する設計です。
一見すると責務が整理されているようでも、実際には「状態の定義」と「状態に応じた処理」が強く結び付いてしまい、仕様変更時の影響範囲を広げることがあります。

では、Enumはどこまで責務を持つべきなのでしょうか。
そして、単なる定数集として扱う場合と、ドメインモデルの一部として活用する場合では、何が違うのでしょうか。

この記事では、PHPのEnumでありがちなアンチパターンを具体的に整理しながら、変更に強い設計へ導く考え方を解説します。
Enumそのものを避けるのではなく、型安全性というメリットを活かしつつ、将来の仕様変更や機能追加でコードが破綻しにくい境界を見極めることが目的です。

「Enumを使っているのに、なぜ修正範囲が広がるのか?」という疑問を出発点に、責務分離、依存関係、条件分岐の扱い方まで掘り下げていきます。

  1. PHP Enumとは?仕様変更に強い設計に活かす基本とメリット
  2. PHP Enumが便利でもアンチパターンが生まれる理由
  3. Enumに処理を詰め込みすぎるアンチパターン
    1. 状態の性質と業務処理を分離する
    2. Enumが巨大化すると何が起きるのか
    3. どこまでEnumに持たせるべきか
  4. Enumの値をアプリ全体で直接参照する設計の問題点
    1. 条件分岐の分散が変更コストを押し上げる
    2. 「値」ではなく「意味」に依存させる
    3. Enumへの依存を一箇所に閉じ込める
    4. Enumの値を直接参照してよいケースもある
  5. PHP Enumで条件分岐が増殖する原因と改善方法
    1. 条件分岐が増える本当の原因
    2. if と match を減らすだけでは解決しない
    3. ドメイン上の意味をメソッドとして表現する
    4. 条件分岐を集約すると仕様変更に強くなる
    5. Enumの追加に強いコードへリファクタリングする
  6. 仕様変更に強いPHP Enumの責務分離と設計ポイント
    1. Enumに持たせる責務を明確にする
    2. 状態と状態遷移を分けて考える
    3. 外部データとの境界でEnumを使う
    4. 表示用の情報とドメイン情報を混同しない
    5. 依存関係の方向を意識する
    6. 「将来追加されるケース」を前提に設計する
    7. 仕様変更の種類ごとに変更先を分ける
  7. ドメインモデルとEnumを組み合わせて変更に強くする方法
    1. Enumは状態を、ドメインモデルは意味を表現する
    2. 状態に応じた操作をドメインモデルへ集約する
    3. 状態遷移をドメインモデルの責務として扱う
    4. 複数の情報を使うルールはドメインサービスへ分離する
    5. RepositoryやControllerからEnumの詳細を遠ざける
    6. テストしやすい設計は仕様変更にも強い
    7. 将来の仕様変更を前提に責務を決める
  8. PHP Enumの使いどころを判断する設計チェックポイント
    1. まず「取り得る値が有限か」を確認する
    2. 値の追加や変更が誰の責務なのかを考える
    3. 値そのものにドメイン上の意味があるかを確認する
    4. 外部システムの値をそのままEnumにしない
    5. Enumに振る舞いを持たせるべきか判断する
    6. Enumの値を多くの場所が直接参照していないか確認する
    7. データベース設計との関係を確認する
    8. チームで理解しやすい型になっているか確認する
    9. 迷ったときは「変更の方向」で判断する
  9. 実装例で見るPHP Enumのアンチパターン改善手順
    1. アンチパターンの実装を確認する
    2. ステップ1:Enumそのものの責務を整理する
    3. ステップ2:重複している業務ルールを見つける
    4. ステップ3:業務上の意味をドメインモデルへ移す
    5. ステップ4:状態遷移を直接代入させない
    6. ステップ5:通知や外部連携をEnumから分離する
    7. ステップ6:Controllerから状態判定を取り除く
    8. ステップ7:リファクタリング後の責務をテストする
    9. 改善後の設計を「依存方向」で確認する
  10. Enum導入後も保守しやすいPHPアプリケーションにするテスト戦略
    1. Enumそのものはシンプルにテストする
    2. 状態ごとの業務ルールをドメインテストで守る
    3. 状態遷移をテストで明示する
    4. Enumケース追加を想定した回帰テストを作る
    5. 仕様変更時に失敗してほしいテストを作る
    6. Tableではなく意味のある振る舞いをテストする
    7. 統合テストではユースケース全体を確認する
    8. 静的解析とテストを組み合わせる
    9. カバレッジの数字だけで品質を判断しない
  11. PHP Enumのアンチパターンを避けて仕様変更に強い設計を実現するまとめ

PHP Enumとは?仕様変更に強い設計に活かす基本とメリット

PHP Enumの基本と仕様変更に強い設計の考え方を示すイメージ

PHP 8.1で導入されたEnumは、アプリケーション内で扱う「限られた選択肢」を、より明確かつ型安全に表現するための機能です。
たとえば、注文の状態を「受付中」「発送済み」「完了」のように管理する場合、従来は文字列や整数の定数を使って表現することが一般的でした。
しかし、文字列による比較では、タイプミスや想定外の値が混入しても、実行時まで問題に気付きにくいという弱点があります。
Enumは、こうした値の集合を型として定義し、プログラム上で扱える範囲を明示できる点に強みがあります。

特に重要なのは、Enumを単なる「定数の置き換え」と捉えないことです。
Enumが表現しているのは、単なる文字列ではなく、アプリケーション上で意味を持つ概念の集合です。
たとえば OrderStatus というEnumがあるなら、それは単に pending や completed という文字列を一覧化したものではありません。
「注文にはどのような状態が存在するのか」というドメイン上のルールを、型としてコードに反映していると考えられます。

この考え方を採用すると、メソッドの引数や戻り値にも意味を持たせやすくなります。
文字列を受け取るメソッドでは、呼び出し側が何を渡せるのかをコードだけから判断しにくいことがあります。
一方でEnumを受け取る設計なら、「この処理は OrderStatus という状態だけを扱う」という契約が型として表現されます。
IDEの補完や静的解析の恩恵も受けられるため、仕様の理解と実装の一貫性を保ちやすくなります。

ただし、ここで一つ注意があります。
Enumを使えば自動的に仕様変更に強くなるわけではありません。
Enumの値をアプリケーション中の多くの場所で直接参照し、それぞれの箇所で条件分岐を行えば、むしろ変更コストが高くなる場合があります。
たとえば新しい状態を一つ追加しただけなのに、画面表示、メール送信、権限判定、集計処理、バッチ処理など、複数の場所へ修正が波及する設計です。
型安全になったとしても、変更点が分散したままでは保守性の問題は解決しません。

仕様変更に強い設計を考えるうえでは、Enumそのものよりも、Enumに何を表現させ、どこまで責務を持たせるかが重要です。
状態や区分そのものをEnumに集約する一方で、その値に応じた業務処理まで無制限に押し込めるのは避ける必要があります。
状態の定義と、それに対する振る舞いを適切な境界で分離することで、変更の影響範囲を小さくできます。
これはオブジェクト指向設計やドメイン駆動設計で重視される、責務の明確化にもつながります。

また、PHPのEnumには大きく分けてUnit EnumとBacked Enumという考え方があります。
外部システムやデータベースとの受け渡しが必要な場合には、文字列や整数を対応付けられるBacked Enumが便利です。
たとえばデータベースでは pending という値を保存し、アプリケーション内部では OrderStatus::Pending として扱う、といった設計ができます。
ここで重要なのは、永続化形式とドメイン上の意味を同一視しないことです。
データベースに保存される文字列はインフラ上の都合かもしれませんが、アプリケーション内部ではEnumという型付きの概念として扱えます。

さらにEnumは、入力値の制約をコードへ反映するうえでも有効です。
APIから受け取った値やフォーム入力をそのまま文字列として全層に渡すのではなく、適切な境界でEnumへ変換すれば、それ以降の処理では許容される値が限定されます。
結果として、if ($status === 'pending') のような文字列比較を各所に散らすより、状態という概念を一貫して扱いやすくなります。
型に意味を持たせることで、コードそのものが仕様書に近づくというわけです。

一方で、Enumに新しいケースを追加した際に、コンパイラや静的解析がすべての影響箇所を完全に教えてくれるとは限りません。
PHPは動的型付けを基盤とする言語であり、実際の挙動を確認するにはテストや静的解析を組み合わせる必要があります。
特に match や条件分岐を利用している場合、新しいEnumケースが追加されたことで既存ロジックの前提が崩れる可能性があります。
したがって、Enumの導入は「型安全にしたから終わり」ではなく、「変更点を明確にし、検証しやすい構造にする」ための第一歩として考えるのが適切です。

では、Enumをどのように設計すれば、仕様変更に強いアプリケーションにつながるのでしょうか。
ポイントは、Enumを中心にすべての処理を集約することではありません。
変わりにくい概念はEnumとして安定させ、変わりやすい業務ルールは適切なサービスやドメインオブジェクトへ分離することです。
たとえば「この状態ならキャンセル可能」というルールと、「キャンセル済みという状態が存在する」という事実は、似ているようで別の責務です。
この境界を整理できると、状態追加や業務ルール変更が発生しても、修正範囲を局所化しやすくなります。

Enumは便利な機能ですが、その価値は列挙子を宣言することだけではありません。
値の集合を型として表現し、コード上の契約を明確にし、変更時にどこを見直すべきかを整理するための設計要素です。
だからこそ、Enumの使い方では「どう書けるか」だけでなく、「どこに責務を置くべきか」という設計上の問いが欠かせません。
次章からは、PHP Enumを使っているにもかかわらず保守性を落としてしまう典型的なアンチパターンを取り上げ、なぜ問題が起きるのかを具体的に見ていきます。

PHP Enumが便利でもアンチパターンが生まれる理由

PHP Enumの便利さと設計上の落とし穴を対比するイメージ

PHP Enumは、有限個の選択肢を型として表現できるため、従来の文字列や整数による状態管理よりも安全にコードを設計しやすくなります。
ところが、Enumを導入したことで設計上の問題が自動的に解消されるわけではありません。
むしろ、便利な機能だからこそ責務を集中させすぎるという別の問題が起こります。
これはEnumに限った話ではなく、抽象化のための機能を「便利だから」という理由だけで広い範囲に適用したときに起きる典型的な設計上の失敗です。

たとえば、注文状態を表すEnumがあるとします。
最初は Pending、Paid、Shipped、Completed 程度のシンプルな状態しか存在しなかったとしても、サービスが成長すると要件は増えていきます。
「支払い済みならキャンセル可能」「発送済みならメールを送信する」「返品受付中なら管理者だけが変更できる」といったルールが追加されるでしょう。
すると、Enumの値を見て処理を切り替えるコードが、コントローラー、アプリケーションサービス、バッチ、通知処理などに少しずつ増えていきます。

このとき問題なのは、Enumそのものではなく、同じ業務知識が複数の場所へ分散することです。
たとえば「発送済みは編集不可」というルールが3か所に実装されていると、仕様変更で条件が変わった際に3か所を修正しなければなりません。
さらに4か所目、5か所目にも同じ判定が存在していた場合、修正漏れの可能性まで生まれます。
Enumは状態を一元化してくれますが、状態に対する判断まで自動的に一元化してくれるわけではないのです。

ここで見落とされやすいのが、Enumを「文字列を安全に包んだもの」とだけ考える発想です。
たしかにBacked Enumを利用すれば、データベースやAPIと文字列をやり取りしながら、アプリケーション内部では型として扱えます。
しかし、保存値が安全に管理できることと、設計全体が変更に強いことは別問題です。
データの表現形式が整理されても、その値を参照する側が無数に増えていれば、変更に伴う影響範囲は広がったままです。

さらに、Enumにメソッドを追加できることも、アンチパターンを生む一因になります。
PHPのEnumは単なる定数一覧ではなく、メソッドやインターフェース実装を持たせることができます。
そのため、「この状態ならこの処理」というロジックをEnumへ集約する設計は一見すると非常にきれいに見えます。
コードを読めば関係する処理が近くにまとまっており、重複も減らせるからです。
ですが、その処理が本当にEnum自身の責務なのかは慎重に判断しなければなりません。

たとえば「発送済みなら配送会社へ通知する」というロジックをEnum自身に持たせた場合、Enumは状態を表現する役割を超えて、外部システムとの連携まで知ることになります。配送会社のAPIが変更されたり、通知手段がメールからWebhookへ変わったりしたとき、状態定義の変更とは無関係な理由でEnumまで修正する必要が出てきます。これは依存関係の方向としても不自然です。変化する処理を、比較的安定していて広く参照される型へ結び付けると、変更の波が広がりやすくなります。

もう一つ重要なのが、Enumのケース追加と既存コードの網羅性です。
ある状態を表すEnumに新しいケースを加えると、それまで成立していた条件分岐の前提が崩れることがあります。
たとえば「未処理」と「処理済み」の二択を前提に書かれた処理へ、「保留中」という第三の状態を追加した場合です。
コードがコンパイルできたとしても、業務上は正しくない動作をする可能性があります。
特に条件分岐が複数の層に散らばっていると、どこに新しいケースの考慮が必要なのか把握しづらくなります。

これはEnumの欠点というより、状態というデータに対する依存関係を管理できていないことが本質です。
設計を考える際には、「Enumを使っているか」ではなく、「Enumの変更がどこまで伝播するか」を見る必要があります。
あるEnumのケースを一つ追加しただけで、十数個のファイルを修正しなければならないなら、そのEnumが広範囲の実装詳細に直接依存されている可能性があります。
逆に、変更すべき箇所が明確な境界に閉じていれば、同じケース追加でも保守コストは大きく変わります。

では、なぜこうしたアンチパターンが生まれるのでしょうか。
大きな理由は、開発初期の「小さな便利さ」が、そのままシステム全体の設計へ拡張されるからです。
最初は switch や match を一つ置くだけで十分だったものが、機能追加のたびに同じ発想で条件分岐を増やしていく。
その結果、Enumは正しく定義されているのに、Enumを使う側が複雑になっていきます。
これは技術的負債が一気に発生するのではなく、少しずつ蓄積されるタイプの問題です。

特に危険なのは、コードの見た目だけでは問題を判断しにくい点です。
Enum自体の定義は簡潔で、型も明確。
静的解析も通る。
テストも一部は成功している。
それでも、仕様変更が入った瞬間に修正箇所が連鎖して見つかることがあります。
つまり、局所的なコード品質と、システム全体の変更容易性は同じ尺度では測れません。
設計を評価するときは、現在のコードがきれいかどうかだけでなく、将来どのような変更が起きるのかまで考える必要があります。

もう一つ意識したいのが、Enumの「万能感」です。
状態を型にできる、比較対象が明確になる、IDEの補完が効く、値の取り得る範囲も限定できる。
これらは確かに優れた性質です。
しかし、型安全性が高くても、責務分離ができていなければ保守性は向上しません。
型安全性と変更容易性は関連していますが、同義ではありません。
この区別を理解しておくことが、Enumを使った設計でアンチパターンを避ける第一歩です。

そして、もう一段深く考えると、「Enumに何を入れるか」だけでなく「Enumを誰が知るべきか」という問題も見えてきます。
ドメイン層が知るべき状態なのか、プレゼンテーション層だけが必要とする表示区分なのか、外部APIの都合で存在する値なのか。
これらをすべて同じEnumとして扱えば、異なる関心事が一つの型に集約されます。
そうなると、一見共通化できたように見えて、実際には変更理由の異なる要素が強く結び付いた状態になります。

したがって、PHP Enumを設計するときは「Enumにするか、しないか」という二択だけで考えるべきではありません。
まず、その値が表している概念は何か。
その概念はどの層に属するのか。
どの程度の頻度で変更されるのか。
そして、その値を参照する処理をどこへ集約すれば変更の影響範囲を抑えられるのか。
こうした観点で責務と依存関係を整理することが重要です。

Enumは強力な道具です。
しかし、強力な道具ほど使い方を誤ったときの設計上の影響も大きくなります。
次に見るべきなのは、実際にどのようなコードがEnumの責務を肥大化させ、保守性を低下させるのかという具体例です。
典型的なアンチパターンを把握すると、現在のPHPコードに潜んでいる「変更しづらさ」の兆候も見つけやすくなります。

Enumに処理を詰め込みすぎるアンチパターン

Enumへ処理を集中させて責務が複雑になるPHPコードのイメージ

PHPのEnumは、値の集合を表現するだけでなく、メソッドやインターフェース実装を持たせることもできます。
この柔軟性は大きなメリットですが、同時に「Enumに関連する処理は全部ここへ置けばよい」という誤解を生みやすいポイントでもあります。
最初は数行のメソッドを追加しただけでも、機能が増えるにつれてEnumが業務ロジックの中心へ変化していくことがあります。
結果として、状態や区分を表現するための型だったはずのEnumが、通知、永続化、外部API連携、権限判定など、さまざまな責務を背負う状態になってしまいます。

このアンチパターンを理解するには、まず「Enumが持ってよい振る舞い」と「Enumから切り離すべき処理」を分けて考える必要があります。
たとえば、注文状態を表す OrderStatus というEnumがあるとします。
「この状態は完了状態か」「この状態からキャンセル可能か」といった判定は、状態そのものの性質として扱える可能性があります。
一方で、「キャンセルされたら顧客へメールを送る」「発送済みなら配送会社のAPIを呼び出す」といった処理は、外部システムやアプリケーションサービスとの関係を含みます。
同じEnumに置いてしまうと、責務の境界が曖昧になります。

状態の性質と業務処理を分離する

Enumに持たせる処理を判断するときは、「そのメソッドはEnumそのものの性質を説明しているか」という視点が役に立ちます。
たとえば isCompleted() のような判定なら、Enumの値そのものから一意に導ける情報なので、比較的自然です。
しかし、sendCompletionMail() のようなメソッドになると話が変わります。
メール送信には送信先、テンプレート、メール基盤、エラー処理など複数の関心事が関係するため、注文状態という型の責務を明らかに超えています。

設計上の境界を見極める簡単な方法は、その処理が別の依存関係を必要とするかを確認することです。
EnumのメソッドがHTTPクライアント、メール送信サービス、リポジトリ、ロガー、設定値などを必要とし始めたら、責務が肥大化しているサインです。
Enumは値の表現として多くの場所から参照されるため、そこへ外部依存を集めると、アプリケーション全体の結合度まで押し上げてしまいます。

特に問題なのは、Enumが非常に広い範囲から利用されやすいことです。注文処理だけでなく、管理画面、API、バッチ、CLI、集計処理などから同じEnumが参照されるケースも珍しくありません。そのEnumに業務処理を詰め込むと、どこか一つの用途の要件変更が、Enumを参照しているすべての機能へ影響する可能性があります。広く使われる型ほど、責務は慎重に限定する必要があります。

Enumが巨大化すると何が起きるのか

Enumへ処理を追加する設計は、初期段階では非常に魅力的です。
状態と処理が同じ場所にあるため、コードを探し回る必要がなく、重複も減らせます。
ところが、仕様が増えるにつれて一つのケースを起点に複数の振る舞いが紐付きます。
すると、Enumのソースコードを開いただけで、データ表現、状態遷移、通知、UI表示、外部連携といった異なる関心事が混在している状態になります。

たとえば「発送済み」という状態に対して、管理画面ではラベルを表示し、顧客向け画面では説明文を表示し、配送会社には連携通知を送り、社内の分析処理では集計対象として扱うとします。
これらをすべてEnumのメソッドとして追加していくと、最終的には一つの状態に多数の責務がぶら下がります。
もちろん、すべての実装をまとめること自体が必ず悪いわけではありません。
しかし、異なる変更理由を持つ処理まで一つのEnumに集めることが問題です。

これは保守性だけでなく、テストにも影響します。
Enumの単純な性質を確認したいだけなのに、外部サービスへの依存を考慮したテストが必要になると、テストの準備コストが上がります。
逆に、Enumが純粋な状態表現に近ければ、テストは小さく保ちやすくなります。
責務を分離することは、単にソースコードをきれいにするだけではなく、検証可能性を高める効果もあります。

さらに、Enumへ業務処理を追加すると、その処理の実行コンテキストも不明瞭になりがちです。
たとえば注文状態の変更がデータベース更新の前後どちらで行われるべきなのか、トランザクション内なのか、非同期ジョブへ渡すべきなのか、といった判断はEnumの責務ではありません。
状態そのものを表す型へ実行タイミングまで持たせると、アプリケーション全体の制御構造が見えにくくなります。

どこまでEnumに持たせるべきか

では、Enumには何を持たせればよいのでしょうか。
基本的には、その値の意味や性質を閉じた形で表現できる処理が適しています。
代表的なのは、状態の判定、表示用の固定的な情報、関連する値への変換などです。
たとえば「完了済みかどうか」「ユーザーに表示する短いラベル」「永続化用の値」といったものです。
これらはEnum自身の意味から直接導けるため、責務として自然です。

一方で、処理対象となるエンティティの状態以外に多くの情報が必要な場合は、別の層へ切り出すことを検討すべきです。
顧客情報、注文情報、外部APIクライアント、認証情報、設定ファイルなどを受け取らなければ処理できないのであれば、そのロジックはEnumよりもサービスやドメインオブジェクトなど、別の責務を持つコンポーネントへ置いたほうが設計を整理しやすくなります。

判断に迷ったときは、「Enumだけを見ればこの処理の意味を説明できるか」と考えるとよいでしょう。
たとえば「この状態はキャンセル可能です」という説明は、状態そのものの性質として説明できます。
しかし「この状態になったらSlackへ通知します」という処理は、Slackという外部サービスの存在を前提にしています。
この差が、Enumに置く処理と置かない処理を分ける一つの基準になります。

もう一つ重要なのが、将来の変更理由です。ソフトウェア設計では、単に現在どのようにまとまっているかだけでなく、「何が変わったときにコードを修正するのか」を考える必要があります。状態の追加と通知方式の変更が、それぞれ別の理由で発生するのであれば、同じクラスへ押し込むべきではありません。変更理由の異なるものを分離することが、仕様変更に強い設計につながります。

Enumは「何でも知っているオブジェクト」にするのではなく、「この値は何を意味するのか」を明確にする型として扱うと、その利点を活かしやすくなります。
状態の性質を表す小さなメソッドはEnumへ寄せ、外部サービスとの連携や複雑な業務フローは適切なサービスへ切り出す。
この境界を意識するだけでも、Enumの肥大化をかなり防げます。

そして、もう一つ見逃せないアンチパターンがあります。
それは、Enum自体を整理していても、その値をアプリケーションの至るところから直接参照し、個別に判断してしまう設計です。
Enumがきれいでも、利用側に条件分岐が拡散していれば、仕様変更時の修正箇所は増えていきます。
次は、Enumの値をアプリ全体で直接参照する設計がなぜ問題になるのかを掘り下げ、依存関係をどう整理すべきか考えていきます。

Enumの値をアプリ全体で直接参照する設計の問題点

Enumの値に多くの処理が依存して変更範囲が広がるイメージ

Enumそのものをきれいに定義できていても、その値をアプリケーションのあらゆる場所から直接参照するようになると、仕様変更への耐性は急速に低下します。
典型的なのが、コントローラー、サービス、Repository、バッチ、通知処理、画面表示などで、同じEnumのケースを個別に判定する設計です。
Enumは一つにまとまっているため、一見すると「状態の定義が一元化されている」と感じます。
しかし実際には、状態に関する判断ロジックが複数箇所へ分散している状態です。
定義の重複はなくても、業務知識の重複が発生しているわけです。

たとえば注文状態を Pending、Paid、Shipped、Completed とします。
管理画面では Paid 以降を編集可能とし、APIでは Shipped 以降を配送情報の対象とし、バッチでは Completed の注文だけを集計する。
この程度なら大きな問題には見えません。
ところが、数か月後に「発送準備中」という新しい状態を追加するとどうでしょうか。
各処理がそれぞれ独自の前提で状態を分類しているため、どの箇所に追加対応が必要なのかを確認する作業から始めなければなりません。

ここで問題なのは、新しいEnumケースを追加すること自体ではありません。
Enumの値を直接参照するコードが、システムの至るところに存在していることです。
ある場所では Paid と Shipped を同じグループとして扱い、別の場所では Shipped と Completed をまとめて扱う、といった個別判断が積み重なると、同じ注文状態に対して異なる解釈が生まれます。
コードレビューをしていても、「この条件分岐は仕様上正しいのか、それとも昔の実装が残っているだけなのか」を判断するのが難しくなります。

条件分岐の分散が変更コストを押し上げる

Enumの値を直接比較するコードが増えると、仕様変更のたびに修正箇所を横断的に調査する必要があります。
たとえば「キャンセル可能なのは支払い前まで」というルールが、「出荷準備前まで」に変更されたとします。
状態定義は変わっていないのでEnumの修正は不要です。
しかし、キャンセル判定を行っている箇所が複数あれば、それらをすべて探して条件を変更する必要があります。
つまり、Enumが型として整理されていても、業務ルールそのものは整理されていません。

特に厄介なのは、こうした判定が目立たない場所にも潜むことです。
画面のボタン表示、APIレスポンスの組み立て、メール送信条件、定期バッチ、CSV出力などは、メインの業務処理とは別の場所に存在します。
開発者が「注文キャンセルのロジックを修正した」と思っていても、別の画面やバッチに同じ条件が残っている可能性があります。
コンパイルエラーのように明確な警告が出ないため、テストケースが不足していると本番環境で初めて発覚することもあります。

この問題は、Enumそのものよりも依存関係の設計に関係しています。
たとえば10個のクラスが OrderStatus::Shipped を直接参照している場合、その10個のクラスは「発送済み」という具体的な表現方法に依存しています。
単純な値の参照に見えても、実際には具体的な状態分類へ依存しているわけです。
依存先が増えるほど、状態モデルの変更が難しくなります。

「値」ではなく「意味」に依存させる

この問題を解決するために有効なのが、利用側のコードをEnumの具体的な値から少し距離を置かせる考え方です。
たとえば、ある処理が知りたいのが「発送済みという状態そのもの」ではなく、「これ以上注文内容を変更できないかどうか」なのであれば、利用側が Shipped や Completed を直接比較する必要はありません。
必要なのは「変更可能か」という業務上の意味です。

この発想を採用すると、状態判定を別のドメインロジックへ集約できます。
具体的なEnumケースを知っている場所を限定し、他のコードは「キャンセルできる」「編集できる」「配送処理の対象である」といった意味に依存する形へ変えていきます。
すると、状態そのものの定義と、それを利用する業務ルールとの境界が明確になります。

たとえば、注文オブジェクトに対して「編集可能か」を問い合わせる設計にすれば、呼び出し側は現在の状態が Paid なのか Shipped なのかを知る必要がありません。将来、「一部の商品だけ発送済み」という状態が追加されても、変更すべきなのは編集可否のルールを管理する場所です。利用側が具体値を知らなくてよい設計は、仕様変更の影響範囲を狭めます。

もちろん、すべてのEnum比較を機械的に隠蔽すればよいわけではありません。
値そのものを扱う必要がある処理もあります。
たとえば、外部APIの値をEnumへ変換するときや、永続化された値からドメイン上の状態を復元するときなどです。
重要なのは、「値そのものを扱う処理」と「値の意味をもとに業務判断する処理」を区別することです。

Enumへの依存を一箇所に閉じ込める

設計を整理するうえでは、「Enumを知っているコードを少なくする」という目標も有効です。
もちろん、完全に一箇所へ集約する必要はありません。
しかし、複数の層で同じEnumケースを直接比較しているなら、それは業務ルールの分散を疑うシグナルになります。
特にUIやControllerがドメイン状態を細かく知り始めたら注意が必要です。

たとえばControllerで OrderStatus の値を見てレスポンスを分岐し、さらにServiceでも同じEnumを見て処理を分岐し、Repositoryでも保存状態に応じた特殊処理を行っているとします。
この構造では、各層が注文状態の知識を持っています。
結果として、状態モデルが変更されたときに複数の層が同時に変更対象になります。
本来、ControllerはHTTPの入力と出力、Repositoryは永続化、ドメインロジックは業務ルールというように、それぞれの責務を分けるべきです。

ここで役立つのが、変換境界を明確にする考え方です。
外部から受け取った文字列はアプリケーションの境界でEnumへ変換し、ドメイン内部では可能な限り型付きの状態として扱う。
そして業務上の判断はドメインモデルや専用のサービスに寄せます。
すると、外部形式、内部の状態表現、業務上の意味という三つの関心を分離できます。

Enumの値を直接参照してよいケースもある

ここで極端に考えて、「Enumの値を直接参照してはいけない」と結論づけるのは適切ではありません。
単純な表示変換やシリアライズなど、Enumの具体的なケースを知っていることが自然な処理もあります。
たとえば管理画面で Pending なら「受付中」、Shipped なら「発送済み」と表示する処理は、用途や構造によってはEnumの表示情報として扱うほうが読みやすい場合もあります。

問題になるのは、具体値への依存が「業務ルールの分散」を引き起こしているケースです。
判断の基準としては、「このコードはEnumの値を変換しているのか、それともEnumの値を見て業務上の意思決定をしているのか」を考えると整理しやすくなります。
前者なら局所的な依存として許容できる可能性がありますが、後者が複数箇所に存在するなら、ロジックの集約を検討すべきです。

この区別は、保守性を評価するうえでかなり重要です。
設計の目的は依存関係をゼロにすることではなく、変更理由の異なるコード同士を不必要に結び付けないことだからです。
Enumを使わない設計に戻す必要もありません。
むしろEnumを型として活かしたまま、どこで具体的なケースを意識するかを限定するほうが現実的です。

最終的に目指したいのは、Enumへケースを追加したときに「どこを直せばよいのか」が明確な構造です。
修正箇所が少ないことだけが重要なのではありません。
状態に関するルールがどこへ集約されているのか、そのルールを利用する側が何に依存しているのかが説明できることが重要です。
これは単なる実装テクニックではなく、システムの変更容易性を設計段階でコントロールする考え方です。

Enumの値をアプリ全体で直接参照する設計は、短期的には分かりやすくても、機能追加とともに依存関係が広がりやすいという問題があります。
Enumをきれいに定義するだけでなく、その値を使っているコードが何のために存在しているのかを見直すことが重要です。
具体的な値への依存ではなく、業務上の意味へ依存させる。
この原則を意識すると、仕様変更の影響範囲を局所化しやすくなります。

次に問題になるのが、こうした直接参照を積み重ねた結果として生まれる条件分岐の増殖です。
Enumのケースが増えるたびに if や match が各所へ追加されると、コードは徐々に複雑化します。
次章では、なぜEnumを起点に条件分岐が増殖してしまうのか、そしてその構造をどう改善できるのかを掘り下げます。

PHP Enumで条件分岐が増殖する原因と改善方法

Enumによる条件分岐が増殖したコードと改善後の設計イメージ

PHP Enumを導入すると、文字列の比較を型安全な形へ置き換えられるため、コードの意図は明確になります。
しかし、それだけで条件分岐が減るとは限りません。
むしろEnumのケースを追加するたびに if や match が各層へ増えていくと、状態管理が以前より複雑になることさえあります。
重要なのは、Enumを使うことではなく、Enumの具体的な値による判断をどこへ集約するかです。

最初はごく自然な実装から始まります。
注文状態が Pending、Paid、Shipped、Completed と定義されていれば、「支払い済みなら次の処理へ進める」「発送済みなら編集不可」といった条件を、その場でEnumと比較するだけで実装できます。
コード量も少なく、要件との対応関係も読み取りやすいでしょう。
問題は、同じような判断が機能追加のたびに別の場所へ複製されることです。

たとえば管理画面、注文API、メール通知、定期バッチのそれぞれで注文状態を判定しているとします。
ある処理では Paid か Shipped なら対象、別の処理では Shipped と Completed なら対象、といったルールが個別に記述されていきます。
Enumの定義は一つでも、状態に関する知識は複数のファイルへ分散します。
ここに PreparingShipment のような新しい状態を追加すると、各条件分岐が正しいかどうかを一つずつ確認する必要が生まれます。

条件分岐が増える本当の原因

条件分岐の増殖をEnumのせいにするのは、やや本質から外れています。
根本原因は、一つの状態から導かれる業務ルールを、それぞれの利用箇所が個別に解釈していることです。
Enumはあくまで「現在どの状態なのか」を表現しているだけで、「その状態を業務上どう扱うか」まで統一してくれるわけではありません。

たとえば「キャンセル可能」というルールがあるとして、画面ではキャンセルボタンの表示条件を判定し、APIではキャンセルリクエストの受付条件を判定し、バッチでは自動キャンセルの対象条件を判定する、といった構造になっているとします。
それぞれがEnumのケースを直接比較していれば、同じ業務概念が3か所に実装されます。
今は一致していても、将来的に仕様が変われば差分が発生する可能性があります。

ここで注目したいのが「状態」と「判断」は別の概念だという点です。
「注文が発送済みである」は状態です。
一方、「発送済みの注文は編集できない」はルールです。
状態を表現するEnumを変更せずに、ルールだけ変更されることもあります。
そのため、状態を参照するすべての箇所で個別に判断してしまうと、仕様変更のたびに多くのコードを調べることになります。

さらに、分岐が増えるとコードの認知負荷も上昇します。
あるメソッドを読むだけで、その状態がどの条件に該当するのかを頭の中で追跡しなければならなくなるからです。
条件が単純なうちは問題ありませんが、例外条件や組み合わせが増えると、同じEnumを見ているのに処理ごとに微妙に意味が違うという状況が起こります。
これはバグを生みやすい構造です。

if と match を減らすだけでは解決しない

条件分岐を減らそうとして、すべての判定をEnumのメソッドへ移す方法もあります。
たとえば状態ごとの判断を canCancel() や canEdit() のようなメソッドにまとめれば、呼び出し側のコードはかなり読みやすくなります。
この方向性は有効ですが、ただ単に分岐をEnumへ移せばよいわけではありません。
Enumが複数の業務ルールの総元締めになってしまえば、今度はEnum自体が巨大化します。

重要なのは、条件分岐の数ではなく、判断責任が適切な場所に集まっているかです。
if や match が一つ残っていても、その条件が一つのドメインルールを表していて、そのルールを利用するすべてのコードから再利用されているなら、設計としては健全です。
逆に、分岐を別のクラスへ移しただけで、そこに異なる目的の判断が次々と追加されているなら、複雑さの居場所が変わっただけです。

したがって、リファクタリングでは「分岐を消す」よりも「分岐の意味を一つにする」ことを目指すべきです。
たとえば、編集可否という一つの関心事について、その判断を一つの責務へ集約します。
UI、API、バッチがそれぞれEnumケースを解釈するのではなく、編集可否という業務上の意味を問い合わせる設計です。
これなら、将来状態が追加されても、変更する場所を特定しやすくなります。

ドメイン上の意味をメソッドとして表現する

実際の設計では、Enumそのものに持たせるか、ドメインモデルに持たせるか、専用のポリシーやサービスに切り出すかを検討します。
たとえば単純な状態の性質だけで判断できるなら、Enumのメソッドとして閉じ込める方法があります。
「この状態は最終状態か」「この状態ではユーザー編集を受け付けられるか」といった、状態そのものから決定できるルールです。

一方で、判断に複数の情報が必要なら、Enumだけでは不十分です。
注文状態に加えて支払い状況、在庫、ユーザー権限、配送地域などを考慮する必要があるなら、専用のドメインサービスやポリシーへ切り出したほうが自然です。
ここで大切なのは、Enumに状態を持たせたまま、複雑なルールだけを適切な責務へ分離できることです。

たとえば「管理者なら発送済みでも一部の項目を変更できる」というルールが追加された場合、状態だけを見て判断する canEdit() では情報が足りません。
このようなケースで無理にEnumへ詰め込むと、Enumがユーザー情報や権限サービスまで知る必要が出てきます。
すると、前章で触れた責務の肥大化につながります。
状態だけで決まらないルールは、状態の外へ出す。
この判断が重要です。

条件分岐を集約すると仕様変更に強くなる

条件分岐を適切に集約すると、仕様変更時の変更範囲を制御しやすくなります。
たとえば「キャンセル可能なのは支払い前まで」というルールが、一か所のドメインロジックに集約されているとします。
その後、「支払い後でも発送準備前ならキャンセル可能」という仕様に変わったとしても、修正対象は原則としてそのルールを持つ場所です。
Controllerや画面テンプレートまで状態比較を追いかける必要がありません。

この構造では、呼び出し側は「なぜキャンセルできるのか」という条件を知る必要がありません。
「この注文はキャンセル可能か」という結果だけを扱います。
これはカプセル化の考え方にも近く、具体的な実装条件を利用側へ漏らさないことが変更耐性につながります。

さらに、テストの設計も整理しやすくなります。
個々の画面やAPIについて状態ごとの組み合わせを大量にテストするのではなく、まず業務ルールそのものを対象にテストできます。
もちろんUIやAPIの統合テストも必要ですが、核心となる判定を一つの責務へ集約することで、仕様変更時に確認すべき場所が明確になります。

これはソフトウェア開発でよくある「変更理由による凝集」の考え方とも一致します。
一緒に変わるコードは近くに置き、異なる理由で変わるコードは分離する。
Enumのケース追加、注文の編集ルール、通知方式の変更がそれぞれ異なるタイミングで発生するなら、それらを一つの巨大な条件分岐へまとめるべきではありません。

Enumの追加に強いコードへリファクタリングする

既存コードを改善するときは、いきなり大規模なアーキテクチャ変更をする必要はありません。
まずはEnumの具体的なケース比較を検索し、「同じ意味の判定」が何か所に存在するのかを把握します。
たとえば OrderStatus::Shipped が10ファイルで使われているとしても、それらがすべて悪いわけではありません。
表示変換、永続化、業務判定など、用途を分類することが先です。

そのうえで、複数箇所に重複している業務ルールを一つずつ抽出します。
「キャンセル可能」「編集可能」「配送対象」といった意味単位で責務を切り出すと、リファクタリングの方向性が見えます。
重要なのは、Enumケースそのものを隠すことではなく、利用側に不要な詳細を知らせないことです。

また、Enumにケースが増えるたびに壊れやすいコードを見つけるために、網羅性のテストを用意する方法も有効です。
すべてのケースに対して明示的な振る舞いを検証し、新しいケース追加時に確認漏れを検出できるようにします。
静的解析、ユニットテスト、統合テストを組み合わせることで、Enum変更による影響を早い段階で発見しやすくなります。

結局のところ、Enumを使った条件分岐の設計で重要なのは、「分岐をなくすこと」ではありません。
具体的な状態から業務上の意味を何度も再計算しないことです。
同じ判断を複数の場所で行っているなら、その判断には一つの責務がある可能性が高いと考えられます。

Enumは有限の状態を明確に表現するための強力な道具ですが、状態を参照する側が好き勝手に意味づけすると、そのメリットは薄れていきます。
状態を表すEnumと、状態から導かれる業務ルールを適切に分けることで、ケース追加や仕様変更の影響を限定できます。

次に考えたいのは、そもそもEnumへどこまで責務を持たせ、どこから先を別のドメインロジックへ委ねるべきなのかという設計上の境界です。
条件分岐を整理するだけでなく、その責務の置き場所まで明確にできれば、PHP Enumを使ったコードはさらに変更に強くなります。

仕様変更に強いPHP Enumの責務分離と設計ポイント

PHP Enumとドメインロジックを分離して責務を整理するイメージ

PHP Enumを仕様変更に強い形で利用するには、Enumを導入すること自体よりも、どの責務をEnumへ持たせ、どこから先を別のオブジェクトへ委ねるかを明確にすることが重要です。
これまで見てきたように、Enumのケースを各所で直接判定したり、Enumの中へ業務処理を詰め込んだりすると、変更の影響範囲が広がります。
逆に、Enumを「状態や区分を表現する型」として捉え、その意味に閉じた振る舞いだけを持たせれば、アプリケーションの設計はかなり安定します。

ここで押さえておきたいのは、責務分離とは「できるだけクラスを増やすこと」ではないという点です。
クラスやサービスを細かく分割すればよいわけではありません。
重要なのは、異なる理由で変更されるものを不必要に同じ場所へ集約しないことです。
注文状態という概念と、通知方式という概念では変更理由が異なります。
それなのに同じEnumへ押し込めば、互いに無関係な仕様変更が一つのコードへ波及します。

Enumに持たせる責務を明確にする

Enumに向いているのは、そのEnumの値そのものから決められる性質です。
たとえば「この状態は完了状態か」「この値は公開状態か」「この権限種別は管理者向けか」といった情報は、Enum自身の意味に閉じています。
このような処理であれば、Enumへメソッドを持たせることで、状態と判断を近い場所へまとめられます。

一方で、「この状態なら顧客へメールを送る」「この状態なら外部APIへ通知する」といった処理は、Enumだけでは完結しません。
メールサービスやHTTPクライアントといった外部依存が必要になり、実行タイミングやエラー処理まで考慮する必要があるからです。
こうした処理はEnumから切り離し、アプリケーションサービスやドメインサービスなど、別の責務を持つコンポーネントに委ねるほうが自然です。

判断基準として、「このメソッドはEnumの意味を説明しているのか、それともEnumをきっかけに別の処理を実行しているのか」を考えると整理しやすくなります。
前者ならEnumに置く余地があり、後者なら切り出す可能性が高い、というわけです。

状態と状態遷移を分けて考える

仕様変更への強さを考えるとき、状態そのものと状態遷移も分けて考える必要があります。
たとえば注文の状態として Pending、Paid、Shipped、Completed があるとしても、「どの状態からどの状態へ変更できるのか」は別の業務ルールです。
Enumが存在することと、その遷移規則が適切に表現されていることは同じではありません。

最初は単純に状態を代入するだけでも問題なく動くかもしれません。
しかし、「支払い完了後でなければ発送できない」「一度発送した注文は支払い待ちへ戻せない」といった制約が増えると、状態遷移のルールが重要になります。
これをアプリケーションの複数箇所で個別に判定すると、再び条件分岐の増殖が始まります。

そのため、状態遷移については、注文自身や専用のドメインロジックに判断を集約する方法が有効です。
たとえば「この注文は次に発送可能か」という問いに対して、呼び出し側がEnumケースを比較するのではなく、注文やポリシーへ問い合わせる形です。
ここでも重要なのは、状態の具体値ではなく業務上の意味をインターフェースとして表現することです。

外部データとの境界でEnumを使う

Backed Enumを利用すると、データベースやAPIの文字列・整数値をアプリケーション内部の型へ変換しやすくなります。
このとき意識したいのが、外部形式とドメイン上の概念を分離することです。
データベースに保存されている pending という文字列は、あくまで永続化の表現です。
アプリケーション内部では、それを OrderStatus という意味のある型として扱えます。

この境界を明確にすると、外部システムの変更にも対応しやすくなります。
たとえばAPI側で値の表記が変更された場合でも、変換処理を境界付近に閉じ込められれば、ドメイン内部まで変更を波及させずに済みます。
反対に、APIの文字列をそのままサービス層や画面まで持ち回ると、外部仕様への依存がアプリケーション全体へ漏れ出します。

Enumはこの変換境界を作るうえでも有効です。
ただし、すべての外部値を無条件にEnumへ変換すればよいわけではありません。
外部システム固有の状態と、自分たちのドメイン上の状態が本当に同じ概念なのかを確認する必要があります。
似た名前だからといって一つのEnumへ統合すると、別々の変更理由を持つ概念を結合してしまうことがあります。

表示用の情報とドメイン情報を混同しない

Enumの利用で意外と起こりやすいのが、UI表示の都合をドメインモデルへ持ち込むケースです。
たとえば注文状態ごとの日本語ラベルをEnumに持たせること自体は、用途によっては便利です。
しかし、Web画面のデザインや文言までEnumが管理し始めると、プレゼンテーション層の変更がドメイン層へ伝わる構造になります。

「発送済み」という状態そのものはドメイン上の概念ですが、「管理画面では青いバッジで表示する」「顧客画面では特定の説明文を表示する」といった情報はUIの関心事です。
同じ情報源から出したい気持ちは理解できますが、変更理由を考えると分けたほうがよい場合があります。

もちろん、固定的な表示ラベルのようにEnumへ置いても大きな問題にならない情報はあります。
ここでも正解は一律ではありません。
重要なのは、デザイン変更や多言語対応、A/Bテストなど、将来起こりそうな変更を考えたうえで、Enumに持たせる情報の安定性を判断することです。

依存関係の方向を意識する

仕様変更に強い設計では、依存関係の方向も重要になります。
Enumがアプリケーションの多くの場所から利用される基礎的な型であるなら、そこへ上位レイヤーの具体的な事情を持ち込むほど依存が逆流します。
たとえば、ドメイン上の状態を表現するEnumが、HTTPクライアントやフレームワーク固有のクラスに依存する設計は避けたほうがよいでしょう。

下位の概念が上位の具体実装を知ってしまうと、変更が連鎖します。
通知基盤を差し替えたい、フレームワークを変更したい、APIクライアントを更新したい、といった変更のたびにEnumまで修正対象になるからです。
逆に、Enumが純粋なドメイン上の概念として保たれていれば、インフラやUIの変更から切り離しやすくなります。

これは依存性逆転の考え方とも相性がよく、安定している概念へ不安定な具体実装を依存させないという原則につながります。
Enumだから特別扱いするのではなく、変更頻度の異なるモジュール間の依存方向を設計する、その一部としてEnumを考えることがポイントです。

「将来追加されるケース」を前提に設計する

Enum設計では、「今あるケースだけが存在する」という前提を置かないことも重要です。
状態管理では、運用開始後に新しい状態が追加されるのは珍しくありません。
「保留中」「一部発送済み」「返金処理中」など、実際の運用から新しい概念が見つかることもあります。

そのため、Enumケースが追加されたときに、どこへ影響が出るのかをあらかじめ把握できる設計が理想です。
具体値を直接参照するコードが少なく、業務ルールが適切な場所へ集約されていれば、追加時の確認ポイントも明確になります。
逆に、状態比較がプロジェクト全体に散らばっていると、新しいケースが既存処理のどこを壊すかを人手で洗い出す必要があります。

実務では、Enumへケースを追加したタイミングで、静的解析やテストを組み合わせて影響を検証することも大切です。
とくに match のようにケースの網羅性が重要になる構造や、状態遷移ルールを持つコードでは、未知のケースが入ったときに失敗を検出できる仕組みを用意しておくと安心です。

仕様変更の種類ごとに変更先を分ける

設計をさらに安定させるには、どんな変更が起きたら、どのコードを修正するのかを意識しておくと効果的です。
たとえば「状態の種類が増える変更」と「通知手段が変わる変更」と「画面の文言が変わる変更」は、それぞれ別の理由で発生します。
この三つが同じクラスへ集まっているなら、どこかで責務が混ざっている可能性があります。

理想的な設計では、状態の追加ならEnumと関連するドメインロジック、通知方式の変更なら通知コンポーネント、画面文言の変更ならプレゼンテーション層というように、変更理由に応じて修正先が自然に分かれます。
これにより、仕様変更の波及範囲を抑えられます。

ここで大事なのは、コード量を最小化することではありません。
多少ファイル数が増えたとしても、変更理由ごとに責務が整理されているほうが、長期的には理解しやすくなります。
ソフトウェアの保守コストは行数だけで決まるものではなく、変更時にどれだけ広い範囲を正しく理解しなければならないかに大きく左右されるからです。

PHP Enumは、適切に使えば状態管理を明確にし、型安全性を高め、ドメイン上の概念をコードへ反映するための強力な手段になります。
しかし、その価値を引き出すには、Enumへ何でも集めるのではなく、値の意味、業務ルール、外部連携、表示処理をそれぞれの責務へ整理することが不可欠です。

「この処理はEnumに置くべきか?」と迷ったときは、その処理がEnumの意味そのものなのか、それともEnumを使った結果として発生する別の業務処理なのかを考えてみてください。
そして、将来その処理が別の理由で変更される可能性があるなら、分離する余地があります。

Enumを中心にすべてをまとめるのではなく、Enumを安定した概念として小さく保つ。
その周辺に必要な振る舞いを適切に配置する。
この設計思想を持つことで、Enumは単なる便利機能から、仕様変更に強いアーキテクチャを支える部品へ変わっていきます。

ドメインモデルとEnumを組み合わせて変更に強くする方法

Enumとドメインモデルを組み合わせた変更に強い設計イメージ

PHP Enumを仕様変更に強い設計へ活かすうえで、非常に相性がよいのがドメインモデルとの組み合わせです。
ここでいうドメインモデルとは、単にデータを保持するクラスではありません。
アプリケーションが扱う業務上の概念と、その概念に紐づくルールをコードとして表現したものです。
Enumで状態や区分を明確にし、その状態から導かれる振る舞いをドメインモデルへ適切に集約すると、利用側に細かな条件を漏らさずに済みます。
結果として、仕様変更が発生したときの修正範囲を局所化しやすくなります。

たとえば注文を扱うアプリケーションであれば、OrderStatus というEnumに Pending、Paid、Shipped、Completed などの状態を定義できます。
しかし、本当に重要なのは状態を列挙することではありません。
「この注文はキャンセルできるのか」「この注文を編集できるのか」「この注文は発送処理へ進められるのか」といった業務上の判断を、どこで行うのかです。
これらをControllerや画面、バッチが直接Enumと比較して判断するのではなく、注文そのものに問い合わせられる形へ近づけると、コード全体の責務が整理されます。

Enumは状態を、ドメインモデルは意味を表現する

Enumとドメインモデルは競合するものではありません。
むしろ役割を分担させると、それぞれの利点を活かせます。
Enumは「どの状態が存在するのか」を表現するのが得意です。
一方、ドメインモデルは「その状態を持つ対象が業務上どう振る舞うのか」を表現するのが得意です。

この違いを意識すると、たとえばControllerが OrderStatus::Shipped を見て「この注文は編集不可」と判断する必要がなくなります。
Controllerが知りたいのは発送済みかどうかという実装上の詳細ではなく、注文を編集できるかどうかという業務上の意味だからです。
そこで注文オブジェクトに「編集可能か」を問い合わせる構造へ変えると、具体的な状態判定をドメイン側へ閉じ込められます。

これはカプセル化の考え方そのものです。内部状態を丸ごと公開して利用者に自由に判断させるのではなく、その状態を管理するオブジェクトに適切な操作を問い合わせます。Enumを外へ公開しすぎず、Enumを含む状態の解釈をドメインモデルへ集約することが、変更耐性を高めるポイントです。

もちろん、すべての処理をドメインモデルへ入れればよいわけではありません。
たとえばメール送信、外部API呼び出し、データベースアクセスなどの処理まで注文オブジェクトへ持たせると、今度はドメインモデルが巨大化します。
ここでも責務分離が重要です。
ドメインモデルには業務上のルールを寄せ、外部システムとの具体的な連携は別のコンポーネントへ分離するのが基本です。

状態に応じた操作をドメインモデルへ集約する

仕様変更に強い設計を目指すなら、「状態を取得してから外で判断する」コードよりも、「業務上の操作を依頼する」コードを優先するとよいでしょう。
たとえば呼び出し側が注文状態を見てからキャンセル処理を実行するのではなく、注文自身にキャンセルを依頼し、許可されているかどうかを注文側で判断する構造です。

この設計のメリットは、状態とルールの距離が近くなることです。
注文状態の追加やキャンセル条件の変更が発生しても、ルールを管理する場所が明確になります。
呼び出し側は「どの状態ならキャンセルできるか」を知る必要がありません。
知る必要がない情報を知らないことが、そのまま変更に強い依存関係につながります。

たとえば、当初は「支払い前だけキャンセル可能」だった仕様が、「支払い後でも発送処理前ならキャンセル可能」に変更されたとします。
状態判定が複数のControllerやServiceへ散らばっていれば、それらをすべて確認する必要があります。
しかし、キャンセル可否を注文のドメインルールとして一元化していれば、変更の中心はそのルールを持つ箇所になります。
もちろん周辺のテストは更新しますが、実装上の変更範囲は小さくできます。

ここで重要なのは、Enumを隠すこと自体が目的ではないことです。
目的は、業務ルールの変更を一か所へ閉じ込めることです。
Enumはそのための基礎的な状態表現として機能します。

状態遷移をドメインモデルの責務として扱う

特に効果が大きいのが、状態遷移をドメインモデルへ集約する考え方です。
注文の現在状態が Paid だからといって、どこからでも Shipped へ変更してよいとは限りません。
「支払い確認が完了しているか」「出荷対象の商品が揃っているか」など、業務上の条件が存在するからです。

状態そのものはEnumで表せますが、状態をどう変化させるかはドメインルールです。
この二つを同じものとして扱うと、状態更新が単なるプロパティ変更になってしまいます。
すると、別の処理から不正な状態へ直接変更できる余地が生まれます。

そこで、状態を直接書き換えるのではなく、意味のある操作をモデルへ与える設計が有効です。
「発送済みに変更する」という技術的な操作ではなく、「発送処理を確定する」「注文をキャンセルする」といった業務上の操作として表現します。
そうすれば、その操作が許可される条件をモデル自身が管理できます。

これは不正な状態遷移を防ぐだけではありません。
将来、仕様変更によって遷移条件が変わったときにも、変更箇所が明確になります。
状態をどのように保存するかとは別に、状態をどう変えるべきかという業務ルールを一つの責務として扱えるためです。

複数の情報を使うルールはドメインサービスへ分離する

一方で、ドメインモデルだけでは扱いにくいルールもあります。
たとえば「プレミアム会員で、注文金額が一定以上で、かつ発送対象地域が国内ならキャンセル期限を延長できる」といったルールです。
ここまで条件が増えると、注文モデル一つにすべての依存情報を渡すのは不自然になる可能性があります。

このような場合は、Enumやエンティティへ無理に詰め込まず、ドメインサービスやポリシーオブジェクトなどへ分離する方法があります。
重要なのは、Enumを使うかドメインモデルを使うかという二択ではなく、どのルールがどの情報に依存しているのかに応じて責務を配置することです。

たとえば注文状態という単純な性質はEnumに閉じ込め、注文自身が持つ情報だけで判断できるルールは注文モデルへ集約する。
そして、複数のエンティティや外部から取得した情報を横断して判断するルールだけをドメインサービスへ置く。
この構造にすると、各コンポーネントの役割がかなり明確になります。

結果として、Enumは小さく保ち、ドメインモデルも過度に肥大化させず、複雑な業務ルールだけを独立させることができます。
設計上の「何でも一つへまとめる」という誘惑から距離を取れるわけです。

RepositoryやControllerからEnumの詳細を遠ざける

仕様変更に強い設計を作るうえで見逃せないのが、ControllerやRepositoryにEnumの業務知識を持ち込まないことです。
ControllerはHTTPリクエストを受け取り、適切なユースケースを呼び出し、その結果をレスポンスへ変換する役割に集中したほうが理解しやすくなります。

たとえばControllerの中で「発送済みなら拒否」「完了済みなら別メッセージ」といった判断を始めると、Webという技術的な関心事の中にドメインルールが混ざります。
そのルールをCLIやバッチ、別のAPIでも利用する場合、同じ条件を再実装することになります。
結果として、アプリケーションの入口ごとに別の判断が存在する状態です。

Repositoryについても同様です。
データベース上の値をEnumへ変換する責務は持てますが、「発送済みだから特別な業務処理をする」といった判断までRepositoryへ入れると、永続化と業務ルールが混ざります。
Repositoryはデータの取得や保存という責務に集中させ、取得した状態の意味はドメイン側で扱うほうが変更理由を分離しやすくなります。

テストしやすい設計は仕様変更にも強い

Enumとドメインモデルを適切に組み合わせると、テストの粒度も自然に整理されます。
たとえば、Enumそのものについては値の定義や固定的な性質を確認し、ドメインモデルについては状態ごとの業務ルールを検証する、といった役割分担ができます。

特に重要なのは、画面やAPIを経由しなくても業務ルールをテストできることです。
キャンセル可否や状態遷移をドメインモデル単位でテストできれば、仕様変更が入ったときに、まず中心となるルールを確認できます。
そのうえでControllerやAPIの統合テストを実行すれば、どのレベルで問題が発生しているのかも切り分けやすくなります。

また、新しいEnumケースを追加する場合も、ドメインルールのテストが設計の安全網になります。
たとえば PreparingShipment を追加したなら、「この状態では編集できるのか」「キャンセルできるのか」「発送処理へ進めるのか」といった業務上の意味を確認します。
こうしたテストがあれば、Enumの追加を単なる値の追加ではなく、ドメインモデルの振る舞いに対する仕様変更として扱えます。

将来の仕様変更を前提に責務を決める

設計時には、「現在の要件で最も簡潔なコードは何か」だけでなく、「次にどのような変更が起きそうか」まで考えることが大切です。
特に状態管理では、ケースの追加、遷移条件の変更、権限条件の追加、外部連携の変更などが頻繁に発生します。

このとき、Enumが状態を表現し、ドメインモデルがその状態を使った基本的な業務ルールを保持し、複数の概念をまたぐ複雑な判断をドメインサービスへ切り出す構造なら、変更理由ごとに修正先が分かれます。
これは偶然きれいに見える設計ではなく、変更軸を意識して責務を配置した結果です。

逆に、「Enumがあるから状態関連のことは全部Enumへ」「注文に関することは全部Orderへ」と大雑把にまとめてしまうと、責務の過密化が起こります。クラスを増やさないことやコードを短くすることだけを目標にすると、将来的な変更コストを見落とします。保守性を考えるなら、現在の行数よりも、変更が発生したときの依存範囲を見るべきです。

Enumとドメインモデルの組み合わせで目指すべきなのは、Enumを高機能にすることでも、すべての条件分岐を消し去ることでもありません。
状態を型として明確に表現し、その状態に関する意味やルールを適切なドメインモデルへ集約し、複雑な横断ルールだけを別の責務へ切り出すことです。

この構造なら、たとえば状態が一つ増えたときにも、変更箇所を追跡しやすくなります。
「どこでEnumを比較しているか」ではなく、「どの業務ルールがこの状態に依存しているか」を確認すればよいからです。
コードを読む人にとっても、状態の定義と振る舞いの責任範囲が見えやすくなります。

PHP Enumを本当に活かしたいなら、Enumだけを見て設計を完結させないことです。Enumは状態を明確にするための型であり、その状態をどう扱うかはドメインモデルやサービスとの組み合わせで決まります。「状態」「意味」「処理」を適切な境界へ分離することが、仕様変更に強いPHPアプリケーションを作るための基本原則です。

PHP Enumの使いどころを判断する設計チェックポイント

PHP Enumを適切に使うための設計判断ポイントを示すイメージ

PHP Enumは、限られた選択肢を型として表現するための強力な機能です。
ただし、便利だからという理由だけで既存の文字列や整数をすべてEnumへ置き換えると、かえって設計を複雑にすることがあります。
重要なのは「Enumを使えるか」ではなく、その値をEnumという型で表現することに設計上の意味があるかを判断することです。

とくに業務アプリケーションでは、状態、種別、権限、カテゴリ、外部システムのコードなど、似ているようで性質の異なる値が大量に登場します。
これらをすべてEnumへまとめてしまうと、単なるコードの置き換えに終わります。
逆に、将来も一定の選択肢として管理したい概念をEnumとして明確に型付けできれば、入力値の制約、可読性、IDEの補完、静的解析、リファクタリングの安全性など、複数のメリットを得られます。

まず「取り得る値が有限か」を確認する

最初のチェックポイントは、その値が本当に有限個の候補から選ばれるものなのかという点です。
Enumは「何でも型にするための仕組み」ではなく、あらかじめ意味のある選択肢を定義するための仕組みです。
たとえば注文状態のように、システム上の仕様として「受付中」「支払い済み」「発送済み」「完了」といった明確な集合が存在するなら、Enumとの相性がよいでしょう。

一方で、ユーザー名、検索キーワード、メールアドレス、商品タイトルのように、値の種類が事前に列挙できないものへEnumを使う意味はありません。
これらをEnumへ寄せようとすると、単純なデータを不自然に型へ変換することになり、コードの複雑さだけが増えます。
有限集合であることは、Enumを検討するための基本条件です。

ただし、「現在は有限に見える」というだけでは不十分です。
運用上、管理者が自由に追加するカテゴリや、将来的に顧客ごとに増えていく設定値などは、Enumへ固定すると変更のたびにコード変更とデプロイが必要になります。
システムの仕様として固定された集合なのか、運用によって変化するデータなのか。
この違いを見極めることが重要です。

値の追加や変更が誰の責務なのかを考える

次に見るべきなのが、その選択肢を誰が変更するのかです。
開発者がソースコードを変更してリリースすることで追加されるものなら、Enumで管理しやすいでしょう。
反対に、業務担当者が管理画面から自由に追加・削除する可能性があるなら、データベースなどで管理するほうが自然です。

たとえば「会員ランク」が Free、Standard、Premium の三種類に固定されている間はEnumが便利です。しかし、マーケティング担当者がキャンペーンのたびに「Gold」「Platinum」「期間限定ランク」などを追加できる要件なら、それは静的な型よりもデータとして扱うほうが適しています。Enumは変更のたびにコードへ反映されるため、頻繁に運用で変わる値をEnumへ押し込むと、変更コストが高くなります。

ここでは「値が増えるかどうか」だけでなく、「誰が、どの頻度で、どのプロセスを通して増やすのか」を考えると判断しやすくなります。
システムの構成管理と、ユーザーや運用担当者によるデータ管理を混同しないことです。

値そのものにドメイン上の意味があるかを確認する

Enumを導入する価値は、単に文字列の入力ミスを防ぐことだけではありません。
より重要なのは、その値に業務上の意味があり、システムの複数箇所で一貫した概念として扱う必要があるかどうかです。

たとえば注文状態の Shipped は、「注文が発送済みである」という明確な意味を持ちます。
キャンセル可否、編集可否、配送処理、通知など、複数の業務ルールに関係する可能性があります。
このような概念なら、Enumとして型を与える意味があります。

一方で、単に一つの関数内部で一時的に使う文字列の選択肢までEnumにすると、抽象化のコストがメリットを上回ることがあります。
Enumを作るということは、新しい型とその責務をシステムへ追加することです。
したがって、「この値はアプリケーション上で独立した概念として扱う必要があるか」という問いも重要になります。

外部システムの値をそのままEnumにしない

APIやデータベースなどの外部システムから文字列コードを受け取る場合も、Enumを検討する場面があります。
ただし、外部値と自分たちのドメイン上の概念が本当に同じものなのかは慎重に確認すべきです。

外部サービスが A、B、C という状態コードを返すからといって、それをそのままドメインEnumにするのは危険です。
外部サービス側の仕様変更と、自分たちの業務ルールの変更は、異なる理由で発生するからです。
外部コードをそのままアプリケーション全体へ漏らしてしまうと、外部仕様への依存が広がります。

より安定した設計を目指すなら、外部入力を境界で変換し、内部では自分たちのドメイン上の意味を持つ型として扱います。
こうすれば、外部APIのコード体系が変わっても、変換部分を修正するだけで済む可能性が高くなります。
Enumは外部値を保持するためだけの型ではなく、外部の表現と内部の意味を切り離す境界としても利用できます。

Enumに振る舞いを持たせるべきか判断する

PHPのEnumにはメソッドを定義できるため、「状態ごとの処理をEnumへ入れる」という設計が可能です。
しかし、ここでも重要なのは、その振る舞いがEnum自身の意味に閉じているかどうかです。

たとえば「この状態は完了状態か」「この状態は編集可能な状態か」といった判定は、Enumの性質として表現しやすいでしょう。
一方で、「この状態になったらメールを送信する」「この状態なら外部APIを呼び出す」といった処理は、外部サービスとの依存関係を含みます。
これをEnumへ追加すると、責務が急速に広がります。

迷ったときは、「そのメソッドが別のサービスやデータを必要とするか」を確認するとよいでしょう。
Enum単体で意味を説明できる処理なら候補になりますが、Repository、HTTPクライアント、メールサービス、設定値などが必要になるなら、別のドメインサービスやアプリケーションサービスへ切り出したほうが保守しやすいケースが多くなります。

Enumの値を多くの場所が直接参照していないか確認する

Enumを使った設計の健全性を見るうえで、実際に何個のクラスがそのケースを直接比較しているかも重要な指標になります。
Enumの定義自体がきれいでも、Controller、Service、Repository、バッチ、画面表示などがそれぞれ Pending や Shipped を直接参照していれば、業務ルールは分散しています。

この状態では、Enumケースを一つ追加しただけでも大量のコードを確認する必要が出てきます。
たとえば「発送準備中」という状態を追加したとき、どの処理では発送済みと同じ扱いにし、どの処理では別扱いにするのかを一つずつ判断しなければなりません。
Enumを使う目的は具体値を増やしていくことではなく、意味を整理し、依存関係をコントロールすることにあります。

そのため、同じ条件分岐が複数箇所に存在するなら、Enumそのものの見直しだけではなく、その判断をドメインモデルやポリシーへ集約できないか検討します。「Enumがあるのに条件分岐が増えている」なら、利用側の責務設計を見るべきです。

データベース設計との関係を確認する

Enumを導入するときは、データベースとの対応関係も忘れてはいけません。
Backed Enumを使えば文字列や整数との対応を明示できますが、だからといってデータベースの値とアプリケーションの型を完全に同一視する必要はありません。

たとえばデータベースには pending、paid、shipped といった値を保存し、アプリケーション内部ではEnumとして扱う設計は自然です。
しかし、データベース側の値を直接SQLや集計ロジックの基準として大量に利用すると、Enumを導入したメリットが薄くなることがあります。
アプリケーションのルールをどこで表現するのかを明確にし、永続化形式との境界を保つことが大切です。

また、データベースの既存値を変更する場合には、コードだけでなくデータ移行も必要になります。
Enumの追加や変更は、型定義だけの問題ではありません。
保存済みデータ、外部API、既存バッチ、分析SQLなど、周辺システムとの整合性まで確認する必要があります。

チームで理解しやすい型になっているか確認する

設計の正しさだけでなく、チーム全体で理解しやすいかどうかも判断基準になります。
Enumは型として意味を持つため、適切に命名されていれば、コードを読む人へ仕様の一部を伝えられます。

たとえば OrderStatus、PaymentMethod、UserRole のように、型名から概念が明確に分かるEnumは読みやすい設計です。
一方で、Type、Mode、Status のような抽象的すぎる名前を大量に作ると、どの文脈の型なのか分からなくなります。
Enumを増やすことそのものを目的にせず、ドメイン上の概念に名前を与えるという観点が必要です。

さらに、Enumケースの命名も重要です。
ケース名が業務用語と一致していれば、仕様書、会話、コードの対応関係が明確になります。
技術的に正しい名前だけでなく、チームが共有している言葉とどれだけ整合するかも考えたいポイントです。

迷ったときは「変更の方向」で判断する

最後に、Enumを使うべきか迷ったときに有効なのが、「この値はどの方向へ変更される可能性が高いか」という視点です。
Enumに適しているのは、選択肢がコード上の仕様として管理され、変更時には開発者が明示的に対応すべきものです。
逆に、運用やユーザー入力によって頻繁に変化するものは、データとして管理するほうが適しています。

たとえば「支払い方法」がシステムの機能として固定されているならEnumは有力な選択肢です。
しかし、新しい決済手段を事業部門が管理画面から自由に追加したいのであれば、データベース上のマスターデータとして設計したほうが柔軟です。
この違いを見ずに「候補が複数あるからEnum」と判断すると、将来の仕様変更に対して弱い構造になります。

判断に迷ったら、次の問いを順番に確認すると整理しやすくなります。

  1. その値は有限個の選択肢として定義できますか?
  2. 選択肢の追加や変更はコード変更を伴うべきものですか?
  3. その値には明確なドメイン上の意味がありますか?
  4. 外部システムの都合と自分たちの業務ルールを混同していませんか?
  5. そのEnumのケースを多数の場所で直接判定する必要はありませんか?

この問いに多く当てはまるなら、Enumを導入する価値は高いでしょう。
逆に、運用で頻繁に増減する、単なる一時的なデータである、外部仕様をそのまま表している、といった性質が強いなら、別の表現方法を検討したほうがよいでしょう。

PHP Enumの設計で最も重要なのは、「Enumを使うこと」ではなく、「変更の単位に合わせて型を設計すること」です。
状態や種別をEnumとして表現し、その型から直接導ける性質を適切に閉じ込める。
一方で、運用によって変化するデータや外部システム固有の都合は、別の境界へ分離する。
この見極めができると、Enumはコードを複雑にする機能ではなく、仕様を明確にするための強力な設計手段になります。

実装例で見るPHP Enumのアンチパターン改善手順

PHP Enumのアンチパターンを改善する実装手順を示すコードイメージ

ここまで、Enumに処理を詰め込みすぎる問題や、Enumの具体的な値をアプリケーション全体で直接参照する問題について見てきました。
ここからは、実際のコードを題材にしながら、どのようにリファクタリングすれば仕様変更に強い設計へ近づけられるのかを整理します。
重要なのは、一気に大規模なアーキテクチャへ作り替えることではありません。
現在のコードに存在する責務の混在を見つけ、変更理由の異なる処理を少しずつ分離していくことです。

今回の例では、ECサイトの注文を想定します。
注文には Pending、Paid、Shipped、Completed の4つの状態があり、状態に応じてキャンセル可否や通知などの処理が変化するものとします。
最初は単純な実装でも、機能追加を重ねるうちに条件分岐が各所へ広がる、という現実的なケースです。

アンチパターンの実装を確認する

まずありがちな実装では、Enumを定義し、その値を見て各処理が直接判断します。
たとえば、注文をキャンセルする処理で現在の状態を判定し、管理画面でも同じ状態を見てキャンセルボタンの表示可否を判断するといった構造です。
さらにメール通知でも状態を比較するようになると、同じEnumを参照するコードが複数箇所に増えていきます。

この構造で問題なのは、コードが動かないことではありません。
むしろ、最初は非常に分かりやすく見えることが問題です。
「発送済みならキャンセル不可」というルールを、その場でEnumと比較して書けば、要件と実装の対応関係も直感的です。
しかし、このルールが別の処理でも必要になった瞬間から、同じ知識を複製することになります。

たとえば次のようなコードは、単独で見れば大きな違和感はありません。

if ($order->status === OrderStatus::Paid || $order->status === OrderStatus::Pending) {
    $order->cancel();
}

ところが、別のController、API、バッチでも同じ条件を書き始めると、仕様変更の影響範囲が広がります。
「発送準備中もキャンセル可能」という変更が入った場合、この条件を使っているすべての場所を修正しなければなりません。
しかも、ある箇所だけ修正し忘れても、PHPの型システムが自動的に教えてくれるとは限りません。

ステップ1:Enumそのものの責務を整理する

最初に行うべきなのは、Enumの責務を確認することです。
注文状態そのものを表す OrderStatus は、あくまで状態の集合を表現する型として扱います。
状態の名称や永続化に必要な値など、Enum自身の意味に直接関係する情報はここへ残します。

一方、「キャンセル可能か」「発送処理へ進めるか」といった業務ルールについては、単純な状態の性質として表現できるものと、注文全体の情報を必要とするものに分けます。
ここを区別しないまま、すべてをEnumへ集約するのは避けます。

たとえば「この状態が完了状態か」という判定は状態そのものから決まります。
一方、「この注文をキャンセルできるか」は、状態に加えて注文の支払状況や特殊な契約条件などを考慮する可能性があります。
この二つを同列に扱わないことが重要です。

ステップ2:重複している業務ルールを見つける

次に、Enumを直接比較しているコードを検索します。
ここでは単に参照数を数えるだけでなく、何のために比較しているのかを分類するのがポイントです。
たとえば「画面表示のための変換」「DBへの保存」「キャンセル可否の判定」「メール送信条件」では、同じEnumを使っていても責務が異なります。

その中から、とくに複数箇所で繰り返されている業務ルールを探します。
「PendingとPaidならキャンセル可能」という条件が3か所に存在するなら、それは単なる重複ではなく、一つの業務知識が分散している状態です。
まずは、このようなルールを抽出するところから始めます。

実務では、IDEの全文検索や静的解析ツールを活用すると効率的です。
OrderStatus:: の参照を一覧化し、条件式、match、switch、比較演算子などを横断的に確認します。
検索結果をそのまま全部リファクタリングするのではなく、用途ごとに分類することが重要です。

ステップ3:業務上の意味をドメインモデルへ移す

重複した判定を見つけたら、次は「具体的なEnumケース」ではなく「業務上の意味」を表す形へ変更します。
たとえばControllerが Pending や Paid を見てキャンセル可否を決定するのではなく、注文オブジェクトへキャンセル操作を依頼する構造にします。

public function cancel(): void
{
    if (!$this->canCancel()) {
        throw new DomainException('この注文はキャンセルできません。');
    }

    $this->status = OrderStatus::Cancelled;
}

この例で重要なのは、canCancel() という名前です。
呼び出し側は「どの状態なら許可されるか」を知る必要がありません。
必要なのは、「この注文はキャンセルできるか」という結果だけです。
具体的な条件を注文自身へ寄せることで、Controllerやサービスから状態判定の詳細を取り除けます。

もちろん、ここで canCancel() の中に複雑すぎる条件を詰め込むのは避けるべきです。
注文状態だけでなく、顧客ランクや決済サービスの状態など、外部情報を大量に必要とするなら、その判定はドメインサービスやポリシーへ切り出すほうが自然です。

ステップ4:状態遷移を直接代入させない

次に見直したいのが、状態の直接変更です。
たとえば、注文オブジェクトの status をどこからでも書き換えられる設計では、「なぜその状態へ変えられるのか」というルールが散らばります。

そこで、状態変更を業務上の操作へ置き換えます。
「発送済みに設定する」のではなく、「発送を確定する」と考えるわけです。
このとき、現在状態から次の状態への遷移が正しいかどうかを、注文モデルや専用のドメインロジックで検証します。

こうすると、「支払い前に発送済みへ変更される」といった不正な遷移を防ぎやすくなります。
さらに、将来状態が増えたときにも、状態遷移のルールを確認する場所が明確です。
単なるデータ更新から、意味のあるドメイン操作へ抽象化することがポイントです。

ステップ5:通知や外部連携をEnumから分離する

アンチパターンを改善するときに非常に重要なのが、外部依存の分離です。
たとえば「注文が発送済みになったら顧客へメールを送る」という処理をEnumへ入れてしまうと、状態定義がメール基盤へ依存します。

これを避けるには、状態変更をトリガーとしてアプリケーションサービスなどが通知処理を呼び出す構造にします。
Enumは「発送済み」という状態を表現するだけです。
メール送信は通知サービス、外部APIへの連携は連携サービスというように、変更理由ごとに責務を分離します。

こうしておけば、将来「メールではなくプッシュ通知にする」「配送会社を変更する」といった仕様変更が発生しても、Enumまで変更する必要がありません。
状態の変更と、その結果として発生する副作用を分離することが、長期的な保守性に効いてきます。

ステップ6:Controllerから状態判定を取り除く

次にControllerを確認します。
ControllerにEnumの条件分岐が多い場合は、ドメインルールがUIやHTTP層へ漏れている可能性があります。

たとえば「キャンセル可能ならキャンセルボタンを表示する」という判断そのものは画面に必要ですが、Controllerが Pending や Paid を直接知る必要はありません。
注文モデルや専用の判定サービスから「キャンセル可能」という結果を受け取れば十分です。

この設計では、ControllerはHTTPリクエストを受け取り、ユースケースを呼び出し、結果をレスポンスへ変換する役割に集中できます。
状態の具体的な意味をControllerが理解しなくてよくなるため、別の入口から同じユースケースを利用するときにもルールを再実装せずに済みます。

ステップ7:リファクタリング後の責務をテストする

コードを整理したら、必ず業務ルールのテストを追加します。
ここで重要なのは、単にメソッドの行数を減らしたことを確認するのではなく、仕様として何が保証されているのかをテストへ落とし込むことです。

たとえばキャンセルについては、「キャンセル可能な状態では成功する」「許可されていない状態では失敗する」というルールを中心にテストします。
状態が増えた場合も、その新しいケースがどのように扱われるべきかを明示します。

さらに、状態遷移についても「PaidからShippedへの遷移は許可される」「PendingからShippedへの遷移は許可されない」といった境界条件を確認します。
こうしたテストがあれば、内部実装を変更しても業務上の契約を維持できます。

テストは単なるバグ検出の道具ではありません。
仕様変更に対して、どの振る舞いを守るべきかをコードで明示する仕組みでもあります。
Enum設計を改善するときには、実装だけでなくテストの構造も同時に見直すと効果的です。

改善後の設計を「依存方向」で確認する

最後に、リファクタリング後のコードを依存関係の観点から確認します。
理想的には、Enumやドメインモデルのような業務上の概念が、Controllerや外部APIといった具体的な実装へ依存しない状態を目指します。

たとえば次のように考えると整理しやすくなります。

  • Enum:状態や種別など、有限個の概念を表現する
  • ドメインモデル:その状態に関連する基本的な業務ルールを表現する
  • ドメインサービスやポリシー:複数の情報を横断する複雑なルールを表現する
  • アプリケーションサービス:ユースケース全体の流れを調整する
  • Controller:HTTPの入出力を処理する
  • 外部連携:メール、API、DBなど具体的なインフラを担当する

もちろん、すべてのPHPアプリケーションでこの層を厳密に分割する必要はありません。
小規模なシステムで過剰に抽象化すると、かえって理解しにくくなることもあります。
重要なのは、変更理由が異なる責務が同じコードへ密集していないかを見ることです。

実装例からも分かるように、Enumのアンチパターンを改善する本質は、Enumを別の何かへ置き換えることではありません。
具体的な状態と、それを使った業務判断を切り離し、必要な判断を適切なオブジェクトへ集約することです。

この手順を進めると、Enumケースを追加したときの影響範囲も把握しやすくなります。
「この値を使っている場所を全部直す」のではなく、「この状態に関係する業務ルールを確認する」という考え方へ変わるからです。

そして、この設計をさらに安定させるには、Enumやドメインモデルが正しく動くことを保証するテスト戦略が欠かせません。
次章では、Enum変更による回帰を防ぎ、仕様追加に対して安全にコードを育てるためのテスト方法を詳しく見ていきます。

Enum導入後も保守しやすいPHPアプリケーションにするテスト戦略

PHP Enumを使ったアプリケーションの品質と保守性を支えるテスト

PHP Enumを導入すると、状態や種別を型として明確に扱えるようになります。
しかし、Enumを使ったからといって、仕様変更による不具合まで自動的に防げるわけではありません。
むしろ、Enumのケースが増えたり、状態遷移のルールが変更されたりすると、既存コードが暗黙に持っていた前提が崩れることがあります。
そこで重要になるのが、Enumの変更と業務ルールの変更を安全に検証できるテスト戦略です。

テストを考えるとき、「Enumのすべてのケースをテストすれば十分」と捉えてしまうのは危険です。
Enumそのものが正しく定義されていることと、そのEnumを利用するアプリケーションの振る舞いが正しいことは別の問題だからです。
たとえば OrderStatus::Shipped が存在することを確認しても、「発送済みの注文をキャンセルしてはいけない」という業務ルールまで保証されたことにはなりません。

仕様変更に強いアプリケーションを目指すなら、テスト対象を「値」「ルール」「ユースケース」の三つ程度に分けて考えると整理しやすくなります。
Enumの値自体は小さく検証し、状態に応じた業務ルールをドメインモデルやポリシーで検証し、最終的な処理の流れをアプリケーションサービスや統合テストで確認する構造です。
こうすると、どのレベルで何を保証しているのかが明確になります。

Enumそのものはシンプルにテストする

まず、Enumそのものに対しては、必要以上に大量のテストを作る必要はありません。
ケースが正しく存在するか、Backed Enumなら外部値との変換が期待どおりか、そしてEnum自身に持たせた性質が正しいかを確認します。

たとえば状態Enumに「最終状態かどうか」を判定するメソッドを持たせているなら、各ケースが期待する結果になることをテストします。
ここで重要なのは、Enumの実装詳細を細かく検証することではありません。
「この状態は業務上どのような性質を持つか」という契約をテストすることです。

また、Backed Enumを利用している場合は、データベースやAPIから受け取った値を正しくEnumへ変換できることも確認します。
未知の値が入力された場合にどう扱うのかも重要です。
外部システムの仕様変更で想定外の値が届く可能性を考えるなら、例外になるのか、別のフォールバックへ進むのかを明示しておく必要があります。

このように、Enum自身のテストは比較的小さく保ちながら、値の意味と境界部分の契約を確認します。
Enumを巨大なロジックの塊にしないことと、テストを小さく維持することには強い相関があります。

状態ごとの業務ルールをドメインテストで守る

Enumを使った設計で最も重要なのは、状態に応じた業務ルールのテストです。
たとえば「PendingとPaidではキャンセルできるが、Shipped以降はできない」といったルールがあるなら、そのルールをドメインモデルやポリシー単位で検証します。

ここで意識したいのが、ControllerやHTTPリクエストを経由しなくてもテストできる状態を作ることです。
業務ルールがドメイン層へ集約されていれば、テストは入力となる状態と期待する結果に集中できます。
テストが速く、読みやすくなり、仕様変更時の影響確認もしやすくなります。

たとえば「キャンセル可能か」という判定を、画面表示、API、バッチそれぞれでテストしてしまうと、同じ仕様を重複して検証することになります。
共通する業務ルールをドメインテストで保証し、外側のテストでは「そのルールが正しく呼び出されるか」を確認するほうが、テストの役割分担として自然です。

特に重要なのは、新しいEnumケースを追加したときです。
既存のテストがすべて成功していても、新ケースがどのような意味を持つのかが検証されていなければ不十分です。
「状態を追加した」という事実だけでなく、「その状態では編集可能なのか」「キャンセルできるのか」「どの遷移が許可されるのか」まで確認する必要があります。

状態遷移をテストで明示する

状態を持つドメインでは、現在の値だけでなく状態遷移そのものも重要なテスト対象です。
たとえば Paid から Shipped への遷移は許可されるが、Pending から直接 Shipped へ進めることはできない、というルールがあるとします。
これらをテストで明示すると、Enumケースの追加や順序変更による影響を発見しやすくなります。

状態遷移をテストするときは、正常系だけでなく不正な遷移も確認します。
実務では「正しい経路」をテストするだけでは不十分です。
禁止される状態への変更が、別のControllerやバッチ経由でも起きないことを確認する必要があります。

ここでドメインモデルに状態変更処理を集約していると大きなメリットがあります。
テスト対象が一か所にまとまるため、状態遷移に関する仕様が明確になります。
逆に、複数のサービスが直接 status を変更する設計では、同じ状態遷移ルールを複数のテストスイートで確認しなければならなくなります。

Enumケース追加を想定した回帰テストを作る

Enumを利用するシステムでは、「新しいケースが追加される」という変更を前提にテストを設計すると効果的です。
たとえば、状態を処理する match や条件分岐がある場合、新しいケースが追加されたことで既存処理が意図しない動作をしないかを確認します。

テストでは「現在存在する4ケースが正しい」という確認だけで終わらせず、「5ケース目が追加されたとき、どの処理が再確認されるべきか」を意識します。
これはテストケースを無限に増やすという意味ではありません。
むしろ、仕様変更時に確認すべき境界をテストとして明示する考え方です。

たとえば「最終状態」という業務ルールがあるなら、特定のケース名を個別に列挙して判定するより、そのルールを表すメソッドやポリシーをテストするほうが変更に強い場合があります。
新しい最終状態が追加されても、業務上の意味を定義する箇所とテストを更新すれば済む構造にできるからです。

仕様変更時に失敗してほしいテストを作る

テスト戦略を考えるうえで非常に重要なのが、「何かが変わったとき、どのテストが失敗してくれるべきか」という視点です。
単にカバレッジを高めることだけを目標にすると、仕様変更に対する検知力が弱いテストが増えることがあります。

たとえば状態を一つ追加したのに、既存テストが一つも失敗しないのであれば、そのテストが新しい状態を考慮できていない可能性があります。
もちろん、意図的に後方互換な変更であるケースもあります。
しかし、業務ルールに関わるEnumなら、新しいケースによって判断が変わる可能性が高いため、適切なテストが更新される設計になっているか確認したいところです。

つまり、テストには「現在のコードを守る」だけでなく、「仕様の境界が変わったことを知らせる」という役割もあります。良いテストとは、仕様変更が起きたときに、変更すべき箇所だけが適切に壊れるテストです。

Tableではなく意味のある振る舞いをテストする

Enumを使っていると、ケースごとの入力と期待値を大量に並べたテストを書きたくなることがあります。
データセットを使ったパラメータ化テストは有効ですが、単に全ケースを機械的に流すだけでは、何を保証したいのかが見えにくくなることがあります。

たとえば Pending、Paid、Shipped、Completed それぞれに対して「結果がtrueかfalseか」だけを確認するより、「支払い前の注文はキャンセルできる」「発送後の注文はキャンセルできない」というように、テスト名や構造から業務上の意味を読み取れるようにしたほうが保守性は高くなります。

テストコードも立派な仕様の一部です。
開発者が数か月後に読み返したとき、なぜそのEnumケースがその結果になるのかを理解できることが重要です。
ケース名だけを機械的に並べるより、業務上のルールを表現するテストを中心に据えます。

統合テストではユースケース全体を確認する

ドメインテストだけでは、実際のアプリケーションの組み立てが正しいことまでは保証できません。
そこで必要になるのが、アプリケーションサービスやControllerなどを含めた統合テストです。

たとえば注文キャンセルというユースケースについて、HTTPリクエストを受け取ってからドメインモデルが状態を判定し、保存処理が実行され、必要ならイベントや通知へつながる一連の流れを確認します。
ただし、すべてを統合テストで網羅する必要はありません。
業務ルールまで含めて毎回エンドツーエンドで確認すると、テストが遅くなり、失敗原因も分かりにくくなります。

そのため、基本的には「細かいルールはユニットテスト」「コンポーネント間の接続は統合テスト」「主要な業務フローは少数のE2Eテスト」というように、目的ごとに粒度を分けます。
Enumの変更に対しても、どのテスト層が問題を検出するべきなのかを意識すると、無駄な重複を減らせます。

静的解析とテストを組み合わせる

PHPのEnumを安全に運用するには、テストだけに頼らず静的解析も組み合わせると効果的です。
PHPStanやPsalmなどの静的解析ツールを利用すると、型の不整合や到達不能なコード、想定される型との不一致などを早い段階で発見できます。

特に、Enumを引数や戻り値へ適切に利用していると、文字列の取り違えや誤った型の受け渡しを検出しやすくなります。
テストは実際に実行したケースを検証するものですが、静的解析はコード上の契約を継続的に監視します。
両者は競合するものではなく、異なる種類の問題を補完する関係です。

ただし、静的解析ですべての仕様変更を検出できるわけではありません。
「発送準備中という新状態を追加した結果、キャンセル可能と判断すべきか」という業務上の問題は、型だけでは決まりません。
ここでも、静的解析は設計の安全網の一つであり、最終的な仕様の正しさを保証するものではないと理解しておく必要があります。

カバレッジの数字だけで品質を判断しない

テスト戦略を整えるとき、コードカバレッジは参考になる指標です。
しかし、カバレッジが高ければ仕様変更に強いとは限りません。
Enumの全ケースを一度通過させたとしても、ケース間の関係や状態遷移、境界条件をテストしていなければ、重要な不具合を見逃します。

たとえば4つのEnumケースをすべて通過するテストがあっても、「PendingからShippedへ直接変更できない」という制約を一切確認していなければ、そこにバグが入っても検知できません。
重要なのは、何パーセントのコードを通ったかだけではなく、どの仕様とリスクをテストで守っているかです。

そのため、テスト計画では「Enumの各ケース」「状態遷移」「業務ルール」「外部境界」「主要ユースケース」といった観点から不足を確認するほうが実務的です。
数字は目標の一つとして使いながら、最終的には変更リスクと仕様の重要度を基準にテストを設計します。

Enumを使ったPHPアプリケーションの保守性を高めるには、Enumを導入することと同じくらい、変更を安全に受け止めるテスト構造を作ることが重要です。
Enumの定義、ドメインルール、状態遷移、ユースケース、外部境界を適切な粒度で検証すれば、新しいケースの追加や仕様変更が発生しても、どこに影響があるのかを早く把握できます。

そして、テストの目的は「すべてのコードを動かすこと」ではありません。
仕様変更によって壊れるべき場所を明確にし、壊れてはいけない振る舞いを守ることです。
Enumを使った設計では、この視点がとくに重要になります。

ここまでの設計とテストを組み合わせると、Enumは単なる便利な定数集ではなく、状態を型として表現し、業務ルールを整理し、変更の影響を追跡しやすくするための設計要素として機能します。
最後に、これまでの内容を整理しながら、PHP Enumのアンチパターンを避け、仕様変更に強いアプリケーションを作るために押さえておきたいポイントをまとめます。

PHP Enumのアンチパターンを避けて仕様変更に強い設計を実現するまとめ

PHP Enumを適切に活用して仕様変更に強いアプリを目指すまとめ

PHP Enumは、状態や種別などの有限個の選択肢を型として表現できるため、従来の文字列や整数による値管理と比べて、コードの意図を明確にしやすい機能です。値の取り得る範囲を明示でき、IDEの補完や静的解析も活用できるため、型安全性と可読性の向上に大きく役立ちます。ただし、ここまで見てきたように、Enumを導入するだけでは仕様変更に強い設計にはなりません。

むしろ注意すべきなのは、Enumの便利さを理由に責務を集中させすぎたり、その値をアプリケーションの各所から直接参照したりすることです。
Enum自体はシンプルでも、利用側に条件分岐が分散すれば、業務ルールは複数箇所へ複製されます。
新しいケースを一つ追加するだけで、Controller、Service、バッチ、通知処理などを横断して修正しなければならない。
こうした状態では、型としての安全性が高くても、変更コストは高いままです。

今回のテーマで最も重要なのは、「Enumを使うべきかどうか」ではなく、Enumに何を表現させ、どこまで責務を持たせるのかという設計判断です。
Enumには状態や種別などの安定した概念を表現させ、その状態そのものから導ける性質を適切に閉じ込めます。
一方で、外部APIへの通知、メール送信、データベースアクセス、複数の情報をまたぐ複雑な業務判断などは、Enumから切り離して別の責務へ委ねます。

たとえば注文状態を表すEnumがある場合、「発送済み」という事実を表現するのはEnumの役割です。
しかし、「発送済みなら顧客へメールを送信する」という処理までEnumへ持たせると、状態定義と通知基盤が強く結び付きます。
将来、メールをプッシュ通知へ変更したり、外部配送サービスを差し替えたりすると、本来変更する必要のなかったEnumまで修正対象になります。
異なる理由で変わるものを、同じ責務へ集約しないことが保守性を高める基本です。

また、Enumの値を直接比較する処理が各所に散らばっている場合は、その判定が本当に利用側の責務なのかを見直します。
「Pendingならキャンセル可能」のような具体条件をControllerが知る必要があるでしょうか。
多くの場合、Controllerが必要としているのは「この注文はキャンセル可能か」という業務上の意味です。
具体的なEnumケースの解釈をドメインモデルやポリシーへ集約すれば、呼び出し側は実装詳細を知らずに済みます。

ここで重要なのが、状態と業務ルールを分けて考えることです。
「注文が発送済みである」は状態ですが、「発送済みなら編集できない」はルールです。
状態の定義と、その状態に対する判断は必ずしも同じ責務ではありません。
この区別ができると、Enumは状態の表現に集中し、ドメインモデルやドメインサービスは状態を使った業務上の振る舞いに集中できます。
結果として、仕様変更時にどこを直すべきなのかが分かりやすくなります。

そして、仕様変更に強い設計を考えるなら、現在のコードがきれいかどうかだけではなく、「何が変わったときに、どのコードが変更されるのか」を確認する必要があります。
状態の追加、状態遷移の変更、権限条件の変更、通知方法の変更、画面表示の変更。
これらが別々の理由で起こるのであれば、それぞれの責務も分離されているほうが自然です。
変更理由を軸にコードを配置することで、不要な影響の伝播を防げます。

Enumの利用判断そのものにも基準があります。
その値が有限個の選択肢として定義できるのか、コード変更によって管理されるべきものなのか、ドメイン上の明確な意味を持つのか。
この条件に当てはまるほどEnumとの相性はよくなります。
反対に、管理者が自由に追加できるカテゴリや、ユーザーが任意に入力するデータのように、運用で頻繁に変化するものをEnumへ固定すると、将来の変更時にコード修正とデプロイが必要になります。

さらに、外部システムの値を扱う場合には、外部の表現と自分たちのドメイン上の意味を混同しないことが重要です。
APIが返す文字列やコードをそのままアプリケーション全体へ流すのではなく、適切な境界でEnumなどの内部表現へ変換します。
これにより、外部仕様と内部の業務ルールを切り離しやすくなります。
Enumは単なる定数集ではなく、異なるモデルの境界を整理する道具としても利用できます。

実装面では、既存コードをいきなり全面的に作り替える必要はありません。
まずEnumケースの直接参照箇所を検索し、どの用途で使われているのかを分類します。
表示、永続化、業務判定、外部連携などに分けるだけでも、責務の混在箇所が見えてきます。
そのうえで、複数箇所に重複している業務ルールを一つずつ抽出し、ドメインモデルやサービスへ集約していけば、段階的に改善できます。

ただし、リファクタリングの目的を「ifやmatchをなくすこと」に設定してはいけません。条件分岐が一つ残っていても、それが明確な業務ルールを表現し、適切な責務へ集約されているなら問題ありません。逆に、分岐をEnumから別クラスへ移しただけで、異なる業務判断が一か所へ詰め込まれているなら、問題の場所が変わっただけです。重要なのは分岐の数ではなく、判断の責務が一貫していることです。

状態遷移についても同じ考え方が使えます。
Enumの値を直接書き換えるだけの設計では、どこからでも不正な状態へ変更できる可能性があります。
そのため、「発送済みに変更する」という技術的な操作よりも、「発送を確定する」「注文をキャンセルする」といった業務上の操作として状態変更を表現するほうが、ルールを閉じ込めやすくなります。
状態そのものと、状態をどう変化させるかを分離して考えることで、将来の仕様変更にも対応しやすくなります。

そして、この設計を長期的に維持するためにはテストが欠かせません。
Enumそのものについては、ケースや変換処理など必要な部分を小さく検証します。
そのうえで、キャンセル可否や状態遷移などの業務ルールをドメインテストで確認し、アプリケーションサービスやControllerではユースケース全体の接続を確認します。
テストを役割ごとに分けることで、Enumのケース追加やルール変更が発生したとき、どの部分を見直せばよいのかを把握しやすくなります。

特に意識したいのは、「仕様変更時に、失敗してほしいテストが失敗するか」という視点です。
カバレッジが高いことだけでは、設計の安全性は保証できません。
新しいEnumケースが追加されたときに、状態遷移の制約や業務ルールを適切に再確認できるテストが存在するか。
そこが重要です。
テストは実装の検査だけでなく、将来も守るべき仕様をコードとして固定するための仕組みでもあります。

ここまでの内容を整理すると、PHP Enumを仕様変更に強く使うための考え方は、それほど複雑ではありません。

  • Enumは有限個の状態や種別を明確な型として表現する
  • Enum自身の意味から直接導ける性質は、必要に応じてEnumへ持たせる
  • 複雑な業務ルールや外部依存は、ドメインモデルやサービスへ分離する
  • Enumの具体的な値による判断をアプリ全体へ拡散させない
  • 状態遷移を意味のあるドメイン操作として扱う
  • Enumケースの追加や仕様変更を想定してテストと静的解析を整える

この原則を押さえておけば、「Enumを使ったのにコードが変更しづらくなった」という状況をかなり避けられます。
大切なのは、Enumを高機能な万能オブジェクトへ育てることではありません。
むしろ、安定した概念としてEnumを小さく保ち、その周囲に必要な振る舞いを適切に配置することです。

ソフトウェアは、現在の要件を動かすだけなら比較的簡単です。
本当に難しいのは、半年後、1年後に要件が変わったとき、それでも安全に修正できる構造を維持することです。
Enumはそのための銀の弾丸ではありません。
しかし、状態を型として整理し、責務と依存関係を意識して設計すれば、変更容易性を高める強力な部品になります。

「このEnumに処理を追加しても大丈夫か」「この値をControllerから直接比較してよいか」「新しいケースが増えたら、どこを修正することになるか」
こうした問いを普段の設計レビューやコードレビューで持つだけでも、アンチパターンは早期に発見できます。
PHP Enumを便利な文法機能としてだけ見るのではなく、ドメインを型として表現し、変更の境界を設計するための道具として扱うこと。
それが、仕様変更に強いPHPアプリケーションへ近づくための本質です。

コメント

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