Controller Skripte

View Scripte

Sobald dein Controller die Variablen übergeben und die render() Methode aufgerufen hat, inkludiert Zend_View das angeforderte View Skript und führt es "innerhalb" des Gültigkeitsbereichs der Zend_View Instanz aus. Deshalb weisen Referenzen auf $this in deinem View Skript auf die Zend_View Instanz selber.

Auf Variablen, die vom Controller an den View übergeben worden sind, kann als Eigenschaften der Instanz zurückgegriffen werden. Wenn der Controller zum Beispiel eine Variable 'irgendwas' übergeben hat, würdest du in deinem View Skript über $this->irgendwas darauf zugreifen können. (Dies erlaubt es dir, den Überblick darüber zu behalten, welche Variablen an das Skript übergeben worden sind und welche Variablen intern zum Skript selber gehören.)

Zur Erinnerung hier noch einmal das Beispiel View Skript aus der Zend_View Einführung.

  1. <?php if ($this->books): ?>
  2.  
  3.     <!-- Eine Tabelle mit einigen Büchern. -->
  4.     <table>
  5.         <tr>
  6.             <th>Autor</th>
  7.             <th>Titel</th>
  8.         </tr>
  9.  
  10.         <?php foreach ($this->books as $key => $val): ?>
  11.         <tr>
  12.             <td><?php echo $this->escape($val['author']) ?></td>
  13.             <td><?php echo $this->escape($val['title']) ?></td>
  14.         </tr>
  15.         <?php endforeach; ?>
  16.  
  17.     </table>
  18.  
  19. <?php else: ?>
  20.  
  21.     <p>Es gibt keine Bücher zum Anzeigen.</p>
  22.  
  23. <?php endif; ?>

Ausgaben maskieren

Eine der wichtigsten Aufgaben, die in einem View Skript zu erledigen sind, ist es sicherzustellen, dass die Ausgaben auch richtig maskiert sind; neben anderen Dingen hilft dies auch Cross-Site Scripting Attacken zu vermeiden. Sofern du keine Funktion, Methode oder einen Helfer verwendest, der die Maskierungen selber durchführt, solltest Du Variablen immer maskieren, wenn du sie ausgeben möchtest.

Zend_View stellt eine Methode escape() bereit, die das Maskieren für dich übernimmt.

  1. // schlechte View Skript Praxis:
  2. echo $this->variable;
  3.  
  4. // gute View Skript Praxis:
  5. echo $this->escape($this->variable);

Standardmäßig verwendet escape() die PHP htmlspecialchars() Funktion für die Maskierung. Allerdings könntest du abhängig von deiner Umgebung den Wunsch haben, die Maskierung anders durchzuführen. Verwende die setEscape() Methode auf der Controller Ebene, um Zend_View mitzuteilen, welche Maskierungsmöglichkeit als Callback verwendet werden soll.

  1. // erstelle eine Zend_View Instanz
  2. $view = new Zend_View();
  3.  
  4. // teile ihr mit, dass htmlentities für die Maskierung
  5. // verwendet werden soll
  6. $view->setEscape('htmlentities');
  7.  
  8. // oder teile ihr mit, eine statische Klassenmethode für
  9. // die Maskierung zu verwenden
  10. $view->setEscape(array('SomeClass', 'methodName'));
  11.  
  12. // sogar Instanzmethoden sind möglich
  13. $obj = new SomeClass();
  14. $view->setEscape(array($obj, 'methodName'));
  15.  
  16. // und dann erstelle die Ausgabe
  17. echo $view->render(...);

Diese Callback Funktion oder Methode sollte den zu maskierenden Wert als ersten Parameter übernehmen und alle anderen Parameter sollten optional sein.

Verwendung alternativer Templatesysteme

Obwohl PHP selber eine mächtiges Templatesystem ist, haben viele Entwickler das Gefühl, dass es zu mächtig oder komplex für die Template Designer ist und möchten ein alternatives Templatesystem verwenden. Zend_View stellt zwei Mechanismen bereit, um dies zu realisieren, die erste durch Viewskripte und die zweite durch Implementierung von Zend_View_Interface.

Template Systeme die View Scripte verwenden

Ein Viewskript kann verwendet werden, um ein separats Templateobjekt zu instanzieren und anzupassen, z.B. für eine PHPLIB-style Template. Das Viewskript für solch eine Aufgabe könnte so aussehen:

  1. include_once 'template.inc';
  2. $tpl = new Template();
  3.  
  4. if ($this->books) {
  5.     $tpl->setFile(array(
  6.         "booklist" => "booklist.tpl",
  7.         "eachbook" => "eachbook.tpl",
  8.     ));
  9.  
  10.     foreach ($this->books as $key => $val) {
  11.         $tpl->set_var('author', $this->escape($val['author']);
  12.         $tpl->set_var('title', $this->escape($val['title']);
  13.         $tpl->parse("books", "eachbook", true);
  14.     }
  15.  
  16.     $tpl->pparse("output", "booklist");
  17. } else {
  18.     $tpl->setFile("nobooks", "nobooks.tpl")
  19.     $tpl->pparse("output", "nobooks");
  20. }

Dies wären die zugehörigen Template Dateien:

  1. <!-- booklist.tpl -->
  2. <table>
  3.     <tr>
  4.         <th>Autor</th>
  5.         <th>Titel</th>
  6.     </tr>
  7.     {books}
  8. </table>
  9.  
  10. <!-- eachbook.tpl -->
  11.     <tr>
  12.         <td>{author}</td>
  13.         <td>{title}</td>
  14.     </tr>
  15.  
  16. <!-- nobooks.tpl -->
  17. <p>Es gibt keine Bücher zum Anzeigen.</p>

Ein Templatesystem mit Hilfe von Zend_View_Interface verwenden

Manche finden es einfacher, ein Zend_View kompatibles Templatesystem zu verwenden. Zend_View_Interface definiert die minimale Schnittstelle, die zur Kompatibilität benötigt wird.

  1. /**
  2. * Gebe das aktuelle Template Engine Objekt zurück
  3. */
  4. public function getEngine();
  5.  
  6. /**
  7. * Setze den Pfad zu den Viewskripten / Templates
  8. */
  9. public function setScriptPath($path);
  10.  
  11. /**
  12. * Setze den Pfad zu allen View Ressourcen
  13. */
  14. public function setBasePath($path, $prefix = 'Zend_View');
  15.  
  16. /**
  17. * Füge einen zusätzlichen Basispfad den View ressourcen hinzu
  18. */
  19. public function addBasePath($path, $prefix = 'Zend_View');
  20.  
  21. /**
  22. * Empfange die aktuellen Skript Pfade
  23. */
  24. public function getScriptPaths();
  25.  
  26. /**
  27. * Überladungsmethoden zum Zuordnen von Templatevariablen
  28. * als Objekteigenschaften
  29. */
  30. public function __set($key, $value);
  31. public function __isset($key);
  32. public function __unset($key);
  33.  
  34. /**
  35. * Manuelle Zuweisung von Templatevariablen oder die Möglichkeit,
  36. * mehrere Variablen in einem Durchgang zuzuordnen.
  37. */
  38. public function assign($spec, $value = null);
  39.  
  40. /**
  41. * Alle zugewiesenen Templatevariablen zurücksetzen
  42. */
  43. public function clearVars();
  44.  
  45. /**
  46. * Rendern des Templates mit dem Namen $name
  47. */
  48. public function render($name);

Durch Verwendung dieses Interfaces ist es relativ einfach, das Templatesystem eines Dritten in eine Zend_View kompatible Klasse zu umhüllen. Als Beispiel folgt ein möglicher Wrapper für Smarty:

  1. class Zend_View_Smarty implements Zend_View_Interface
  2. {
  3.     /**
  4.      * Smarty object
  5.      * @var Smarty
  6.      */
  7.     protected $_smarty;
  8.  
  9.     /**
  10.      * Constructor
  11.      *
  12.      * @param string $tmplPath
  13.      * @param array $extraParams
  14.      * @return void
  15.      */
  16.     public function __construct($tmplPath = null, $extraParams = array())
  17.     {
  18.         $this->_smarty = new Smarty;
  19.  
  20.         if (null !== $tmplPath) {
  21.             $this->setScriptPath($tmplPath);
  22.         }
  23.  
  24.         foreach ($extraParams as $key => $value) {
  25.             $this->_smarty->$key = $value;
  26.         }
  27.     }
  28.  
  29.     /**
  30.      * Gebe das aktuelle Template Engine Objekt zurück
  31.      *
  32.      * @return Smarty
  33.      */
  34.     public function getEngine()
  35.     {
  36.         return $this->_smarty;
  37.     }
  38.  
  39.     /**
  40.      * Setze den Pfad zu den Templates
  41.      *
  42.      * @param string $path Das Verzeichnis, das als Pfad gesetzt werden soll.
  43.      * @return void
  44.      */
  45.     public function setScriptPath($path)
  46.     {
  47.         if (is_readable($path)) {
  48.             $this->_smarty->template_dir = $path;
  49.             return;
  50.         }
  51.  
  52.         throw new Exception('Invalid path provided');
  53.     }
  54.  
  55.     /**
  56.      * Empfange das aktuelle template Verzeichnis
  57.      *
  58.      * @return string
  59.      */
  60.     public function getScriptPaths()
  61.     {
  62.         return array($this->_smarty->template_dir);
  63.     }
  64.  
  65.     /**
  66.      * Alias für setScriptPath
  67.      *
  68.      * @param string $path
  69.      * @param string $prefix nicht verwendet
  70.      * @return void
  71.      */
  72.     public function setBasePath($path, $prefix = 'Zend_View')
  73.     {
  74.         return $this->setScriptPath($path);
  75.     }
  76.  
  77.     /**
  78.      * Alias für setScriptPath
  79.      *
  80.      * @param string $path
  81.      * @param string $prefix nicht verwendet
  82.      * @return void
  83.      */
  84.     public function addBasePath($path, $prefix = 'Zend_View')
  85.     {
  86.         return $this->setScriptPath($path);
  87.     }
  88.  
  89.     /**
  90.      * Weise dem Template eine Variable zu
  91.      *
  92.      * @param string $key der Variablenname.
  93.      * @param mixed $val der Variablenwert.
  94.      * @return void
  95.      */
  96.     public function __set($key, $val)
  97.     {
  98.         $this->_smarty->assign($key, $val);
  99.     }
  100.  
  101.     /**
  102.      * Erlaubt das Testen von empty() und isset()
  103.      *
  104.      * @param string $key
  105.      * @return boolean
  106.      */
  107.     public function __isset($key)
  108.     {
  109.         return (null !== $this->_smarty->get_template_vars($key));
  110.     }
  111.  
  112.     /**
  113.      * Erlaubt das Zurücksetzen von Objekteigenschaften
  114.      *
  115.      * @param string $key
  116.      * @return void
  117.      */
  118.     public function __unset($key)
  119.     {
  120.         $this->_smarty->clear_assign($key);
  121.     }
  122.  
  123.     /**
  124.      * Weise dem Template Variablen zu
  125.      *
  126.      * Erlaubt das Zuweisen eines bestimmten Wertes zu einem bestimmten
  127.      * Schlüssel, ODER die Übergabe eines Array mit Schlüssel => Wert
  128.      * Paaren zum Setzen in einem Rutsch.
  129.      *
  130.      * @see __set()
  131.      * @param string|array $spec Die zu verwendene Zuweisungsstrategie
  132.      * (Schlüssel oder Array mit Schlüssel => Wert paaren)
  133.      * @param mixed $value (Optional) Wenn ein Variablenname verwendet wurde,
  134.      *                                verwende diesen als Wert
  135.      * @return void
  136.      */
  137.     public function assign($spec, $value = null)
  138.     {
  139.         if (is_array($spec)) {
  140.             $this->_smarty->assign($spec);
  141.             return;
  142.         }
  143.  
  144.         $this->_smarty->assign($spec, $value);
  145.     }
  146.  
  147.     /**
  148.      * Setze alle zugewiesenen Variablen zurück.
  149.      *
  150.      * Setzt alle Variablen zurück, die Zend_View entweder durch
  151.      * {@link assign()} oder Überladen von Eigenschaften
  152.      * ({@link __get()}/{@link __set()}) zugewiesen worden sind.
  153.      *
  154.      * @return void
  155.      */
  156.     public function clearVars()
  157.     {
  158.         $this->_smarty->clear_all_assign();
  159.     }
  160.  
  161.     /**
  162.      * Verarbeitet ein Template und gibt die Ausgabe zurück
  163.      *
  164.      * @param string $name Das zu verarbeitende Template
  165.      * @return string Die Ausgabe.
  166.      */
  167.     public function render($name)
  168.     {
  169.         return $this->_smarty->fetch($name);
  170.     }
  171. }

In diesem Beispiel kannst du die Zend_View_Smarty anstelle von Zend_View instanzieren und es dann ungefähr wie Zend_View verwenden:

  1. // Beispiel 1. In initView() des Initialisers.
  2. $view = new Zend_View_Smarty('/Pfad/der/Templates');
  3. $viewRenderer =
  4.     Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer');
  5. $viewRenderer->setView($view)
  6.              ->setViewBasePathSpec($view->_smarty->template_dir)
  7.              ->setViewScriptPathSpec(':controller/:action.:suffix')
  8.              ->setViewScriptPathNoControllerSpec(':action.:suffix')
  9.              ->setViewSuffix('tpl');
  10.  
  11. // Beispiel 2. Die Verwendung im Action Controller bleibt die gleiche...
  12. class FooController extends Zend_Controller_Action
  13. {
  14.     public function barAction()
  15.     {
  16.         $this->view->book   = 'Zend PHP 5 Zertifizierungs Study Guide';
  17.         $this->view->author = 'Davey Shafik und Ben Ramsey'
  18.     }
  19. }
  20.  
  21. // Beispiel 3. Initialisierung der View im Action Controller
  22. class FooController extends Zend_Controller_Action
  23. {
  24.     public function init()
  25.     {
  26.         $this->view   = new Zend_View_Smarty('/path/to/templates');
  27.         $viewRenderer = $this->_helper->getHelper('viewRenderer');
  28.         $viewRenderer->setView($this->view)
  29.                      ->setViewBasePathSpec($view->_smarty->template_dir)
  30.                      ->setViewScriptPathSpec(':controller/:action.:suffix')
  31.                      ->setViewScriptPathNoControllerSpec(':action.:suffix')
  32.                      ->setViewSuffix('tpl');
  33.     }
  34. }

Controller Skripte