Examples

The Bootstrap class itself will typically be fairly minimal; often, it will simply be an empty stub extending the base bootstrap class:

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.

span style="color: #808080; font-style: italic;">// Ensure front controller instance is present, and fetch it
        $this->bootstrap('FrontController');
        $front = $this->getResource('FrontController');
 
        // Initialize the request object
'/foo');
 
        // Add it to the front controller
        $front->setRequest($request);
 
        // Bootstrap will store this value in the 'request' key of its container

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:

span style="color: #ff0000;">'XHTML1_STRICT');
        $view->headTitle()->setSeparator(' - ''My Site''Content-Type',
                                           'text/html; charset=utf-8''parseOnLoad''/js/dojo/dojo.js')
                     ->registerModulePath('../spindle', 'spindle')
                     ->addStylesheetModule('spindle.themes.spindle''spindle.main''ViewRenderer'

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"):

span style="color: #ff0000;">'resources''My_Bootstrap_Resource_View'// full class name; OR
            'view'// short name
 
            'FrontController''controllerDirectory''/controllers',
            ),
        ),
 
        // For short names, define plugin paths:
        'pluginPaths = array(
            '' => 'My/Bootstrap/Resource',
        )
    )
);

Resource plugins can call on other resources and initializers by accessing the parent bootstrap:

span style="color: #808080; font-style: italic;">// 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:

For a custom script, you might need to simply initialize specific resources:

span style="color: #ff0000;">'db''Foo');  // uses database...

Instead of using the bootstrap() method to call the internal methods or resources, you may also use overloading: