interface Zend_Application_Bootstrap_Bootstrapper
{
    public function __construct($application);
    public function setOptions(array $options);
    public function getApplication();
    public function getEnvironment();
    public function getClassResources();
    public function getClassResourceNames();
    public function bootstrap($resource = null);
    public function run();
}

Die Implementation von Zend_Application_Bootstrap_BootstrapAbstract bietet eine einfache Konvention für die Definition von Methoden für Ressourcen-Klassen. Jede geschützte Methode (protected), deren Name mit _init beginnt, wird als Ressourcemethode angenommen.

Um eine einzelne Ressource-Methode zu bootstrappen, muß die Methode bootstrap() verwendet und der Name der Ressource übergeben werden. Der Name ist der Name der Methode ohne das Präfix _init.

Um mehrere Ressourcen-Methoden zu bootstrappen, muß ein Array von Namen übergeben werden. Um alle Ressourcen-Methoden zu bootstrappen, darf nichts übergeben werden.

Nehmen wir die folgende Bootstrap-Klasse an:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initFoo()
    {
        // ...
    }

    protected function _initBar()
    {
        // ...
    }

    protected function _initBaz()
    {
        // ...
    }
}

Um nur die Methode _initFoo() zu bootstrappen, machen wir das folgende:

$bootstrap->bootstrap('foo');

Um die Methoden _initFoo() und _initBar() zu bootstrappen, machen wir das folgende:

$bootstrap->bootstrap(array('foo', 'bar'));

Um alle Ressourcen-Methoden zu bootstrappen, rufen wir bootstrap() ohne Argumente auf:

$bootstrap->bootstrap();

Um Bootstraps wiederverwendbarer zu machen, wurde die Fähigkeit zur Verfügung gestellt, Ressourcen in Ressource-Plugin-Klassen zu geben. Das erlaubt es, Ressourcen einfach über die Konfiguration zu mischen und zu sehen ob sie passen. Wir behandeln später wie Ressourcen erstellt werden; in diesem Abschnitt zeigen wir nur, wie sie angepasst werden können.

Wenn das Bootstrap dazu in der Lage sein soll, Ressource-Plugins zu verwenden, muß man ein zusätzliches Interface implementieren, Zend_Application_Bootstrap_ResourceBootstrapper. Dieses Interface definiert eine API für das Erkennen, Registrieren und Laden von Ressource-Plugins:

interface Zend_Application_Bootstrap_ResourceBootstrapper
{
    public function registerPluginResource($resource, $options = null);
    public function unregisterPluginResource($resource);
    public function hasPluginResource($resource);
    public function getPluginResource($resource);
    public function getPluginResources();
    public function getPluginResourceNames();
    public function setPluginLoader(Zend_Loader_PluginLoader_Interface $loader);
    public function getPluginLoader();
}

Ressource-Plugins bieten grundsätzlich die Fähigkeit, Ressource-Initialisierer zu erstellen, die zwischen Anwendungen wiederverwendet werden können. Das erlaubt es, die aktuelle Bootstrap relativ klein zu halten, und neue Ressourcen einzuführen ohne sie in der Bootstrap selbst anzugreifen.

Zend_Application_Bootstrap_BootstrapAbstract (und bei Erweiterung Zend_Application_Bootstrap_Bootstrap) implementiert dieses Interface genauso, und erlaubt es Ressource-Plugins zu verwenden.

Um Ressource-Plugins zu verwenden, müssen diese in den Optionen spezifiziert werden, die dem Anwendungsobjekt und/oder der Bootstrap übergeben werden. Diese Optionen können von einer Konfigurationsdatei kommen, oder manuell übergeben werden. Optionen sind Paare von Schlüssel zu Optionen, wobei der Schlüssel den Namen der Ressource repräsentiert. Der Ressourcename ist das Segment, das dem Klassenpräfix folgt. Die Ressourcen, die zum Beispiel mit Zend Framework ausgeliefert werden, haben das Klassenpräfix "Zend_Application_Resource_"; alles was folgt würde der Name der Ressource sein. Als Beispiel:

$application = new Zend_Application(APPLICATION_ENV, array(
    'resources' => array(
        'FrontController' => array(
            'controllerDirectory' => APPLICATION_PATH . '/controllers',
        ),
    ),
));

Das bedeutet, dass die Ressource "FrontController" verwendet werden sollte, mit den spezifizierten Optionen.

Wenn man beginnt, eigene Ressource-Plugins zu schreiben, oder Ressource-Plugins von dritten anzupassen, muß man der eigenen Bootstrap mitteilen, wo nach ihnen zu suchen ist. Intern verwendet Bootstrap Zend_Loader_PluginLoader, so dass man nur die üblichen Klassenpräfix und Pfadpaare angeben muß.

Als Beispiel nehmen wir an, dass wir eigene Ressource-Plugins in APPLICATION_PATH/resources/ haben, und dass sie das gemeinsame Klassenpräfix My_Resource teilen. Man würde diese Information dem Anwendungsobjekt wie folgt übergeben:

$application = new Zend_Application(APPLICATION_ENV, array(
    'pluginPaths' => array(
        'My_Resource' => APPLICATION_PATH . '/resources/',
    ),
    'resources' => array(
        'FrontController' => array(
            'controllerDirectory' => APPLICATION_PATH . '/controllers',
        ),
    ),
));

Man ist jetzt in der Lage, Ressourcen aus diesem Verzeichnis zu verwenden.

Wie Ressource-Methoden kann die Methode bootstrap() verwendet werden, um Ressource-Plugins zu verwenden. Wie bei Ressource-Methoden kann man entweder einzelne Ressource-Plugins spezifizieren, mehrere Plugins (über ein Array), oder alle Plugins. Zusätzlich kann man mischen und entsprechende Ressource-Methoden genauso ausführen.

// Eine ausführen:
$bootstrap->bootstrap('FrontController');

// Mehrere ausführen:
$bootstrap->bootstrap(array('FrontController', 'Foo'));

// Alle Ressource Methoden und Plugins ausführen:
$bootstrap->bootstrap();

Viele, wenn nicht sogar alle, der eigenen Ressource-Methoden oder -Plugins initialisieren Objekte, und in vielen Fällen werden diese Objekte an anderen Orten der Anwendung benötigt. Wie kann man auf sie zugreifen?

Zend_Application_Bootstrap_BootstrapAbstract bietet eine lokale Registry für diese Objekte. Um eigene Objekte darin zu speichern, müssen diese einfach von den eigenen Ressourcen zurückgegeben werden.

Für maximale Flexibilität wird diese Registry intern als "Container" bezeichnet; die einzige Voraussetzung ist, dass es ein Objekt ist. Ressourcen werden dann als Eigenschaften registriert, die nach dem Namen der Ressource benannt sind. Standardmäßig wird eine Instanz von Zend_Registry verwendet, man kann aber jedes andere Objekt spezifizieren, wenn man das will. Die Methoden setContainer() und getContainer() können verwendet werden, um den Container selber zu manipulieren. getResource($resource) kann verwendet werden, um eine angegebene Ressource vom Container zu holen, und hasResource($resource) um zu prüfen, ob die Ressource aktuell schon registriert wurde.

Als Beispiel nehmen wir eine grundlegenden View Ressource an:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initView()
    {
        $view = new Zend_View();
        // weitere Initialisierungen...

        return $view;
    }
}

Man kann sie prüfen und/oder sie wie folgt holen:

// Verwendung der has- und getResource()-Paare:
if ($bootstrap->hasResource('view')) {
    $view = $bootstrap->getResource('view');
}

// Über den Container:
$container = $bootstrap->getContainer();
if (isset($container->view)) {
    $view = $container->view;
}

Es ist zu beachten, dass die Registry und auch der Container nicht global sind. Das bedeutet, dass man auf die Bootstrap zugreifen muß, um Ressourcen zu holen. Zend_Application_Bootstrap_Bootstrap bietet einigen Komfort hierfür: während der Ausführung von run(), registriert sie sich als FrontController-Parameter "bootstrap", was es erlaubt, sie von Routern, Dispatchern, Plugins und Action-Controllern zu holen.

Wenn man zum Beispiel auf die View Ressource von oben im eigenen Action Controller zugreifen will, kann man das wie folgt tun:

class FooController extends Zend_Controller_Action
{
    public function init()
    {
        $bootstrap = $this->getInvokeArg('bootstrap');
        $view = $bootstrap->getResource('view');
        // ...
    }
}

Zusätzlich zur Ausführung von Ressource-Methoden und -Plugins, ist es notwendig sicherzustellen, dass diese einmal und wirklich nur einmal ausgeführt werden; sie sollen eine Anwendung bootstrappen, und die mehrfache Ausführung von ihnen kann zu einem Overhead von Ressourcen führen.

Zur gleichen Zeit können Ressourcen von anderen ausgeführten Ressourcen abhängen. Um diese zwei Fälle zu lösen bietet Zend_Application_Bootstrap_BootstrapAbstract einen einfachen und effektiven Mechanismus für die Erkennung von Abhängigkeiten.

Wie vorher erwähnt werden alle Ressourcen -- ob Methoden oder Plugins -- durch den Aufruf von bootstrap($resource) gebootstrappt, wobei $resource der Name einer Ressource ist, ein Array von Ressourcen oder leer gelassen wird, was zeigt, dass alle Ressourcen ausgeführt werden sollen.

Wenn eine Ressource von anderen Ressourcen abhängig ist, sollten Sie in Ihrem Code bootstrap() aufrufen um sicherzustellen, dass die Ressource ausgeführt wurde. Weitere Aufrufe von ihr werden dann ignoriert.

In einer Ressource-Methode würde so ein Aufruf wie folgt aussehen:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initRequest()
    {
        // Sicherstellen, dass der FrontController initialisiert wird
        $this->bootstrap('FrontController');

        // Den FrontController von der Bootstrap Registry erhalten
        $front = $this->getResource('FrontController');

        $request = new Zend_Controller_Request_Http();
        $request->setBaseUrl('/foo');
        $front->setRequest($request);

        // Sicherstellen, dass die Anfrage in der Bootstrap Registry
        // gespeichert ist
        return $request;
    }
}