# Exemples

La classe de bootstrap elle-même sera typiquement minimaliste ; souvent, elle s'agira simplement d'une extension vide de la classe de bootstrap de base :

    class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
    {
    }

Avec un fichier de configuration tel que :

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

Espaces de noms de l'autoloader

Comme ces exemples utilisent du code personnalisé, nous devons enregistrer les préfixes des espaces de noms pour ce code dans notre configuration ; ceci est réalisé avec la clé de configuration autoloaderNamespaces, qui est un tableau.

De plus, afin de s'assurer que les plugins de ressources sont trouvées, nous devons enregistrer un préfixe de chemin de plugin lors de l'amorçage. Ceci peut être réalisé avec la clé de configuration pluginpaths, qui est un tableau associatif dont les clés sont les préfixes à utiliser et les valeurs sont les chemins relatifs à ces préfixes.

Cependant, si de l'initialisation personnalisée est nécessaire, alors vous avez 2 choix. D'abord vous pouvez écrire des méthodes préfixées par _init pour ajouter du code au bootstrap. De telles méthodes seront appelées par bootstrap(), et peuvent être appelées comme si elles étaient publiques, par : bootstrap<resource>(). Elles peuvent accepter un tableau d'options.

Si votre méthode de ressource retourne une valeur, elle sera stockée dans un conteneur du bootstrap. Ceci peut être utile quand différentes ressources ont besoin d'interagir (comme une ressource s'injectant elle-même dans une autre). La méthode getResource() peut être utilisée pour récupérer ces valeurs.

L'exemple ci-dessous montre une méthode de ressource pour l'initialisation d'un objet requête. Il utilise le traqueur de dépendances (il dépend de la ressource de contrôleur frontal), récupère une ressource à partir du bootstrap, et retourne une valeur à stocker dans le bootstrap.

    class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
    {
        protected function _initRequest()
        {
            // Vérifie que le contrôleur frontal est bien présent, et le récupère
            $this->bootstrap('FrontController');
            $front = $this->getResource('FrontController');

            // Initialise l'objet requête
            $request = new Zend_Controller_Request_Http();
            $request->setBaseUrl('/foo');

            // On l'ajoute au contrôleur frontal
            $front->setRequest($request);

            // Le bootstrap va stocker cette valeur dans la clé 'request'
            // de son conteneur
            return $request;
        }
    }

Notez l'appel à bootstrap() ; Ceci permet de s'assurer que le contrôleur frontal a bien été initialisé avant d'appeler cette méthode.

Une autre option consiste à utiliser des ressources de bootstrap. Les plugins de ressources sont des objets qui s'occupent d'initialisations spéciales, elles peuvent être spécifiées :

- à l'instanciation d'un objet Zend_Application ;

- pendant l'initialisation de l'objet bootstrap ;

- en les activant spécifiquement via des appels de méthodes sur l'objet de bootstrap.

Les plugins de ressources implémentent Zend_Application_Resource_ResourceAbstract, qui définit simplement qu'elles peuvent être injectées dans l'objet les appelant, et qu'elles ont une méthode init(). Voici un exemple d'un bootstrap de vue :

    class My_Bootstrap_Resource_View
        extends Zend_Application_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;
        }
    }

Pour dire au bootstrap d'utiliser cette classe, vous devrez fournir le nom de la classe pour ce plugin de ressource, ou une combinaison préfixe / chemin de chargeur de plugin (plugin loader) et le nom court du plugin de ressource ("view") :

    $application = new Zend_Application(
        APPLICATION_ENV,
        array(
            'resources' => array(
                'My_Bootstrap_Resource_View' => array(), // nom de la classe OU
                'view' => array(),                       // nom court

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

            // Pour les noms courts, définissez les chemins :
            'resourcePaths = array(
                'My_Bootstrap_Resource' => 'My/Bootstrap/Resource',
            )
        )
    );

Les plugins de ressource peuvent en appeler d'autres via le bootstrap parent :

    class My_Bootstrap_Resource_Layout
        extends Zend_Application_ResourceAbstract
    {
        public function init()
        {
            // Assurons nous que la vue est initialisée...
            $this->getBootstrap()->bootstrap('view');

            // Récupère l'objet de vue :
            $view = $this->getBootstrap()->getResource('view');

            // ...
        }
    }

En usage normal, vous instancierez votre application, lancerez le bootstrap, puis l'application :

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

Pour un script personnalisé, vous auriez peut être besoin de ne lancer que des ressources spécifiques :

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

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

Plutôt que d'utiliser la méthode bootstrap() pour appeler les méthodes internes, vous pouvez surcharger :

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