Enterprise Pattern - MVC

Enterprise an Kirk - Bitte kommen? Entperprise? Ja, gehts denn noch?

In der Enterprise-Entwicklung geht es zwar auch um die verschiedenen Verhaltensmuster, aber es geht auch darum, neben der intelligenten Implementierung, die Schichten einer Applikation sauber zu trennen. Bisher haben wir in unseren Codes immer lustig HTML und PHP gemischt, die einen Methoden haben etwas zur Verfügung gestellt, andere etwas geholt und ausgegeben. Das könnte doch aber auch etwas sauberer getrennt werden, oder? Genau dafür gibt es z.B. das Prinzip des Model-View-Controllers (MVC). Hier arbeiten mehrere Klassen zusammen um die Anfrage des Browsers und die dann ausgegebenen Daten in der Logik sauber zu trennen.

 

  • Controller: nimmt die Aktionen des Benutzers an, fordert die Daten vom Model an und gibt sie an den View weiter.
  • Model: Holt die Daten aus der Datenbank und gibt sie an den Controller zurück
  • View: ist für das parsen des Templates zuständig und gibt die Daten aus dem Model in HTML aus.

 

Auf diese Weise kann es eine saubere Trennung der einzelnen Schichten einer Applikation geben. Unabhängig davon, können hier selbstverständlich viele weitere Klassen beteiligt sein, wie z.B. eine vernünftige Request-Klasse, Datenbank-Klasse oder Registry-Klasse, die selbst verschiedenen Verhaltensmustern angehören. Naja, klar, kompliziert gehts immer... Folgendes Beispiel zeigt einen Minimal-MVC:

./index.php
define ('BASEPATH', realpath(dirname(__FILE__)));
include(BASEPATH.DIRECTORY_SEPARATOR.'classes' .DIRECTORY_SEPARATOR.'autoload.class.php');

$controller = new Controller();
echo $controller->display();
./classes/autoload.class.php
function __autoload ($classe) {
	
	$class = strtolower($classe);	
	$class = $class.'.class.php';
	
	if (file_exists(BASEPATH.DIRECTORY_SEPARATOR.'classes' .DIRECTORY_SEPARATOR.$class)) {
		include(BASEPATH.DIRECTORY_SEPARATOR.'classes' .DIRECTORY_SEPARATOR.$class);
	}
}
./classes/controller.class.php
class Controller {
	
	private $template;
	private $view;
	private $data;

	public function __construct() { 
		$this->view = new View();
		$this->data = Model::getData();
	}

	public function display() {		
		$this->view->setTemplate();
		$this->view->setContent("title", "OOP mit PHP");
		$this->view->setContent("content", $this->data);
		$this->view->setContent("footer", "&copy 2011 by mausernetwork\n");
		
		return $this->view->parseTemplate();
	}
	
}
./classes/model.class.php
class Model {
	
	public function __construct() {
		// ich hole hier spaeter die Datenbankverbindung :)
	}

	public static function getData() {
		return "Das Model gibt diese Daten an den Controller zurück :)";
	}
}
./classes/view.class.php
class View {

	private $path 		= 'templates';
	private $template;
	private $content 	= array();

	public function setContent($key, $value){
		$this->content[$key] = $value;
	}


	public function setTemplate($template = 'default') {
			$this->template = $this->path . DIRECTORY_SEPARATOR . $template . '.tpl.php';
	}


	public function parseTemplate() {
		
		if (file_exists($this->template)) {

			ob_start();
				include $this->template;
				$output = ob_get_contents();
			ob_end_clean();
				
		return $output;
		}
		return "Kann das Template ".$this->template." nicht finden";
	}
}
./templates/default.tpl.php
<html>
<head>
	<title><?php echo $this->content['title']; ?></title>
</head>
<body>
<?php echo $this->content['content']; ?>
<br />
<?php echo $this->content['footer']; ?>
</body>

Ok, und wie funktioniert das nun? Das ist wirklich ziemlich simpel:

  • Zunächst wird die index.php aufgerufen und diese implementiert die autoload.class.php
  • Jetzt wird der Controller aufgerufen: dieser holt sich mittels der statischen Methode $this->data = Model::getData(); die Daten aus dem Model und gibt sie danach mittels $this->view->setContent(); an den View weiter.
  • Im View werden jetzt alle Daten in einem Array gespeichert und am Abschluss an das Template übergeben.

Tja, und das ist auch schon alles. Eigentlich ziemlich simpel. Was aber, wenn man verschiedene Ausgaben haben möchte und wenn die Daten vielleicht aus verschiedenen Datenbanken kommen sollen? Dann braucht man mehrere Models, Controller und Views - abhängig von der Browseranfrage. Und genau da setzt ein Framework an. Denn jetzt kommt z.B. auch eine Request-Klasse mit ins Spiel, die die verschiedenen Anfragen an verschiedene Controller und Models weiterleitet.

Download des Mini-MVC

Download Download (3,9 kB)

Kommentare

Kommentar von Peter | 19.12.2013

Top

Kommentar von Deniz | 25.12.2013

Hallo,

Super Seite!!!
Mich würde noch interessieren, wie man das mit der Request Klasse macht, also wie man mehrere Seiten mittels MVC erstellen kann. Wäre echt cool wenn du es mir zeigen würdest.

Mach weiter so!
ps: ich habe keine Email

Liebe Grüße

Kommentar von Rico | 26.12.2013

Schön, dass das Thema MVC interessant ist :)
Das hier beschriebene Modell ist schon 2 Jahre alt. Mal sehen, ob ich noch eine vernünftige Request-Klasse finde. Ich mache das in den nächsten Tagen mal fertig.

LG Rico

Kommentar von Amil | 17.11.2015

supa mvc

Kommentar von Werner | 01.12.2015

Deine Art MVC anzuwenden ist die aller aller beste!
Ich bewundere dich Rico!

Kommentar von Frank | 25.03.2016

Bin gerade auch dabei per PHP und OOP ein MVC zu erstellen, da dient mir dieses Skript wirklich eine gute Grundlage, thx ;-)