O cache do Magento não é diferente. Começando com o básico, as opções de cache podem ser visualizadas navegando para
Sistema-> Gerenciamento de Cache
no back-end. Você pode ver as diferentes áreas do cache que podem ser ativadas / desativadas, como configurações, layout.xml, blocos, página inteira e arquivos API. Obviamente, o ideal é ter tudo isso ativado quando o site estiver ativo.
O cache também pode ser limpo ou liberado a partir daqui. Pressionar o botão rotulado “Flush Magento Cache”liberará todos os arquivos de cache que correspondem a um determinado conjunto de tags padrão incorporadas que o Magento usa. Essa é a maneira "mais segura" de limpar o cache, pois não limpa absolutamente tudo. Se você estiver usando algum tipo de cache secundário, clique em “Flush Cache Storage”para garantir que você limpou o cache, pois ele limpa TUDO. Os outros dois botões que você vê na página de administrador limparão as imagens javascript, css e catálogo.
Uma maneira alternativa e um pouco menos segura de limpar o cache é navegar para
websiteroot / var / cache
e excluindo manualmente todos os arquivos. O mesmo vale para
websiteroot / var / full_page__cache
se você tiver o cache de página completo ativado.
O cache de página inteira, disponível na Enterprise Edition, acelera o site em 10 vezes, mas é importante saber um pouco sobre ele, caso você note algum conteúdo dinâmico sendo armazenado em cache. Um arquivo interessante para se olhar é
websiteroot / app / code / core / Enterprise / PageCache / etc / cache.xml
Aqui você pode ver o que está sendo armazenado em cache pelo FPC, o nome do bloco, o nome do contêiner e a duração da sessão. Se você achar absolutamente necessário editar ou remover qualquer um desses blocos do cache, poderá fazê-lo criando um módulo dependente do módulo PageCache e colocando quaisquer modificações nele.
A tag do espaço reservado informa ao FPC que esse bloco é considerado dinâmico. Quando uma página é carregada, se o bloco ainda não estiver no cache, esse valor de ID nas tags de espaço reservado é pesquisado no cache e, se não existir, esse bloco será chamado e gerado, e o ID será adicionado a o cache.
O recurso de compilação do Magento pode ser encontrado em
Sistema> Ferramentas> Compilação
Se você estiver executando uma nova instalação, provavelmente receberá uma mensagem do sistema informando que ambos os includes and includes/src/diretórios devem ser gravados. Quando isso é feito, podemos clicar no botão 'Executar processo de compilação' e você está basicamente pronto, o núcleo do Magento está usando a compilação.
Quando o Magento compila seu código fonte, o framework faz algumas coisas. Sendo tanto acionado via de administração ou shell, see shell/compiler.php, toda a compilação é feita por uma única classe: Mage_Compiler_Model_Process. Nesta classe, você encontrará o seguinte trecho, que é na verdade uma visão panorâmica de todo o processo.
/**
* Run compilation process
*
* @return Mage_Compiler_Model_Process
*/
public function run()
{
$this->_collectFiles();
$this->_compileFiles();
$this->registerIncludePath();
return $this;
}
Iniciado pela $this->_collectFiles();chamada, o Magento copia todos os arquivos PHP dos dois
aplicativo / código
e diretórios lib para o
/ includes / src
diretório. Como você pode ver no trecho abaixo: durante esse processo, o Magento repete recursivamente todos os arquivos e diretórios. Esses caminhos são eventualmente usados como o nome do arquivo. Quando o processo recursivo atinge um arquivo, ele verifica a extensão do PHP e, quando encontrado, o arquivo é copiado para o diretório do compilador. Outros tipos de arquivos são mantidos intocados.
Como exemplo: o caminho para a classe Mage_Catalog_Model_Category foi
app / code / core / Mage / Catalog / Model / Category.php
mas, com a compilação ativada, tornou-se agora
inclui / 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;
}
Os controladores estão recebendo outro tratamento. Todos os diretórios do controlador são copiados para
inclui / src /
mas são armazenados em um diretório que tem o nome de seu espaço para nome relacionado, pense: Mage, Enterprise ou seu próprio espaço para nome.
Dentro desses diretórios de namespace, os controladores são armazenados por módulo e a estrutura de diretórios do controlador é mantida intocada. O mesmo vale para o nome do arquivo, é apenas uma cópia exata. Toda essa lógica pode ser encontrada no seguinte método$this->_copyControllers($path);
Este segundo nível de compilação coleta todos os escopos e suas respectivas listas de classes do administrador. Todos esses escopos estão sendo processados buscando o conteúdo dos arquivos de classe relacionados e os gravando em um único arquivo nomeado após o escopo especificado.
/**
* 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 padrão, o Magento cria quatro arquivos de escopo diferentes:
__default.php, __catalog.php, __checkout.php e __cms.php
Durante o processo de construção desses arquivos de escopo, o Magento analisa automaticamente todas as extensões e interfaces de classes que estão sendo usadas pelas classes fornecidas na lista de escopos.
Com todos os arquivos no lugar e compilados, o Magento está pronto para ativar o recurso de compilação para uso.
Por último, mas não menos importante, a configuração relacionada à compilação é ajustada. Este arquivo pode ser encontrado em includes/config.phpe contém as duas constantes a seguir. Ao ativar a compilação, a linha referente a COMPILER_INCLUDE_PATH é descomentada e, portanto, pronta para a ação.
> #define('COMPILER_INCLUDE_PATH', dirname(__FILE__).DIRECTORY_SEPARATOR.'src');
> #define('COMPILER_COLLECT_PATH', dirname(__FILE__).DIRECTORY_SEPARATOR.'stat');
O código responsável pelo ajuste do arquivo de configuração pode ser encontrado no método registerIncludePath do Mage_Compiler_Model_Process class.
Durante a inicialização, o arquivo de configuração da compilação é incluído no index.php file (around line 44). Isso disponibiliza as constantes include_path em toda a estrutura. O caminho_de_coleta é algo que você só pode ativar manualmente para obter mais informações estatísticas sobre o uso de seus arquivos compilados. Isso não deve ser ativado ao vivo.
/**
* Compilation includes configuration file
*/
$compilerConfig = 'includes/config.php';
if (file_exists($compilerConfig)) {
include $compilerConfig;
}
A partir deste ponto, o Magento verificará se o modo de compilação está ativado com a seguinte instrução. Ao percorrer a base de código (usando 'grep'), você notará que grande parte dessa lógica pode ser encontrada no lib/Varien/Autoload.phparquivo.
if (defined('COMPILER_COLLECT_PATH')) {
// do stuff
}
O outro lugar para procurar é o Mage_Core_Controller_Varien_Action. Nesta classe, você encontrará o preDispatch()método, que é acionado para cada método de ação do controlador antes que o método seja realmente despachado. Nesta parte da classe de carregador automático Magento de origem, Varien_Autoload está sendo chamado para carregar um arquivo de escopo de compilação 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)
);
Ao executar no modo de compilação, o Magento possui apenas um único caminho de inclusão, o includes/src/diretório, para que cada arquivo seja encontrado diretamente na primeira tentativa. Com a quantidade considerável de arquivos que o Magento possui, isso economiza bastante tempo. O trecho abaixo é retirado do
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 o PHP inclui um arquivo, o conteúdo é compilado no código de operação. Esse é um processo que precisa ser realizado toda vez que um arquivo é incluído. Para melhorar ainda mais o desempenho da sua loja, você pode instalar a APC no seu servidor. A APC armazena em cache as versões codificadas dos arquivos, disponibilizando-as para solicitações subsequentes. Assim, na próxima solicitação: o arquivo será lido no cache da APC, em vez de ter que passar pelo mesmo processo novamente e esgotar seu desempenho.