[MVC] Parere su classe "istanziatrice".

[wartpro]

Vi siete mai serviti di una "classe includitrice" (che include in ordine N files che vi servono) e, all'interno di questa, una "classe instanziatrice" (che ritorna un'array con chiavi $nomeClasse => $istanzaDiStaClasse) che poi può essere utilizzata direttamente per fare varie cose?

Mi piacerebbe ricevere pareri a riguardo.

----------------------------------------------------------------------------------------

Nel frattempo si assuma una directory structure di base di questo tipo:

index.php
/site/model/ ...
/site/view/ ...
/site/controller/ ...
/site/boot/ ...



Prototipo "classe includitrice" di file necessari, passati sottoforma di valori in array, nell'ordine in cui vanno inclusi.

<?php

class BootFileIncluder
{
   private $_classPackage = array();

   public function __construct(array $files) {

      foreach($files as $filetype => $file) {

         if (file_exists(SERVER_ROOT . DS . "site" . DS . $filetype . DS . $file . '.php') 
             && is_readable(SERVER_ROOT . DS . "site" . DS . $filetype . DS . $file . '.php')
         ) {

            include '/site/' . $filetype . '/' . $file . '.php';

            if($filetype == 'view') { // Skip files from /view folder
               continue;
            }
            $this->_classPackage[] = $filetype . $file;
          } else {

            die('<h2>Errore nel BootFileIncluder</h2>File [b]' . $filetype . '.' . $file . '.php[/b] non trovato');
          }
      }
   }

   public function getClassPackage() {

      include_once '/site/boot/BootClassInstantiator.php';
      $boot = new BootClassInstantiator($this->_classPackage);
      $classArray = $boot->getInstances();
      return $classArray;
   }
}

Esempio "classe istanziatrice", la quale riceve i dati dalla classe precedente, nell'ordine prestabilito.

<?php

class BootClassInstantiator {

   private $_instances = array();

   public function __construct(array $classPackage) {

      foreach($classPackage as $class) {

         $this->_instances[$class] = new $class;
      }
   }

   public function getInstances() {
      return $this->_instances;
   }

}

E file index.php , entry point

<?php

 define('SERVER_ROOT', __DIR__ );
 define('DS', DIRECTORY_SEPARATOR);
 define('WEB_ROOT' , 'http://127.0.0.1:8080/framework/'); 
 
 include_once SERVER_ROOT . '\site\boot\BootFileIncluder.php';
 
 $home = array(
  'model'      => 'Home',
  'controller' => 'Home',
  'view'       => 'Home',
 );

 $classPack = new BootFileIncluder($home);
 
 $arr = array();
 $arr = $classPack->getClassPackage();

 // Modo 1: usare notazione array
 $arr['modelHome']->test(); 

 /**
  * Modo 2
  *
  * Estrazione, per evitare di digitare $arr['modelHome'] che 
  * puo' essere ostico da leggere/scrivere
  */

 extract($arr);
 $modelHome->test();

E per finire, le classi controller e model si chiameranno rispettivamente "controllerHome" e "modelHome" per mantenere coerenza nella naming convention.


L'avete mai usato?
Se si ma avete cambiato rotta, perchè?
Consigli, pareri, riflessioni a riguardo?


Grazie in anticipo.

[Santino83_02]

hum

mi rispiegheresti a parole tue a che servono quelle due classi? Visto che normalmente l'MVC viene implementato con un Front Controller (per semplificare, la tua index.php) tu dovresti seguire, o cmq prendere spunto, più che altro questo di pattern:

http://java.sun.com/blueprints/corej...ontroller.html

Anche se in php viene un pò diversa la cosa (o almeno io l'ho sempre visto implementato diversamente in un punto):
index.php (front controller) istanzia una classe (che per comodità possiamo chiamare FrontController/App/Dispatcher, come ti pare) la quale si deve preoccupare solamente di istanziare il giusto controller a seconda dei parametri richiesti e quindi delegare l'elaborazione della richiesta al controller. Il controller a sua volta elaborerà la richiesta e passerà l'output alla classe per la gestione dell'output che metterà insieme i vari templare etc e genererà l'output.

istanziare in un colpo solo tutte le classi sopra citate come fai te è, ihmo, inutile, dispendioso, e soprattutto riduttivo. 3 esempi:

1) nel tuo codice non c'è niente che permetta di mappare i controllers ad altre url diverse dal formato "scelto" (normalmente è una url del tipo: domain.ext/plugin/controller/method/params, nel tuo esempio non si poterbbe per esempio mappare domain.ext/pippo al controller pluto del plugin foo);

2) instanzi classi che potrebbero non servirti (ad esempio non è detto che ti serva la view del controller home metodo home)

3) Un controller può dover usare più models o dover scegliere dinamicamente la view da utilizzare

Etc che ci sarebbe pure altro. Se vuoi essere sicuro di istanziare una classe una volta sola, la usi in singleton attraverso una factory che ti dia l'istanza che ti serve, ma nel caso specifico non ne vedo molto l'utilità.

[wartpro]

Si si no infatti è solo una riflessione.

Dunque la prima classe illustrata si occupa di includere tutti i file necessari per una data pagina. In questo caso index.php. EDIT: in un ordine preciso.

La seconda invece è quella su cui punto la riflessione ed è quella che, sembre seguendo una determinata naming convention e struttura directory precisa, istanzia le classi che servono e ne ritorna un array di istanze appunto, "nominate".

In questo caso vengono prese solo due classi (la view non è una classe in questo caso), il controllerHome e il modelHome (ordine al contrario: modelHome -> controllerHome).

E poi vabè, per evitare che si digiti la notazione "arrayana" (italianizzazioni.. ) le trasformo con extract.

Sto facendo degli esperimenti e ogni punto di vista è buono per farmi riflettere.

Però sento che mi potrebbe essere comodo un "bootstrapper" generale. Non so. E si, il fattore singleton l'ho pensato pure io...magari all'interno di sto bootstrapper stesso. Boh.

[Santino83_02]

Cavolo avevo scritto un tema ma poi ho per errore chiuso il browser.. uff

vabbeh sintetizzo

Il bootstrapper dovrebbe solo occuparsi di configurare l'ambiente in cui girerà il resto dell'applicazione. Tale configurazione normalmente, visto anche il contesto web e l'uso del php, si limita alla definizione di alcune costanti (path e simili) e all'installazione di un autoloader per permettere di poter instanziare le varie classi del sistema senza stare, sostanzialmente, a perder tempo con include/path relative e assolute etc etc e poter fare new MyClass sapendo che l'autoloader la troverà e quant'altro.

Dopo che l'ambiente è configurato, instanzi il front controller che si preoccuperà di gestire la richiesta instanziando gli altri controller e quant'altro...

Usare il bootstrapper per instanziare "tutte le classi di cui avrai bisogno" è sbagliato, anche perché non è il suo compito...

Definito un autoloader, instanziare le classi, o meglio includere le classi, non è più un tuo problema perché l'hai già risolto. Già dire che il controller lo instanzio come singleton mi viene da chiederti "perché?", anche per le classi model e view lo stesso. Comunque per i singleton poi puoi usare una factory apposta per fare queste operazioni (che ovviamente non può essere il bootstrapper ) etc e procedi con il resto.

Scusa discorso sconclusionato, ma vado di corsa

PS: tra arr['key'] e l'extract e poi $key, preferisco la prima notazione...