Zend Framework 1.9.9 Manual

Die Controller Architektur beinhaltet ein Pluginsystem, das den Aufruf von Anwendercode ermöglicht, wenn bestimmte Ereignisse im Controller Prozess auftreten. Der Front Controller verwendet einen Plugin Broker als eine Registry für User Plugins und der Plugin Broker stellt sicher, dass die Ereignismethoden von jedem Plugin aufgerufen werden, die im Front Controller registriert worden sind.

Die Ereignismethoden sind in der abstrakten Klasse Zend_Controller_Plugin_Abstract definiert, von dem User Plugin Klassen angeleitet werden müssen:

• routeStartup() wird aufgerufen bevor Zend_Controller_Front den Router aufruft, um den Request anhand der registrierten Routen zu überprüfen.

• routeShutdown() wird aufgerufen, nachdem der Router das Routing der Anfrage beendet.

• dispatchLoopStartup() wird aufgerufen, bevor Zend_Controller_Front den Dispatch Loop aufnimmt.

• preDispatch() wird von dem Dispatcher aufgerufen, bevor eine Aktion verarbeitet wird. Dieser Callback erlaubt ein Proxy oder Filter Verhalten. Durch Verändern des Requests und Zurücksetzen des Verarbeitungsstatus (mittels Zend_Controller_Request_Abstract::setDispatched(false)) kann die aktuelle Aktion abgebrochen oder ersetzt werden.

• postDispatch() wird von dem Dispatcher aufgerufen, nachdem eine Aktion verarbeitet wurde. Dieser Callback erlaubt ein Proxy oder Filter Verhalten. Durch Verändern des Requests und Zurücksetzen des Verarbeitungsstatus (mittels Zend_Controller_Request_Abstract::setDispatched(false)) kann eine neue Aktion für die Verarbeitung angegeben werden.

• dispatchLoopShutdown() wird aufgerufen, nachdem Zend_Controller_Front den Dispatch Loop beendet.

Um eine Plugin Klasse zu schreiben, bindet man einfach die abstrakte Klasse Zend_Controller_Plugin_Abstract ein und erweitert sie:

class MyPlugin extends Zend_Controller_Plugin_Abstract
{
    // ...
}

Keine der Methoden von Zend_Controller_Plugin_Abstract ist abstrakt, so dass Plugin Klassen nicht gezwungen werden, irgend einen der vorhandenen Ereignismethoden zu implemetieren, die oben gelistet wurden. Schreiber von Plugins brauchen nur die Methoden zu implementieren, die sie für ihre speziellen Bedürfnisse benötigen.

Zend_Controller_Plugin_Abstract stellt den Controller Plugins außerdem die Request und Response Objekte über die getRequest() und getResponse() Methoden zur Verfügung.

Plugin Klassen werden mit Zend_Controller_Front::registerPlugin() registriert und können jederzeit registriert werden. Der folgende Schnipsel zeigt, wie ein Plugin in der Controllerkette verwendet werden kann:

class MyPlugin extends Zend_Controller_Plugin_Abstract
{
    public function routeStartup(Zend_Controller_Request_Abstract $request)
    {
        $this->getResponse()
             ->appendBody("
routeStartup() called
\n");
    }

    public function routeShutdown(Zend_Controller_Request_Abstract $request)
    {
        $this->getResponse()
             ->appendBody("
routeShutdown() called
\n");
    }

    public function dispatchLoopStartup(
        Zend_Controller_Request_Abstract $request)
    {
        $this->getResponse()
             ->appendBody("
dispatchLoopStartup() called
\n");
    }

    public function preDispatch(Zend_Controller_Request_Abstract $request)
    {
        $this->getResponse()
             ->appendBody("
preDispatch() called
\n");
    }

    public function postDispatch(Zend_Controller_Request_Abstract $request)
    {
        $this->getResponse()
             ->appendBody("
postDispatch() called
\n");
    }

    public function dispatchLoopShutdown()
    {
        $this->getResponse()
             ->appendBody("
dispatchLoopShutdown() called
\n");
    }
}

$front = Zend_Controller_Front::getInstance();
$front->setControllerDirectory('/path/to/controllers')
      ->setRouter(new Zend_Controller_Router_Rewrite())
      ->registerPlugin(new MyPlugin());
$front->dispatch();

Angenommen das keine der Aktionen igendeine Ausgabe produzieren, und nur eine Aktion aufgerufen wurde, dann erzeugt die Funktionalität des obigen Plugins trotzdem die folgende Ausgabe:

routeStartup() aufgerufen
routeShutdown() aufgerufen
dispatchLoopStartup() aufgerufen
preDispatch() aufgerufen
postDispatch() aufgerufen
dispatchLoopShutdown() aufgerufen

Note:

Plugins können jederzeit wärend der Ausführung des Frontcontrollers registriert werden. Wenn trotzdem ein Event ausgeführt wurde für das das Plugin eine registrierte Eventmethode enthält, wird diese Methode nicht getriggert.

Fallweise kann es notwendig sein ein Plugin zu entfernen oder empfangen. Die folgenden Methoden des Frontcontrollers erlauben dies:

• getPlugin($class) erlaubt es ein Plugin durch den Klassennamen zu empfangen. Wenn kein Plugin entspricht, wird FALSE zurückgegeben. Wenn mehr als ein Plugin dieser Klasse registriert ist, wird ein Array zurückgegeben.

• getPlugins() empfängt den kompletten Plugin Stack.

• unregisterPlugin($plugin) erlaubt die Entfernung eines Plugins vom Stack. Es kann ein Plugin Objekt oder der Klassenname des Plugins, das entfernt werden soll, übergeben werden. Wenn der Klassenname übergeben wird, wird jedes Plugin dieser Klasse entfernt.

Zend Framework enthält ein Plugin für die Fehlerbehandlung in der Standard Distribution.

class ErrorController extends Zend_Controller_Action
{
    public function errorAction()
    {
        $errors = $this->_getParam('error_handler');
    }
}

class ErrorController extends Zend_Controller_Action
{
    public function errorAction()
    {
        $errors = $this->_getParam('error_handler');

        switch ($errors->type) {
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
                // 404 Fehler -- Controller oder Aktion nicht gefunden
                $this->getResponse()
                     ->setRawHeader('HTTP/1.1 404 Not Found');

                // ... Ausgabe für die Anzeige erzeugen...
                break;
            default:
                // Anwendungsfehler; Fehler Seite anzeigen, aber den
                // Status Code nicht ändern
                break;
        }
    }
}

public function errorAction()
{
        $errors = $this->_getParam('error_handler');

        switch ($errors->type) {
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
                // 404 Fehler -- Controller oder Aktion nicht gefunden
                $this->getResponse()
                     ->setRawHeader('HTTP/1.1 404 Not Found');

                // ... Ausgabe für die Anzeige erzeugen...
                break;
            default:
                // Anwendungsfehler; Fehler Seite anzeigen, aber den
                // Status Code nicht ändern

                // ...

                // Ausnahme loggen:
                $exception = $errors->exception;
                $log = new Zend_Log(
                    new Zend_Log_Writer_Stream(
                        '/tmp/applicationException.log'
                    )
                );
                $log->debug($exception->getMessage() . "\n" .
                            $exception->getTraceAsString());
                break;
        }
}

$this->getResponse()->clearBody();

$front = Zend_Controller_Front::getInstance();
$front->registerPlugin(new Zend_Controller_Plugin_ErrorHandler());

$front = Zend_Controller_Front::getInstance();
$front->registerPlugin(new Zend_Controller_Plugin_ErrorHandler(array(
    'module'     => 'mystuff',
    'controller' => 'static',
    'action'     => 'error'
)));

$plugin = new Zend_Controller_Plugin_ErrorHandler();
$plugin->setErrorHandlerModule('mystuff')
       ->setErrorHandlerController('static')
       ->setErrorHandlerAction('error');

$front = Zend_Controller_Front::getInstance();
$front->registerPlugin($plugin);

class ErrorController extends Zend_Controller_Action
{
    public function errorAction()
    {
        $errors = $this->_getParam('error_handler');

        switch ($errors->type) {
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
                // 404 Fehler -- Controller oder Aktion nicht gefunden
                $this->getResponse()->setRawHeader('HTTP/1.1 404 Not Found');

                $content =<<Error!
Die angefragte Seite konnte nicht gefunden werden.
EOH;
                break;
            default:
                // Anwendungsfehler
                $content =<<Fehler!
Ein unerwarteter Fehler trat auf.
Bitte versuchen Sie es etwas später nocheinmal.
EOH;
                break;
        }

        // Vorherige Inhalte löschen
        $this->getResponse()->clearBody();

        $this->view->content = $content;
    }
}

PUT /notes/5.xml HTTP/1.1

title=Hallo&body=Welt

$front = Zend_Controller_Front::getInstance();
$front->registerPlugin(new Zend_Controller_Plugin_PutHandler());

...
public function putAction()
{
    $title = $this->getRequest()->getParam('title'); // $title = "Hallo"
    $body = $this->getRequest()->getParam('body'); // $body = "Welt"
}
...