MVC è l’acronimo di Model, View e Controller. Possiamo definirlo come un pattern design oppure per gli esseri umani come un “metodo di progettazione del software”.

E a me, povero webdeveloper/designer, cosa me ne viene?

Ultimamente stiamo assistendo ad una oggettizzazione (scusate il termine :D ) dei nostri amati/odiati linguaggi di programmazione per il web. Sia php, dalla versione 5, che flash (con actionscript 3.0). Questo apre ad una realizzazione di framework per rendere più semplici i nostri siti dinamici oppure aggiungere qualche funzionalità che noi non riusciamo per tempo/voglia a programmare da soli.

Per capire questo metodo possiamo analizzare questo codice, che per chi programma in php sicuramente avrà incontrato:

< ?php
//ricerca di un input dell'utente nel database
$query = "SELECT  titolo FROM distudio ORDER BY data";
//invio della query al database (inc. già creato a parte)
$result = mysql_query($query, $db);
//stampa dei risultati con il famoso while
while ($row = mysql_fetch_array($result)){
echo "$row[titolo]"
}
?>

Questo esempio è il classico paradigma affrontato con il metodo input dell’utente, elaborazione del server e output.

Il pattern mvc, consigliato per i grandi progetti, come ad esempio le applicazioni web, divide lo sviluppo dell’applicazione in tre parti separate, come dice il nome: si parte dal controller, che ha il compito di analizzare ogni cambiamento dell’interfaccia (vista) che l’utente crea, utilizzando appunto modelli predefiniti che lavorano sul database. Più facile vederlo all’opera, ve lo assicuro :D

mvc, quindi lavora sulle classi, quindi chi ha una base di programmazione con i linguaggi a oggetti si troverà certamente facilitato. Vi spiego velocemente l’ottimo esempio che trovate qui

< ?php
//creazione del modello dove verranno salvati i dati
 $registry->db = db::getInstance();
?>

con questo abbiamo creato un modello astratto di dati, quindi creato la M, adesso toccherà alla C

< ?php
Abstract Class Controllo {
/*
 * @registry object
 */
protected $registry;
function __construct($registry) {
        $this->registry = $registry;
}
/**
 * @all controllers must contain an index method
 */
abstract function index();
}
?>

Da qui possiamo estendere la classe controllo per realizzare ciò che ci piace di più. Possiamo realizzare velocemente le nostre viste, ad esempio, se vogliamo creare un blog chiedere al controllo di prendere gli ultimi tot post e pubblicarli nella nostra home page, proprio come fa wordpress. Adesso creiamo la vista, chiamata Template, che ci permette di stampare quello che abbiamo creato

< ?php
Class Template {
/*
 * @the registry
 * @access private
 */
private $registry;
/*
 * @Variables array
 * @access private
 */
private $vars = array();
/**
 *
 * @constructor
 *
 * @access public
 *
 * @return void
 *
 */
function __construct($registry) {
        $this->registry = $registry;
}
 /**
 *
 * @set undefined vars
 *
 * @param string $index
 *
 * @param mixed $value
 *
 * @return void
 *
 */
 public function __set($index, $value)
 {
        $this->vars[$index] = $value;
 }

function show($name) {
        $path = __SITE_PATH . '/views' . '/' . $name . '.php';
        if (file_exists($path) == false)
        {
                throw new Exception('Template not found in '. $path);
                return false;
        }

        // Load variables
        foreach ($this->vars as $key => $value)
        {
                $$key = $value;
        }

        include ($path);
}
}
?>

Il template quindi ha il compito di osservare l’url del sito, e di agire di conseguenza. Qundi diamo per scontato il rewrite engine attivo nel nostro server php
Per la gioia quindi di tutti i webdesigners per stampare il nostro contenuto possiamo utilizzare questo comando:

< ?php echo $heading; ?>

< ?php echo $content; ?>

Queste variabili sono state create attraverso un’estensione del costruttore. Come già detto, per avere un esempio più completo, seguite questo tutorial, io volevo solo argomentare!
Aspetta, ma è possibile scrivere di meno? Io vedo scritto di più!
Eccoci qui.. Se dobbiamo creare molte viste, pagine personalizzate (in stile facebook, per intenderci) il pattern mvc fa di sicuro al caso nostro. Se dobbiamo invece realizzare un piccolo progetto allora possiamo fare tutto nel vecchio metodo, ma non venite a lamentarvi se ogni volta dovete andare a trovare il pezzo di codice da copiare e incollare! :D

Il potere della comunità
Da non sottovalutare, anzi, forse è la forza del pattern mvc, è la possibilità di appoggiarsi ad un framework Ce ne sono tanti, io personalmente consiglio Zend Framework e Code Igniter. Il potere di una comunità di sviluppo è quella di aiutarsi l’un con l’altro a scrivere codice più efficace, ed aiutare persone a sviluppare applicazioni web che da soli sarebbero impossibili da realizzare