Comment puis-je accéder à la configuration d'une application Zend Framework à partir d'un contrôleur?

J'ai une application Zend Framework basé sur le de démarrage rapide de l'installation.

J'ai obtenu les démos de travail et je suis maintenant sur le point de l'instanciation d'un modèle de classe pour faire du travail de qualité. Dans mon contrôleur je veux passer d'un paramètre de configuration (spécifié dans la demande.ini) pour mon modèle constructeur, quelque chose comme ceci:

class My_UserController extends Zend_Controller_Action
{
    public function indexAction()
    {
        $options = $this->getFrontController()->getParam('bootstrap')->getApplication()->getOptions();
        $manager = new My_Model_Manager($options['my']);
        $this->view->items = $manager->getItems();
    }
}

L'exemple ci-dessus ne permettent d'accéder aux options, mais semble très rond. Est-il un meilleur moyen pour accéder à la configuration?

InformationsquelleAutor Adam Franco | 2009-11-05

php zend-framework

47

J'ai toujours l'ajouter à la suite de l'initialisation de la méthode à mon bootstrap pour passer de la configuration dans le registre.
```
protected function _initConfig()
{
    $config = new Zend_Config($this->getOptions(), true);
    Zend_Registry::set('config', $config);
    return $config;
}
```
Cela permettra de réduire votre code un peu:
```
class My_UserController extends Zend_Controller_Action
{
    public function indexAction()
    {
        $manager = new My_Model_Manager(Zend_Registry::get('config')->my);
        $this->view->items = $manager->getItems();
    }
}
```
- Cela prendra un peu de travail pour ré-analyser le tableau dans un objet. Si vous préférez avoir la config comme un tableau, c'est juste "Zend_Registry::set('config', $this->getOptions());" si vous aurez à le sortir dans une variable avant d'obtenir la valeur.
- Vous avez raison, le plus rapide serait de stocker les options de tableau à l'intérieur de la base de registre - mais le stockage de la matrice à chaque fois que vous souhaitez récupérer une seule valeur peut être lourd.
- Ce n'est pas différent de l' $GLOBALS['demande'] idée ci-dessous, avec l'avantage supplémentaire que $GLOBALS['demande'] fonctionne probablement 99% du temps.
- D'autre part, Zend_Registry::get('config') exige que le contrôleur/développeur de modules de coordonner avec Bootstrap pour obtenir la configuration dans la base de registre.
- Bien sûr, un singleton est toujours un peu la programmation orientée objet-moyen d'une variable globale. Néanmoins, le modèle de Registre est une commune et reconnu de la distribution de ressources dans une application. L'utilisation de Zend_Registry vous permet d'offrir un objet personnalisé comme son référentiel d'étendre ses fonctionnalités en un localisateur de service ou le conteneur d'injection de dépendance. Toutes ces choses ne sont pas possibles avec le GLOBALS approche. Je ne vois pas pourquoi le Zend_Registry approche ne doit pas travailler à 100% du temps par la route.
- Exactement ce que je cherchais. Merci @StefanGehrig!
InformationsquelleAutor Stefan Gehrig
22

Depuis la version 1.8, vous pouvez utiliser le code ci-dessous dans votre Contrôleur:
```
$my = $this->getInvokeArg('bootstrap')->getOption('my');
```
InformationsquelleAutor yarson

Sinon, au lieu d'utiliser Zend_Registry vous pouvez également créer un singleton Application de classe qui contiendra tous les détails d'une application, avec des fonctions membres publiques qui permettent d'accéder à des données pertinentes. Vous trouverez ci-dessous un extrait de code avec le code pertinent (il ne s'exécute pas comme il est, juste pour vous donner une idée de comment il peut être mis en œuvre) :

final class Application
{
    /**
     * @var Zend_Config
     */    
    private $config = null;

    /**
     * @var Application
     */    
    private static $application;

    //snip

    /**
     * @return Zend_Config
     */
    public function getConfig()
    {
        if (!$this->config instanceof Zend_Config) {
            $this->initConfig();
        }
        return $this->config;
    }

    /**
     * @return Application
     */
    public static function getInstance()
    {
        if (self::$application === null) {
            self::$application = new Application();
        }
        return self::$application;
    }

    /**
     * Load Configuration
     */
    private function initConfig()
    {
        $configFile = $this->appDir . '/config/application.xml';
        if (!is_readable($configFile)) {
            throw new Application_Exception('Config file "' . $configFile . '" is not readable');
        }
        $config = new Zend_Config_Xml($configFile, 'test');
        $this->config = $config;
    }

    //snip

    /**
     * @param string $appDir
     */
    public function init($appDir)
    {
        $this->appDir = $appDir;
        $this->initConfig();
        //snip
    }

    public function run ($appDir)
    {
        $this->init($appDir);
        $front = $this->initController();
        $front->dispatch();            
    }
}

Votre bootstrap devrait ressembler à ceci :

require 'Application.php';
try {
    Application::getInstance()->run(dirname(dirname(__FILE__)));
} catch (Exception $e) {
    header("HTTP/1.x 500 Internal Server Error");
    trigger_error('Application Error : '.$e->getMessage(), E_USER_ERROR);
}

Lorsque vous souhaitez accéder à la configuration, vous devez utiliser la suivante :

$var = Application::getInstance()->getConfig()->somevar;

InformationsquelleAutor wimvds

3

Dans la plupart des ZF applications, l'objet application est déclarée dans la portée globale (voir public/index.php dans les applications créées avec ZFW_DISTRIBUTION/bin/zf.sh).

Ce n'est pas exactement la ZF chemin, mais vous pouvez accéder à l'objet avec $GLOBALS['application'].
Il se sent un peu comme de la tricherie, mais si vous êtes après de la performance, ce sera probablement l'option la plus rapide.
```
$manager = new My_Model_Manager($GLOBALS['application']->getOption('my'));
```
- Il est toujours possible de contourner le cadre et l'ensemble de ses abstractions. Une solution comme cela devrait être une tout autre personne, ne donne pas de hack, pas une solution unique. La Performance est peu probable d'être critique dans tous les cas; une variable de config n'a pas besoin d'être récupérée à l'intérieur d'un critiques des performances de la boucle.
- Quelle est la My_Model_Manager??
- ma meilleure supposition (4 ans), c'est que c'est un hypothétique de l'utilisateur des terres de la classe qui dépend d'une hypothétique de l'utilisateur défini par l'option "mon". Ces deux sont gleened de la question 😉
InformationsquelleAutor Chris Trahey

$this->getInvokeArg('bootstrap')->getOptions();
//or 

$configDb = $this->getInvokeArg('bootstrap')->getOption('db');

InformationsquelleAutor SLIM

J'ai de définir un raccourci en quelque lieu que je require_once() en début de bootstrap:

function reg($name, $value=null) {
    (null===$value) || Zend_Registry::set($name, $value);
    return Zend_Registry::get($name);
}

et dans le bootstrap, j'ai un:

protected function _initFinal()
{
    reg('::app', $this->getApplication());
}

alors je peux obtenir l'instance de l'Application de n'importe où par l'utilisation:

$app = reg('::app');

InformationsquelleAutor XUE Can

Une manière très simple pour accéder aux options de configuration est en accédant directement à l'globalement défini $demande variable.

class My_UserController extends Zend_Controller_Action {
    public function indexAction() {
        global $application;
        $options = $application->getOptions();
    }
}

InformationsquelleAutor Milan

Vous devez vous connecter pour publier un commentaire.