El caché de Magento no es diferente. Comenzando con lo básico, las opciones de caché se pueden ver navegando a
Sistema-> Gestión de caché
en el backend Puede ver las diferentes áreas de almacenamiento en caché que se pueden habilitar / deshabilitar, como cualquier configuración, layout.xml, bloques, página completa y archivos api. Obviamente, lo ideal es tener todo esto habilitado una vez que el sitio esté activo.
El caché también se puede borrar o enjuagar desde aquí. Al presionar el botón etiquetado “Flush Magento Cache”se eliminarán los archivos de caché que coincidan con un cierto conjunto de etiquetas predeterminadas incorporadas que utiliza Magento. Esta es la forma "más segura" de borrar el caché, ya que no borra absolutamente todo. Si está utilizando algún tipo de caché secundario, al hacer clic “Flush Cache Storage”se asegurará de haber limpiado su caché, ya que borra TODO. Los otros dos botones que ve en la página de administración borrarán las imágenes de JavaScript y CSS y del catálogo.
Una forma alternativa y un poco menos segura de borrar el caché es navegar a
websiteroot / var / cache
y eliminar manualmente todos los archivos. Lo mismo vale para
websiteroot / var / full_page__cache
si tiene habilitada la caché de página completa.
La memoria caché de página completa, disponible en Enterprise Edition, acelera su sitio 10 veces, pero es importante saber un poco al respecto, en caso de que observe que se almacena en caché cualquier contenido dinámico. Un archivo interesante para mirar es
websiteroot / app / code / core / Enterprise / PageCache / etc / cache.xml
Aquí puede ver lo que FPC almacena en caché, el nombre del bloque, el nombre del contenedor y la duración de la sesión. Si considera absolutamente necesario editar o eliminar cualquiera de estos bloques de la memoria caché, puede hacerlo creando un módulo dependiente del módulo PageCache y colocando cualquier modificación allí.
La etiqueta de marcador de posición le dice al FPC que ese bloque se considera dinámico. Cuando se carga una página, si el bloque aún no está en la memoria caché, este valor de ID en las etiquetas de marcador de posición se busca en la memoria caché, y si no existe, ese bloque se llama y se genera, y la ID se agrega a el caché
La función de compilación de Magento se puede encontrar en
Sistema> Herramientas> Compilación
Si está ejecutando una instalación nueva, probablemente reciba un mensaje del sistema que indica que ambos includes and includes/src/directorios deben poder escribirse. Cuando esto esté hecho, podemos presionar el botón 'Ejecutar proceso de compilación' y básicamente ya está listo, el núcleo de Magento está usando la compilación.
Cuando Magento compila su código fuente, el marco hace algunas cosas. Al estar ya sea provocada a través de la administración o shell, see shell/compiler.php, toda la compilación se realiza por una sola clase: Mage_Compiler_Model_Process. Dentro de esta clase, encontrará el siguiente fragmento, que en realidad es una vista panorámica de todo el proceso.
/**
* Run compilation process
*
* @return Mage_Compiler_Model_Process
*/
public function run()
{
$this->_collectFiles();
$this->_compileFiles();
$this->registerIncludePath();
return $this;
}
Iniciado por la $this->_collectFiles();llamada, Magento copia todos los archivos PHP de ambos
aplicación / código
y directorios de lib a la
/ incluye / src
directorio. Como puede ver en el fragmento a continuación: durante este proceso, Magento itera recursivamente a través de todos los archivos y directorios. Estas rutas se utilizan finalmente como el nombre del archivo. Cuando el proceso recursivo llega a un archivo, buscará una extensión PHP y, cuando se encuentre, el archivo se copia en el directorio del compilador. Otros tipos de archivos se mantienen intactos.
Como ejemplo: la ruta para la clase Mage_Catalog_Model_Category fue
app / code / core / Mage / Catalog / Model / Category.php
pero, con la compilación habilitada, ahora se ha convertido
incluye / src / Mage_Catalog_Model_Category.php
/**
* Copy files from all include directories to one.
* Lib files and controllers files will be copied as is
*
* @return Mage_Compiler_Model_Process
*/
protected function _collectFiles()
{
$paths = $this->_getIncludePaths();
$paths = array_reverse($paths);
$destDir= $this->_includeDir;
$libDir = Mage::getBaseDir('lib');
$this->_mkdir($destDir);
foreach ($paths as $path) {
$this->_controllerFolders = array();
$this->_copy($path, $destDir); // this one will run recursively through all directories
$this->_copyControllers($path);
if ($path == $libDir) {
$this->_copyAll($libDir, $destDir);
}
}
$destDir.= DS.'Data';
$this->_mkdir($destDir);
$this->_copyZendLocaleData($destDir);
return $this;
}
Los controladores están recibiendo otro tratamiento. Todos los directorios del controlador se copian a
incluye / src /
pero se almacenan dentro de un directorio que tiene el nombre de su espacio de nombres relacionado, piense: Mage, Enterprise o su propio espacio de nombres.
Dentro de estos directorios de espacio de nombres, los controladores se almacenan por módulo y la estructura del directorio del controlador se mantiene intacta. Lo mismo ocurre con el nombre del archivo, es solo una copia exacta. Toda esta lógica se puede encontrar en el siguiente método$this->_copyControllers($path);
Este segundo nivel de compilación recopila todos los ámbitos y sus respectivas listas de clases del administrador. Todos estos ámbitos se están procesando recuperando el contenido de los archivos de clase relacionados y escribiéndolos en un solo archivo con el nombre del alcance dado.
/**
* Compile classes code to files
*
* @return Mage_Compiler_Model_Process
*/
protected function _compileFiles()
{
$classesInfo = $this->getCompileClassList();
foreach ($classesInfo as $code => $classes) {
$classesSorce = $this->_getClassesSourceCode($classes, $code);
file_put_contents($this->_includeDir.DS.Varien_Autoload::SCOPE_FILE_PREFIX.$code.'.php', $classesSorce);
}
return $this;
}
Por defecto, Magento crea cuatro archivos de alcance diferentes:
__default.php, __catalog.php, __checkout.php y __cms.php
Durante el proceso de creación de estos archivos de alcance, Magento analiza automáticamente todas las extensiones de clase e interfaces que están utilizando las clases proporcionadas en la lista de alcance.
Con todos los archivos en su lugar y compilados, Magento está listo para habilitar la función de compilación para su uso.
Por último, pero no menos importante, se ajusta la configuración relacionada con la compilación. Este archivo se puede encontrar en includes/config.phpy contiene las siguientes dos constantes. Al habilitar la compilación, la línea relativa a COMPILER_INCLUDE_PATH no está comentada y, por lo tanto, está lista para la acción.
> #define('COMPILER_INCLUDE_PATH', dirname(__FILE__).DIRECTORY_SEPARATOR.'src');
> #define('COMPILER_COLLECT_PATH', dirname(__FILE__).DIRECTORY_SEPARATOR.'stat');
El código responsable de ajustar el archivo de configuración se puede encontrar en el método registerIncludePath de Mage_Compiler_Model_Process class.
Durante el arranque, el archivo de configuración de compilación se incluye dentro de index.php file (around line 44). Esto hace que las constantes include_path estén disponibles en todo el marco. Collect_path es algo que solo puede habilitar manualmente para obtener más información estadística sobre el uso de sus archivos compilados. Esto no debe habilitarse en vivo.
/**
* Compilation includes configuration file
*/
$compilerConfig = 'includes/config.php';
if (file_exists($compilerConfig)) {
include $compilerConfig;
}
A partir de este momento, Magento verificará si el modo de compilación está habilitado con la siguiente declaración. Al revisar la base de código (usando 'grep') notará que la mayor parte de esta lógica se puede encontrar en el lib/Varien/Autoload.phparchivo.
if (defined('COMPILER_COLLECT_PATH')) {
// do stuff
}
El otro lugar para buscar es el Mage_Core_Controller_Varien_Action. En esta clase, encontrará el preDispatch()método, que se activa para cada método de acción del controlador antes de que el método se envíe realmente. En esta parte de la fuente, se llama a la clase de autocargador Miennto Varien_Autoload para cargar un archivo de alcance de compilación específico.
Mage::dispatchEvent('controller_action_predispatch', array('controller_action'=>$this));
Mage::dispatchEvent(
'controller_action_predispatch_'.$this->getRequest()->getRouteName(),
array('controller_action'=>$this)
);
Varien_Autoload::registerScope($this->getRequest()->getRouteName()); // right here
Mage::dispatchEvent(
'controller_action_predispatch_'.$this->getFullActionName(),
array('controller_action'=>$this)
);
Cuando se ejecuta en modo de compilación, Magento solo tiene una única ruta de inclusión, el includes/src/directorio, por lo que cada archivo se encuentra directamente en el primer intento. Con la considerable cantidad de archivos que tiene Magento, esto ahorra bastante tiempo. El fragmento debajo se toma del
app / Mage.php
if (defined('COMPILER_INCLUDE_PATH')) {
$appPath = COMPILER_INCLUDE_PATH;
set_include_path($appPath . PS . Mage::registry('original_include_path'));
include_once "Mage_Core_functions.php";
include_once "Varien_Autoload.php";
} else {
/**
* Set include path
*/
$paths[] = BP . DS . 'app' . DS . 'code' . DS . 'local';
$paths[] = BP . DS . 'app' . DS . 'code' . DS . 'community';
$paths[] = BP . DS . 'app' . DS . 'code' . DS . 'core';
$paths[] = BP . DS . 'lib';
$appPath = implode(PS, $paths);
set_include_path($appPath . PS . Mage::registry('original_include_path'));
include_once "Mage/Core/functions.php";
include_once "Varien/Autoload.php";
}
Cuando PHP incluye un archivo, el contenido se compila en opcode. Este es un proceso que debe hacerse cada vez que se incluye un archivo. Para mejorar aún más el rendimiento de su tienda, puede instalar APC en su servidor. APC almacena en caché las versiones codificadas de los archivos, haciéndolos disponibles para solicitudes posteriores. Entonces, en la próxima solicitud: el archivo se leerá de la memoria caché de APC, en lugar de tener que pasar por el mismo proceso nuevamente y agotar su rendimiento.