Examples
The Bootstrap class itself will typically be fairly minimal; often,
it will simply be an empty stub extending the base bootstrap class:
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
}
With a corresponding configuration file:
; 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]
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
{
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;
}
}
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"):
$application = new Zend_Application(
APPLICATION_ENV,
'My_Bootstrap_Resource_View' =>
array(),
// full class name; OR 'view' =>
array(),
// short name
'FrontController' =>
array( 'controllerDirectory' => APPLICATION_PATH . '/controllers',
),
),
// For short names, define plugin paths:
'pluginPaths = array(
'My_Bootstrap_Resource' => 'My/Bootstrap/Resource',
)
)
);
Resource plugins can call on other resources and initializers by accessing the
parent bootstrap:
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');
// ...
}
}
In normal usage, you would instantiate the application, bootstrap it,
and run it:
$application = new Zend_Application(...);
$application->bootstrap()
->run();
For a custom script, you might need to simply initialize specific
resources:
$application = new Zend_Application(...);
$application->getBootstrap()->bootstrap('db');
$service = new Zend_XmlRpc_Server();
$service->setClass('Foo'); // uses database...
Instead of using the bootstrap() method to call the
internal methods or resources, you may also use overloading:
$application = new Zend_Application(...);
$application->getBootstrap()->bootstrapDb();