Nutzungsanalyse des Zend Framework-Aktionsassistenten

In diesem Artikel wird hauptsächlich die Verwendung des Zend Framework-Aktionsassistenten (Zend_Controller_Action_Helper) vorgestellt und die Funktion, Definition, Verwendung und der zugehörige Implementierungscode des Aktionsassistenten Zend_Controller_Action_Helper im Detail analysiert

In diesem Artikel werden die Beispiele erläutert. Ich habe die Verwendung des Zend Framework-Aktionshelfers (Zend_Controller_Action_Helper) kennengelernt. Teilen Sie es als Referenz mit allen. Die Details lauten wie folgt:

Durch den Assistentenmodus können einige häufig verwendete Funktionsmodule gekapselt werden, sodass sie bei Bedarf flexibel verwendet werden können, hauptsächlich in Aktionen.

Es gibt zwei Arten von Helfern im Zend Framework: Aktionsassistenten (Zend_Controller_Action_Helper) und Ansichtsassistenten (Zend_View_Helper).

Der Aktionsassistent kann sofort Funktionen (Laufzeit- und/oder On-Demand-Funktionalität) zu jedem abgeleiteten Aktionscontroller von Zend_Controller_Action hinzufügen, sodass beim Hinzufügen öffentlicher Aktionscontrollerfunktionen die abgeleitete Aktionssteuerung minimiert werden kann. Geräteklasse ist notwendig.

Der Aktionshelfer wird geladen, wenn er aufgerufen werden muss, und kann bei Anforderung (Bootstrap) oder beim Erstellen des Aktionscontrollers (init()) instanziiert werden.

Die zugehörigen Dateien

befinden sich in /library/Zend/Controller/Action/

│ Exception.php
│ HelperBroker.php
│ Interface . php
│
├─Helper
│ │ Abstract.php
│ │ ActionStack.php
│ │ AjaxContext.php
│ │ AutoCompleteDojo.php
│ │ Auto CompleteScriptaculous .php
│ │ Cache.php
│ │ ContextSwitch.php
│ │ FlashMessenger.php
│ │ Json.php
│ │ Redirector.php
│ │ Url.php
│ │ ViewRenderer.php
│ │
│ └─AutoComplete
│                  

Zu den gängigen Aktionsassistenten gehören
:

FlashMessenger wird verwendet um mit Flash umzugehen Messenger-Sitzungen; Json wird zum Dekodieren und Senden von JSON-Antworten verwendet; Redirector stellt eine weitere Implementierungsmethode bereit, um das Programm automatisch auf interne oder externe Seiten umzuleiten; schließt den Prozess der Einrichtung eines Ansichtsobjekts im Controller und des Renderns der Ansicht ab;

AutoComplete reagiert automatisch auf die automatische Vervollständigung von AJAX;

Cache implementiert Cache-bezogene Vorgänge ;
ActionStack wird zum Betreiben des Aktionsstapels verwendet.


Mehrere praktische Instanziierungsmethoden



1. Über die getHelper()-Methode des $_helper-Mitglieds von Zend_Controller_Action

. Rufen Sie einfach getHelper() direkt auf und übergeben Sie den Namen des Helfers.

$redirector = $this->_helper->getHelper('Redirector');
//$redirector->getName();
$redirector->gotoSimple('index2');

2. Greifen Sie direkt auf das Hilfsobjekt

zu, das dem Attribut des _helper-Assistenten entspricht.

$redirector = $this->_helper->Redirector;

Zend_Controller_Action_HelperBroker

Der chinesische Name wird mit „Assistant Broker“ übersetzt, wie der Name schon sagt, handelt es sich um den Mittelsmann des Aktionsassistenten .

Die zweite Methode, die bei der Aktionsinstanziierung verwendet wird, ist die magische Methode __get() von Zend_Controller_Action_HelperBroker.

Der Assistentenmakler wird verwendet, um Assistentenobjekte und Assistentenpfade zu registrieren, Assistenten zu erhalten und andere Funktionen.

Zend_Controller_Action_HelperBroker-Implementierung und Liste gängiger Methoden

<?php
/**
 * @see Zend_Controller_Action_HelperBroker_PriorityStack
 */
require_once &#39;Zend/Controller/Action/HelperBroker/PriorityStack.php&#39;;
/**
 * @see Zend_Loader
 */
require_once &#39;Zend/Loader.php&#39;;
/**
 * @category  Zend
 * @package  Zend_Controller
 * @subpackage Zend_Controller_Action
 * @copyright Copyright (c) 2005-2011 Zend Technologies USA Inc. (http://www.zend.com)
 * @license  http://framework.zend.com/license/new-bsd   New BSD License
 */
class Zend_Controller_Action_HelperBroker
{
  /**
   * $_actionController - ActionController reference
   *
   * @var Zend_Controller_Action
   */
  protected $_actionController;
  /**
   * @var Zend_Loader_PluginLoader_Interface
   */
  protected static $_pluginLoader;
  /**
   * $_helpers - Helper array
   *
   * @var Zend_Controller_Action_HelperBroker_PriorityStack
   */
  protected static $_stack = null;
  /**
   * Set PluginLoader for use with broker
   *
   * @param Zend_Loader_PluginLoader_Interface $loader
   * @return void
   */
  public static function setPluginLoader($loader)
  {
    if ((null !== $loader) && (!$loader instanceof Zend_Loader_PluginLoader_Interface)) {
      require_once &#39;Zend/Controller/Action/Exception.php&#39;;
      throw new Zend_Controller_Action_Exception(&#39;Invalid plugin loader provided to HelperBroker&#39;);
    }
    self::$_pluginLoader = $loader;
  }
  /**
   * Retrieve PluginLoader
   *
   * @return Zend_Loader_PluginLoader
   */
  public static function getPluginLoader()
  {
    if (null === self::$_pluginLoader) {
      require_once &#39;Zend/Loader/PluginLoader.php&#39;;
      self::$_pluginLoader = new Zend_Loader_PluginLoader(array(
        &#39;Zend_Controller_Action_Helper&#39; => &#39;Zend/Controller/Action/Helper/&#39;,
      ));
    }
    return self::$_pluginLoader;
  }
  /**
   * addPrefix() - Add repository of helpers by prefix
   *
   * @param string $prefix
   */
  static public function addPrefix($prefix)
  {
    $prefix = rtrim($prefix, &#39;_&#39;);
    $path  = str_replace(&#39;_&#39;, DIRECTORY_SEPARATOR, $prefix);
    self::getPluginLoader()->addPrefixPath($prefix, $path);
  }
  /**
   * addPath() - Add path to repositories where Action_Helpers could be found.
   *
   * @param string $path
   * @param string $prefix Optional; defaults to &#39;Zend_Controller_Action_Helper&#39;
   * @return void
   */
  static public function addPath($path, $prefix = &#39;Zend_Controller_Action_Helper&#39;)
  {
    self::getPluginLoader()->addPrefixPath($prefix, $path);
  }
  /**
   * addHelper() - Add helper objects
   *
   * @param Zend_Controller_Action_Helper_Abstract $helper
   * @return void
   */
  static public function addHelper(Zend_Controller_Action_Helper_Abstract $helper)
  {
    self::getStack()->push($helper);
    return;
  }
  /**
   * resetHelpers()
   *
   * @return void
   */
  static public function resetHelpers()
  {
    self::$_stack = null;
    return;
  }
  /**
   * Retrieve or initialize a helper statically
   *
   * Retrieves a helper object statically, loading on-demand if the helper
   * does not already exist in the stack. Always returns a helper, unless
   * the helper class cannot be found.
   *
   * @param string $name
   * @return Zend_Controller_Action_Helper_Abstract
   */
  public static function getStaticHelper($name)
  {
    $name = self::_normalizeHelperName($name);
    $stack = self::getStack();
    if (!isset($stack->{$name})) {
      self::_loadHelper($name);
    }
    return $stack->{$name};
  }
  /**
   * getExistingHelper() - get helper by name
   *
   * Static method to retrieve helper object. Only retrieves helpers already
   * initialized with the broker (either via addHelper() or on-demand loading
   * via getHelper()).
   *
   * Throws an exception if the referenced helper does not exist in the
   * stack; use {@link hasHelper()} to check if the helper is registered
   * prior to retrieving it.
   *
   * @param string $name
   * @return Zend_Controller_Action_Helper_Abstract
   * @throws Zend_Controller_Action_Exception
   */
  public static function getExistingHelper($name)
  {
    $name = self::_normalizeHelperName($name);
    $stack = self::getStack();
    if (!isset($stack->{$name})) {
      require_once &#39;Zend/Controller/Action/Exception.php&#39;;
      throw new Zend_Controller_Action_Exception(&#39;Action helper "&#39; . $name . &#39;" has not been registered with the helper broker&#39;);
    }
    return $stack->{$name};
  }
  /**
   * Return all registered helpers as helper => object pairs
   *
   * @return array
   */
  public static function getExistingHelpers()
  {
    return self::getStack()->getHelpersByName();
  }
  /**
   * Is a particular helper loaded in the broker?
   *
   * @param string $name
   * @return boolean
   */
  public static function hasHelper($name)
  {
    $name = self::_normalizeHelperName($name);
    return isset(self::getStack()->{$name});
  }
  /**
   * Remove a particular helper from the broker
   *
   * @param string $name
   * @return boolean
   */
  public static function removeHelper($name)
  {
    $name = self::_normalizeHelperName($name);
    $stack = self::getStack();
    if (isset($stack->{$name})) {
      unset($stack->{$name});
    }
    return false;
  }
  /**
   * Lazy load the priority stack and return it
   *
   * @return Zend_Controller_Action_HelperBroker_PriorityStack
   */
  public static function getStack()
  {
    if (self::$_stack == null) {
      self::$_stack = new Zend_Controller_Action_HelperBroker_PriorityStack();
    }
    return self::$_stack;
  }
  /**
   * Constructor
   *
   * @param Zend_Controller_Action $actionController
   * @return void
   */
  public function __construct(Zend_Controller_Action $actionController)
  {
    $this->_actionController = $actionController;
    foreach (self::getStack() as $helper) {
      $helper->setActionController($actionController);
      $helper->init();
    }
  }
  /**
   * notifyPreDispatch() - called by action controller dispatch method
   *
   * @return void
   */
  public function notifyPreDispatch()
  {
    foreach (self::getStack() as $helper) {
      $helper->preDispatch();
    }
  }
  /**
   * notifyPostDispatch() - called by action controller dispatch method
   *
   * @return void
   */
  public function notifyPostDispatch()
  {
    foreach (self::getStack() as $helper) {
      $helper->postDispatch();
    }
  }
  /**
   * getHelper() - get helper by name
   *
   * @param string $name
   * @return Zend_Controller_Action_Helper_Abstract
   */
  public function getHelper($name)
  {
    $name = self::_normalizeHelperName($name);
    $stack = self::getStack();
    if (!isset($stack->{$name})) {
      self::_loadHelper($name);
    }
    $helper = $stack->{$name};
    $initialize = false;
    if (null === ($actionController = $helper->getActionController())) {
      $initialize = true;
    } elseif ($actionController !== $this->_actionController) {
      $initialize = true;
    }
    if ($initialize) {
      $helper->setActionController($this->_actionController)
          ->init();
    }
    return $helper;
  }
  /**
   * Method overloading
   *
   * @param string $method
   * @param array $args
   * @return mixed
   * @throws Zend_Controller_Action_Exception if helper does not have a direct() method
   */
  public function __call($method, $args)
  {
    $helper = $this->getHelper($method);
    if (!method_exists($helper, &#39;direct&#39;)) {
      require_once &#39;Zend/Controller/Action/Exception.php&#39;;
      throw new Zend_Controller_Action_Exception(&#39;Helper "&#39; . $method . &#39;" does not support overloading via direct()&#39;);
    }
    return call_user_func_array(array($helper, &#39;direct&#39;), $args);
  }
  /**
   * Retrieve helper by name as object property
   *
   * @param string $name
   * @return Zend_Controller_Action_Helper_Abstract
   */
  public function __get($name)
  {
    return $this->getHelper($name);
  }
  /**
   * Normalize helper name for lookups
   *
   * @param string $name
   * @return string
   */
  protected static function _normalizeHelperName($name)
  {
    if (strpos($name, &#39;_&#39;) !== false) {
      $name = str_replace(&#39; &#39;, &#39;&#39;, ucwords(str_replace(&#39;_&#39;, &#39; &#39;, $name)));
    }
    return ucfirst($name);
  }
  /**
   * Load a helper
   *
   * @param string $name
   * @return void
   */
  protected static function _loadHelper($name)
  {
    try {
      $class = self::getPluginLoader()->load($name);
    } catch (Zend_Loader_PluginLoader_Exception $e) {
      require_once &#39;Zend/Controller/Action/Exception.php&#39;;
      throw new Zend_Controller_Action_Exception(&#39;Action Helper by name &#39; . $name . &#39; not found&#39;, 0, $e);
    }
    $helper = new $class();
    if (!$helper instanceof Zend_Controller_Action_Helper_Abstract) {
      require_once &#39;Zend/Controller/Action/Exception.php&#39;;
      throw new Zend_Controller_Action_Exception(&#39;Helper name &#39; . $name . &#39; -> class &#39; . $class . &#39; is not of type Zend_Controller_Action_Helper_Abstract&#39;);
    }
    self::getStack()->push($helper);
  }
}

Allgemeine Verwendung von Assistant Broker:

1. Registrieren Sie einen Assistenten

Zend_Controller_Action_HelperBroker::addHelper($helper);

2. Mit einer Klasse über die addPrefix()-Methode Prefix Parameter, der zum Hinzufügen des Pfads zur benutzerdefinierten Hilfsklasse verwendet wird. Erfordert, dass das Präfix der Klassenbenennungskonvention von Zend Framework folgt.

// Add helpers prefixed with My_Action_Helpers in My/Action/Helpers/
Zend_Controller_Action_HelperBroker::addPrefix('My_Action_Helpers');

3. Verwenden Sie die Methode addPath(). Der erste Parameter ist ein Verzeichnis und der zweite Parameter ist das Klassenpräfix (Standard ist „Zend_Controller_Action_Helper“). .

wird verwendet, um Ihr eigenes Klassenpräfix dem angegebenen Verzeichnis zuzuordnen.

// Add helpers prefixed with Helper in Plugins/Helpers/
Zend_Controller_Action_HelperBroker::addPath('./Plugins/Helpers',
                       'Helper');

2. Bestimmen Sie, ob der Assistent vorhanden ist

Verwenden Sie die Methode hasHelper($name), um festzustellen, ob der Assistant Broker existiert Ob ein Assistent existiert, $name ist der Kurzname des Assistenten (mit entferntem Präfix):

// Check if 'redirector' helper is registered with the broker:
if (Zend_Controller_Action_HelperBroker::hasHelper('redirector')) {
  echo 'Redirector helper registered';
}

Es gibt zwei statische Methoden zum Abrufen der Assistent vom Assistant-Broker: getExistingHelper() und getStaticHelper(). getExistingHelper() ruft den Helper nur ab, wenn er zuvor aufgerufen oder explizit beim Helper-Broker registriert wurde, andernfalls wird eine Ausnahme ausgelöst. getStaticHelper() macht dasselbe wie getExistingHelper(), aber wenn der Helper-Stack nicht registriert wurde, wird versucht, den Helper zu initialisieren. Um den Helper zu erhalten, den Sie konfigurieren möchten, ist getStaticHelper() eine gute Wahl. Beide Methoden verwenden einen Parameter, $name, der der Kurzname des Assistenten ist (ohne Präfix).

// Check if 'redirector' helper is registered with the broker, and fetch:
if (Zend_Controller_Action_HelperBroker::hasHelper('redirector')) {
  $redirector =
    Zend_Controller_Action_HelperBroker::getExistingHelper('redirector');
}
// Or, simply retrieve it, not worrying about whether or not it was
// previously registered:
$redirector =
  Zend_Controller_Action_HelperBroker::getStaticHelper('redirector');
}

3. RemoveHelper($name) löscht einen Assistenten im Assistant-Broker, $name ist der Kurzname des Assistenten

.

// Conditionally remove the 'redirector' helper from the broker:
if (Zend_Controller_Action_HelperBroker::hasHelper('redirector')) {
  Zend_Controller_Action_HelperBroker::removeHelper('redirector')
}

以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！

相关推荐：

Zend Framework校验器Zend_Validate的用法解析

Zend Framework中Zend_View组件的用法解析

Das obige ist der detaillierte Inhalt vonNutzungsanalyse des Zend Framework-Aktionsassistenten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!