Das Beispiel in diesem Artikel beschreibt die Anwendungsnutzung des Zend Framework-Tutorials. Teilen Sie es als Referenz mit allen. Die Details lauten wie folgt:

Zend_Application ist die Kernkomponente von Zend Framework. Zend_Application stellt grundlegende Funktionen für Zend Framework-Anwendungen bereit und ist der Einstiegspunkt des Programms. Seine Hauptfunktionen sind zwei: Laden und Konfigurieren der PHP-Umgebung (einschlie?lich automatischem Laden) und Booten der Anwendung.

Typischerweise wird der Zend_Application-Konstruktor über Konfigurationsoptionen konfiguriert, er kann aber auch vollst?ndig mithilfe einer benutzerdefinierten Methode konfiguriert werden. Nachfolgend finden Sie zwei Anwendungsf?lle.

Zend_Application-Konfigurationsoptionen

Konstruktor:

/**
 * Constructor
 *
 * Initialize application. Potentially initializes include_paths, PHP
 * settings, and bootstrap class.
 *
 * @param string          $environment
 * @param string|array|Zend_Config $options String path to configuration file, or array/Zend_Config of configuration options
 * @throws Zend_Application_Exception When invalid options are provided
 * @return void
 */
public function __construct($environment, $options = null)
{
  $this->_environment = (string) $environment;
  require_once 'Zend/Loader/Autoloader.php';
  $this->_autoloader = Zend_Loader_Autoloader::getInstance();
  if (null !== $options) {
    if (is_string($options)) {
      $options = $this->_loadConfig($options);
    } elseif ($options instanceof Zend_Config) {
      $options = $options->toArray();
    } elseif (!is_array($options)) {
      throw new Zend_Application_Exception('Invalid options provided; must be location of config file, a config object, or an array');
    }
    $this->setOptions($options);
  }
}

Zend_Application-Konfigurationsmethode

1. Konfigurationsdatei verwenden

Allgemeine Konfigurationsoptionen

Hinweis:

Bei Optionsnamen wird die Gro?-/Kleinschreibung nicht beachtet.

Zend_Application-Methode

Konfigurationsbeispiel:

Standard:

// Create application, bootstrap, and run
$application = new Zend_Application(
  APPLICATION_ENV,
  APPLICATION_PATH . '/configs/application.ini'
);
$application->bootstrap()
      ->run();

Quellcode

<?php
class Zend_Application
{  /**
   * Constructor
   *
   * Initialize application. Potentially initializes include_paths, PHP
   * settings, and bootstrap class.
   *
   * @param string          $environment
   * @param string|array|Zend_Config $options String path to configuration file, or array/Zend_Config of configuration options
   * @throws Zend_Application_Exception When invalid options are provided
   * @return void
   */
  public function __construct($environment, $options = null)
  {
    $this->_environment = (string) $environment;
    require_once &#39;Zend/Loader/Autoloader.php&#39;;
    $this->_autoloader = Zend_Loader_Autoloader::getInstance();
    if (null !== $options) {
      if (is_string($options)) {
        $options = $this->_loadConfig($options);
      } elseif ($options instanceof Zend_Config) {
        $options = $options->toArray();
      } elseif (!is_array($options)) {
        throw new Zend_Application_Exception(&#39;Invalid options provided; must be location of config file, a config object, or an array&#39;);
      }
      $this->setOptions($options);
    }
  }
  /**
   * Retrieve current environment
   *
   * @return string
   */
  public function getEnvironment()
  {
    return $this->_environment;
  }
  /**
   * Retrieve autoloader instance
   *
   * @return Zend_Loader_Autoloader
   */
  public function getAutoloader()
  {
    return $this->_autoloader;
  }
  /**
   * Set application options
   *
   * @param array $options
   * @throws Zend_Application_Exception When no bootstrap path is provided
   * @throws Zend_Application_Exception When invalid bootstrap information are provided
   * @return Zend_Application
   */
  public function setOptions(array $options)
  {
    if (!empty($options[&#39;config&#39;])) {
      if (is_array($options[&#39;config&#39;])) {
        $_options = array();
        foreach ($options[&#39;config&#39;] as $tmp) {
          $_options = $this->mergeOptions($_options, $this->_loadConfig($tmp));
        }
        $options = $this->mergeOptions($_options, $options);
      } else {
        $options = $this->mergeOptions($this->_loadConfig($options[&#39;config&#39;]), $options);
      }
    }
    $this->_options = $options;
    $options = array_change_key_case($options, CASE_LOWER);
    $this->_optionKeys = array_keys($options);
    if (!empty($options[&#39;phpsettings&#39;])) {
      $this->setPhpSettings($options[&#39;phpsettings&#39;]);
    }
    if (!empty($options[&#39;includepaths&#39;])) {
      $this->setIncludePaths($options[&#39;includepaths&#39;]);
    }
    if (!empty($options[&#39;autoloadernamespaces&#39;])) {
      $this->setAutoloaderNamespaces($options[&#39;autoloadernamespaces&#39;]);
    }
    if (!empty($options[&#39;autoloaderzfpath&#39;])) {
      $autoloader = $this->getAutoloader();
      if (method_exists($autoloader, &#39;setZfPath&#39;)) {
        $zfPath  = $options[&#39;autoloaderzfpath&#39;];
        $zfVersion = !empty($options[&#39;autoloaderzfversion&#39;])
              ? $options[&#39;autoloaderzfversion&#39;]
              : &#39;latest&#39;;
        $autoloader->setZfPath($zfPath, $zfVersion);
      }
    }
    if (!empty($options[&#39;bootstrap&#39;])) {
      $bootstrap = $options[&#39;bootstrap&#39;];
      if (is_string($bootstrap)) {
        $this->setBootstrap($bootstrap);
      } elseif (is_array($bootstrap)) {
        if (empty($bootstrap[&#39;path&#39;])) {
          throw new Zend_Application_Exception(&#39;No bootstrap path provided&#39;);
        }
        $path = $bootstrap[&#39;path&#39;];
        $class = null;
        if (!empty($bootstrap[&#39;class&#39;])) {
          $class = $bootstrap[&#39;class&#39;];
        }
        $this->setBootstrap($path, $class);
      } else {
        throw new Zend_Application_Exception(&#39;Invalid bootstrap information provided&#39;);
      }
    }
    return $this;
  }
  /**
   * Retrieve application options (for caching)
   *
   * @return array
   */
  public function getOptions()
  {
    return $this->_options;
  }
  /**
   * Is an option present?
   *
   * @param string $key
   * @return bool
   */
  public function hasOption($key)
  {
    return in_array(strtolower($key), $this->_optionKeys);
  }
  /**
   * Retrieve a single option
   *
   * @param string $key
   * @return mixed
   */
  public function getOption($key)
  {
  }
  /**
   * Merge options recursively
   *
   * @param array $array1
   * @param mixed $array2
   * @return array
   */
  public function mergeOptions(array $array1, $array2 = null)
  {
    if (is_array($array2)) {
      foreach ($array2 as $key => $val) {
        if (is_array($array2[$key])) {
          $array1[$key] = (array_key_exists($key, $array1) && is_array($array1[$key]))
                 ? $this->mergeOptions($array1[$key], $array2[$key])
                 : $array2[$key];
        } else {
          $array1[$key] = $val;
        }
      }
    }
    return $array1;
  }
  /**
   * Set PHP configuration settings
   *
   * @param array $settings
   * @param string $prefix Key prefix to prepend to array values (used to map . separated INI values)
   * @return Zend_Application
   */
  public function setPhpSettings(array $settings, $prefix = &#39;&#39;)
  {
    foreach ($settings as $key => $value) {
      $key = empty($prefix) ? $key : $prefix . $key;
      if (is_scalar($value)) {
        ini_set($key, $value);
      } elseif (is_array($value)) {
        $this->setPhpSettings($value, $key . &#39;.&#39;);
      }
    }
    return $this;
  }
  /**
   * Set include path
   *
   * @param array $paths
   * @return Zend_Application
   */
  public function setIncludePaths(array $paths)
  {
    $path = implode(PATH_SEPARATOR, $paths);
    set_include_path($path . PATH_SEPARATOR . get_include_path());
    return $this;
  }
  /**
   * Set autoloader namespaces
   *
   * @param array $namespaces
   * @return Zend_Application
   */
  public function setAutoloaderNamespaces(array $namespaces)
  {
    $autoloader = $this->getAutoloader();
    foreach ($namespaces as $namespace) {
      $autoloader->registerNamespace($namespace);
    }
    return $this;
  }
  /**
   * Set bootstrap path/class
   *
   * @param string $path
   * @param string $class
   * @return Zend_Application
   */
  public function setBootstrap($path, $class = null)
  {
    // setOptions() can potentially send a null value; specify default
    // here
    if (null === $class) {
      $class = &#39;Bootstrap&#39;;
    }
    if (!class_exists($class, false)) {
      require_once $path;
      if (!class_exists($class, false)) {
        throw new Zend_Application_Exception(&#39;Bootstrap class not found&#39;);
      }
    }
    $this->_bootstrap = new $class($this);
    if (!$this->_bootstrap instanceof Zend_Application_Bootstrap_Bootstrapper) {
      throw new Zend_Application_Exception(&#39;Bootstrap class does not implement Zend_Application_Bootstrap_Bootstrapper&#39;);
    }
    return $this;
  }
  /**
   * Get bootstrap object
   *
   * @return Zend_Application_Bootstrap_BootstrapAbstract
   */
  public function getBootstrap()
  {
    if (null === $this->_bootstrap) {
      $this->_bootstrap = new Zend_Application_Bootstrap_Bootstrap($this);
    }
    return $this->_bootstrap;
  }
  /**
   * Bootstrap application
   *
   * @param null|string|array $resource
   * @return Zend_Application
   */
  public function bootstrap($resource = null)
  {
    $this->getBootstrap()->bootstrap($resource);
    return $this;
  }
  /**
   * Run the application
   *
   * @return void
   */
  public function run()
  {
    $this->getBootstrap()->run();
  }
  /**
   * Load configuration file of options
   *
   * @param string $file
   * @throws Zend_Application_Exception When invalid configuration file is provided
   * @return array
   */
  protected function _loadConfig($file)
  {
    $environment = $this->getEnvironment();
    $suffix   = pathinfo($file, PATHINFO_EXTENSION);
    $suffix   = ($suffix === &#39;dist&#39;)
           ? pathinfo(basename($file, ".$suffix"), PATHINFO_EXTENSION)
           : $suffix;
    switch (strtolower($suffix)) {
      case &#39;ini&#39;:
        $config = new Zend_Config_Ini($file, $environment);
        break;
      case &#39;xml&#39;:
        $config = new Zend_Config_Xml($file, $environment);
        break;
      case &#39;json&#39;:
        $config = new Zend_Config_Json($file, $environment);
        break;
      case &#39;yaml&#39;:
      case &#39;yml&#39;:
        $config = new Zend_Config_Yaml($file, $environment);
        break;
      case &#39;php&#39;:
      case &#39;inc&#39;:
        $config = include $file;
        if (!is_array($config)) {
          throw new Zend_Application_Exception(&#39;Invalid configuration file provided; PHP file does not return array value&#39;);
        }
        return $config;
        break;
      default:
        throw new Zend_Application_Exception(&#39;Invalid configuration file provided; unknown config type&#39;);
    }
    return $config->toArray();
  }
}

Ich hoffe, dieser Artikel wird für alle hilfreich sein, die sich mit PHP-Programmierung befassen.

Ausführlichere Erl?uterungen zu Anwendungsnutzungsbeispielen in Zend Framework-Tutorials und verwandten Artikeln finden Sie auf der chinesischen PHP-Website!