MVC: Costruiamo il nostro piccolo framewok (parte -1)

04 May 2019 | M.A.D.R.

Creare un nostro framework per lo sviluppo veloce di applicazioni con l’uso delle nostre logiche.

Salve a tutti oggi iniziamo a parlare di come strutturare una progettino che faccia da strato di comunicazione tra il server e l’applicazione senza dover ricorrere alla creazione di 10000 file per la risoluzione di problematiche comuni.

Come potrete immaginare, l’utilizzo di framework più o meno conosciuti ha lo svantaggio di applicare le logiche di comunicazione di che effettivamente ha contribuito allo sviluppo dello stesso, anche se le linee guida sono sempre le stesse non sempre l’uso di questi risulta facile ed immediato.

Parliamo della teoria, non pensiamo di costruire il nostro piccolo sistema durante lo sviluppo di un sito web, ma bensì dobbiamo prenderci un pò di tempo, credo che con uno studio approfondito dell’argomento una 10ina di giorni potrebbero bastare per mettere su un sistemino base che svolga le operazioni più comuni in totale autonomia.

Prima di tutto vi segnalo alcuni articoli che spiegano come svolgono il loro lavoro i Controller, Model e View:

Vista la prima infarinatura, possiamo iniziare stilando la lista della spesa:

  1. Configurazione
    1. Applicazione
    2. Route
    3. Database
    4. File
    5. …..etc…
  2. Router
  3. Librerie di Sistema
  4. Helper estesi su tutta l’applicazione
  5. Librerie personali
  6. Controller
  7. Model
  8. View

Visto un pò l’occorrente andiamo ad analizzare il punto

1. Per configurazione s’intende tutte le variabile che servono per inizializzare la nostra applicazione.

Naturalmente l’uso di uno o più file è a discrezione di chi crea materialmente l’applicazione; consiglio sempre di separare quanto più possibile i file per una lettura più facile.

Quindi i nostri file di configurazione andranno a definire quali sono i parametri iniziali della nostra applicazione.

Vediamo brevemente l’esempio di un file:

/**
 * Created by PhPS.
 * User: Marco Arena Di R.
 * Date: 25/04/2018
 * Time: 08:02
 */

/**
 * Nome Applicazione
 */
$config['app']['name']='DEMO MIC FRAMEWORK';
/**
 * File principale
 */
$config['app']['index']='index.php';
/**
 * Parametro in get per instanziare una nuova classe
 */
$config['app']['c_request']='request';
/**
 * Parametro in get per instaziare un metodo della classe
 */
$config['app']['f_request']='fire';
/**
 * Url Rewrite
 */
$config['app']['rewrite']=TRUE;
/**
 * Autoload vendor
 */
$config['app']['autoload']=TRUE;
/**
 * Path di log
 */
$config['app']['log']='app_log';
$config['app']['log_path']='/application/logs/';

Questo è l’esempio del file config.php, nel quale andremo ad indicare le nostre preferenze; in totale nel MicFramework esistono 5 file di configurazione e sono:

  • Config
  • DB
  • Cache
  • Routes
  • Templates

che rispettivamente hanno le configurazioni base per inizializzare la nostra applicazione, quindi in basso più o meno l’organizzazione delle nostre directory:

Come potete notare l’alberatura del nostro framework è semplicemente divisa in directory abbastanza comprensibili, quindi non dovremo più andare alla ricerca di un file all’interno della nostra applicazione, ma basterà capire quale classe/funzione stiamo chiamando per capire al volo il file incriminato.

Ma vediamo il cuore dell’applicazione stessa, il file è il MicFramework, il quale recupera ed instanzia dinamicamente le classi con i metodi adeguati passati.

Il nostro costruttore:

public function __construct() {
		$parameter=
			[
				'host'=>self::$config['db']['host_database'],
				'user'=>self::$config['db']['username'],
				'pass'=>self::$config['db']['password'],
				'db_name'=>self::$config['db']['database_name']
			];
		$this->conn=new Custom_QueryBuilder($parameter);
		if(self::$config['app']['autoload']){
			include_once(APPPATH.'/vendor/autoload.php');
			$this->load_smarty();
			$this->load_guzzle();
			$this->log=new Logger(self::$config['app']['log']);
			$stream=new StreamHandler(APPPATH.self::$config['app']['log_path'].date('d-m-Y',time()).'.log', Logger::DEBUG);
			$this->log->pushHandler($stream);
			Registry::addLogger($this->log, self::$config['app']['log']);
			ErrorHandler::register($this->log);
		}
	}

Ho omesso di dire che sono stati implementati:

  1. Un sistema di “Template" – > Smarty
  2. Un “Log" – > Monolog
  3. Un sistema di “Richieste" -> Guzzle

In questo trace abbiamo necessità anche di richiamare un file che riesca a gestire tutte le richieste, che indubbiamente è il nostro file “index.php" che riporta solo ed esclusivamente 2 righe di codice:

A questo punto il nostro piccolo framework “MicFramework" inizia a prendere forma, non resta che andare a prelevare le nostre famose classi scritte in precedenza, naturalmente integrabili senza alcuna difficoltà per abilitare la connessione al DB, l’esportazione dei dati etc…

Leggi anche:

Nel prossimo articolo andremo ad analizzare la nostra cartella helper con relative funzioni.

Soluzioni complete per ogni esigenza