In questo articolo scriveremo lo "scheletro" del nostro progetto. Con la parola "framework" intendo codice funzionante che sarà basato sull'approccio MVC, ovvero avrà una chiara divisione della logica in controller, azioni, modelli (viste) e modelli.

E quindi iniziamo, come ho già scritto nell'articolo precedente, il pattern MVC implica un punto di ingresso: index.php, tutte le richieste passeranno attraverso questo script, tutta la logica del progetto funzionerà attraverso di esso. Per implementare questo approccio, è necessario configurare il server, si presume che il sito sia in esecuzione sul server apache, quindi dobbiamo solo creare un file .htaccess in cui specifichiamo le regole di routing dell'URL. Oltre a definire un punto di ingresso, il routing consente di creare CNC (URL leggibili dall'uomo). Cioè, dopo le impostazioni corrette, gli indirizzi delle pagine appariranno come questo site.ru/article/new.
Per prima cosa, creiamo un .htaccess che reindirizzerà l'elaborazione di tutte le pagine allo script index.php. Il codice si presenta così:

RewriteEngine su RewriteCond %(REQUEST_FILENAME) !-f RewriteCond %(REQUEST_FILENAME) !-d RewriteRule ^(.*)$ index.php?route=$1

Il file .htaccess deve trovarsi nella cartella principale del sito, è necessario creare immediatamente lo script index.php, che è il punto di ingresso. Scriviamo una riga in index.php per verificare se il reindirizzamento funziona:

eco "prova";

Ora puoi verificare se il reindirizzamento funziona, inserire un qualsiasi indirizzo e vedere cosa succede: test-mvc.web/sdf/sdf/ o test-mvc.web/sdf/sdf/2342/ non importa, in ogni caso il lo schermo dovrebbe mostrare "test". Se hai visto questa iscrizione, significa che ci siamo riusciti.
Continuiamo, per comodità, creiamo un file config.php nella root del sito, in cui imposteremo varie costanti che ci facilitano la configurazione del sito. Questi possono essere percorsi diversi per script, approcci al database e così via. Ora nella configurazione, impostiamo quanto segue:

// Imposta le costanti: define("DS", DIRECTORY_SEPARATOR); // separatore per i percorsi dei file $sitePath = realpath(dirname(__FILE__) .DS); define("PERCORSO_SITO", $Percorsosito); // percorso della cartella principale del sito // per connettersi al database define("DB_USER", "root"); define("DB_PASS", ""); define("DB_HOST", "localhost"); define("DB_NAME", "blog_mvc");

Affinché le costanti e altri dati di configurazione possano essere utilizzati durante il progetto, è necessario includere lo script config.php nel file index.php.
Oltre a collegare il file delle impostazioni, è necessario creare una connessione al database in index.php, collegare lo script con il core del sito e avviare il router in cui avverrà il routing.
Ora, nell'ordine, la creazione della connessione al database sarà in index.php in modo che la connessione venga aperta una sola volta. Una volta aperta la connessione, possiamo utilizzarla in tutti i controller e modelli, ma ne parleremo più avanti. Ora creiamo solo una connessione al database. Per lavorare con il database, ho deciso di utilizzare PDO. Puoi leggere di più sulla DOP.
Metteremo il core del sito nella cartella core e chiameremo lo script core.php, qui scriveremo una funzione che si collegherà, le classi necessarie al lavoro. Tale funzione faciliterà e semplificherà notevolmente il nostro lavoro con controller, modelli, ecc. Perché, guardando al futuro, dirò che ogni controller e ogni modello sarà una classe separata.
Oltre all'autoconnessione delle classi, aggiungeremo un repository (registro) al centro della creazione di un repository, in cui memorizzeremo tutti gli oggetti e le variabili necessari che possono essere utili in qualsiasi parte del progetto.
Connetteremo anche il router nel file di indice, analizzerà l'URL e collegherà il controller e l'azione necessari. Che cos'è un controller, ho scritto nell'articolo precedente, e ho deliberatamente perso le informazioni sull'azione, senza essere caricato con informazioni non necessarie. Allora cos'è l'azione?
Il controller è una classe che contiene vari metodi, con l'approccio MVC, ogni metodo sarà un'azione. Cioè, un'azione (azione) è un metodo di classe che elaborerà i dati e li passerà alla vista (al modello). Potrebbe non essere ancora del tutto chiaro, ma dopo un esempio, tutto andrà a posto.
A questo punto basta la teoria, passiamo alla pratica. Darò il codice dei file, il cui lavoro, ho descritto sopra.
Codice dello script Index.php:

// attiva la visualizzazione di tutti gli errori error_reporting (E_ALL); // include la configurazione include ("/config.php"); // Connessione al database $dbObject = new PDO("mysql:host=" . DB_HOST . ";dbname=" . DB_NAME, DB_USER, DB_PASS); // include il core del sito include (SITE_PATH . DS . "core" . DS . "core.php"); // Carica router $router = nuovo router($registro); // scrive i dati nel registro $registry->set ("router", $router); // imposta il percorso della cartella controllers. $router->setPath(SITE_PATH . "controller"); // avvia il router $router->start();

script core.php:

// Carica le classi al volo, funzione __autoload($className) ( $filename = strtolower($className) . ".php"; // definisce la classe e trova il percorso $expArr = esplode("_", $className ); if(empty($expArr) OR $expArr == "Base")( $cartella = "classi"; )else( switch(strtolower($expArr))( case "controller": $ folder = "controller"; break ; case "model": $folder = "models"; break; default: $folder = "classes"; break; ) ) // percorso della classe $file = SITE_PATH .$folder .DS .$filename; // verifica la disponibilità del file if (file_exists($file) == false) ( return false; ) // include il file con la classe include ($file); ) // avvia il registro (archiviazione) $registry = new Registry;

La classe di archiviazione Registry.php si troverà nella cartella /classes/

// Classe di archiviazione Class Registry ( private $vars = array(); // record data function set($key, $var) ( if (isset($this->vars[$key]) == true) ( ​​​​throw new Exception("Impossibile impostare var `" . $key . "`. Già impostato."); ) $this->vars[$key] = $var; return true; ) // funzione di recupero dati get($ key) ( if (isset($this->vars[$key]) == false) ( return null; ) return $this->vars[$key]; ) // elimina la funzione dati remove($var) ( unset ($ questo->vars[$chiave]); ) )

Il codice del file router.php, che si trova nella cartella /classes/

// classe router Class Router ( private $registry; private $path; private $args = array(); // ottiene la funzione di repository __construct($registry) ( $this->registry = $registry; ) // imposta il percorso alla cartella con i controller funzione setPath($percorso) ( $percorso = trim($percorso, "/\\"); $percorso .= DS; // segnala se il percorso non esiste if (is_dir($percorso) = = false ) ( lancia una nuova eccezione ("Percorso controller non valido: `" . $percorso . "`"); ) $questo->percorso = $percorso; ) // definisce il controller e l'azione dalla funzione privata dell'URL getController(&$file , & $controller, &$azione, &$args) ( $route = (vuoto($_GET["percorso"])) ? "" : $_GET["percorso"]; unset($_GET["percorso"] ); if (vuoto($percorso)) ( $percorso = "indice"; ) // Ottieni parti dell'URL $percorso = trim($percorso, "/\\"); $parti = esplode("/", $percorso ); // Trova il controller $cmd_path = $this->path; foreach ($parts as $part) ( $fullpath = $cmd_path . $part; // Controlla se la cartella esiste se (is_dir($fullpath)) ( $ percorso_cmd .= $ parte.DS; array_shift($parti); Continua; ) // Trova il file if (is_file($fullpath . ".php")) ( $controller = $part; array_shift($parts); break; ) ) // se il controller non è specificato nell'URL, usa l'indice predefinito if (vuoto ($controller)) ( $controller = "index"; ) // Ottieni l'azione $action = array_shift($parts); if (vuoto($azione)) ( $azione = "indice"; ) $file = $percorso_cmd. $ controllore. ".php"; $args = $parti; ) function start() ( // Analizza il percorso $this->getController($file, $controller, $action, $args); // Controlla se il file esiste, altrimenti 404 if (is_readable($file) == false ) ( die ("404 non trovato"); ) // Include file include ($file); // Crea istanza controller $class = "Controller_" .$controller;$controller = new $class($this->registry) ; // Se l'azione non esiste - 404 if (is_callable(array($controller, $action)) == false) ( die ("404 Not Found"); ) // Esegui l'azione $controller->$action (); ) )

Ora devi creare cartelle per archiviare controller, modelli e modelli: alla radice creeremo tre cartelle controller, viste e modelli. E creiamo alcuni file di test /controllers/index.php, /views/index/index.php e /models/model_users.php, e ora riempiamo i file:
Per il controllore:

// Classe controller Controller_Index Estende Controller_Base ( // template public $layouts = "first_layouts"; // action function index() ( $model = new Model_Users(); $userInfo = $model->getUser(); $this-> template->vars("userInfo", $userInfo); $this->template->view("index"); ) )

Per la visualizzazione(/views/index/index.php)

vista di prova
id:
nome:

E modello:

// Class Model Model_Users( public function getUser()( return array("id"=>1, "name"=>"test_name"); ) )

Come avrai notato, la classe controller eredita dalla classe padre Controller_Base. Questo viene fatto per semplificare la classe del controller. Poiché abbiamo ancora bisogno di connettere la classe per lavorare con i modelli, la sua connessione viene spostata su Controller_Base.
Ecco il suo codice, si trova nella cartella /classes/ e si chiama controller_base.php:

// classe controller astratta Classe astratta Controller_Base ( protected $registry; protected $template; protected $layouts; // template public $vars = array(); // include modelli nella funzione di costruzione __construct($registry) ( $this->registry = $registry; // templates $this->template = new Template($this->layouts, get_class($this)); ) indice funzione astratta(); )

Ora non resta che occuparsi dei modelli. Nella classe astratta Controller_Base, chiamiamo la classe Template e le passiamo il nome del modello e il nome del controller.
Codice della classe del modello, che si trova qui /classes/ e si chiama template.php

// classe per connettere modelli e passare dati al display Modello di classe ( private $template; private $controller; private $layouts; private $vars = array(); function __construct($layouts, $controllerName) ( $this->layouts = $layouts; $arr = esplode("_", $controllerName); $this->controller = strtolower($arr); ) // imposta le variabili per visualizzare la funzione vars($varname, $value) ( ​​if ( isset( $this->vars[$varname]) == true) (trigger_error ("Impossibile impostare var `" . $varname . "`. Già impostato e sovrascrittura non consentita.", E_USER_NOTICE); return false ; ) $this ->vars[$varname] = $value; return true; ) // visualizza la funzione view($name) ( $pathLayout = SITE_PATH . "views" . DS . "layouts" . DS . $this-> layout . ". php"; $contentPage = SITE_PATH . "views" . DS . $this->controller . DS . $name . ".php"; if (file_exists($pathLayout) == false) ( trigger_error ("Layout `" . $ this->layouts . "` non esiste.", E_USER_NOTICE); return false; ) if (file_exists ($contentPage) == false) ( trigger_error ("Modello `" . $nome. "`non esiste.", E_USER_NOTICE); restituire falso; ) foreach ($this->vars as $key => $value) ( ​​$$key = $value; ) include ($pathLayout); ) )

Se hai letto attentamente il codice, probabilmente hai capito che per la visualizzazione sulle pagine utilizziamo il template first_layouts e la vista index.php (display) - ho citato il suo codice un po' più in alto. Non ci resta che creare il file modello first_layouts. Mettiamolo nella cartella /views/layouts/first_layouts.php
Il modello conterrà il seguente codice:

intestazione

piè di pagina

Questo è tutto, questo completa la creazione del "quadro". Ora abbiamo la struttura più semplice, basata sul modello MVC. In questo articolo, non ho toccato il lavoro con il database, l'ho menzionato solo di sfuggita, poiché l'articolo si è comunque rivelato di grandi dimensioni. Descriverò il lavoro con il database direttamente nel prossimo articolo.
Questo articolo è finito, puoi scaricare il codice sorgente nell'archivio.

modello Model-View-Controller (MVC), scoperto alla fine degli anni '70, è un modello di progettazione dell'architettura software il cui obiettivo principale è separare le funzioni di lavoro con i dati dalla loro rappresentazione. Teoricamente, un'applicazione MVC ben progettata consentirà agli sviluppatori front-end e back-end di non interferire nelle reciproche aree di responsabilità durante il lavoro, ovvero lo sviluppatore front-end non ha bisogno di sapere nulla della "cucina" di il suo collega di back-end e viceversa.

Sebbene MVC sia stato originariamente progettato per lo sviluppo desktop, è stato adattato per attività moderne ed è molto popolare tra gli sviluppatori Web perché è diventato possibile creare codice più chiaro e riutilizzabile attraverso la separazione delle preoccupazioni. Il modello MVC porta a sistemi chiari e modulari che consentono agli sviluppatori di apportare modifiche al codice esistente molto rapidamente.

In questo articolo, illustreremo i principi di base di MVC, iniziando con la definizione di un modello e continuando ad applicarlo in un piccolo esempio. Questo articolo sarà utile principalmente a coloro che non hanno mai incontrato questo modello nella loro vita e anche, forse, a coloro che vogliono rinfrescare la loro conoscenza di MVC.

Capire MVC

Come già accennato, il nome del pattern deriva dall'abbreviazione di tre parole: Modello (modello), Visualizza (visualizza) e Controllore (controllore). In breve, il principio del pattern può essere illustrato con un diagramma (può essere trovato su Wikipedia):

Questo diagramma mostra chiaramente il flusso unidirezionale di informazioni nel modello e descrive anche i ruoli di ciascun componente.

Modello

Il modello viene utilizzato per accedere e manipolare i dati. Nella maggior parte dei casi, un modello è ciò che viene utilizzato per accedere a un archivio dati (come un database). Il modello fornisce un'interfaccia per il recupero, la creazione, la modifica e l'eliminazione dei dati dallo storage. Nel contesto del pattern MVC, il modello è un intermediario tra la vista e il controller.

Una caratteristica estremamente importante del modello è che tecnicamente non ha alcuna conoscenza di ciò che sta accadendo con i dati nel controller e nella visualizzazione. Il modello non dovrebbe mai fare o aspettarsi richieste a/da altri componenti del modello.

Tuttavia, ricorda sempre che un modello non è solo un gateway di accesso a un database o un altro sistema, che consiste nel passare i dati avanti e indietro. Il modello è come un gateway per i dati. Il modello è spesso la parte più complessa del sistema, in parte perché il modello stesso è il collegamento a tutte le altre parti.

Prestazione

La vista è dove i dati ricevuti dal modello vengono visualizzati nella forma desiderata. Nelle applicazioni web tradizionali sviluppate nel modello MVC, la vista è la parte del sistema in cui viene generato il codice HTML. La vista è anche responsabile della ricezione di azioni dall'utente al fine di inviarle al controller. Ad esempio, una vista visualizza un pulsante nell'interfaccia utente e, quando si fa clic su di esso, richiama l'azione del controller appropriata.

Ci sono alcune idee sbagliate sullo scopo di una vista, specialmente tra gli sviluppatori Web che stanno appena iniziando a creare le proprie applicazioni utilizzando MVC. Una delle regole più frequentemente violate è quella la vista non deve comunicare in alcun modo con il modello, e tutto i dati ricevuti dalla vista dovrebbero provenire solo dal responsabile del trattamento. In pratica, gli sviluppatori spesso ignorano questo concetto, che è al centro del pattern MVC. L'articolo di Fabio Cevasco illustra questo approccio confuso a MVC con CakePHP, uno dei tanti framework MVC non standard:

È estremamente importante capire che per ottenere una corretta architettura MVC, non dovrebbero esserci interazioni dirette tra viste e modelli. Tutte le logiche di scambio di dati tra di loro devono essere implementate nei controllori.

Inoltre, esiste un malinteso comune sul fatto che una vista sia solo un file modello. Come ha sottolineato Tom Butler, questo malinteso ha una portata enorme a causa del fatto che molti sviluppatori fraintendono la struttura MVC fin dall'inizio, dopodiché le masse di sviluppatori principianti iniziano a infondere ulteriormente questa "conoscenza". In realtà, una vista è molto più di un semplice modello, ma molti framework basati sul modello MVC hanno distorto il concetto di vista così tanto che a nessuno importa quanto siano corrette le loro applicazioni dal punto di vista del modello MVC.

Un altro punto importante è che la vista non funziona mai con i dati "puri" del controller, ovvero il controller non lavora mai con la vista, bypassando il modello. Nel processo di interazione tra il controller e la vista, il modello deve essere sempre tra di loro.

Controllore

Il controller è l'ultimo pezzo del bundle MVC. Il compito del responsabile del trattamento è ricevere i dati dall'utente e manipolare il modello. È il controllore, e solo lui, quella parte del sistema che interagisce con l'utente.

In poche parole, il responsabile del trattamento può essere descritto come un raccoglitore di informazioni che le trasmette al modello per l'elaborazione e l'archiviazione. Non dovrebbe fare nulla con i dati, ma solo essere in grado di riceverli dall'utente. Il controller è associato a una vista e a un modello, organizzando così un flusso di dati unidirezionale, controllandolo in ogni fase.

È molto importante ricordare che il controller inizia il suo lavoro solo in seguito all'interazione dell'utente con la vista, che chiama la funzione del controller corrispondente. L'errore più comune tra gli sviluppatori è che il controller viene semplicemente trattato come un gateway tra la vista e il modello. Di conseguenza, il controller è dotato di quelle funzioni che dovrebbero essere eseguite dalla vista (a proposito, è da qui che viene l'idea che la vista sia solo un file modello). Inoltre, molti generalmente scaricano tutta la logica dell'elaborazione dei dati, dimenticando a cosa è destinato il modello nel modello MVC.

MVC in PHP

Propongo di provare a implementare quanto sopra in una piccola applicazione. Iniziamo creando le classi modello, vista e controller:

string = "MVC + PHP = Fantastico!"; ) )controllore = $controllore; $questo->

" . $questo->modello->stringa. "

"; } } modello = $modello; ) )

Le classi principali sono pronte. Ora colleghiamoli insieme ed eseguiamo la nostra applicazione:

produzione();

Come puoi vedere, il controller non ha alcuna funzionalità perché l'utente non interagisce in alcun modo con l'applicazione. Tutte le funzionalità sono posizionate nella vista, poiché la nostra applicazione è esclusivamente per la visualizzazione dei dati.

Espandiamo un po' l'app con un po' di interattività per vedere come funziona il controller:

string = "MVC + PHP = Fantastico, clicca qui!"; ) )controllore = $controllore; $questo->modello = $modello; ) output della funzione pubblica() ( return "

modello->stringa. "

"; } } modello = $modello; ) public function clicked() ( $this->model->string = "Dati aggiornati, grazie a MVC e PHP!" ) )

E infine, modernizziamo un po' il codice di collegamento:

($_GET["azione"])(); ) echo $view->output();

Risultati

In questo breve articolo, abbiamo trattato i concetti di base del design pattern MVC e sviluppato una semplice applicazione basata su di esso, anche se ovviamente siamo ancora molto lontani dal poterlo utilizzare nella vita reale. Nel prossimo articolo, esamineremo le principali difficoltà che incontrerai se osserverai più da vicino la creazione di un'architettura applicativa basata sul pattern MVC. Rimani sintonizzato!

In questo tutorial imparerai come costruire un semplice sistema MVC (Model-View-Controller) in PHP 5.1 utilizzando le funzionalità SPL (Standard PHP Library, PHP Standard Library).

introduzione

Benvenuti nel primo tutorial completo per PHP 5. Avrai bisogno di PHP 5.1 con la libreria SPL installata, poiché utilizzeremo alcune delle ultime funzionalità di PHP 5.

In questo tutorial, ti mostrerò come costruire un semplice sistema MVC (l'architettura MVC è il modello di progettazione più comune per applicazioni Web di grandi dimensioni). Ti guiderò attraverso tutti i passaggi dall'inizio alla fine della creazione di un sistema MVC completo.

Un punto di ingresso

Una delle cose importanti di MVC è un singolo punto di ingresso all'applicazione invece di un mucchio di file PHP che fanno qualcosa del genere:

Avremo un file che gestirà tutte le richieste. Ciò significa che non dobbiamo preoccuparci di includere global.php ogni volta che dobbiamo creare una nuova pagina. Questo "single entry point" si chiamerà index.php e per ora sarà così:

Come puoi vedere, questo script non fa ancora nulla, ma aspetta un minuto.

Per indirizzare tutte le richieste alla pagina principale, useremo mod_rewrite e imposteremo la direttiva RewriteRule in .htaccess. Incolla il seguente codice nel file .htaccess e salvalo nella stessa directory di index.php:

RewriteEngine su RewriteCond %(REQUEST_FILENAME) !-f RewriteCond %(REQUEST_FILENAME) !-d RewriteRule ^(.*)$ index.php?route=$1

Innanzitutto, controlliamo se il file richiesto esiste utilizzando la direttiva RewriteCond e, in caso contrario, reindirizziamo la richiesta a index.php. Questo controllo dell'esistenza del file è necessario perché altrimenti index.php cercherà di elaborare tutte le richieste al sito, comprese le richieste di immagini. Ed è proprio ciò di cui non abbiamo bisogno.

Se non sei in grado di utilizzare .htaccess o mod_rewrite, dovrai indirizzare manualmente tutte le richieste a index.php. In altre parole, tutti i collegamenti dovrebbero essere nel formato "index.php?route=[request-goes-here]". Ad esempio, "index.php?route=chat/index".

Ora che tutte le richieste passano attraverso lo stesso punto di ingresso, possiamo iniziare a scrivere lo script index.php. La prima cosa che dobbiamo fare è inizializzare il sistema. Creiamo la directory include, e in essa il file startup.php (sarà il nostro file di inizializzazione). Incolla il seguente codice in index.php:

In questo esempio, dichiariamo alcune costanti, scopriamo dove si trovano i file di sistema e controlliamo anche che la versione PHP sia almeno 5.1.

La prossima cosa da fare è un oggetto del Registro di sistema per contenere valori globali. Verrà passato ai singoli oggetti di sistema e utilizzato per accedere ai valori globali senza dover designare le variabili come "globali" o fare riferimento all'array $GLOBALS. Leggi l'articolo "Utilizzo dei valori globali in PHP" per ulteriori informazioni sull'oggetto del registro.

Aggiungi il codice seguente al file startup.php dopo il codice nell'esempio precedente:

$registro = nuovo Registro;

Se provi ad avviare il sistema ora, puoi visualizzare il seguente errore:

Errore irreversibile: classe "Registry" non trovata in g:\Projects\PHP\content\simple mvc php5\demo\includes\startup.php on line 12

Questa, ovviamente, non è una grande sorpresa per noi, perché non abbiamo ancora scritto la classe Registry stessa. Il file di classe potrebbe essere semplicemente incluso usando la funzione include(). Usiamo una delle nuove funzionalità di PHP 5: __autoload().

La funzione magica __autoload() viene utilizzata per caricare dinamicamente le classi. Quando PHP rileva una classe inesistente, chiama prima la funzione __autoload() e solo dopo genera un errore. Possiamo sfruttare questa opportunità per caricare le classi al volo.

Incolla questo codice prima del codice dell'esempio precedente:

// Funzione di caricamento al volo delle classi __autoload($class_name) ( $filename = strtolower($class_name) . ".php"; $file = site_path . "classes" . DIRSEP . $filename; if (file_exists($file) = = false) (restituisce false; ) include ($file); )

La nostra funzione __autoload() prende il nome della classe passato come argomento e controlla se esiste un file con un nome simile nella directory delle classi. Se il file non esiste, la funzione restituirà semplicemente false e verrà visualizzato un errore irreversibile. Ma se il file esiste, verrà caricato. Quelli. la classe richiesta verrà dichiarata e non ci saranno errori.

Non abbiamo ancora creato la classe Registry stessa, quindi l'errore apparirà ancora. Andiamo avanti con questo.

Creazione della classe Registry

La classe Registry viene utilizzata per passare valori globali tra singoli oggetti. In realtà è una classe piuttosto semplice che deve implementare alcuni piccoli metodi.

Per prima cosa, creiamo la directory delle classi e il file register.php in essa. Incolla il seguente codice in register.php:

Ora abbiamo uno "scheletro" della classe Registry e dobbiamo caricarlo con i metodi. Scriviamo 2 metodi: set() per impostare i valori e get() per ottenere valori. Puoi anche scrivere un metodo remove() per rimuovere i valori. Aggiungiamo questi metodi alla classe Registry:

Function set($key, $var) ( if (isset($this->vars[$key]) == true) ( ​​lancia new Exception("Impossibile impostare var `" . $key . "`. Già set. "); ) $this->vars[$key] = $var; return true; ) function get($key) ( if (isset($this->vars[$key]) == false) ( return null; ) return $this->vars[$key]; ) funzione remove($var) ( unset($this->vars[$key]); ) ?>

Questi metodi sono semplici, impostano, ottengono e rimuovono elementi dall'array $vars, che è un attributo della classe. Nel metodo set(), controlliamo anche se esiste già un valore con la chiave specificata e, in tal caso, lanciamo un'eccezione. Ciò è necessario per evitare la sovrascrittura accidentale dei valori.

Ora abbiamo una classe Registry a tutti gli effetti, ma non ci fermeremo qui. Usiamo una delle funzionalità della libreria SPL: ArrayAccess. SPL (abbreviazione di Standard PHP Library) è una raccolta di interfacce e classi progettate per risolvere problemi comuni. Una delle interfacce SPL, ArrayAccess, può essere utilizzata per fornire l'accesso a un oggetto come un normale array. Diamo un'occhiata a questo esempio:

set("nome", "Dennis Pallett"); // Ottieni il valore usando get() echo $registry->get ("name"); // Ottieni valore usando l'accesso all'array echo $registry["name"] ?>

Il trucco è che $registry diventa come un array, sebbene in realtà sia un oggetto. Naturalmente, ArrayAccess non offre vantaggi speciali, ma consente di ridurre la quantità di codice, poiché non è necessario scrivere "-> get ()" ogni volta. Per utilizzare questa interfaccia, è necessario correggere la prima riga della classe ("Registro delle classi") come segue:

Il registro di classe implementa l'accesso all'array (

La parola chiave "Implements" dice all'interprete che stiamo implementando un'interfaccia con questa classe, che è in realtà ArrayAccess.

Una classe che implementa l'interfaccia ArrayAccess deve avere i seguenti metodi:

Funzione offsetExists($offset) ( return isset($this->vars[$offset]); ) function offsetGet($offset) ( return $this->get($offset); ) function offsetSet($offset, $valore) ( $this->set($offset, $value); ) funzione offsetUnset($offset) ( unset($this->vars[$offset]); )

Questi metodi dovrebbero essere autoesplicativi. Ulteriori informazioni possono essere trovate nella documentazione SPL.

Ora, dopo aver implementato l'interfaccia ArrayAccess, possiamo accedere all'oggetto come se fosse un normale array. Questo è chiaramente dimostrato, sia nell'esempio precedente che in questo:

get("nome"); // Ottieni valore usando l'accesso all'array echo $registry["name"] ?>

La classe Registry è ora completa e, se si tenta di avviare il sistema, tutto dovrebbe funzionare (anche se non verrà ancora visualizzato nulla). Ora che abbiamo finito con il file di inizializzazione, siamo pronti per passare al passaggio successivo nella scrittura del nostro sistema MVC: implementare l'accesso al database, che nell'architettura MVC è chiamato "Model".

Modello

La "M" o modello è la parte del sistema MVC che ha il compito di interrogare il database (o altra fonte esterna) e fornire informazioni al responsabile del trattamento. Sarebbe possibile caricare il modello necessario a seconda della richiesta, ma preferisco sfumare leggermente i confini tra il modello e il controller in questo luogo, ad es. il controller funziona con il database direttamente tramite la libreria di interazione del database, anziché tramite un modello separato. Forse vuoi farlo diversamente, è una questione di gusti.

Dobbiamo scrivere il codice necessario per stabilire una connessione al database e inserirlo in index.php. Ci sono molte fantastiche librerie di database là fuori (incluso il mio, AutoCRUD), ma PHP 5 ne ha già uno, PDO. Pertanto, non è necessario utilizzarne altri.

Incolla il seguente codice nel file index.php (dopo aver incluso il file di inizializzazione):

# Connessione al database $db = new PDO("mysql:host=localhost;dbname=demo", "", ""); $registro->set("db", $db);

In questo esempio, creiamo prima una nuova istanza della libreria PDO e ci connettiamo al nostro database MySQL. Quindi rendiamo disponibile globalmente la variabile $db utilizzando la nostra classe Registry.

Il componente modello del nostro sistema è pronto, quindi passiamo alla scrittura del controller.

Scrivere un controller significa anche scrivere la classe Router, che è responsabile del caricamento del controller desiderato a seconda della richiesta (ricorda, in index.php, la variabile $route viene passata attraverso l'URL).

Classe router

La classe Router analizzerà la richiesta e quindi caricherà il controller richiesto. Creiamo uno "scheletro" della classe:

registro = $registro; ) ) ?>

Quindi aggiungi le seguenti righe a index.php:

# Carica router $router = nuovo router($registro); $registro->set("router", $router);

La prima cosa che scriveremo è il metodo setPath() per impostare la directory in cui saranno tutti i nostri controller. Il metodo è simile a questo e dovrebbe essere aggiunto alla classe Router:

Funzione setPath($percorso) ( $percorso = trim($percorso, "/\\"); $percorso .= DIRSEP; if (is_dir($percorso) == false) ( lancia nuova eccezione ("Percorso controller non valido: ` " . $percorso . "`"); ) $questo->percorso = $percorso; )

Quindi aggiungi le seguenti righe a index.php:

$router->setPath(site_path . "controller");

Ora che abbiamo impostato il percorso dei nostri controller, scriviamo il metodo stesso responsabile del caricamento del controller. Questo metodo sarà chiamato delegato() e analizzerà la richiesta. Il primo pezzo di questo metodo è:

Function delegate() ( // Analizza il percorso $this->getController($file, $controller, $action, $args);

Come puoi vedere, utilizza un altro metodo, getController() , per ottenere il nome del controller e alcune altre variabili. Questo metodo si presenta così:

Funzione privata getController(&$file, &$controller, &$azione, &$args) ( $route = (empty($_GET["route"])) ? "" : $_GET["route"]; if ( empty($percorso)) ( $percorso = "indice"; ) // Ottieni parti divise $percorso = trim($percorso, "/\\"); $parti = esplode("/", $percorso); // Trova il controller corretto $cmd_path = $this->path; foreach ($parts as $part) ( $fullpath = $cmd_path . $part; // Esiste una cartella con questo percorso? if (is_dir($fullpath)) ( $cmd_path .= $part .DIRSEP; array_shift($parts); continua; ) // Trova il file if (is_file($fullpath . ".php")) ( $controller = $part; array_shift($parts); break ; ) ) if (vuoto($controllore)) ( $controllore = "indice"; ); // Ottieni azione $azione = array_shift($parti); if (vuoto($azione)) ( $azione = "indice"; ) $file = $percorso_cmd .$controller..php"; $args = $parti; )

Esaminiamo questo metodo. Prende prima il valore della variabile $route dalla richiesta, quindi lo divide in parti usando la funzione esplode(). Ad esempio, la query "members/view" viene convertita in un array come questo: array('members', 'view').

Quindi passa attraverso ogni parte con un ciclo foreach e controlla se quella parte è una directory. Se lo è, lo aggiunge al percorso del file e controlla la parte successiva. Ciò consente di inserire i controller in sottodirectory e quindi ottenere una gerarchia di controller. Se la parte corrente della richiesta non è una directory, ma è un file, viene memorizzata nella variabile $controller e usciamo dal ciclo perché è stato trovato il controller di cui abbiamo bisogno.

Dopo il ciclo, controlliamo la variabile con il nome del controller. Se è vuoto, utilizziamo il controller "index", che sarà il nostro controller predefinito. Il metodo definisce quindi l'azione da eseguire. Un controller è una classe composta da diversi metodi. Un'azione punta a un metodo specifico. Se l'azione non è specificata, useremo "index" - l'azione predefinita.

Infine, otteniamo il percorso completo del file del controller concatenando tre variabili: il percorso, il nome del controller e l'estensione "php".

Ora che abbiamo analizzato la richiesta, è il momento di chiamare il metodo delegate() per caricare il controller ed eseguire l'azione. Il metodo completo delegate() si presenta così:

Function delegate() ( // Analizza il percorso $this->getController($file, $controller, $action, $args); // Il file è disponibile? if (is_readable($file) == false) ( die ( "404 Not Found"); ) // Include il file include ($file); // Crea un'istanza del controller $class = "Controller_" . $controller; $controller = new $class($this->registry) ; // Azione disponibile? if (is_callable(array($controller, $action)) == false) ( die ("404 non trovato"); ) // Esegui l'azione $controller->$action(); )

Dopo aver analizzato la richiesta con il metodo getController(), controlliamo se il file esiste effettivamente e, in caso contrario, restituiamo un semplice messaggio di errore.

Successivamente, includiamo il file con il controller e creiamo un'istanza della sua classe, che dovrebbe essere chiamata "Controller_[nome]". Poco dopo parleremo dei controller in modo più dettagliato.

Quindi controlliamo se l'azione specificata (cioè il metodo) esiste e se può essere chiamata (usiamo la funzione is_callable() per questo). Infine, eseguiamo l'azione stessa, su cui termina il ruolo della classe Router.

Dopo aver scritto il metodo completo delegate(), aggiungi la seguente riga al file index.php:

$router->delega();

Se proviamo ad avviare il sistema ora, vedremo il seguente errore (ovviamente, se la directory dei controller non esiste ancora):

Errore irreversibile: eccezione non rilevata "Eccezione" con messaggio "Percorso controller non valido: `g:\Projects\PHP\content\simple mvc php5\demo\controllers\`" in g:\Projects\PHPit\content\simple mvc php5\demo \classes\router.php:18 Traccia dello stack: #0 g:\Projects\PHP\content\simple mvc php5\demo\index.php(13): Router->setPath("g:\Projects\PHP... ") #1 (principale) lanciato in g:\Projects\PHP\content\simple mvc php5\demo\classes\router.php on line 18

In caso contrario, vedremo un errore "404 Not Found", poiché non ci sono ancora controller. Ma questo è ciò che faremo ora.

Controllore

I controller nel nostro sistema MVC saranno abbastanza semplici e richiederanno pochissimo tempo. Innanzitutto, assicurati che la directory dei controller esista. Crea un file controller_base.php nella directory classes e incolla il seguente codice al suo interno:

registro = $registro; ) indice di funzione astratta(); ) ?>

Questa classe astratta sarà la classe genitore per tutti i nostri controller. Farà solo due cose: mantenere una copia locale della classe Registry e utilizzare il metodo abstract index() per forzare tutti i controller figlio a implementare questo metodo.

Scriviamo il nostro primo controller. Crea un file index.php nella directory dei controller e incolla il seguente codice al suo interno:

Abbiamo appena creato il nostro primo controller e se proviamo ad avviare il sistema, possiamo vedere quanto segue:

Ciò significa che la classe Router ha svolto il suo lavoro e ha eseguito l'azione richiesta dal controller richiesto. Scriviamo un altro controller che corrisponderà alla richiesta "members/view". Crea un filemembers.php nella directory dei controller e incolla il seguente codice al suo interno:

Ora andiamo al nostro sistema MVC richiedendo "members/view" o "index.php?route=members/view". Dovremmo vedere questo risultato:

Semplicemente scrivendo un nuovo controller e aggiungendo un metodo ad esso, siamo stati in grado di creare una nuova pagina senza dover modificare nulla nel sistema stesso. Inoltre, i nostri controller non hanno bisogno di includere un file global.php o qualcosa del genere.

Ora che abbiamo i nostri controller, è rimasta solo una cosa: "V" o "View".

Schermo

Come per i modelli, ci sono diverse opzioni per creare un componente View in un sistema MVC. Potremmo insegnare alla classe Router a caricare automaticamente un altro file chiamato qualcosa come questo: "view_(name).php". Ma per rendere la guida più comprensibile, scriviamo una classe Template che gestirà l'output dei template.

Per prima cosa, creiamo un file template.php nella directory delle classi e incolliamo il seguente codice al suo interno:

registro = $registro; ) ) ?>

Ora abbiamo la struttura principale della nostra classe Template. Il passaggio successivo consiste nell'aggiungere il seguente codice al file index.php subito prima delle righe relative alla classe Router:

# Crea un oggetto modello $template = new Template($registry); $registro->set("modello", $modello);

Poiché dovremo utilizzare i valori di modelli e controller, scriveremo un metodo set() per impostare le variabili disponibili nei modelli. Diamo un'occhiata a un esempio:

Function set($varname, $value, $overwrite=false) ( if (isset($this->vars[$varname]) == true AND $overwrite == false) ( trigger_error ("Impossibile impostare var `" . $varname . "`. Già impostato e sovrascrittura non consentita.", E_USER_NOTICE); return false; ) $this->vars[$varname] = $value; return true; ) function remove($varname) ( unset($ this->vars[$varname]); restituisce true; )

I metodi set() e remove() sono abbastanza semplici e vengono usati rispettivamente per impostare e rimuovere variabili.

Scriviamo il metodo show(), che visualizzerà i modelli. Il modo più semplice è creare una directory di modelli separata in cui sono archiviati tutti i file di modello e utilizzare include() per l'output del modello. Ovviamente, il tuo metodo show() può essere completamente diverso e caricare modelli dal database o fare qualcos'altro. Diamo un'occhiata a Kuso

Voti: 745 | Visualizzazioni: 8080

Nonostante il significato della frase "architettura del sito web" possa essere intuitivo per te, proviamo a studiare una serie di definizioni da fonti attendibili.

Architettura- questa è l'organizzazione di base del sistema, incarnata nelle sue componenti, nel loro rapporto tra loro e con l'ambiente, nonché i principi che determinano la progettazione e lo sviluppo del sistema.

Architettura programma o sistema informatico è la struttura o le strutture del sistema, che includono elementi del programma, le proprietà di questi elementi che sono visibili dall'esterno e le connessioni tra loro [Bassi].

Architetturaè la struttura dell'organizzazione e il comportamento del sistema ad essa associato. Un'architettura può essere scomposta in modo ricorsivo in parti che interagiscono attraverso interfacce, collegamenti che collegano le parti e condizioni per l'assemblaggio delle parti. Le parti che interagiscono attraverso le interfacce includono classi, componenti e sottosistemi.

Architettura Il software di un sistema o di un insieme di sistemi consiste in tutte le importanti decisioni di progettazione relative alle strutture del programma e alle interazioni tra queste strutture che costituiscono i sistemi. Le decisioni di progettazione forniscono l'insieme desiderato di proprietà che un sistema deve supportare per avere successo. Le decisioni di progettazione forniscono la struttura concettuale per lo sviluppo, il supporto e la manutenzione del sistema.

Allora, cos'è l'architettura del programma?

Le definizioni date nella sezione precedente sono troppo aride per essere percepite da un lettore impreparato. Cercheremo di spiegare l'essenza nel modo più semplice possibile.

Quando un programma diventa abbastanza grande, il programmatore lo suddivide in più file. Se non si pensa di isolare gruppi di funzioni simili e di inserirli in moduli separati, una tale divisione sarà di scarsa utilità. Il codice non sarà riutilizzabile e sarà difficile da navigare. Sarà difficile ampliare e modificare il programma.

Quindi, la prima domanda si sta preparando: come dividere il programma in file. L'architettura dei file di un programma è un aspetto della sua struttura.

Selezionando i moduli del sistema, è necessario capire in quale relazione saranno tra loro. Ad esempio, i moduli di accesso al database e di elaborazione grafica non hanno bisogno di sapere nulla dell'esistenza dell'altro. Ma il modulo dell'interfaccia utente li conoscerà entrambi (e non lo faranno).

Anche le relazioni tra i componenti del sistema sono determinate dalla sua architettura.

In generale, tutte le decisioni significative finalizzate all'organizzazione del programma, e non ai problemi risolti con il suo aiuto, possono essere attribuite all'architettura.

Livelli di astrazione

Quando si progettano i moduli (scegliendo gruppi di funzioni e distribuendoli tra i file nel caso di un approccio procedurale), è importante evidenziare le astrazioni e cercare di scomporle in più livelli.

I moduli di basso livello sono il più autonomi possibile, non dipendono da altre parti del programma. Moduli ben progettati isolano il "mondo esterno" dalla complessità della risoluzione dei loro problemi. Il chiamante conosce solo l'interfaccia del modulo (funzioni esterne), l'interno è ad esso chiuso.

Prendiamo una galleria fotografica come esempio. Le informazioni su immagini e utenti sono archiviate nel database, l'interfaccia utente è suddivisa nella parte client e nel pannello di amministrazione.

La struttura del programma potrebbe essere quella mostrata nella figura seguente:

Questo esempio traccia tre livelli di astrazione.

In ogni programma destinato all'uso umano si possono distinguere almeno due livelli: l'interfaccia utente e il modello. Il modulo dell'interfaccia utente è progettato per presentare e visualizzare i dati, elaborare la reazione dell'utente. Il modello contiene la logica del problema da risolvere e non deve in alcun modo dipendere dal modo in cui i dati vengono visualizzati. Il modello dovrebbe essere facilmente trasportabile tra diversi tipi di interfaccia utente.

Architettura MVC

Ora popolare Modello di progettazione MVC. Serve a separare la logica dell'applicazione dall'interfaccia utente. Ma prima, chiariamo cos'è un design pattern.

Questo è un insieme di soluzioni progettuali tipiche, una struttura di un'architettura o un suo frammento. Se una libreria è un pacchetto di codice riutilizzabile, un design pattern è un pacchetto di soluzioni riutilizzabili.

Cosa ci offre MVC per separare la logica dell'applicazione dall'interfaccia utente?

Campione MVC ti consente di separare dati, presentazione ed elaborazione delle azioni dell'utente in tre componenti separate:

1. Modello. Il Modello fornisce i dati (solitamente alla Vista) e risponde anche alle richieste (solitamente del Titolare) modificandone lo stato;
2. Visualizzazione. Responsabile della visualizzazione delle informazioni (interfaccia utente);
3. Controllore. Interpreta l'input dell'utente e informa il modello e la vista per reagire in modo appropriato.

La figura seguente mostra la relazione tra i componenti del framework. Illustriamo la figura con un piccolo esempio.

Immagina un modulo in cui puoi inserire del testo, fare clic sul pulsante Modifica e ottenere la sua traslitterazione:

Ripetiamo i passaggi mostrati nel diagramma:

1. L'utente fa clic sul pulsante Modifica Prestazione(Visualizza) invia un messaggio Controllore(Controllore): "Comando: modifica"
2. controllore accetta messaggio e accede al modello chiamando il metodo Edit().
3. Di conseguenza modifiche del modello il suo stato (il testo traslitterato in esso memorizzato) e notifica al punto di vista: "Evento: modificato".
4. Sottomissione Accetta signal e accede al modello per un nuovo valore di risultato chiamando il relativo metodo Get().

Implementazione MVC

L'implementazione di MVC presuppone un approccio orientato agli oggetti (OOP). Tuttavia, un modello di progettazione è solo un insieme di decisioni. Li adattiamo per PHP senza l'uso di OOP. La semplificazione viene eseguita per concentrarsi sull'essenza della separazione della logica e anche in modo che il materiale possa essere applicato da un lettore che non ha familiarità con l'OOP.

Considera di nuovo esempio di galleria fotografica.
Ha due modalità di visualizzazione:

1. Modalità di visualizzazione miniature (tutto in una volta);
2. Modalità di visualizzazione foto a grandezza naturale (singola).

C'è anche la possibilità caricare foto al server. Inoltre, implementiamo il supporto per i tipi di visualizzazione per valutare la flessibilità del framework.

Il sito lo farà due punti di ingresso:

1. index.php (vista galleria);
2. photo.php (visualizza la foto a grandezza naturale).

Questi due file verranno presi in considerazione Controllori.

Come Modelli ci sarà un modulo che fornisce il lavoro con l'archiviazione delle immagini. Chiamiamolo galleria.php e mettilo in una cartella modello.

Lancio Rappresentazione I modelli HTML agiranno, saranno nella cartella modelli. Cosa sono i modelli ea cosa servono: si vedrà più avanti.

Le pagine di visualizzazione galleria e visualizzazione foto avranno un'intestazione e un piè di pagina comuni, solo la parte centrale sarà diversa.

La vista galleria avrà due tipi di visualizzazione:

1. Come tabella (predefinito);
2. Sotto forma di elenco.

Abbiamo bisogno di quattro modelli:

1. main.php (frame di pagina);
2. content_index_table.php (visualizzazione tabella dei contenuti della galleria);
3. content_index_list.php (visualizzazione elenco dei contenuti della galleria);
4. content_photo.php (contenuto della pagina di visualizzazione delle foto).

Ciò si traduce nella seguente struttura del sito:

La struttura del file è divisa da due linee orizzontali che formano tre sezioni. I file della sezione superiore appartengono al Modello, i file della sezione centrale alla Vista, i file della sezione inferiore al Controller.

Modello

Cominciamo con l'implementazione del Modello. Il codice seguente non è completamente mostrato per la minimizzazione e una migliore chiarezza dell'esempio.

Abbiamo solo definito l'interfaccia del Modello, lasciando omessa l'implementazione. Tuttavia, per l'implementazione di esempio del framework MVC, non è affatto necessario.

Prestazione

Ora diamo un'occhiata ai modelli. Iniziamo con lo scheletro generale della pagina:

Non dovresti essere imbarazzato dal fatto che il modello utilizzi le variabili $title e $content dal nulla. Il Titolare li sostituirà. Ma ne parleremo più avanti.

- questa è una versione abbreviata .

È comodo da usare nei modelli. È anche più conveniente usare modi alternativi di scrivere i costrutti if-else , foreach , for , while nei modelli. Sembrano così:

Se(<условие>): <тело>finisci se; per ciascuno(<инициализация цикла>): <тело>endforeach;

Il resto dei modelli verrà sostituito in main.php in questo modo:

Gli esempi seguenti mostrano il loro codice:

Modelli di codice/content_index_table.php

Tavolo| Elenco

"> " />

Modelli di codice/content_index_list.php

tavola | Elenco

"> " />

templates/content_photo.php: Indietro

" />

Controllore

E infine, metteremo tutto insieme, descrivendo i nostri due Controller. Il loro compito è elaborare la richiesta, selezionare un modello e sostituire i dati richiesti dal modello. I dati sono presi, di regola, dal modello.

Il controller della galleria carica una foto se l'utente ha inviato un file. In caso contrario, recupera un elenco di foto dal modello, seleziona il modello desiderato (a seconda del desiderio dell'utente) ed emette questo modello, passandogli un elenco di foto:

codice index.php

Il controller per la visualizzazione delle foto è ancora più semplice:

codice foto.php

Infine

Cerca di prestare sufficiente attenzione all'architettura della tua applicazione. Se inizialmente crei una cornice forte ed espandibile, lo sforzo ripagherà cento volte.

Per implementare il modello MVC, è meglio scegliere approccio orientato agli oggetti .

Esistono molte soluzioni framework già pronte, ad esempio in Zend Framework. Tuttavia, le informazioni presentate nella lezione in corso sono sufficienti per comprendere le soluzioni architetturali MVC e iniziare a usarle sin da subito.

Cos'è MVC?

Quindi, MVC riguarda l'interfaccia utente (UI). Non necessariamente grafico, anche il controllo vocale è buono. Non dimentichiamo che un programma potrebbe non avere un'interfaccia utente, potrebbe avere un'API o nessuna, ed essere comunque utile.

Ma se abbiamo un utente, allora ci deve essere un'interfaccia utente. Che cos'è un'interfaccia? È il confine contiguo tra i due sistemi. Nel nostro caso: da un lato - il programma, dall'altro - l'utente. Eccoli.

Il programma è completamente astratto, qualsiasi codice soggetto. Sa come fare qualcosa di utile e l'utente ha esigenze che possono essere soddisfatte con questo programma. Poi ci sono pezzi di logica che "sanno" come, usando questo programma, fare direttamente ciò che l'utente vuole. Pezzi - non soggetto, soggetto logica nel programma. Sono più rilevanti per l'utente con le sue esigenze specifiche e sono combinazioni di chiamate e chiamate al programma.

Casi d'uso

Ad esempio, immagina un terminale per fare trading in borsa. L'utente del terminale invia un ordine in cui indica di voler acquistare 20 azioni della società Svetly Put al prezzo di 1.500 rubli per azione. Indica anche che l'ordine è valido per quattro ore e da quale dei suoi conti addebitare il denaro in caso di transazione andata a buon fine.

Numero percettibile di attributi. Passa del tempo e si rende conto che non sarà in grado di acquistare a un prezzo del genere ed è pronto ad aumentare il prezzo a 1550 rubli, lasciando tutti gli altri valori. Quindi seleziona questo ordine, preme il pulsante "cambia", specifica un nuovo prezzo, sì. È comodo.

Ma in borsa non è possibile modificare l'applicazione, nell'area tematica non esiste una cosa del genere. La domanda può essere solo depositata e annullata. Per dare all'utente la possibilità di modificare l'applicazione in un clic, è necessario ricordare i vecchi valori, rimuovere l'applicazione, lasciare che modifichi ciò che ricordava e presentare una nuova domanda. Una tale combinazione. Ma per l'utente, sembra una semplice azione: cambiare l'applicazione. Questo è chiamato caso d'uso.

Integriamo il nostro diagramma con un posto per i casi d'uso.

L'utente deve anche avere l'opportunità di estrarre questi casi d'uso e ottenere il risultato. Questi possono essere pulsanti e altri elementi grafici di input-output, gesti, riconoscimento e sintesi vocale. Qualsiasi opzione per lo scambio di dati e comandi. Ecco:

L'utente estrae uno dei casi utente, che, a sua volta, manipola il programma. Il programma pubblica il risultato o cambia il suo stato.

Allora, dov'è MVC dopo tutto?

Non resta che distribuire nomi familiari ai componenti risultanti.

Quando il modello pubblica le modifiche, non importa per chi, non sa nulla della vista. Invece di o insieme a View, potrebbe esserci un altro sottosistema a quell'estremità.

Ora alcuni dettagli.

Era una versione classica di MVC - Active Model. Succede anche che il modello non notifichi le modifiche. Quindi il controllore si assume questa responsabilità. Sa quali manipolazioni sta facendo con il modello e, ovviamente, sa quali cambiamenti nello stato del modello possono seguire. Questo è il modello passivo.

E un momento. La divisione del codice in soggetto e non soggetto è condizionale e dipende da quanto pedantemente vogliamo modellare l'area tematica. A volte è una decisione razionale includere un qualche tipo di caso d'uso nel modello. Forse questo ridurrà la quantità di codice in generale e lo semplificherà.

Ringraziamo il nostro abbonato Stanislav Ilyichev per il materiale