Das MVC-Muster ist in der Website-Architektur sehr verbreitet. Es ermöglicht uns, eine dreistufige Anwendung zu erstellen, nützliche Schichten vom Code zu trennen, Designern und Entwicklern bei der Zusammenarbeit zu helfen und unsere Fähigkeit zu verbessern, bestehende Anwendungen zu warten und zu erweitern.
Ansicht
„Ansicht“ bezieht sich hauptsächlich auf das Endergebnis, das wir an den Webbrowser senden – beispielsweise den von unserem Skript generierten HTML-Code. Wenn es um Ansichten geht, denken viele an Vorlagen, aber die Richtigkeit der Bezeichnung von Vorlagenlösungsansichten ist fraglich.
Das Wichtigste an einer Ansicht ist wahrscheinlich, dass sie „selbstbewusst“ ist. Wenn die Ansicht gerendert wird, sind sich ihre Elemente ihrer Rolle im größeren Rahmen bewusst.
Am Beispiel von XML lässt sich sagen, dass die DOM-API beim Parsen von XML über solche Kenntnisse verfügt, dass ein Knoten im DOM-Baum weiß, wo er sich befindet und was er enthält. (Wenn ein Knoten in einem XML-Dokument mit SAX analysiert wird, macht es nur dann Sinn, wenn der Knoten analysiert wird.)
Die meisten Vorlagenschemata verwenden einfache prozedurale Sprachen und Vorlagen-Tags wie diese:
<p>{some_text}</p ＞
＜p＞{some_more_text}＜/p＞
Sie haben im Dokument keine Bedeutung, sie bedeuten lediglich, dass PHP es durch etwas anderes ersetzen wird.
Wenn Sie dieser losen Beschreibung von Ansichten zustimmen, stimmen Sie auch zu, dass die meisten Vorlagenlösungen Ansichten und Modelle nicht effektiv trennen. Das Vorlagen-Tag wird durch alles ersetzt, was im Modell gespeichert ist.
Stellen Sie sich beim Implementieren der Ansicht einige Fragen: „Ist es einfach, die gesamte Ansicht zu ersetzen?“ „Wie lange dauert es, eine neue Ansicht zu implementieren?“ „Ist es einfach, die Beschreibungssprache der Ansicht zu ersetzen?“ Verwenden von SOAP in derselben Ansicht. Dokument ersetzt HTML-Dokument)“
Modell (Modell)
Das Modell repräsentiert die Programmlogik. (In Programmen auf Unternehmensebene oft als Geschäftsschicht bezeichnet)
Im Allgemeinen besteht die Aufgabe des Modells darin, die Originaldaten in Daten mit einer bestimmten Bedeutung umzuwandeln, die in der Ansicht angezeigt werden. Normalerweise kapselt das Modell Datenabfragen, möglicherweise über eine abstrakte Datenklasse (Datenzugriffsschicht), um die Abfrage zu implementieren. Wenn Sie beispielsweise den jährlichen Niederschlag in Großbritannien berechnen möchten (nur um einen schönen Urlaubsort zu finden), empfängt das Modell den täglichen Niederschlag für zehn Jahre, berechnet den Durchschnitt und gibt ihn an die Ansicht weiter.
Controller (Controller)
bedeutet einfach, dass der Controller der erste Teil der eingehenden HTTP-Anfrage in der Webanwendung ist. Es überprüft die empfangene Anfrage, beispielsweise einige GET-Variablen, und gibt entsprechendes Feedback. Es ist schwierig, mit dem Schreiben von anderem PHP-Code zu beginnen, bevor Sie Ihren ersten Controller geschrieben haben. Die häufigste Verwendung ist eine Struktur wie die switch-Anweisung in index.php:
<?php
switch ($_GET['viewpage']) {
Fall „Neuigkeiten“:
$page=new NewsRenderer;
brechen;
Fall „Links“:
$page=new LinksRenderer;
brechen;
Standard:
$page=new HomePageRenderer;
brechen;
}
$page->display();
?>
Dieser Code mischt prozeduralen und objektorientierten Code, aber für kleine Websites ist dies normalerweise die beste Wahl. Obwohl der obige Code noch optimiert werden kann.
Controller sind eigentlich Steuerelemente, die zum Auslösen von Bindungen zwischen den Daten- und Ansichtselementen des Modells verwendet werden.
Beispiel
Hier ist ein einfaches Beispiel für die Verwendung des MVC-Musters.
Zuerst benötigen wir eine Datenbankzugriffsklasse, bei der es sich um eine gewöhnliche Klasse handelt.
<?php
/**
* Eine einfache Klasse zum Abfragen von MySQL
*/
Klasse DataAccess {
/**
*Privat
* $db speichert eine Datenbankressource
*/
var $db;
/**
*Privat
* $query speichert eine Abfrageressource
*/
var $query; // Ressource abfragen
//!
/**
* Erstellt ein neues DataAccess-Objekt
* @param $host string Hostname für Datenbankserver
* @param $user string dbserver-Benutzer
* @param $pass string Datenbankserver-Benutzerkennwort
* @param $db string Datenbankname
*/
Funktion DataAccess ($host,$user,$pass,$db) {
$this->db=mysql_pconnect($host,$user,$pass);
mysql_select_db($db,$this->db);
}
//! Ein Accessor
/**
* Ruft eine Abfrageressourcen ab und speichert sie in einem lokalen Mitglied
* @param $sql string die auszuführende Datenbankabfrage
* @return void
*/
Funktion fetch($sql) {
$this->query=mysql_unbuffered_query($sql,$this->db); // Abfrage hier durchführen
}
//! Ein Accessor
/**
* Gibt ein assoziatives Array einer Abfragezeile zurück
* @return gemischt
*/
Funktion getRow () {
if ( $row=mysql_fetch_array($this->query,MYSQL_ASSOC) )
return $row;
anders
return false;
}
}
?＞
Stellen Sie das Modell darauf.
<?php
/**
* Ruft „Produkte“ aus der Datenbank ab
*/
Klasse ProductModel {
/**
*Privat
* $dao eine Instanz der DataAccess-Klasse
*/
var $dao;
//! Ein Konstruktor.
/**
* Konstruiert ein neues ProductModel-Objekt
* @param $dbobject eine Instanz der DataAccess-Klasse
*/
Funktion ProductModel (&$dao) {
$this-＞dao=& $dao;
}
//! Ein Manipulator
/**
* Weist $dboject an, diese Abfrage als Ressource zu speichern
* @param $start die Zeile, mit der begonnen werden soll
* @param $rows die Anzahl der abzurufenden Zeilen
* @return void
*/
Funktion listProducts($start=1,$rows=50) {
$this->dao->fetch("SELECT * FROM products LIMIT ".$start.", ".$rows);
}
//! Ein Manipulator
/**
* Weist $dboject an, diese Abfrage als Ressource zu speichern
* @param $id ein Primärschlüssel für eine Zeile
* @return void
*/
Funktion listProduct($id) {
$this->dao->fetch("SELECT * FROM products WHERE PRODUCTID='".$id."'");
}
//! Ein Manipulator
/**
* Ruft ein Produkt als assoziatives Array aus dem $dbobject ab
* @return gemischt
*/
Funktion getProduct() {
if ( $product=$this->dao->getRow() )
$product zurückgeben;
anders
return false;
}
}
?>
Zu beachten ist, dass die Interaktion zwischen dem Modell und der Datenzugriffsklasse nie mehr als eine Zeile umfasst – es werden nicht mehrere Zeilen gesendet, was das Programm schnell verlangsamt. Das gleiche Programm muss nur eine Zeile (Row) im Speicher für die Klasse behalten, die das Schema verwendet – der Rest wird an die gespeicherte Abfrageressource (Abfrageressource) übergeben – mit anderen Worten, wir lassen MYSQL die Ergebnisse für uns verwalten.
Als nächstes kommt die Ansicht – ich habe den HTML-Code entfernt, um Platz zu sparen. Den vollständigen Code können Sie in diesem Beitrag nachlesen.
<?php
/**
* Bindet Produktdaten an das HTML-Rendering
*/
Klasse ProductView {
/**
*Privat
* $model eine Instanz der ProductModel-Klasse
*/
var $model;
/**
*Privat
* $output gerenderter HTML-Code wird hier zur Anzeige gespeichert
*/
var $output;
//! Ein Konstruktor.
/**
* Erstellt ein neues ProductView-Objekt
* @param $model eine Instanz der ProductModel-Klasse
*/
Funktion ProductView (&$model) {
$this->model=& $model;
}
//! Ein Manipulator
/**
* Erstellt den oberen Rand einer HTML-Seite
* @return void
*/
function header () {
}
//! Ein Manipulator
/**
* Erstellt das Ende einer HTML-Seite
* @return void
*/
function footer () {
}
//! Ein Manipulator
/**
* Zeigt ein einzelnes Produkt an
* @return void
*/
Funktion productItem($id=1) {
$this->model->listProduct($id);
while ( $product=$this->model->getProduct() ) {
// Daten an HTML binden
}
}
//! Ein Manipulator
/**
* Erstellt eine Produkttabelle
* @return void
*/
Funktion productTable($rownum=1) {
$rowsperpage='20';
$this->model->listProducts($rownum,$rowsperpage);
while ( $product=$this->model->getProduct() ) {
// Daten an HTML binden
}
}
//! Ein Accessor
/**
* Gibt den gerenderten HTML-Code zurück
* @return-String
*/
Funktionsanzeige () {
return $this->output;
}
}
?＞
Zusammenfassung: Das MVC-Muster ist in der Website-Architektur sehr verbreitet. Es ermöglicht uns, eine dreistufige Anwendung zu erstellen, nützliche Schichten vom Code zu trennen, Designern und Entwicklern bei der Zusammenarbeit zu helfen und unsere Fähigkeit zu verbessern, bestehende Anwendungen zu warten und zu erweitern. Dieser Artikel führt Sie in die Implementierung des MVC-Musters in PHP ein.
Tags: PHP MVC MVC-Muster PHP-Website
Oracle hilft Ihnen, genaue Einblicke in jede Logistikverbindung zu gewinnen
Oracle hilft Ihnen dabei, einen genauen Einblick in jede Logistikverbindung zu erhalten. Schließlich implementieren wir die Ansicht als Unterklasse.
<?php
/**
* Steuert die Anwendung
*/
Klasse ProductController erweitert ProductView {
//! Ein Konstruktor.
/**
* Konstruiert ein neues ProductController-Objekt
* @param $model eine Instanz der ProductModel-Klasse
* @param $getvars die eingehenden HTTP-GET-Methodenvariablen
*/
Funktion ProductController (&$model,$getvars=null) {
ProductView::ProductView($model);
$this->header();
switch ( $getvars['view'] ) {
Fall „Produkt“:
$this->productItem($getvars['id']);
brechen;
Standard:
if ( empty ($getvars['rownum']) ) {
$this->productTable();
} anders {
$this->productTable($getvars['rownum']);
}
brechen;
}
$this->footer();
}
}
?＞
Beachten Sie, dass dies nicht die einzige Möglichkeit zur Implementierung von MVC ist. Sie können beispielsweise Controller verwenden, um gleichzeitig Modelle zu implementieren und Ansichten zu integrieren. Dies ist nur eine Möglichkeit, das Muster zu demonstrieren.
Unsere index.php-Datei sieht so aus:
<?php
require_once('lib/DataAccess.php');
require_once('lib/ProductModel.php');
require_once('lib/ProductView.php');
require_once('lib/ProductController.php');
$dao=& new DataAccess ('localhost','user','pass','dbname');
$productModel=& neues ProductModel($dao);
$productController=& new ProductController($productModel,$_GET);
echo $productController->display();
?＞
Schön und einfach.
Wir haben einige Tricks für die Verwendung von Controllern, in PHP können Sie dies tun:
$this->{$_GET['method']}($_GET['param']);
Ein Vorschlag ist, dass Sie die URL-Namespace-Form des Programms besser definieren (Namespace), dann wird es standardisierter, zum Beispiel:
„index.php?class=ProductView&method=productItem&id=4“
Dadurch können wir unseren Controller wie folgt verarbeiten:
$view=new $_GET['class'];
$view->{$_GET['method']($_GET['id']);
Manchmal ist der Aufbau eines Controllers schwierig, beispielsweise wenn man einen Kompromiss zwischen Entwicklungsgeschwindigkeit und Anpassungsfähigkeit eingeht. Ein guter Ort, um sich inspirieren zu lassen, sind die Java Struts der Apache-Gruppe, deren Controller vollständig durch XML-Dokumente definiert werden.