Der Dispatcher
Überblick
Dispatching ist der Prozess, das Request Objekt
Zend_Controller_Request_Abstract zu übernehmen, die dort
enthaltenen Modul, Controller und Aktion Namen sowie die optionalen Parameter zu
extrahieren und dann den Controller zu instanzieren und die Aktion dieses Controllers
aufzurufen. Wenn kein Modul, kein Controller oder keine Aktion gefunden wurde, werden
dafür Standardwerte verwendet.
Zend_Controller_Dispatcher_Standard legt
index für jede der Controller und Action Standardwerte fest und
default für den Standardwert des Moduls, erlaubt dem Entwickler
aber auch, diese durch Verwendung der setDefaultController(),
setDefaultAction() und
setDefaultModule() Methoden zu verändern.
Note: Standard Module
Bei der Erstellung von modularen Anwendungen kann es sein das man auch einen
Namespace für eigene Standard Module haben will (die Standardkonfiguration ist, dass
das Standardmodul keinen Namensraum hat). Ab 1.5.0, kann das
durch Spezifizierung von prefixDefaultModule auf
TRUE, entweder im Front Controller oder im Dispatcher, getan
werden:
// Im Front Controller:
$front->setParam('prefixDefaultModule'// Im Dispatcher:
$dispatcher->setParam('prefixDefaultModule'
Das erlaubt es existierende Module als Standardmodule für eine Anwendung
wiederzuverwenden.
Dispatching läuft innerhalb einer Schleife im Front Controller ab. Vor dem Dispatching
fragt der Front Controller den Request ab, um benutzerspezifizierte Werte für Modul,
Controller, Aktion und optionale Parameter zu finden. Dann startet er die Dispatch
Schleife, um die Anfrage zu verarbeiten.
Zu Beginn jeden Durchlaufes setzt er im Request Objekt einen Schalter, der angibt, dass
die Aktion verarbeitet worden ist. Wenn eine Aktion oder ein pre- oder postDispatch
Plugin diesen Schalter zurücksetzt, wird die Dispatch Schleife fortgesetzt und
versucht, die neue Anfrage zu verarbeiten. Durch Ändern des Controllers und / oder der
Aktion im Request Objekt und Zuürcksetzen des Verarbeitungsstatus, kann der Entwickler
eine zu durchlaufende Anfragekette definieren.
Die Controller Methode, die solch eine Verarbeitung kontrolliert lautet
_forward(); rufe diese Methode von einer beliebigen
preDispatch(), postDispatch()
oder Aktionsmethode auf und übergebe Aktion, Controller, Modul und beliebige optionale
Parameter, die du zur neuen Aktion übersenden möchtest:
span style="color: #808080; font-style: italic;">// weiterleiten zu einer anderen Aktion im aktuellen Controller und Modul:
'bar''baz' => 'bogus'// Weiterleiten zu einer Aktion in einem anderen Controller:
// FooController::bazAction(), im aktuellen Modul:
'baz', 'foo''baz' => 'bogus'// weiterleiten zu einer Aktion in einem anderen Controller in einem
// anderen Modul Foo_BarController::bazAction():
'baz', 'bar', 'foo''baz' => 'bogus'));
}
Erben vom Dispatcher
Zend_Controller_Front ruft zuerst den Router auf, um die erste
Aktion für den Request zu ermitteln. Danach startet es die Dispatch Schleife, welche
den Dispatcher aufruft, um die Aktion zu verarbeiten.
Der Dispatcher benötigt eine Vielzahl von Daten um seine Arbeit zu erledigen - er muß
wissen wie die Namen von Controller und Aktionen formatiert werden sollen, wo nach
Dateien der Controller Klassen gesucht wird, ob ein übergebener Modulname gültig ist
oder nicht, und eine API um festzustellen ob eine gegebene Anfrage,
basierend auf den anderen vorhandenen Informationen, bearbeitbar ist.
Zend_Controller_Dispatcher_Interface definiert die folgenden
Methoden die für jede Dispatcher Implementierung benötigt werden:
span style="color: #808080; font-style: italic;">/**
* Format a string into a controller class name.
*
* @param string $unformatted
* @return string
*//**
* Format a string into an action method name.
*
* @param string $unformatted
* @return string
*//**
* Determine if a request is dispatchable
*
* @param Zend_Controller_Request_Abstract $request
* @return boolean
*//**
* Set a user parameter (via front controller, or for local use)
*
* @param string $name
* @param mixed $value
* @return Zend_Controller_Dispatcher_Interface
*//**
* Set an array of user parameters
*
* @param array $params
* @return Zend_Controller_Dispatcher_Interface
*//**
* Retrieve a single user parameter
*
* @param string $name
* @return mixed
*//**
* Retrieve all user parameters
*
* @return array
*//**
* Clear the user parameter stack, or a single user parameter
*
* @param null|string|array single key or array of keys for params to clear
* @return Zend_Controller_Dispatcher_Interface
*//**
* Set the response object to use, if any
*
* @param Zend_Controller_Response_Abstract|null $response
* @return void
*//**
* Retrieve the response object, if any
*
* @return Zend_Controller_Response_Abstract|null
*//**
* Add a controller directory to the controller directory stack
*
* @param string $path
* @param string $args
* @return Zend_Controller_Dispatcher_Interface
*//**
* Set the directory (or directories) where controller files are stored
*
* @param string|array $dir
* @return Zend_Controller_Dispatcher_Interface
*//**
* Return the currently set directory(ies) for controller file lookup
*
* @return array
*//**
* Dispatch a request to a (module/)controller/action.
*
* @param Zend_Controller_Request_Abstract $request
* @param Zend_Controller_Response_Abstract $response
* @return Zend_Controller_Request_Abstract|boolean
*//**
* Whether or not a given module is valid
*
* @param string $module
* @return boolean
*//**
* Retrieve the default module name
*
* @return string
*//**
* Retrieve the default controller name
*
* @return string
*//**
* Retrieve the default action
*
* @return string
*/
In den meisten Fällen sollte trotzdem einfach die abstrakte Klasse
Zend_Controller_Dispatcher_Abstract erweitert werden, und welcher
jede davon schon definiert wurde, oder
Zend_Controller_Dispatcher_Standard um Funktionalitäten des
Standard Dispatchers zu modifizieren.
Mögliche Gründe um den Dispatcher zu erweitern beinhaltet den Wunsch eine anderes
Klassen oder Methoden Namensschema in den eigenen Aktion Controllern zu verwenden, oder
den Wunsch ein anderes Verarbeitungs Paradigma wie das Verarbeiten zu Aktionsdateien
unter den Controller Verzeichnissen (statt auf Klassen Methoden zu verarbeiten).
|
|