Analyse de l'utilisation de l'assistant d'action Zend Framework

Cet article présente principalement l'utilisation de l'assistant d'action Zend Framework (Zend_Controller_Action_Helper), et analyse en détail la fonction, la définition, l'utilisation et le code d'implémentation associé de l'assistant d'action Zend_Controller_Action_Helper. Les amis dans le besoin peuvent se référer à ce qui suit

<.>Cet article explique les exemples d'utilisation de l'assistant d'action du Zend Framework (Zend_Controller_Action_Helper). Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Grâce au mode assistant, certains modules fonctionnels fréquemment utilisés peuvent être encapsulés, afin qu'ils puissent être utilisés de manière flexible là où cela est nécessaire, principalement dans des actions.

Il existe deux types d'assistants dans Zend Framework, l'assistant d'action (Zend_Controller_Action_Helper) et l'assistant de visualisation (Zend_View_Helper).

L'assistant d'action peut ajouter instantanément des fonctions (fonctionnalités d'exécution et/ou à la demande) à n'importe quel contrôleur d'action dérivé de Zend_Controller_Action, afin de minimiser le contrôle d'action dérivé lorsque l'ajout de fonctions de contrôleur d'action publique est nécessaire. .

L'assistant d'action est chargé lorsqu'il doit être appelé et peut être instancié sur demande (bootstrap) ou lorsque le contrôleur d'action est créé (init()).

Les fichiers associés impliqués

se trouvent dans /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
│                  

Les assistants d'action courants incluent
 :

FlashMessenger est utilisé gérer Flash Sessions Messenger ;

Json est utilisé pour décoder et envoyer des réponses JSON ; Url est utilisé pour créer des URL ; Redirector Fournit une autre méthode d'implémentation pour aider le programme à rediriger automatiquement vers des pages internes ou externes ; termine le processus d'établissement d'un objet de vue dans le contrôleur et de rendu de la vue ;

AutoComplete répond automatiquement à l'achèvement automatique d'AJAX ;

ContextSwitch et AjaxContext fournissent des formats de réponse alternatifs pour vos actions
Cache implémente les opérations liées au cache ; ;
ActionStack est utilisé pour faire fonctionner la pile d'actions.


Plusieurs méthodes d'instanciation pratiques

1 Via la méthode getHelper() du membre $_helper de Zend_Controller_Action

. Appelez simplement getHelper() directement et transmettez le nom de l’assistant.

2. Accédez directement à l'objet helper

correspondant à l'attribut de l'assistant _helper.

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

Zend_Controller_Action_HelperBroker

Le nom chinois se traduit par "Assistant Broker", comme son nom l'indique, c'est l'intermédiaire du assistant d'action.

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

La deuxième façon d'instancier une action consiste à utiliser la méthode magique __get() de Zend_Controller_Action_HelperBroker.

Le courtier assistant est utilisé pour enregistrer des objets assistant et des chemins d'assistant, obtenir des assistants et d'autres fonctions.

Implémentation de Zend_Controller_Action_HelperBroker et liste des méthodes courantes

Utilisation courante des courtiers assistants :

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

1. Enregistrez un assistant

1.

2. Avec un paramètre de préfixe de classe, utilisé pour ajouter le chemin à la classe d'assistance personnalisée.

Nécessite que le préfixe suive la convention de dénomination des classes de Zend Framework.

Zend_Controller_Action_HelperBroker::addHelper($helper);

3. Utilisez la méthode addPath() Le premier paramètre est un répertoire et le deuxième paramètre est le préfixe de la classe (la valeur par défaut est 'Zend_Controller_Action_Helper). ').

est utilisé pour mapper votre propre préfixe de classe au répertoire spécifié.

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

2. Déterminez si l'assistant existe

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

Utilisez la méthode hasHelper($name) pour déterminer le courtier adjoint Qu'il y ait un assistant dans la personne, $name est le nom court de l'assistant (avec le préfixe supprimé) :

Là Il existe deux façons d'obtenir l'assistant auprès du courtier assistant. Deux méthodes statiques : getExistingHelper() et getStaticHelper(). getExistingHelper() obtiendra l'assistant uniquement s'il a été appelé auparavant ou explicitement enregistré auprès du courtier d'assistance, sinon il lèvera une exception. getStaticHelper() fait la même chose que getExistingHelper(), mais si la pile d'assistance n'a pas été enregistrée, elle tentera d'initialiser l'assistance que vous souhaitez configurer, getStaticHelper() est un bon choix.

Les deux méthodes prennent un paramètre, $name, qui est le nom court de l'assistant (avec le préfixe supprimé).

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

3. removeHelper($name) supprime un assistant dans le courtier assistant, $name est le nom court de l'assistant

.

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

// 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组件的用法解析

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!