La cache di Magento non è diversa. Partendo dalle basi, è possibile visualizzare le opzioni della cache accedendo a
Sistema-> Gestione cache
nel backend. Puoi vedere le diverse aree della cache che possono essere abilitate / disabilitate, come qualsiasi configurazione, layout.xml, blocchi, pagina intera e file api. Ovviamente l'ideale è avere tutti questi abilitati una volta che il sito è attivo.
Da qui è anche possibile cancellare o svuotare la cache. Premendo il pulsante etichettato “Flush Magento Cache”, tutti i file di cache che corrispondono a un determinato set di tag predefiniti integrati verranno utilizzati da Magento. Questo è il modo "più sicuro" per cancellare la cache, in quanto non cancella assolutamente tutto. Se si utilizzano tipi di cache secondari, fare clic “Flush Cache Storage”per assicurarsi di aver cancellato la cache, poiché cancella TUTTO. Gli altri due pulsanti visualizzati nella pagina di amministrazione cancelleranno javascript e css e le immagini del catalogo.
Un modo alternativo e leggermente meno sicuro per svuotare la cache è navigare verso
websiteroot / var / cache
e eliminando manualmente tutti i file. Lo stesso vale per
websiteroot / var / full_page__cache
se hai abilitato la cache a pagina intera.
La cache a pagina intera, disponibile su Enterprise Edition, accelera il tuo sito di 10 volte, ma è importante conoscerne un po ', nel caso in cui noti che i contenuti dinamici vengono memorizzati nella cache. Un file interessante da guardare è
websiteroot / app / code / core / Enterprise / pagecache / etc / cache.xml
Qui puoi vedere cosa viene memorizzato nella cache da FPC, il nome del blocco, il nome del contenitore e la durata della sessione. Se ritieni assolutamente necessario modificare o rimuovere uno di questi blocchi dalla cache, puoi farlo creando un modulo dipendente dal modulo PageCache e inserendo eventuali modifiche.
Il tag segnaposto indica all'FPC che quel blocco è considerato dinamico. Quando viene caricata una pagina, se il blocco non è ancora nella cache, questo valore ID nei tag segnaposto viene cercato nella cache e, se non esiste, viene chiamato e generato quel blocco e l'ID viene aggiunto a la cache.
La funzione di compilazione di Magento è disponibile sotto
Sistema> Strumenti> Compilazione
Se stai eseguendo una nuova installazione, probabilmente ricevi un messaggio di sistema sul fatto che entrambe le includes and includes/src/directory devono essere rese scrivibili. Al termine, possiamo premere il pulsante "Esegui processo di compilazione" e, in pratica, il core di Magento utilizza la compilazione.
Quando Magento compila il suo codice sorgente, il framework fa alcune cose. Essendo sia attivato tramite l'amministratore o shell, see shell/compiler.php, tutta la redazione è fatto da una singola classe: Mage_Compiler_Model_Process. All'interno di questa classe troverai il seguente frammento che è in realtà una visione a volo d'uccello dell'intero processo.
/**
* Run compilation process
*
* @return Mage_Compiler_Model_Process
*/
public function run()
{
$this->_collectFiles();
$this->_compileFiles();
$this->registerIncludePath();
return $this;
}
Iniziato dalla $this->_collectFiles();chiamata, Magento copia tutti i file PHP da entrambi
app / code
e directory lib per il
/ Include / src
directory. Come puoi vedere nello snippet di seguito: durante questo processo Magento scorre in modo ricorsivo tutti i file e le directory. Questi percorsi vengono infine utilizzati come nome file. Quando il processo ricorsivo colpisce un file, verifica la presenza di un'estensione PHP e, quando trovato, il file viene copiato nella directory del compilatore. Altri tipi di file non vengono toccati.
Ad esempio: il percorso per la classe Mage_Catalog_Model_Category era
app / code / core / Mage / Catalogo / Modello / category.php
ma, con la compilazione abilitata, ora è diventato
includes / 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;
}
I controller stanno ricevendo un altro trattamento. Tutte le directory dei controller vengono copiate
includes / src /
ma sono memorizzati in una directory che ha il nome del suo spazio dei nomi correlato, pensa: Mage, Enterprise o il tuo spazio dei nomi dato.
All'interno di queste directory dello spazio dei nomi i controller sono memorizzati per modulo e la struttura della directory dei controller rimane intatta. Lo stesso vale per il nome file, è solo una copia esatta. Tutta questa logica può essere trovata nel seguente metodo$this->_copyControllers($path);
Questo secondo livello di compilazione raccoglie tutti gli ambiti e i rispettivi elenchi di classi dall'amministratore. Tutti questi ambiti vengono elaborati recuperando il contenuto dei file di classe correlati e scrivendoli in un singolo file denominato dopo l'ambito specificato.
/**
* 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;
}
Per impostazione predefinita Magento crea quattro diversi file di ambito:
__default.php, __catalog.php, __checkout.php e __cms.php
Durante il processo di creazione di questi file di ambito Magento analizza automaticamente tutte le estensioni e le interfacce di classe utilizzate dalle classi fornite nell'elenco degli ambiti.
Con tutti i file in atto e compilati, Magento è pronto per abilitare la funzione di compilazione per l'uso.
Ultimo ma non meno importante, la configurazione relativa alla compilazione viene modificata. Questo file può essere trovato su includes/config.phpe contiene le seguenti due costanti. Dopo aver abilitato la compilazione, la riga relativa a COMPILER_INCLUDE_PATH è senza commenti e quindi pronta per l'azione.
> #define('COMPILER_INCLUDE_PATH', dirname(__FILE__).DIRECTORY_SEPARATOR.'src');
> #define('COMPILER_COLLECT_PATH', dirname(__FILE__).DIRECTORY_SEPARATOR.'stat');
Il codice responsabile della regolazione del file di configurazione è disponibile nel metodo registerIncludePath di Mage_Compiler_Model_Process class.
Durante il bootstrap il file di configurazione della compilation è incluso in index.php file (around line 44). Questo rende le costanti include_path disponibili in tutto il framework. Collect_path è qualcosa che puoi abilitare solo manualmente per ottenere maggiori informazioni statistiche sull'uso dei tuoi file compilati. Questo non dovrebbe essere abilitato in diretta.
/**
* Compilation includes configuration file
*/
$compilerConfig = 'includes/config.php';
if (file_exists($compilerConfig)) {
include $compilerConfig;
}
Da questo punto in poi Magento verificherà se la modalità di compilazione è abilitata con la seguente dichiarazione. Passando attraverso la base di codice (usando 'grep') noterai che la maggior parte di questa logica può essere trovata nel lib/Varien/Autoload.phpfile.
if (defined('COMPILER_COLLECT_PATH')) {
// do stuff
}
L'altro posto in cui cercare è il Mage_Core_Controller_Varien_Action. In questa classe troverai il preDispatch()metodo, che viene attivato per ciascun metodo di azione del controller prima che il metodo venga effettivamente inviato. In questa parte della fonte del caricatore automatico di Magento di origine viene richiesto Varien_Autoload per caricare un file di ambito di compilazione specifico.
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)
);
Quando viene eseguito in modalità compilation Magento ha solo un singolo percorso include, la includes/src/directory, quindi ogni file viene trovato direttamente al primo tentativo. Con la considerevole quantità di file di Magento, questo fa risparmiare parecchio tempo. Lo snippet sottostante è preso da
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";
}
Quando PHP include un file, il contenuto viene compilato in codice operativo. Questo è un processo che deve essere eseguito ogni volta che viene incluso un file. Per migliorare ulteriormente le prestazioni del tuo negozio, puoi installare APC sul tuo server. APC memorizza nella cache le versioni codificate dei file, rendendole disponibili per le richieste successive. Quindi alla prossima richiesta: il file verrà letto dalla cache APC, invece di dover ripetere lo stesso processo e svuotare le prestazioni.