Note: Autoloader namespaces
Because these examples use custom code, we need to register the namespace prefixes for
that code with our configuration; this is done with the
autoloaderNamespaces configuration key, which is an array.
Additionally, to ensure that custom plugin resources are discovered, we need to register
a plugin prefix path with the bootstrap. This is done with the
pluginpaths configuration key, which is an associative array, with
keys denoting the prefix to use, and values denoting the path related to that prefix.

However, should custom initialization be necessary, you have two
choices. First, you can write methods prefixed with _init
to specify discrete code to bootstrap. These methods will be called by
bootstrap(), and can also be called as if they were public methods:
bootstrap<resource>(). They should accept an optional
array of options.

If your resource method returns a value, it will be stored in a
container in the bootstrap. This can be useful when different resources
need to interact (such as one resource injecting itself into another).
The method getResource() can then be used to retrieve those
values.

The example below shows a resource method for initializing the request
object. It makes use of dependency tracking (it depends on the front
controller resource), fetching a resource from the bootstrap, and
returning a value to store in the bootstrap.

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap

{

protected function _initRequest()

{

// Ensure front controller instance is present, and fetch it

$this->bootstrap('FrontController');

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

// Initialize the request object

$request = new Zend_Controller_Request_Http();

$request->setBaseUrl('/foo');

// Add it to the front controller

$front->setRequest($request);

// Bootstrap will store this value in the 'request' key of its container

return$request;

}

}

Note in this example the call to bootstrap();
this ensures that the front controller has been initialized prior to
calling this method. That call may trigger either a resource or another
method in the class.

The other option is to use resource plugins. Resource plugins are
objects that perform specific initializations, and may be specified:

When instantiating the Zend_Application object

During initialization of the bootstrap object

By explicitly enabling them via method calls to the bootstrap
object

Resource plugins implement
Zend_Application_Resource_ResourceAbstract,
which defines simply that they allow injection of the caller and
options, and that they have an init() method. As an
example, a custom "View" bootstrap resource might look like the
following:

class My_Bootstrap_Resource_View

extends Zend_Application_Resource_ResourceAbstract

{

publicfunction 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;

}

}

To tell the bootstrap to use this, you would need to provide either the
class name of the resource plugin, or a combination of a plugin loader prefix
path and the short name of the resource plugin (e.g, "view"):