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();
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);
	}
}
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();
	}
	
}
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 :)";
	}
}
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";
	}
}
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.

Kommentare