# Beispiele

Die Klasse Bootstrap selbst wird typischerweise sehr minimal sein; oft wird sie einfach nur ein leerer Stub sein, der die Basis Bootstrapping-Klasse erweitert:

    class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
    {
    }

Mit einer entsprechenden Konfigurationsdatei:

    ; APPLICATION_PATH/configs/application.ini
    [production]
    autoloaderNamespaces[] = "My_"
    bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
    bootstrap.class = "Bootstrap"
    pluginpaths.My_Bootstrap_Resource = "My/Bootstrap/Resource"
    resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

    [testing: production]
    [development : production]

## Namespaces für Autoloader

Weil diese Beispiele eigenen Code verwenden, müssen wir die Präfixe der Namespaces für diesen Code in unserer Konfiguration registrieren; dies wird mit dem Konfigurationsschlüssel autoloaderNamespaces getan, welcher ein Array ist.

Um zusätzlich sicherzustellen, dass eigene Plugin-Ressourcen erkannt werden, müssen wir einen Plugin-Präfixpfad in der Bootstrap registrieren. Das wird mit dem Konfigurationsschlüssel pluginpaths getan, welcher ein assoziatives Array ist, mit Schlüsseln, die das zu verwendenden Präfix kennzeichnen, und Werten, welche den Pfad enthalten, der diesem Präfix entspricht.

Sollten trotzdem eigene Initialisierungen notwendig sein, hat man zwei Möglichkeiten. Erstens kann man Methoden schreiben, die mit _init anfangen, um eigenen Code zu spezifizieren, der für das Bootstrapping verwendet werden soll. Diese Methoden werden durch `bootstrap()` aufgerufen, und können genauso aufgerufen werden, wie wenn sie öffentliche Methoden wären: bootstrap<resource>(). Sie sollten ein optionales Array an Optionen akzeptieren.

Wenn die eigene Ressource-Methode einen Wert zurückgibt, wird diese in einem Container im Bootstrap gespeichert. Das kann nützlich sein, wenn verschiedene Ressourcen interagieren müssen (wie wenn eine Ressource sich selbst in eine andere iniziiert). Die Methode `getResource()` kann dann verwendet werden, um diese Werte zu erhalten.

Das Beispiel unten zeigt eine Ressource-Methode für die Initialisierung des Anfrage-Objekts. Es verwendet die Erkennung der Abhängigkeit (diese hängt von der Ressource FrontController ab), holt eine Ressource vom Bootstrap, und gibt einen Wert zurück, um ihn im Bootstrap zu speichern.

    class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
    {
        protected function _initRequest()
        {
            // Sicherstellen, dass eine FrontController-Instanz vorhanden ist
            // und diese holen
            $this->bootstrap('FrontController');
            $front = $this->getResource('FrontController');

            // Das Anfrage-Objekt initialisieren
            $request = new Zend_Controller_Request_Http();
            $request->setBaseUrl('/foo');

            // Sie dem FrontController hinzufügen
            $front->setRequest($request);

            // Bootstrap speichert den Wert im 'request' Schlüssel
            // seines Containers
            return $request;
        }
    }

Man beachte in diesem Beispiel den Aufruf von `bootstrap()`; dieser stellt sicher, dass der FrontController initialisiert wurde, bevor die Methode aufgerufen wird. Dieser Aufruf kann entweder eine Ressource oder eine andere Methode in der Klasse auslösen.

Die andere Option ist, die Verwendung eines Ressource-Plugins. Ressource-Plugins sind Objekte, die spezielle Initialisierungen ausführen, und die wie folgt spezifiziert werden können:

- Während der Instanzierung des Objekts `Zend_Application`

- Während der Initialisierung des Objekts Bootstrap

- Durch explizites Einschalten über Methodenaufrufe auf dem Objekt Bootstrap

Ressource-Plugins implementieren `Zend_Application_Resource_ResourceAbstract`, welche einfach definieren, dass sie Injektion des Aufrufers und von Optionen erlauben, und die eine `init()` Methode haben. Als Beispiel, könnte eine eigene "View"-Bootstrap-Ressource wie folgt aussehen:

    class My_Bootstrap_Resource_View
        extends Zend_Application_Resource_ResourceAbstract
    {
        public function init()
        {
            $view = new Zend_View($this->_getOptions());
            Zend_Dojo::enableView($view);

            $view->doctype('XHTML1_STRICT');
            $view->headTitle()->setSeparator(' - ')->append('Meine Site');
            $view->headMeta()->appendHttpEquiv('Content-Type',
                                               'text/html; charset=utf-8');

            $view->dojo()->setDjConfigOption('parseOnLoad', true)
                         ->setLocalPath('/js/dojo/dojo.js')
                         ->registerModulePath('../spindle', 'spindle')
                         ->addStylesheetModule('spindle.themes.spindle')
                         ->requireModule('spindle.main')
                         ->disable();

            $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper(
                'ViewRenderer'
            );
            $viewRenderer->setView($view);

            return $view;
        }
    }

Um der Bootstrap zu sagen, dass sie das verwenden soll, würde man entweder den Klassennamen des Ressource-Plugins übergeben müssen, oder eine Kombination eines Plugin Loader Präfixpfades und den Kurznamen des Ressource-Plugins (z.B. "view"):

    $application = new Zend_Application(
        APPLICATION_ENV,
        array(
            'resources' => array(
                'My_Bootstrap_Resource_View' => array(), // kompletter Klassenname
                'view',                                  // ODER Kurzname

                'FrontController' => array(
                    'controllerDirectory' => APPLICATION_PATH . '/controllers',
                ),
            ),

            // Für Kurznamen, definiere die Plugin Pfade:
            'pluginPaths = array(
                'My_Bootstrap_Resource' => 'My/Bootstrap/Resource',
            )
        )
    );

Ressource-Plugins können andere Ressourcen und Initialisierungen aufrufen, indem sie auf den Eltern-Bootstrap zugreifen:

    class My_Bootstrap_Resource_Layout
        extends Zend_Application_Resource_ResourceAbstract
    {
        public function init()
        {
            // Sicherstellen, dass die View initialisiert ist...
            $this->getBootstrap()->bootstrap('view');

            // Das View-Objekt erhalten
            $view = $this->getBootstrap()->getResource('view');

            // ...
        }
    }

Bei normaler Verwendung würde man die Anwendung instanzieren, sie bootstrappen, und anschließend ausführen:

    $application = new Zend_Application(...);
    $application->bootstrap()
                ->run();

Für ein eigenes Skript müsste man einfach spezifische Ressourcen initialisieren:

    $application = new Zend_Application(...);
    $application->getBootstrap('db');

    $service = new Zend_XmlRpc_Server();
    $service->setClass('Foo');  // Verwende die Datenbank...
    echo $service->handle();

Statt der Verwendung der Methode `bootstrap()`, um interne Methoden oder Ressourcen aufzurufen, kann man auch Überladung verwenden:

    $application = new Zend_Application(...);
    $application->getBootstrapDb();