La propia clase Bootstrap suelen ser bastante mínima; a menudo, será simplemente un talón vacío ampliando la clase base bootstrap:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
}

Con el archivo de configuración coresspondiente:

; APPLICATION_PATH/configs/application.ini
[production]
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

[testing : production]
[development : production]

Sin embargo, si debiera ser necesaria un inicialización personalizada, usted tiene dos opciones. En primer lugar, usted puede escribir métodos prefijados con _init para especificar códigos distintos de arranque. Estos métodos pueden ser llamados por bootstrap() , y también pueden ser llamados como si fueran métodos públicos: bootstrap<resource>() . Deben aceptar opcionalmente un array de opciones.

Si su método recurso devuelve un valor, será almacenado en un contenedor en el bootstrap. Esto puede ser útil cuando diferentes recursos necesitan interactuar (como un recurso inyectándose a sí mismo en otro). Luego, el método getResource() puede ser utilizado para recuperar esos valores.

El siguiente ejemplo muestra un recurso de método para inicializar el objeto solicitado. Hace uso del segimiento de la dependencia (que depende del recurso Front Controller), obteniendo un recurso desde el bootstrap y devolver el valor para almacenar en el bootstrap.

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initRequest(array $options = array())
    {
        // Garantizar que la instancia de front controller esté presente, y buscarla

        $this->bootstrap('FrontController');
        $front = $this->getResource('FrontController');

        // Inicializar el objeto requerido
        $request = new Zend_Controller_Request_Http();
        $request->setBaseUrl('/foo');

        // Agregarlo al front controller
        $front->setRequest($request);

        // Bootstrap guardará este valor en la clave 'request' de su contenedor
        return $request;
    }
}

Nótese en este ejemplo la llamada a bootstrap() ; esto asegura que el front controller ha sido inicializado antes de llamar a este método. Esa llamada puede desencadenar tanto un recurso u otro método de la clase.

La otra opción es usar plugins de recursos, estos son objetos que realizan inicializaciones específicas, y pueden ser especificados:

Los recursos de plugins implementan Zend_Application_Resource_ResourceAbstract , que define simplemente que permitirán la inyección del llamador y opciones, y que tienen un método init() method. Como ejemplo, un recurso de una Vista (View) personalizada de bootstrap podría ser como lo siguiente:

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('My 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;
    }
}

Para decirle al bootstrap que utilice éste, se tendría que proporcionar ya sea el nombre de la clase del plugin del recurso, o una combinación del del prefijo de la ruta de carga del plugin y el nombre corto del plugin del recurso (por ejemplo, "view"):

$application = new Zend_Application(
    APPLICATION_ENV,
    array(
        'resources' => array(
            'My_Bootstrap_Resource_View' => array(), // full class name; OR
            'view' => array(),                       // short name

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

        // For short names, define plugin path:
       'pluginPaths = array(
            'My_Bootstrap_Resource' => 'My/Bootstrap/Resource',
        )
    )
);

Los recursos que son plugins puede llamar a otros recursos e inicializadores accediendo al bootstrap padre:

class My_Bootstrap_Resource_Layout
    extends Zend_Application_Resource_ResourceAbstract
{
    public function init()
    {
        // ensure view is initialized...
        $this->getBootstrap()->bootstrap('view');

        // Get view object:
        $view = $this->getBootstrap()->getResource('view');

        // ...
    }
}

En el uso normal, se podría instanciar la aplicación, arrancarla, y ejecutarla:

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

Para un script personalizado, se podría necesitar simplemente inicializar recursos específicos:

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

$service = new Zend_XmlRpc_Server();
$service->setClass('Foo');  // uses database...
echo $service->handle();

En lugar de utilizar el método bootstrap() para llamar a los métodos internos o recursos, también puede usar sobrecarga:

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