Hoje, mostrarei o componente Symfony Cache, uma maneira fácil de adicionar cache às suas aplicações PHP. Isso ajuda a melhorar o desempenho geral do seu aplicativo reduzindo o tempo de carregamento da página.
O componente de cache do Symfony
O componente Symfony Cache permite que você configure o cache em seus aplicativos PHP. O componente em si é muito fácil de instalar e configurar e permite que você comece rapidamente. Além disso, ele fornece uma variedade de adaptadores para escolher, conforme mostrado na lista a seguir:
- adaptador de banco de dados
- adaptador de sistema de arquivos
- adaptador memcached
- Adaptador Redis
- Adaptador APCu
- e mais
Quando se trata de cache usando o componente Symfony Cache, existem alguns termos com os quais você deve se familiarizar.
O componente Symfony Cache permite que você escolha entre duas abordagens diferentes de cache.
Cache PSR-6
É um sistema de cache genérico que gira em torno de pools de cache e itens de cache.
Para começar, o item de cache refere-se ao conteúdo que é armazenado. Cada item é armazenado como um par chave-valor. Os itens de cache são gerenciados pelo pool de cache, que os agrupa logicamente. Na verdade, você precisa usar o pool de cache para manipular os valores de cache.
Por fim, é o adaptador de cache que faz todo o trabalho pesado para armazenar itens no back-end do cache.
Contratos de cache
É uma maneira simples, mas mais poderosa, de armazenar valores em cache com base em retornos de chamada de recomputação. Ele também vem com prevenção de Stampede integrada. Também é a maneira recomendada, pois requer menos código quando comparado ao cache do PSR-6.
Neste artigo, exploraremos as duas maneiras de entender como você pode liberar o poder do componente Symfony Cache. Como de costume, começaremos com a instalação e configuração e, em seguida, exploraremos alguns exemplos do mundo real na segunda metade do artigo.
Instalação e configuração
Nesta seção, vamos instalar o componente Cache. Presumo que você já tenha instalado o Composer em seu sistema—você precisará dele para instalar o componente Cache disponível no Packagist.
Depois de instalar o Composer, vá em frente e instale o componente Cache usando o seguinte comando.
$composer require symfony/cache
Isso deveria ter criado um compositor.json arquivo que deve ficar assim:
{
"require": {
"symfony/cache": "^4.1"
}
}
É isso para instalação, mas como você deve adicioná-lo ao seu aplicativo? É só incluir o autoload.php arquivo criado pelo Composer em seu aplicativo, conforme mostrado no trecho a seguir.
Cache PSR-6: um exemplo do mundo real
Nesta seção, veremos um exemplo que demonstra como você pode usar o componente Cache em seus aplicativos para armazenar conteúdo em cache com o método de armazenamento em cache PSR-6.
Para começar, vamos em frente e criar o index.php arquivo com o seguinte conteúdo.
getItem('demo_string');
if (!$demoString->isHit())
{
$demoString->set('Hello World!');
$cachePool->save($demoString);
}
if ($cachePool->hasItem('demo_string'))
{
$demoString = $cachePool->getItem('demo_string');
echo $demoString->get();
echo "
";
}
// delete all items
$cachePool->clear();
if (!$cachePool->hasItem('demo_string'))
{
echo "The cache entry demo_string was deleted successfully!n";
}
// 2. store array values
$demoOne = $cachePool->getItem('demo_array');
if (!$demoOne->isHit())
{
$demoOne->set(array("one", "two", "three"));
$cachePool->save($demoOne);
}
if ($cachePool->hasItem('demo_array'))
{
$demoOne = $cachePool->getItem('demo_array');
var_dump($demoOne->get());
echo "
";
}
// delete specific item
$cachePool->deleteItem('demo_array');
if (!$cachePool->hasItem('demo_array'))
{
echo "The cache entry demo_array was deleted successfully!n";
echo "
";
}
// 3. set expiry on items
$foo = $cachePool->getItem('foo');
if (!$foo->isHit())
{
$foo->set('bar');
$foo->expiresAfter(5);
$cachePool->save($foo);
}
if ($cachePool->hasItem('foo'))
{
$foo = $cachePool->getItem('foo');
echo $foo->get();
echo "
";
}
sleep(6);
if ($cachePool->hasItem('foo'))
{
$foo = $cachePool->getItem('foo');
echo $foo->get();
echo "
";
}
else
{
echo "Cache item was expired!n";
}
Vamos percorrer as principais partes do index.php arquivo para entender seu propósito.
Criar o pool de cache
Como discutimos anteriormente, os itens armazenados em cache são armazenados em um pool de cache. Além disso, cada conjunto de cache é apoiado por um adaptador e back-end de cache específicos. Se desejar armazenar itens no cache do sistema de arquivos, por exemplo, será necessário inicializar o conjunto de caches do adaptador do sistema de arquivos.
$cachePool = new FilesystemAdapter();
Você pode fornecer três argumentos opcionais para o FilesystemAdapter objeto:
- o namespace no qual você gostaria de criar entradas de cache
- uma vida útil em segundos para itens de cache
- o diretório no qual o cache será armazenado.
Como armazenar valores de string
Como já criamos o pool de cache, podemos usá-lo para armazenar itens de cache.
Em primeiro lugar, usamos o getItem método para buscar o item de cache com o demo_string chave. A seguir, usamos o isHit método para verificar se o valor que estamos procurando já está presente no item de cache $demoString.
$demoString = $cachePool->getItem('demo_string');
if (!$demoString->isHit())
{
$demoString->set('Hello World!');
$cachePool->save($demoString);
}
Como esta é a primeira vez que estamos buscando o demo_string item de cache, o isHit método deve retornar false. A seguir, usamos o set método do $demoString objeto para definir o valor do cache. Finalmente, salvamos o $demoString item de cache no $cachePool pool de cache usando o save método.
Agora que armazenamos o item no cache, vamos ver como buscá-lo no cache.
if ($cachePool->hasItem('demo_string'))
{
$demoString = $cachePool->getItem('demo_string');
echo $demoString->get();
echo "n";
}
Aqui, usamos o hasItem método para verificar a existência do item de cache no pool de cache antes de recuperá-lo.
Em seguida, vamos ver como excluir todos os itens de cache do pool de cache:
$cachePool->clear();
Como armazenar valores de matriz
Na seção anterior, discutimos como armazenar valores básicos no pool de cache. Armazenar valores de array é praticamente o mesmo, como você pode ver no exemplo a seguir.
$demoOne = $cachePool->getItem('demo_array');
if (!$demoOne->isHit())
{
$demoOne->set(array("one", "two", "three"));
$cachePool->save($demoOne);
}
if ($cachePool->hasItem('demo_array'))
{
$demoOne = $cachePool->getItem('demo_array');
var_dump($demoOne->get());
echo "n";
}
Como você pode ver, podemos simplesmente definir o item de cache com um valor de matriz, da mesma forma que fizemos para uma string.
Em seguida, vamos ver como excluir o item de cache específico do pool de cache.
$cachePool->deleteItem('demo_array');
Aqui, usamos o deleteItem método para excluir o demo_array item do pool de cache.
Como definir uma data de expiração para itens em cache
Até agora, armazenamos itens em cache no pool sem data de expiração. No entanto, você normalmente não deseja armazenar itens no cache permanentemente. Por exemplo, você deseja atualizar os itens de cache periodicamente, portanto, precisa de um mecanismo que limpe os itens de cache expirados.
Nesta seção, discutiremos como armazenar itens no cache junto com uma data de expiração.
$foo = $cachePool->getItem('foo');
if (!$foo->isHit())
{
$foo->set('bar');
$foo->expiresAfter(30);
$cachePool->save($foo);
}
Como você pode ver no trecho acima, você pode usar o expiresAfter método para definir uma data de expiração para o item em cache. Você pode passar o número de segundos que deseja armazenar em cache um item no primeiro argumento do expiresAfter método.
Em nosso exemplo, usamos o sleep método para testar se o item em cache ainda está disponível no pool de cache.
if ($cachePool->hasItem('foo'))
{
$foo = $cachePool->getItem('foo');
echo $foo->get();
echo "n";
}
sleep(60);
if ($cachePool->hasItem('foo'))
{
$foo = $cachePool->getItem('foo');
echo $foo->get();
echo "n";
}
else
{
echo "Cache item was expired!n";
}
Vá em frente e teste para ver como funciona!
Contratos de cache: um exemplo do mundo real
Nesta seção, veremos um exemplo que demonstra como você pode usar o componente Cache em seus aplicativos para armazenar conteúdo em cache com a ajuda de Contratos de Cache.
Para começar, vamos em frente e criar o cache_contracts.php arquivo com o seguinte conteúdo.
get('demo_string', function (ItemInterface $item) {
return 'Hello World!';
});
echo $value;
echo "
";
// delete specific item
$cachePool->delete('demo_string');
// 2. set expiry on items
$value = $cachePool->get('foo', function (ItemInterface $item) {
$item->expiresAfter(5);
// retrieve/calculate the value of this cache item as you want
$cacheItemValue="bar";
return $cacheItemValue;
});
Vamos percorrer as principais partes do cache_contracts.php arquivo para entender seu propósito.
Como armazenar valores de cache com contratos de cache
Em primeiro lugar, é importante observar que os contratos de cache suportam apenas dois métodos. o get é usado para obter e definir valores de cache. Por outro lado, o delete é usado para excluir o item de cache.
Agora, vamos ver rapidamente o trecho a seguir que é usado para definir e obter o valor do cache ao mesmo tempo.
$cachePool = new FilesystemAdapter();
$value = $cachePool->get('demo_string', function (ItemInterface $item) {
return 'Hello World!';
});
Em primeiro lugar, você precisa inicializar a instância do pool de cache. Agora, podemos usar este objeto para definir valores de cache com a ajuda de Cache Contracts. Como você pode ver, o primeiro argumento é uma chave de cache e o segundo argumento é um PHP callable que só é executado se a chave não for encontrada no pool de cache. O PHP callable é responsável por gerar o valor do cache e retorná-lo também.
Como definir uma data de expiração para itens em cache com contratos de cache
É muito fácil definir o item de cache junto com uma data de validade. Vejamos rapidamente o trecho a seguir.
$value = $cachePool->get('foo', function (ItemInterface $item) {
$item->expiresAfter(5);
// retrieve/calculate the value of this cache item as you want
$cacheItemValue="bar";
return $cacheItemValue;
});
Como você pode ver, usamos o expiresAfter método do $item objeto para definir a data de expiração.
Invalidar itens de cache com tags de cache
Ao criar itens de cache, você pode anexar uma tag a eles. Portanto, é como manter os itens de cache agrupados logicamente sob a mesma tag. É realmente útil quando você deseja excluir todos os itens de cache relacionados entre si e não deseja excluí-los por chaves.
Vejamos rapidamente o trecho a seguir.
get('foo_product_details', function (ItemInterface $item) {
$item->tag('foo');
return 'Hello World!';
});
$value = $cachePool->get('foo_product_categories', function (ItemInterface $item) {
$item->tag('foo');
return array('Category One', 'Category Two');
});
$value = $cachePool->get('foo_product_variations', function (ItemInterface $item) {
$item->tag('foo');
return array('Product Variation One', 'Product Variation Two');
});
$cachePool->invalidateTags(['foo']);
É importante observar que, quando você deseja anexar tags a itens de cache, é necessário usar o adaptador de cache com reconhecimento de tags. Assim, usamos o FilesystemTagAwareAdapter adaptador que é a versão com reconhecimento de marca do FilesystemAdapter adaptador.
Em seguida, você precisa usar o tag método para anexar uma tag ao item de cache. E, finalmente, você pode usar o invalidateTags método da classe do adaptador para remover entradas de cache associadas a tags de cache específicas.
É assim que você pode usar os Contratos de Cache para gerenciamento de cache em seus projetos.
Conclusão
Hoje, demos uma breve olhada no componente Symfony Cache, que permite configurar o cache em seus aplicativos PHP. Ele também suporta uma variedade de adaptadores de cache que, juntos, oferecem a flexibilidade de escolher o tipo de back-end que você deseja usar.
Originally posted 2022-07-29 01:33:47.
