repo_zf1/documentation/manual/de/module_specs/Zend_Controller-Dispatcher.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 14978 -->
<!-- Reviewed: no -->
<sect1 id="zend.controller.dispatcher">
    <title>Der Dispatcher</title>

    <sect2 id="zend.controller.dispatcher.overview">
        <title>Überblick</title>

        <para>
            Dispatching ist der Prozess, das Request Objekt
            <classname>Zend_Controller_Request_Abstract</classname> 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. <classname>Zend_Controller_Dispatcher_Standard</classname> legt
            <code>index</code> für jede der Controller und Action Standardwerte fest und
            <code>default</code> für den Standardwert des Moduls, erlaubt dem Entwickler aber auch,
            diese durch Verwendung der <code>setDefaultController()</code>,
            <code>setDefaultAction()</code> und <code>setDefaultModule()</code> Methoden zu
            verändern.
        </para>

        <note>
            <title>Standard Module</title>

            <para>
                Bei der Erstellung von modularen Anwendungen kann es sein das man auch einen
                Namespace für eigene Standard Module haben will (die Standardkonfiguration ist, das
                das Standardmodul <emphasis>keinen</emphasis> Namensraum hat). Ab 1.5.0, kann das
                durch Spezifizierung von <code>prefixDefaultModule</code> auf true, entweder im
                Front Kontroller oder im Dispatcher, getan werden:
            </para>

            <programlisting role="php"><![CDATA[
// Im Front Controller:
$front->setParam('prefixDefaultModule', true);

// Im Dispatcher:
$dispatcher->setParam('prefixDefaultModule', true);
]]>
            </programlisting>

            <para>
                Das erlaubt es existierende Module als Standardmodule für eine Anwendung
                wiederzuverwenden.
            </para>
        </note>

        <para>
            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.
        </para>

        <para>
            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/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.
        </para>

        <para>
            Die Controller Methode, die solch eine Verarbeitung kontrolliert lautet
            <code>_forward()</code>; rufe diese Methode von einer beliebigen pre/postDispatch()
            oderAktionsmethode auf und übergebe Aktion, Controller, Modul und beliebige optionale
            Parameter, die du zur neuen Aktion übersenden möchtest:
        </para>

        <programlisting role="php"><![CDATA[
public function fooAction()
{
    // weiterleiten zu einer anderen Aktion im aktuellen Controller und Modul:
    $this->_forward('bar', null, null, array('baz' => 'bogus'));
}

public function barAction()
{
    // Weiterleiten zu einer Aktion in einem anderen Controller:
    // FooController::bazAction(), im aktuellen Modul:
    $this->_forward('baz', 'foo', null, array('baz' => 'bogus'));
}

public function bazAction()
{
    // weiterleiten zu einer Aktion in einem anderen Controller in einem
    // anderen Modul Foo_BarController::bazAction():
    $this->_forward('baz', 'bar', 'foo', array('baz' => 'bogus'));
}
]]>
        </programlisting>
    </sect2>

    <sect2 id="zend.controller.dispatcher.subclassing">
        <title>Erben vom Dispatcher</title>

        <para>
            <classname>Zend_Controller_Front</classname> 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.
        </para>

        <para>
            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.
        </para>

        <para>
            <classname>Zend_Controller_Dispatcher_Interface</classname> definiert die folgenden Methoden die für jede
            Dispatcher Implementierung benötigt werden:
        </para>

        <programlisting role="php"><![CDATA[
interface Zend_Controller_Dispatcher_Interface
{
    /**
     * Format a string into a controller class name.
     *
     * @param string $unformatted
     * @return string
     */
    public function formatControllerName($unformatted);

    /**
     * Format a string into an action method name.
     *
     * @param string $unformatted
     * @return string
     */
    public function formatActionName($unformatted);

    /**
     * Determine if a request is dispatchable
     *
     * @param  Zend_Controller_Request_Abstract $request
     * @return boolean
     */
    public function isDispatchable(
        Zend_Controller_Request_Abstract $request
    );

    /**
     * Set a user parameter (via front controller, or for local use)
     *
     * @param string $name
     * @param mixed $value
     * @return Zend_Controller_Dispatcher_Interface
     */
    public function setParam($name, $value);

    /**
     * Set an array of user parameters
     *
     * @param array $params
     * @return Zend_Controller_Dispatcher_Interface
     */
    public function setParams(array $params);

    /**
     * Retrieve a single user parameter
     *
     * @param string $name
     * @return mixed
     */
    public function getParam($name);

    /**
     * Retrieve all user parameters
     *
     * @return array
     */
    public function getParams();

    /**
     * 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
     */
    public function clearParams($name = null);

    /**
     * Set the response object to use, if any
     *
     * @param Zend_Controller_Response_Abstract|null $response
     * @return void
     */
    public function setResponse(
        Zend_Controller_Response_Abstract $response = null
    );

    /**
     * Retrieve the response object, if any
     *
     * @return Zend_Controller_Response_Abstract|null
     */
    public function getResponse();

    /**
     * Add a controller directory to the controller directory stack
     *
     * @param string $path
     * @param string $args
     * @return Zend_Controller_Dispatcher_Interface
     */
    public function addControllerDirectory($path, $args = null);

    /**
     * Set the directory (or directories) where controller files are stored
     *
     * @param string|array $dir
     * @return Zend_Controller_Dispatcher_Interface
     */
    public function setControllerDirectory($path);

    /**
     * Return the currently set directory(ies) for controller file lookup
     *
     * @return array
     */
    public function getControllerDirectory();

    /**
     * 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
     */
    public function dispatch(
        Zend_Controller_Request_Abstract $request,
        Zend_Controller_Response_Abstract $response
    );

    /**
     * Whether or not a given module is valid
     *
     * @param string $module
     * @return boolean
     */
    public function isValidModule($module);

    /**
     * Retrieve the default module name
     *
     * @return string
     */
    public function getDefaultModule();

    /**
     * Retrieve the default controller name
     *
     * @return string
     */
    public function getDefaultControllerName();

    /**
     * Retrieve the default action
     *
     * @return string
     */
    public function getDefaultAction();
}
]]>
        </programlisting>

        <para>
            In den meisten Fällen sollte trotzdem einfach die abstrakte Klasse
            <classname>Zend_Controller_Dispatcher_Abstract</classname> erweitert werden, und welcher jede davon schon
            definiert wurde, oder <classname>Zend_Controller_Dispatcher_Standard</classname> um Funktionalitäten des
            Standard Dispatchers zu modifizieren.
        </para>

        <para>
            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).
        </para>
    </sect2>
</sect1>
<!--
vim:se ts=4 sw=4 et:
-->