In che misura separo il codice del modello dal codice del controllore durante la scrittura di MVC?

Ho un codice in cui Controller dipende da Model , e nel mio caso Model agisce come un oggetto di accesso al database.

use FQDN\Model;

class Controller
{
    /** @var FQDN\Model */
    private $model;

    function setModel(Model $model)
    {
        $this->model = $model;
    }

    function showPage()
    {
        // model is set up (injected) in constructor
        $data = $this->model->getData();
        return ViewModel($data);
    }
}

Inizialmente, nelle precedenti iterazioni di codice, il mio Model NON è stato iniettato nel mio Controller e mi è stato detto che non dovevo solo iniettare Model come ho fatto sopra, ma fare inversione di controllo al punto dove Controller non dipende affatto da Model . Mi piace così:

class Controller
{       
    /** @var array */
    private $data; //controller-specific data

    function setData(array $data)
    {
        $this->data = $data;
    }

    function showPage()
    {
        // data has already been injected into controller
        // Controller has been created via Factory Method
        // and populated with data
        return ViewModel($this->data);
    }
}

Il controller NON è a conoscenza del modello. Model è al di fuori di Controller interamente. ControllerFactory (o ControllerBuilder ) sarà invece:

• crea il controller
• invoca Model
• popola il controller con dati specifici del controllore

Volevo chiederti se c'è una linea guida chiara per MVC che dovrei seguire per avere Controller in base al modello, o per farlo in modo specifico NON a seconda del modello. Perché anche con l'iniezione delle dipendenze, il mio primo esempio di codice ha ancora costrutti di codice all'interno di Controller che lo rendono consapevole del modello e quindi dipendente da esso. Io non lo so

Gradi di separazione

Se sarà possibile definire alcuni gradi di separazione dall'accoppiamento più stretto a quello più lento:

• Il modello viene istanziato all'interno del Controller (cablato)
• Il modello viene iniettato all'interno del Controller tramite un costruttore o un setter (iniettato)
• Il modello viene istanziato all'interno di ControllerFactory, i dati estratti dal modello e trasferiti nel controller (separati)

Tutti "funzioneranno", ma ciò che può aiutarmi a decidere quale sia il migliore per quel particolare caso. O c'è una linea guida chiara per questo?