Der Standard Router

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:

  1. // Im Front Controller:
  2. $front->setParam('prefixDefaultModule'// Im Dispatcher:
  3. $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:

  1. span style="color: #808080; font-style: italic;">// weiterleiten zu einer anderen Aktion im aktuellen Controller und Modul:
  2. 'bar''baz' => 'bogus'// Weiterleiten zu einer Aktion in einem anderen Controller:
  3.     // FooController::bazAction(), im aktuellen Modul:
  4. 'baz', 'foo''baz' => 'bogus'// weiterleiten zu einer Aktion in einem anderen Controller in einem
  5.     // anderen Modul Foo_BarController::bazAction():
  6. 'baz', 'bar', 'foo''baz' => 'bogus'));
  7. }

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:

  1. span style="color: #808080; font-style: italic;">/**
  2.      * Format a string into a controller class name.
  3.      *
  4.      * @param string $unformatted
  5.      * @return string
  6.      *//**
  7.      * Format a string into an action method name.
  8.      *
  9.      * @param string $unformatted
  10.      * @return string
  11.      *//**
  12.      * Determine if a request is dispatchable
  13.      *
  14.      * @param  Zend_Controller_Request_Abstract $request
  15.      * @return boolean
  16.      *//**
  17.      * Set a user parameter (via front controller, or for local use)
  18.      *
  19.      * @param string $name
  20.      * @param mixed $value
  21.      * @return Zend_Controller_Dispatcher_Interface
  22.      *//**
  23.      * Set an array of user parameters
  24.      *
  25.      * @param array $params
  26.      * @return Zend_Controller_Dispatcher_Interface
  27.      *//**
  28.      * Retrieve a single user parameter
  29.      *
  30.      * @param string $name
  31.      * @return mixed
  32.      *//**
  33.      * Retrieve all user parameters
  34.      *
  35.      * @return array
  36.      *//**
  37.      * Clear the user parameter stack, or a single user parameter
  38.      *
  39.      * @param null|string|array single key or array of keys for params to clear
  40.      * @return Zend_Controller_Dispatcher_Interface
  41.      *//**
  42.      * Set the response object to use, if any
  43.      *
  44.      * @param Zend_Controller_Response_Abstract|null $response
  45.      * @return void
  46.      *//**
  47.      * Retrieve the response object, if any
  48.      *
  49.      * @return Zend_Controller_Response_Abstract|null
  50.      *//**
  51.      * Add a controller directory to the controller directory stack
  52.      *
  53.      * @param string $path
  54.      * @param string $args
  55.      * @return Zend_Controller_Dispatcher_Interface
  56.      *//**
  57.      * Set the directory (or directories) where controller files are stored
  58.      *
  59.      * @param string|array $dir
  60.      * @return Zend_Controller_Dispatcher_Interface
  61.      *//**
  62.      * Return the currently set directory(ies) for controller file lookup
  63.      *
  64.      * @return array
  65.      *//**
  66.      * Dispatch a request to a (module/)controller/action.
  67.      *
  68.      * @param  Zend_Controller_Request_Abstract $request
  69.      * @param  Zend_Controller_Response_Abstract $response
  70.      * @return Zend_Controller_Request_Abstract|boolean
  71.      *//**
  72.      * Whether or not a given module is valid
  73.      *
  74.      * @param string $module
  75.      * @return boolean
  76.      *//**
  77.      * Retrieve the default module name
  78.      *
  79.      * @return string
  80.      *//**
  81.      * Retrieve the default controller name
  82.      *
  83.      * @return string
  84.      *//**
  85.      * Retrieve the default action
  86.      *
  87.      * @return string
  88.      */

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).


Der Standard Router