PHP (OOP, MVC), HTML, MySQL, Javascript, AJAX und vieles mehr!

<< Zurück zur Übersicht

Jetzt kommen wir zu einem wirklich wichtigen und interessanten Teil. Bisher konnten wir nämlich noch gar nichts ausgeben, ohne das EVA-Prinzip (Eingabe – Verarbeitung – Ausgabe) zu verletzen. Es soll jetzt eine weitere Schicht des MVC-Patterns implementiert werden, die View-Schicht!

Anforderungen

Mir war wichtig, dass es verschiedene Ausgabeformate geben kann. Bisher habe ich zwar nur HTML benötigt, aber dank der abstrakten Architektur könnte ich auch problemlos JSON, XML oder PDF ausgeben lassen. Es gibt eine View-Factory, die die richtige View-Klasse instanziiert und das Objekt zurückgibt:

final class FW_View
{    
   /**
    * @access public static
    * @return object    
    * 
    * Diese Methode soll das richtige View-Objekt liefern. Es dient also als
    * Factory für die Views. Das soll dazu führen, dass der Programmierer nicht
    * wissen muss, mit welchem View-Objekt er arbeitet.                
    */       
   public static function getView()
   {
     return call_user_func_array(array(FW_FrontController::$view,'getInstance'),array());
   }
}

Man kann jetzt überall im kompletten Projekt mit FW_View::getView() mit dem View-Objekt arbeiten.
Wie man sieht, ist es erforderlich, dass alle View-Klassen die getInstance implementieren. Es ist zwar nicht zwingend notwendig, dass sie auch ein Singleton sind (getInstance() könnte genausogut auch bei jedem Aufruf ein Objekt erzeugen), aber wer braucht schon mehrere Views? Mir würde da jetzt kein Sinn einfallen.

Alle Views müssen das FW_View_Interface implementieren, das so aussieht:

interface FW_View_Interface
{   
  public function display(FW_Http_Response $response);
  public static function getInstance();
}

Die Methode display() wird aufgerufen, wenn die Ausgabe gemacht werden soll.

Es gibt noch die abstrakte Klasse FW_View_Abstract, von der jede View erben muss. Damit implementiert sie automatisch das FW_View_Interface.

abstract class FW_View_Abstract implements FW_View_Interface
{
   public static $layout = "Standart";
   protected $templates = array();
   protected $templateNow = null;
   
   protected $viewHelpers = array();
   
   protected static $instance = null;
   
   protected function __clone() {}
   protected function __construct() {}   
   
   //------------------------------------------
   // getInstance() kann nicht in der abstrakten Klasse definiert werden,
   // weil dazu der Klassenname bekannt sein muss.
   // self zeigt immer auf FW_View_Abstract. Das wird mit PHP 6 aber endlich
   // funktionieren.
   
   /**
    * @access public
    * @param string $func
    * @param array  $params
    * 
    * Aufruf von ViewHelpers.
    * Wenn der Name des helpers mit FW_ beginnt, ist der Helper ein Teil des
    * Frameworks. Deshalb wird FW_View_Helper_ als Prefix benutzt.
    * Ansonsten ist das Prefix einfach ViewHelper.                            
    */       
   public function __call($func, $params)
   {
       if(substr($func, 0, 3) == "FW_")
       {
         $class = "FW_View_Helper_".substr($func, 3);
       }
       else
       {
         $class = "ViewHelper_".$func;
       }
       
       if(!isset($this->viewHelpers[$class]))
       {
         $this->viewHelpers[$class] = new $class;
       }       
       
       return $this->viewHelpers[$class]->run($params);
   }

In der statischen Eigenschaft $layout wird definiert, welches Seitenlayout angezeigt werden soll. Was genau das ist, wird später erklärt.

Die magische Methode __call habe ich hier zum einfacheren Verwenden von ViewHelpern geschrieben.

Die wichtigste Klasse ist aber FW_View_HTML. Sie wird zum Erzeugen von HTML-Dokumenten benutzt.

class FW_View_HTML extends FW_View_Abstract
{
   public static function getInstance()
   {
     if(self::$instance === null)
     {
        self::$instance = new self();
     }
     return self::$instance;
   }
   
   public function display(FW_Http_Response $response)
   {
      ob_start();
      $path = FW_Config::getInstance()->get("viewpath")."/layouts/".self::$layout.".tpl.php";
      if(file_exists($path))
      {
        include($path);
        $content = ob_get_clean();
        $response->addContent($content);
      }
      else
      {
        $debugger = FW_Debugger::getInstance();
        $debugger->log("Layout kann nicht gefunden werden", __FILE__, __LINE__, "error");
      }
   }
   
   public function addTemplateContent($templatename, $content, $templatefile)
   { 
     $this->templates[$templatename] = array($content, $templatefile);
   }
      
   public function __get($key) //darf nur vars aus aktuellem tplcontent zeigen
   {
     if(isset($this->templates[$this->templateNow][0][$key]))
     {
        return $this->templates[$this->templateNow][0][$key];
     }
   }
   
   public function showTemplateContent($templatename)
   {  
     $this->templateNow = $templatename;   
     if(isset($this->templates[$this->templateNow]))
     {
      include(FW_Config::getInstance()->get("viewpath")."/templates/".$this->templates[$this->templateNow][1]);
     }
     else
     {
      echo "Das Template ".$templatename." wurde von keinem Controller mit Daten gefuettert!";
     }
   }
   
   public function includeTemplateFile($templatename)
   {
     $path = FW_Config::getInstance()->get("viewpath")."/static_templates/".$templatename.".tpl.php";
     if(file_exists($path))
     {
      include($path);
     } 
     else
     {
      echo "Template nicht gefunden: ".$templatename." in ".$path;
     }
   }
}

Erklärung der einzelnen Methoden
display()

   public function display(FW_Http_Response $response)
   {
      ob_start();
      $path = FW_Config::getInstance()->get("viewpath")."/layouts/".self::$layout.".tpl.php";
      if(file_exists($path))
      {
        include($path);
        $content = ob_get_clean();
        $response->addContent($content);
      }
      else
      {
        $debugger = FW_Debugger::getInstance();
        $debugger->log("Layout kann nicht gefunden werden", __FILE__, __LINE__, "error");
      }
   }

Display() ist die Methode, die später vom FrontController aufgerufen wird, wenn er mit der Abarbeitung aller Controller fertig ist und die Antwort an den Client senden will.

Es wird die Layout-Datei geöffnet und die Ausgabe in $content abgespeichert. Die Layout-Datei ist die Datei, die das Layout der Seite ohne Inhalt enthält. Der eigentliche Inhalt wird dann in dieser Datei dynamisch geladen.

addTemplateContent()

public function addTemplateContent($templatename, $content, $templatefile)
   { 
     $this->templates[$templatename] = array($content, $templatefile);
   }

Hiermit kann man im Controller Daten zur Ausgabe abspeichern.

__get()

 public function __get($key) //darf nur vars aus aktuellem tplcontent zeigen
   {
     if(isset($this->templates[$this->templateNow][0][$key]))
     {
        return $this->templates[$this->templateNow][0][$key];
     }
   }

Im einzelnen Templatefile kann über $this->irgend_eine_variable auf die Variablen zugegriffen werden, die vorher mit addTemplateContent definiert wurden. Da es mehrere Templates geben kann, dient $this->templateNow als Pointer auf das aktuelle Template.

$this->templateNow wird immer dann gesetzt, wenn showTemplateContent() aufgerufen wird

public function showTemplateContent($templatename)
   {  
     $this->templateNow = $templatename;   
     if(isset($this->templates[$this->templateNow]))
     {
      include(FW_Config::getInstance()->get("viewpath")."/templates/".$this->templates[$this->templateNow][1]);
     }
     else
     {
      echo "Das Template ".$templatename." wurde von keinem Controller mit Daten gefuettert!";
     }
   }

Ein kleines Beispiel:
Es gibt 3 Templates: Content, Menu, Shoutbox

TemplateNow zeigt nach showTemplateContent(„content“) auf „content“ und stellt die Daten dar, die vorher mit addTemplateContent(„content“, $data, „content.tpl.php“) definiert wurden.
TemplateNow zeigt nach showTemplateContent(„Menu“) auf „Menu“ und stellt die Daten dar, die vorher mit addTemplateContent(„Menu“, $data, „Menu.tpl.php“) definiert wurden.
TemplateNow zeigt nach showTemplateContent(„Shoutbox“) auf „Shoutbox“ und stellt die Daten dar, die vorher mit addTemplateContent(„Shoutbox“, $data, „Shoutbox.tpl.php“) definiert wurden.

Anwendung
Als erstes legen wir im Projektordner unter viewfiles/layouts die Datei Standart.tpl.php an. Diese Datei muss in jedem Projekt vorhanden sein! Der Inhalt dieser Datei sieht zu Testzwecken ganz einfach aus:

Der Inhalt der Seite ist: 

< ?php $this->showTemplateContent("content"); ?>

Auch eine Templatedatei wird benötigt. Diese Datei wird jetzt einfach unter viewfiles/templates/content.tpl.php erstellt. Als Inhalt verwenden wir wieder was ganz schlichtes:

< ?=$this->text; ?>

Wenn man das Skript jetzt aufruft, erscheint kein Inhalt. Warum? Weil „Text“ noch nicht definiert wurde!

Das wird nämlich im Controller gemacht:

class Controller_Index extends FW_Controller_Abstract
{
  public function Index_Action()
  {
    FW_View::getView()->addTemplateContent("content", array("text" => "Es geht!"), "content.tpl.php");
  }
}

Und jetzt geht es! Ich hoffe, auch dieses Kapitel wurde ausführlich genug beschrieben. Wenn nicht, bin ich in den Kommentaren für euch da!

(3 Stimme, durchschnittlich 5,00 / 5)

Loading...