Dove si inserisce Zend_Form nel paradigma Controller vista modello

Question

Il numero Zend Framework è principalmente destinato all'utilizzo MVC. Uno dei componenti molto utili è Zend_Form.

Ho un po 'di problemi a trovare il posto di Zend_Form. Fa parte della vista, modello o controllore e quali responsabilità dovrei darlo.

Il fatto è che Zend_Form fa due cose: decorare e rendere il modulo e convalidarlo. Il primo è un compito di visualizzazione reale, il secondo un compito modello reale.

Ora l'uso più comune sembra essere quello di avere le forme interagiscono con il controller solo, mettendo efficacemente entrambe le attività (rendering e convalida) alla vista/controller.

Un'altra opzione fornita da Matthew Weier O'Phinney consiste nell'associare il modulo al modello e aggiungere le opzioni di visualizzazione successive nel controller.

Quindi, sto dubitando. Dove nel pattern MVC dovrei posizionare Zend_Form e come dovrei usarlo?

Modifica Buone risposte finora, grazie! Assegnerò il premio una o due ore prima che scada, quindi per favore dai una risposta se hai altri pensieri!

Answer 1

Zend_Form può essere visualizzato in diversi punti. Non può essere considerato affatto come parte di un solo strato di pattern MVC.

Prima di tutto Zend_Form utilizza i decoratori e visualizza gli helper per rendere il modulo, a questo punto fa parte del livello di vista. Quindi, Zend_Form fa parte del lavoro di modello che filtra e convalida il contenuto.

Sappiamo che il livello Controller esegue il rendering dell'input dalla vista e lo passa al modello. In realtà, il livello del controller decide quale risorsa caricare dal livello del modello e quindi esegue le chiamate corregge.

Quando si chiama Zend_Form dal livello controller, è possibile considerare che si sta chiamando una risorsa modello per eseguire le azioni di valutazione e filtraggio e decidere se questo è un input valido. Per esempio:

public function newAction() 
{ 
    $form = $this->getForm(); 

    if($this->getRequest()->isPost()) 
    { 
     $formData = $this->_request->getPost(); 

     if($form->isValid($formData)) 
     { 
      $Model = $this->getModel(); 
      $id = $Model->insert($form->getValues()); 
     } 
    } 

    $this->view->form = $form; 
} 

Tie forme al modello può essere considerato un buon pratice perché quando si esegue azioni di filtraggio e di convalida si è in livello di modello.Così, come Matthew proposto:

class Model_DbTable_Users extends Zend_Db_Table 
{ 
    protected $_name = 'users'; 
    protected $_form; 

    public function getForm() 
    { 
     if(!$this->_form) 
      $this->_form = new Form_User(); 
     return $this->_form; 
    } 

    public function add($data) 
    { 
     $form = $this->getForm(); 
     if(!$form->isValid($data)) return false; 

     if($form->getValue('id')) 
     { 
      $id = (int) $form->getValue('id'); 
      $this->update($form->getValues(), 'id =' . $id); 
     } 
     else 
     { 
      $id = $this->insert($form->getValues()); 
     } 
     return $id; 
    } 
} 

Dalla struttura di directory standard possiamo vedere che forme non sono nella cartella del modello né nella cartella vista perché Zend_Form è una classe specifica che legano molte risorse e strati insieme. Se controlli il post di Matthews ti renderai conto che questo è esattamente ciò che viene detto quando l'URL azione è impostato sullo script di visualizzazione e il modulo è legato al modello.

Infine, è possibile analizzare il contesto e prendere uno di questi due approcci.

Attualmente, la mia scelta è quella di legare i moduli ai modelli. Sembra bello! E ha molto senso per me.

Answer 2

Zend_Form spesso si sente come l'uomo dispari. Penso che il chilometraggio di ognuno varia.

Ultimamente, la maggior parte delle mie interfacce amministrative sono state molto drag + drop AJAX-y, e richiedono una buona dose di html e javascript - gli elementi dei moduli reali sono scarsi. Così ho scelto di astenermi da molte delle funzionalità di Zend_Form e usarlo come un fantastico assistente di visualizzazione con filtri. Tutta la mia convalida viene eseguita su un livello separato nel modello.

Penso che l'idea di O'Phinney abbia molto senso. Qui, sceglie di pensare al modulo quasi come componente dell'oggetto dominio, dove può aggiungere la logica aziendale. Questo suona bene, purché tu stia attento a mantenere tutte le logiche di visualizzazione per il modulo separato. Come nota, si tratta di dare un senso semantico. Non c'è necessariamente una regola dura e veloce.

Answer 3

IMO, Zend_Form è progettato per indossare cappelli multipli. È, infatti, un ponte tra la vista e il modello con un raggio di supporto gigante dal controller.

Invece di assegnare un modulo a un modello, considerare l'assegnazione di modelli a un modulo.

Nel livello Modello, è possibile avere un metodo getFormInputs in grado di restituire gli elementi necessari per immettere i dati. Il modello non si cura di quale forma lo userà, lo rende semplicemente disponibile a chiunque ne voglia.

Ora nel livello modulo, creare un metodo setupInputs che eseguirà il ciclo su una serie di modelli per acquisire tutti gli input. Se c'era un solo modello, aggiungere gli input al modulo. Se esisteva più di un modello, crea forme secondarie.

Il controller avvierà il modulo e restituirà i valori al modello (vedere il nuovo metodo ActionAzione di Keyne)