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', true);
  3.  
  4. // Im Dispatcher:
  5. $dispatcher->setParam('prefixDefaultModule', true);
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. public function fooAction()
  2. {
  3.     // weiterleiten zu einer anderen Aktion im aktuellen Controller und Modul:
  4.     $this->_forward('bar', null, null, array('baz' => 'bogus'));
  5. }
  6.  
  7. public function barAction()
  8. {
  9.     // Weiterleiten zu einer Aktion in einem anderen Controller:
  10.     // FooController::bazAction(), im aktuellen Modul:
  11.     $this->_forward('baz', 'foo', null, array('baz' => 'bogus'));
  12. }
  13.  
  14. public function bazAction()
  15. {
  16.     // weiterleiten zu einer Aktion in einem anderen Controller in einem
  17.     // anderen Modul Foo_BarController::bazAction():
  18.     $this->_forward('baz', 'bar', 'foo', array('baz' => 'bogus'));
  19. }

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. interface Zend_Controller_Dispatcher_Interface
  2. {
  3.     /**
  4.      * Format a string into a controller class name.
  5.      *
  6.      * @param string $unformatted
  7.      * @return string
  8.      */
  9.     public function formatControllerName($unformatted);
  10.  
  11.     /**
  12.      * Format a string into an action method name.
  13.      *
  14.      * @param string $unformatted
  15.      * @return string
  16.      */
  17.     public function formatActionName($unformatted);
  18.  
  19.     /**
  20.      * Determine if a request is dispatchable
  21.      *
  22.      * @param  Zend_Controller_Request_Abstract $request
  23.      * @return boolean
  24.      */
  25.     public function isDispatchable(
  26.         Zend_Controller_Request_Abstract $request
  27.     );
  28.  
  29.     /**
  30.      * Set a user parameter (via front controller, or for local use)
  31.      *
  32.      * @param string $name
  33.      * @param mixed $value
  34.      * @return Zend_Controller_Dispatcher_Interface
  35.      */
  36.     public function setParam($name, $value);
  37.  
  38.     /**
  39.      * Set an array of user parameters
  40.      *
  41.      * @param array $params
  42.      * @return Zend_Controller_Dispatcher_Interface
  43.      */
  44.     public function setParams(array $params);
  45.  
  46.     /**
  47.      * Retrieve a single user parameter
  48.      *
  49.      * @param string $name
  50.      * @return mixed
  51.      */
  52.     public function getParam($name);
  53.  
  54.     /**
  55.      * Retrieve all user parameters
  56.      *
  57.      * @return array
  58.      */
  59.     public function getParams();
  60.  
  61.     /**
  62.      * Clear the user parameter stack, or a single user parameter
  63.      *
  64.      * @param null|string|array single key or array of keys for params to clear
  65.      * @return Zend_Controller_Dispatcher_Interface
  66.      */
  67.     public function clearParams($name = null);
  68.  
  69.     /**
  70.      * Set the response object to use, if any
  71.      *
  72.      * @param Zend_Controller_Response_Abstract|null $response
  73.      * @return void
  74.      */
  75.     public function setResponse(
  76.         Zend_Controller_Response_Abstract $response = null
  77.     );
  78.  
  79.     /**
  80.      * Retrieve the response object, if any
  81.      *
  82.      * @return Zend_Controller_Response_Abstract|null
  83.      */
  84.     public function getResponse();
  85.  
  86.     /**
  87.      * Add a controller directory to the controller directory stack
  88.      *
  89.      * @param string $path
  90.      * @param string $args
  91.      * @return Zend_Controller_Dispatcher_Interface
  92.      */
  93.     public function addControllerDirectory($path, $args = null);
  94.  
  95.     /**
  96.      * Set the directory (or directories) where controller files are stored
  97.      *
  98.      * @param string|array $dir
  99.      * @return Zend_Controller_Dispatcher_Interface
  100.      */
  101.     public function setControllerDirectory($path);
  102.  
  103.     /**
  104.      * Return the currently set directory(ies) for controller file lookup
  105.      *
  106.      * @return array
  107.      */
  108.     public function getControllerDirectory();
  109.  
  110.     /**
  111.      * Dispatch a request to a (module/)controller/action.
  112.      *
  113.      * @param  Zend_Controller_Request_Abstract $request
  114.      * @param  Zend_Controller_Response_Abstract $response
  115.      * @return Zend_Controller_Request_Abstract|boolean
  116.      */
  117.     public function dispatch(
  118.         Zend_Controller_Request_Abstract $request,
  119.         Zend_Controller_Response_Abstract $response
  120.     );
  121.  
  122.     /**
  123.      * Whether or not a given module is valid
  124.      *
  125.      * @param string $module
  126.      * @return boolean
  127.      */
  128.     public function isValidModule($module);
  129.  
  130.     /**
  131.      * Retrieve the default module name
  132.      *
  133.      * @return string
  134.      */
  135.     public function getDefaultModule();
  136.  
  137.     /**
  138.      * Retrieve the default controller name
  139.      *
  140.      * @return string
  141.      */
  142.     public function getDefaultControllerName();
  143.  
  144.     /**
  145.      * Retrieve the default action
  146.      *
  147.      * @return string
  148.      */
  149.     public function getDefaultAction();
  150. }

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