SRP applicata ad un esempio di flusso: come strutturare le classi in modo ragionevole

Question

Ho un problema con decidere sulle responsabilità di classe.
Ho 3 html forme:

1. Per ogni modulo c'è un modello HTML che contiene un testo e un marcatore per la forma da inserire
2. Ogni modulo deve essere convalidato, se si verifica un errore il modello e la forma da (1) deve nuovamente visualizzata, insieme ad alcuni messaggi di errore. Solo alcuni campi sono comuni tra le diverse forme.
3. Se non ci sono errori di un messaggio di risultato deve essere inviato. Per ogni modulo c'è un modello di risultato di posta elettronica.

Trovo molto difficile decidere su un buon sistema di classe per questo problema. Una possibilità è quella di classi separandoli con funzionalità

• CheckFormData: la verifica dei dati dei moduli
• DisplayForm: modulo con display / senza errori (? O separare questo troppo)
• EmailForm:. Emailform

Sono incerto su questo. La conoscenza dei campi di una forma particolare sono dispersi attraversato le varie classi.

C'è un po 'il flusso di lavoro. Forse dovrei anche avere una classe flusso di lavoro:

class FormSubmitWorkFlow
{
   function start() 
   {
     $this->displayForm->render();
   }

   function processFormData($data)
   {
      $this->checkForm->setData($data);
      if (!$this->checkForm->isValid())    {

         $errors = $this->checkForm->getErrors();
         $this->displayForm->setData($data)->setErrors($errors)->render();
      } else {
         $this->emailForm->setData($data)->email();
      }
   }

   function setDisplayForm(DisplayForm $df)
   {
      $this->displayForm = $df;
   }

   function setCheckForm(CheckForm $cf)
   {
      $this->checkForm = $cf;
   }

   function setEmailForm(CheckForm $ef)
   {
      $this->emailForm = $ef;
   }
}

Per ogni tipo di forma (ricordate, ci sono 3 di loro) avrei bisogno di un

1. CheckForm,
2. EmailForm e
3. class DisplayForm.

3 * 3 = 9 classi + 3 classi di base = 12 classi.
Inoltre, si vuole iniettare il diritto checkForm-sottoclasse e EmailForm-sottoclasse nel flusso di lavoro, tutti hanno bisogno di essere dello stesso tipo di modulo. Forse abbiamo bisogno di creare una FormWorkFlowFactory per questo. Questo aggiunge fino a 13 le classi.

Ora ho avuto la sensazione che sto facendo qualcosa di terribilmente sbagliato. Se avessi FormSubmitWorkFlow come classe Template Method, ho potuto solo creare 3 sottoclassi, ma ogni sottoclasse sarebbe mescolare diverse responsabilità.

Come si potrebbe migliorare questo, e potrebbe motivare la tua risposta, vale a dire quale metodo si porta alla tua risposta?

---

modifica : anche se l'unica risposta corrente è utile, sarebbe bello vedere qualche voto da parte di persone che sono d'accordo con esso, o mi piacerebbe sentire migliori soluzioni da parte della comunità. Io sono l'unico che upvoted questa risposta. Questa domanda potrebbe usare più di ingresso, quindi sentitevi liberi di fornire in modo da: -)

Answer 1

Non sono sicuro se questo sarà rispondere alla tua domanda o no, ma ovviamente l'obiettivo di SRP è quello di scrivere il codice in modo che se si deve cambiare qualcosa, è per un solo motivo. Come se la vostra macchina ha avuto SRP allora non ci sarebbe una classe che regolata la temperatura e anche mettere le finestre su e giù. Che violerebbero il principio. In questo caso, ti sembra di essere facendo bene. Sì, è un sacco di classi, ma l'alternativa è un sacco di confusione. A meno che non ci fosse un modo che si potrebbe creare una sola classe che avrebbe convalidare le forme (che in realtà dovrebbe essere possibile a seconda che tipo di verifica è necessario).

Se è stato creato un corso di verifica in cui si può solo aggiungere una catena di valori attesi e vedere se abbinato poi si sarebbe probabilmente avere classi più generale, ma penso che sarebbe stato molto meno accoppiato. Fatemi sapere se ho capito bene o no.