Wie kann ich von einem Controller aus auf die Konfiguration einer Zend Framework-Anwendung zugreifen?

Ich habe eine Zend Framework-Anwendung, die auf dem basiert Schnellstart Einrichtung.

Ich habe die Demos zum Laufen gebracht und bin jetzt an dem Punkt, eine neue Modellklasse zu instanziieren, um echte Arbeit zu leisten. In meinem Controller möchte ich einen Konfigurationsparameter (angegeben in der application.ini) an meinen Modellkonstruktor übergeben, etwa so:

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();
    }
}

Das obige Beispiel erlaubt den Zugriff auf die Optionen, scheint aber sehr umständlich zu sein. Gibt es einen besseren Weg, um auf die Konfiguration zuzugreifen?

Ich füge meinem Bootstrap immer die folgende Init-Methode hinzu, um die Konfiguration an die Registrierung zu übergeben.

protected function _initConfig()
{
    $config = new Zend_Config($this->getOptions(), true);
    Zend_Registry::set('config', $config);
    return $config;
}

Dies wird Ihren Code ein wenig verkürzen:

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();
    }
}

Seit Version 1.8 können Sie den folgenden Code in Ihrem Controller verwenden:

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

Alternativ können Sie, anstatt Zend_Registry zu verwenden, auch eine Singleton-Anwendungsklasse erstellen, die alle Anwendungsinformationen enthält, mit öffentlichen Mitgliedsfunktionen, die Ihnen den Zugriff auf die relevanten Daten ermöglichen. Unten finden Sie ein Snippet mit relevantem Code (es wird nicht so ausgeführt, wie es ist, nur um Ihnen eine Vorstellung davon zu geben, wie es implementiert werden kann):

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();            
    }
}

Ihr Bootstrap würde so aussehen:

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);
}

Wenn Sie auf die Konfiguration zugreifen möchten, verwenden Sie Folgendes:

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

In den meisten ZF-Apps ist das Anwendungsobjekt im globalen Geltungsbereich deklariert (vgl public/index.php in Apps erstellt mit ZFW_DISTRIBUTION/bin/zf.sh).

Es ist nicht gerade der ZF-Weg, aber Sie können mit auf das Objekt zugreifen $GLOBALS['application']. Es fühlt sich ein bisschen wie Betrug an, aber wenn Sie nach Leistung suchen, ist dies wahrscheinlich die schnellste Option.

$manager = new My_Model_Manager($GLOBALS['application']->getOption('my'));

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

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

Ich habe an einer Stelle, an der ich require_once() am Anfang von boostrap verwende, eine kurze Hand definiert:

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

und im Bootstrap habe ich ein:

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

dann kann ich die Anwendungsinstanz überall abrufen, indem ich sie verwende:

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

Eine wirklich einfache Möglichkeit, auf die Konfigurationsoptionen zuzugreifen, ist der direkte Zugriff auf die global definierte $Anwendung Variable.

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