CodeIgniter: configurazione iniziale e pattern MVC

Ho da poco tempo iniziato ad utilizzare il framework php CodeIgniter e dalle prime prove devo ammettere che la sua facilità di utilizzo rispetto ad altri framework mi ha positivamente sorpreso.

Purtroppo, in lingua italiana non si trovano molti tutorial che spiegano come utilizzarlo e muovere i primi passi con tale framework e le poche guide presenti sono piuttosto datate.

Per questo motivo mi accingo ad iniziare una serie di articoli dedicati all'utilizzo di CodeIgniter.

Iniziamo con la banalissima istallazione. Andate alla pagina di download del framework e scaricate l'ultima verisone diponibile. Scompattate il contenuto della cartella compressa.

Troveremo tre cartelle: system, application ed user_guide.

La cartella user_guide non contiene altro che una serie di file .html che illustrano la guida all'utilizzo del framework e, ovviamente, questi non costituisco file ricompresi nel framework vero e proprio. Pertando a fini operativi questa cartella potrà essere tranquillamente eliminata.

La User guide è la  documentazione del framework, poco prolissa ma piuttosto chiara e corredata da semplici esempi, ed è consultabile anche on line.

Le due catelle system e application dovranno essere collocate nella document root (oppure nella sottocartella nella quale andremo a sviluppare il nostro applicativo). A questo punto puntando su di essa ci dovrà comparira la pagina di benevenuto (welcome).

Configurazione

Tutti i file di configurazione di CodeIgniter sono contenuti nella cartella /application/config/.

Vi sono diversi file e in ognuno di essi sono presenti diversi parametri di configurazione (sotto forma di array) che sarà possibile impostare. Alcuni di questi li illustrerò man mano che ve ne sarà la necessità.

Tuttavia, per iniziare a lavorare con CodeIgniter vi sarà sufficiente eseguire solo alcuni minimali settaggi.

Impostare l'URL della hompage

All'interno del file /application/config/config.php impostare l'url della home page dell'applicativo che andremo a sviluppare. Lavorando in locale io ho impostato http://localhost/ (che è il valore preimpostato quando lo andrete a scaricare) altrimenti dovremo impostare l'URL del nostro dominio:

$config['base_url'] = 'http://localhost/';

Se invece decidete di realizzare il vostro applicativo con CodeIgniter in una sottocartella del vostro sito web impostarete come segue:

$config['base_url'] = 'http://localhost/sottocartella/';

Impostare i parametri di connessione al database

Essendo che quasi sicuramente dovremo interagire con una base dati dovremo impostare i parametri di connessione ad essa. Tale impostazione è presente nel file /application/config/database.php.

Sono presenti diversi parametri (alcuni dei quali anche io al momento non ne conosco lo scopo) ma ai nostri fini, ovvero interagire con un database MySql, sarà sufficiente impostare i seguenti:

$db['default']['hostname'] = 'localhost';
$db['default']['username'] = 'root';
$db['default']['password'] = '';
$db['default']['database'] = 'codeigniter';
$db['default']['dbdriver'] = 'mysql';

Il paradigma MVC

Dalla pagina di welcome è possibile leggere da essa che:

Se si desidera modificare questa pagina la troverete in:

application/views/ welcome_message.php

Il controller corrispondente per questa pagina è disponibile in:

application/controllers/welcome.php

Vediamo cosa significa tutto ciò.

CodeIgniter è un framework che rispetta il paradigma MVC, acronimo di Model-View-Controller: questo, come vedremo pocanzi, costituisce una struttura ordinata di progettazione del nostro applicativo.

Iniziare a lavorare rispettanto il pattern MVC inizialmente può disorientare ma, vi assicuro, col tempo imparerete ad apprezzarlo. Infatti, il codice che andremo a scrivere risulterà essere maggiormente ordinato e manutenibile dato che andemo a separare rigidamente tre aspetti:

• la gestione dei dati che sarà affidata ai model;
• la gestione delle richieste provenienti dall'utente che sarà affidata ai controller;
• la gestione dell'interfaccia grafica che sarà affidata alle view.

Se avete capito poco o nulla del pattern MVC non spaventatevi, anzi è del tutto normale. Ma con un banalissimo esempio mostreremo in che modo si coordinano queste tre componenti e sarà tutto più chiaro.

Model: gestore dei dati

Ogni model si occupa di gestire i dati riguardanti un certo oggetto o caratteristica.

Ad esempio, poniamo di voler creare un model per gestire alcune informazioni della nostra azienda e che gestirà tre dati: il nome dell'azienda, il numero di telefono e gli indirizzi email.

Nel creare un model dovremo rispettare quattro semplici regole:

1. dovranno essere tutti extends CI_Model (CI sta per Code Igniter).
2. la prima lettera del nome della classe dovà essere maiuscola e la restante parte minuscolo;
3. il nome del file che contiene il modello dovrà avere lo stesso nome della classe ma tutto minuscolo.
4. dovranno essere collocati all'interno della cartella /application/models/.

Quindi, il nostro model lo chiameremo, ad esempio "Info_azienda_model", e sarà collocato al seguente percorso /application/models/info_azienda_model.php.

Vediamo come si articolerà questo semplificissimo model:

<?php
/*
meccanismo adottato da CodeIgniter 
per evitare gli accessi diretti al file
*/
if ( ! defined('BASEPATH')) exit('No direct script access allowed');

Class Info_azienda_model extends CI_Model{
	private $nome = 'Miniscript Spa';
	private $telefono = '00 11223344';
	private $email = array(
				'DirettoreVendite' => 'vendite@email.it',
				'DirettoreAquisti' => 'aquisti@email.it'
				);

	public function GetNome(){
		return $this->nome;
		}

	public function GetTelefono(){
		return $this->telefono;
		}
	
	public function GetEmail($settore_aziendale){
		switch($settore_aziendale){
			case 'acquisti': 
				return $this->email['DirettoreAquisti'];
				break;
			case 'vendite': 
				return $this->email['DirettoreVendite'];
				break;
			default:
				return null;
				break;
			}
		}
	}

Si tratta di una classe semplicissima (fin troppo): tre proprietà private ($nome, $telefono, $email) che rappresentano in questo caso i dati da "gestire" e tre metodi (GetNome, GetTelefono, GetEmail) per ottenere i valori di queste proprietà.

Ovviamente questo model ha scopo prettamente didattico e, generalmente, i model hanno metodi che si interfacciano con un database. In qul caso "gestire" assumerà varie declinazioni: restituzione dei daiti, inserimento, modifica, eliminazione, etc etc..

Tuttavia, al fine di comprendere il pattern MVC prendiamo per buono questo model.

Controller: gestire le richieste dell'utente

Il controller sulla base della richiesta di un URL proveniente dall'utente decide se e quale model utilizzare nonchè se e quale view mostrare.

In particolare gli URL nell'ambito dell'MVC assumeranno una particolare struttura che vedremo poco appresso.

In analogia con quanto visto per i model nel creare un controller dovremo rispettare quattro regole:

1. dovrà essere extends CI_Controller;
2. il nome della classse dovrà iniziare con la lettera maiuscola;
3. il nome del file dovrà essere tutto minuscolo;
4. Il file dovrà essere collocato nella cartella /application/controllers/.

Per seguire il nostro esempio creiamo il controller che chiameremo, ad esempio, "Azienda" e sarà collocato al seguente percorso /application/controllers/azienda.php.

Esso avrà tre metodi in corrispondenza delle diverse richieste provenienti dal client: l'utente potrà richedere di visualizzare il nome dell'azienda, il numero di telefono oppure le email.

Pertanto il controller avrà tre metodi: "index" per visualizzare il nome della nostra azienda; "telefono" per visualizzare il numero di telefono; "email" per visualizzare gli indiritti email.

<?php
/*
meccanismo adottato da CodeIgniter 
per evitare gli accessi diretti al file
*/
class Azienda extends CI_Controller {
	
	public function index(){
		/* 
		eseguiamo il load del model che ci occorre
		(indicazione tutta minuscola)
		*/
		$this->load->model('info_azienda_model');
		
		/* 
		ci facciamo restituire dal nostro model il nome dell'azienda 
		eseguendo il metodo GetNome()
		*/		
		$nome = $this->info_azienda_model->GetNome();

		/* 
		creiamo un array $data che conterrà tutte le variabili 
		che andremo a passare alla view 
		*/
		$data = array();
		$data['titolo'] = 'La nostra azienda';
		$data['contenuto'] = 'Il nome della nostra azienda: ' . $nome;

		/*
		eseguiamo il load della view e nei due parametri fissiamo
		quale view mostrare (senza indicare .php)
		e passiamo l'array $data che abbiamo popolato
		*/
		$this->load->view('vista', $data);
		}

	public function telefono(){
		/* analogamente faremo per questo metodo */
		$this->load->model('info_azienda_model');		
		$telefono = $this->info_azienda_model->GetTelefono();

		$data = array();
		$data['titolo'] = 'Il nostro numero di telefono';
		$data['contenuto'] = 'Il numero di telefono della nostra azienda: ' . $telefono;

		$this->load->view('vista', $data);
		}

	public function email($parametro = 'acquisti'){
		$this->load->model('info_azienda_model');
		/* 
		a seconda del $parametro 
		andremo a selezionare uno degli indirizzi email 
		attraverso il metodo GetEmail del model model info_azienda_model 
		*/
		if($parametro == 'acquisti'){
			$email = $this->info_azienda_model->GetEmail('acquisti');
			}
		else if($parametro == 'vendite'){
			$email = $this->info_azienda_model->GetEmail('vendite');
			}
		else{
			$email = 'Undefined';
			}

		$data = array();
		$data['titolo'] = 'Le nostre email';
		$data['contenuto'] = $email;

		$this->load->view('vista', $data);
		}
	}

Occorre notare che il metodo "email" richiede un parametro e assume come valore di default 'acquisti'. Ciò avrà importanza quando andremo a vedere il modo in cui si compone l'URL.

La view: interfaccia grafica

Le view si occupano dell'interfaccia grafica del nostro applicativo e della stampa a video dei dati provenienti dal controller (cha sua volta li preleva dal model).

Nell'esempio esempio proposto tutti i metodi del controller azienda (index, telefono ed email) eseguono il load della stessa view chiamata "vista" e gli passano come dati un array ($data) con chiavi letterali ('titolo' e 'contenuto').

Andiamo, quindi, a creare la view che collocheremo in /application/views/vista.php al cui interno i dati dell'array $data diventano delle variabili il cui nome è costituito dalle chiavi che queste assumono nell'array ($titolo e $contenuto).

<html>
<head>
	<title><?php echo $titolo; ?></title>
</head>
<body>
	<h1><?php echo $titolo; ?></h1>
	<p><?php echo $contenuto; ?></p>
</body>
</html>

La struttura degli URL

Creati questi tre file e opportunamente collocati come da indicazioni andiamo ad visualizzare i seguenti URL:

• http://localhost/index.php/azienda/
• http://localhost/index.php/azienda/telefono
• http://localhost/index.php/azienda/email
• http://localhost/index.php/azienda/email/acquisti
• http://localhost/index.php/azienda/email/vendite

E' facile, quindi, intuire la struttura assunta dagli URL nell'ambito di un framework che segue la logica dell'MVC:

index.php/CONTROLLER/METODO_CONTROLLER/PARAMETRO_METODO/ALTRO_PARAMETRO_METODO

Nei seguenti URL vi è una parte ridondante composta da index.php che dal punto di vista SEO non è ottimale. Per eliminare index.php dai nostri URL dovremo inserire nella document root del nostro sito un file .htaccess con i seguenti comandi:

RewriteEngine on
RewriteCond $1 !^(index\.php|images|css|js|robots\.txt)
RewriteRule ^(.*)$ /index.php/$1 [L]

Dopodichè dovrete andare a modificare nel file di configurazione /application/config/config.php il parametro $config['index_page'] e lasciarlo vuoto:

$config['index_page'] = '';

Affinchè ciò funzioni correttamente occorre che apache abbia il mode rewrite attivato.

Io in locale su windows ho avuto problemi ad eliminare index.php con questo tipo di mode rewrite (rinunciandoci) mentre on line su hosting linux non ho avuto alcun problema (test su Altervista e su Aruba).

Impostare il controller della homepage

La home page del nostro applicativo è tuttavia rimasta la pagina di welcome preimpostata.

Poniamo di voler impostare il nostro controller "Azienda" come home page.

Dovremo andare a modificare il file di configurazione /application/config/routes.php ed in particolare il parametro $route['default_controller'] che sarà impostato in questo modo:

$route['default_controller'] = "azienda";

Ulteriormente potremo settare la pagina di errore tramite la variabile $route['404_override']. Queste pagine dovranno essere collocate in /application/errors/.

Errori da non compiere

I diversi "ruoli" che il sistema MVC affida ai suoi tre componenti devono essere rispettati.

Per tale ragone è opportuno sgombrare il campo da alcuni errori fequenti:

• inserire markup (html) nel model o nel controller: l'interfaccia grafica deve essere affidata solo alle view; questa regola, in via eccezionale, potrebbe anche avere delle limitatissime deroghe ma è sempre meglio rispettarla in modo rigoroso.
• gestire i dati attraverso i controller (o peggio ancora nelle view): il controller deve occuparsi esclusivamente di interpretare la richiesta effettuara dall'utente tramite l'URL andando a prelevare i dati necessari tramite gli opportuni model e selezionare la view corrispondente.

Conclusioni

L'esempio proposto è volutamente banale dato che il mio scopo era puramente illustrare il funzionamento del pattern MVC, che costituisce un aspetto fondamentale di tutti i framework php attualmente più diffusi.

Ovviamente CodeIgniter offre anche molto altro e non è facile riassumerlo. I prossimi articoli avranno un taglio più "operativo" e vedremo come in concreto si articola un model che interagisce con un database.

Per qualsiasi dubbio, critica o problema non esistate a lasciarmi un commento.