Haciendo que Zend-Framework funcione más rápido

Question

¿Cuáles son las mejores maneras de hacer que Zend-Framwork funcione más rápido además de Zend Optimizer?

Si no recuerdo mal, el análisis de archivos .ini en PHP lleva mucho tiempo. Por lo tanto, lo guardo en la memoria caché (el archivo no cambiará durante una solicitud)

¿Hay alguna otra forma de mejorar el rendimiento de ZF?

Answer 1

cacheamos mis application.ini De esta manera:

Asegúrese de que tiene el siguiente directorio (el directorio caché): /application/data/cache

extiendo Zend_Application con My_Application, véase el código:

<?php 
require_once 'Zend/Application.php'; 

class My_Application extends Zend_Application 
{ 

    /** 
    * Flag used when determining if we should cache our configuration. 
    */ 
    protected $_cacheConfig = false; 

    /** 
    * Our default options which will use File caching 
    */ 
    protected $_cacheOptions = array(
     'frontendType' => 'File', 
     'backendType' => 'File', 
     'frontendOptions' => array(), 
     'backendOptions' => array() 
    ); 

    /** 
    * Constructor 
    * 
    * Initialize application. Potentially initializes include_paths, PHP 
    * settings, and bootstrap class. 
    * 
    * When $options is an array with a key of configFile, this will tell the 
    * class to cache the configuration using the default options or cacheOptions 
    * passed in. 
    * 
    * @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) 
    { 
     if (is_array($options) && isset($options['configFile'])) { 
      $this->_cacheConfig = true; 

      // First, let's check to see if there are any cache options 
      if (isset($options['cacheOptions'])) 
       $this->_cacheOptions = 
        array_merge($this->_cacheOptions, $options['cacheOptions']); 

      $options = $options['configFile']; 
     } 
     parent::__construct($environment, $options); 
    } 

    /** 
    * Load configuration file of options. 
    * 
    * Optionally will cache the configuration. 
    * 
    * @param string $file 
    * @throws Zend_Application_Exception When invalid configuration file is provided 
    * @return array 
    */ 
    protected function _loadConfig($file) 
    { 
     if (!$this->_cacheConfig) 
      return parent::_loadConfig($file); 

     require_once 'Zend/Cache.php'; 
     $cache = Zend_Cache::factory(
      $this->_cacheOptions['frontendType'], 
      $this->_cacheOptions['backendType'], 
      array_merge(array(// Frontend Default Options 
       'master_file' => $file, 
       'automatic_serialization' => true 
      ), $this->_cacheOptions['frontendOptions']), 
      array_merge(array(// Backend Default Options 
       'cache_dir' => APPLICATION_PATH . '/data/cache' 
      ), $this->_cacheOptions['backendOptions']) 
     ); 

     $config = $cache->load('Zend_Application_Config'); 
     if (!$config) { 
      $config = parent::_loadConfig($file); 
      $cache->save($config, 'Zend_Application_Config'); 
     } 

     return $config; 
    } 
} 

Y cambio mi index.php (en la raíz public) a:

<?php 

// Define path to application directory 
defined('APPLICATION_PATH') 
    || define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application')); 

// Define application environment 
defined('APPLICATION_ENV') 
    || define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'production')); 

// Ensure library/ is on include_path 
set_include_path(implode(PATH_SEPARATOR, array(
    realpath(APPLICATION_PATH . '/../library'), 
    get_include_path(), 
))); 

/** My_Application */ 
require_once 'My/Application.php'; 

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

Vuelva a cargar la página y verá el archivo ini en la memoria caché. Buena suerte.

Answer 2

ver también http://www.kimbs.cn/2009/06/caching-application-ini-for-zend-framework-apps/

Answer 3

analizar archivos .ini puede ser un poco lento, pero yo no esperaría que estar cerca de la parte más lenta de una aplicación típica de ZF. Sin ver ningún resultado, parece que incluir un grupo de archivos (Zend_Cache_ *) en algunos casos puede ser aún más lento que analizar un archivo .ini simple. De todos modos, eso es sólo un área ...

ZF ha publicado una buena guía en la optimización: http://framework.zend.com/manual/en/performance.classloading.html

En resumen,

1. Utilizar el almacenamiento en caché donde importa: consultas de bases de datos/operaciones complejas, lleno caché de página, etc.
2. Strip require_once llama a favor de la carga automática según la documentación.
3. caché de archivos PluginLoader/asignación de clase

Si desea obtener un poco más en él,

1. Saltar utilizando el componente Zend_Application
2. Habilitar algún tipo de caché de código de operación
3. Realice otros métodos típicos de optimización de PHP (creación de perfiles, almacenamiento en memoria caché, etc.)

Answer 4

¿Por qué borraste tu última pregunta? que tenía un buen enlace para usted:

oí cosas como esto antes, pero la combinación suele estar relacionada con la migración de una plataforma a otra.

Comprobar en este enlace:

http://devblog.policystat.com/php-to-django-changing-the-engine-while-the-c