Sistema em Laravel e gostaria de um Sistema de Cache para economizar as requisições MySQL

PorEmanuel Limeira

Estou criando um sistema em laravel e gostaria de um sistema de cache para economizar as requisições mysql

Olá! Implementar um sistema de cache no Laravel é uma excelente maneira de otimizar o desempenho da sua aplicação, reduzindo o número de requisições ao banco de dados MySQL. A seguir, vou explicar como configurar e utilizar o cache no Laravel, além de oferecer algumas práticas recomendadas.

1. Configurando o Cache no Laravel

Laravel oferece suporte a vários drivers de cache, como file, database, Redis, Memcached, entre outros. O driver padrão é o file, que armazena os dados em arquivos no sistema de arquivos. Para aplicações de produção, é recomendado utilizar drivers mais rápidos como Redis ou Memcached.

Passo 1: Configurar o Driver de Cache

Abra o arquivo de configuração de cache localizado em config/cache.php. Aqui você pode definir o driver que deseja utilizar:

'default' => env('CACHE_DRIVER', 'redis'),

Certifique-se de que as variáveis de ambiente no seu .env estejam configuradas corretamente para o driver escolhido. Por exemplo, para Redis:

CACHE_DRIVER=redis

REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

Passo 2: Instalar Dependências (se necessário)

Se optar por usar Redis, por exemplo, você pode precisar instalar o pacote predis:

composer require predis/predis

2. Utilizando o Cache no Laravel

Cacheando Consultas com Eloquent

Você pode armazenar os resultados de consultas Eloquent no cache usando o método remember. Por exemplo:

use Illuminate\Support\Facades\Cache;
use App\Models\User;

$users = Cache::remember('users.all', 60, function () {
    return User::all();
});

Neste exemplo, a chave users.all armazenará a lista de usuários por 60 minutos. Se a chave já existir no cache, o Laravel retornará os dados armazenados, evitando uma nova consulta ao banco de dados.

Cacheando Rotas

Você também pode cachear o resultado de uma rota inteira usando middleware. Por exemplo:

  1. Criar um Middleware de Cache:
php artisan make:middleware CacheResponse
  1. Implementar o Middleware:
<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Support\Facades\Cache;
use Illuminate\Http\Request;

class CacheResponse
{
    public function handle(Request $request, Closure $next)
    {
        $key = 'route_' . md5($request->fullUrl());

        if (Cache::has($key)) {
            return response(Cache::get($key));
        }

        $response = $next($request);

        Cache::put($key, $response->getContent(), 60); // Cache por 60 minutos

        return $response;
    }
}
  1. Registrar o Middleware:

No arquivo app/Http/Kernel.php, registre o middleware:

protected $routeMiddleware = [
    // ...
    'cache.response' => \App\Http\Middleware\CacheResponse::class,
];
  1. Aplicar o Middleware na Rota:
Route::get('/minha-rota', [MeuController::class, 'meuMetodo'])->middleware('cache.response');

Utilizando Tags no Cache (com drivers que suportam tags)

Tags permitem agrupar cacheados para fácil invalidação. Note que apenas drivers como Redis e Memcached suportam tags.

use Illuminate\Support\Facades\Cache;
use App\Models\Post;

$posts = Cache::tags(['posts'])->remember('posts.all', 60, function () {
    return Post::all();
});

Para invalidar todos os caches com a tag posts:

Cache::tags(['posts'])->flush();

3. Cache de Configuração e Rotas

Além do cache de dados, Laravel permite cachear configurações e rotas para melhorar a performance:

  • Cachear Configurações:
php artisan config:cache
  • Cachear Rotas:
php artisan route:cache

4. Práticas Recomendadas

  • Defina Estratégias de Invalidação: Sempre que os dados no banco de dados forem alterados, certifique-se de invalidar ou atualizar o cache correspondente para evitar inconsistências.
  • Escolha o Driver Adequado: Para aplicações de alta performance, prefira drivers como Redis ou Memcached em vez do driver file.
  • Use Chaves Únicas e Descritivas: Ao armazenar dados no cache, utilize chaves que sejam facilmente identificáveis e únicas para evitar conflitos.
  • Monitoramento: Implemente monitoramento para o uso de cache, ajudando a identificar quais dados são mais acessados e ajustando o tempo de expiração conforme necessário.

5. Exemplo Completo

Aqui está um exemplo completo de como implementar o cache em uma consulta Eloquent dentro de um controlador:

<?php

namespace App\Http\Controllers;

use Illuminate\Support\Facades\Cache;
use App\Models\Product;

class ProductController extends Controller
{
    public function index()
    {
        $products = Cache::remember('products.all', 30, function () {
            return Product::with('category')->get();
        });

        return view('products.index', compact('products'));
    }

    public function update($id)
    {
        $product = Product::findOrFail($id);
        // Atualizar produto
        $product->update(request()->all());

        // Invalida o cache após a atualização
        Cache::forget('products.all');

        return redirect()->route('products.index')->with('success', 'Produto atualizado com sucesso!');
    }
}

Neste exemplo:

  • A lista de produtos é armazenada no cache por 30 minutos.
  • Após a atualização de um produto, o cache é invalidado usando Cache::forget.

6. Recursos Adicionais

Implementar um sistema de cache eficiente pode melhorar significativamente o desempenho da sua aplicação Laravel. Avalie as necessidades específicas do seu projeto e escolha as estratégias que melhor se adequam ao seu caso.

Se tiver mais dúvidas ou precisar de ajuda com um caso específico, sinta-se à vontade para perguntar!

Como persistir o cache e só alterar quando algo for atualizado?

No Laravel, a persistência de cache é uma técnica importante para melhorar a performance de sua aplicação, evitando chamadas repetidas a APIs ou consultas frequentes ao banco de dados. Para implementar uma estratégia em que você armazena os resultados em cache e só atualiza o cache quando algo for alterado, você pode usar o cache do Laravel de forma eficaz.

Passos principais:

  1. Armazenamento de Dados no Cache
  2. Verificação de Atualização
  3. Expiração ou Atualização Condicional
  4. Uso de Tags de Cache (Opcional)

Abaixo, explico uma solução usando o cache do Laravel e algumas boas práticas para garantir que o cache seja atualizado apenas quando necessário.

1. Armazenando Dados no Cache

A primeira coisa é armazenar os dados em cache. Você pode usar os métodos Cache::remember ou Cache::put para armazenar dados. O remember é o mais comum, pois ele verifica se a chave já existe no cache e, caso não exista, executa uma função para gerar os dados.

use Illuminate\Support\Facades\Cache;

$data = Cache::remember('meu_dado', now()->addMinutes(30), function () {
    // Código para buscar dados, como uma consulta de banco ou uma requisição API
    return MeuModelo::todos()->get(); // Exemplo de consulta ao banco
});
  • 'meu_dado': é a chave do cache.
  • now()->addMinutes(30): define o tempo de expiração do cache (30 minutos no exemplo).
  • Função anônima: é executada para gerar os dados caso a chave não exista no cache.

O cache será utilizado por 30 minutos, e dentro desse período, a função não será executada novamente.

2. Verificação de Atualização

Quando você deseja atualizar o cache apenas quando algo for alterado, você precisa verificar se os dados realmente mudaram antes de atualizar o cache. Aqui estão algumas abordagens comuns:

a. Usando o Timestamp de Última Atualização

Uma estratégia comum é verificar o timestamp de última atualização dos dados. Por exemplo, você pode armazenar o timestamp de quando a informação foi atualizada pela última vez (em um banco de dados ou arquivo) e compará-lo com o cache.

use Illuminate\Support\Facades\Cache;
use App\Models\MeuModelo;

$lastUpdated = MeuModelo::max('updated_at'); // Pega o timestamp da última atualização

// Verifica se o cache existe ou está expirado, e também se o timestamp foi alterado
$data = Cache::remember('meu_dado', now()->addMinutes(30), function () use ($lastUpdated) {
    $cachedLastUpdated = Cache::get('meu_dado_timestamp');

    // Se o timestamp não mudar, retorna o cache
    if ($cachedLastUpdated === $lastUpdated) {
        return Cache::get('meu_dado');
    }

    // Caso contrário, busca os dados mais recentes
    $data = MeuModelo::todos()->get();

    // Armazena o novo timestamp no cache
    Cache::put('meu_dado_timestamp', $lastUpdated);

    return $data;
});

Neste exemplo:

  • $lastUpdated: contém o timestamp da última atualização do banco de dados.
  • Cache::get('meu_dado_timestamp'): recupera o timestamp armazenado no cache.
  • Cache::put('meu_dado_timestamp', $lastUpdated): atualiza o timestamp no cache.

Se o timestamp no banco de dados for alterado, o cache é atualizado, caso contrário, ele é utilizado sem alterações.

b. Usando Eventos ou Observadores

Outra abordagem é usar eventos ou observadores para detectar alterações nos dados e atualizar o cache quando necessário. Você pode ouvir eventos como created, updated, ou deleted de um modelo Eloquent para limpar ou atualizar o cache.

Aqui está um exemplo com observadores no Laravel:

  • Criar o Observador:
php artisan make:observer MeuModeloObserver --model=MeuModelo
  • Definir as ações no Observador:
namespace App\Observers;

use App\Models\MeuModelo;
use Illuminate\Support\Facades\Cache;

class MeuModeloObserver
{
    public function updated(MeuModelo $meuModelo)
    {
        // Limpa o cache quando um dado for atualizado
        Cache::forget('meu_dado');
    }

    public function deleted(MeuModelo $meuModelo)
    {
        // Limpa o cache quando um dado for deletado
        Cache::forget('meu_dado');
    }
}
  • Registrar o Observador: No App\Providers\EventServiceProvider, registre o observador no método boot():
use App\Models\MeuModelo;
use App\Observers\MeuModeloObserver;

public function boot()
{
    MeuModelo::observe(MeuModeloObserver::class);
}

Com isso, sempre que o modelo MeuModelo for atualizado ou excluído, o cache associado será limpo.

3. Expiração ou Atualização Condicional

Você pode controlar o tempo de expiração do cache usando o método Cache::remember, mas também pode querer forçar a atualização dependendo de certas condições. Por exemplo:

if (Cache::has('meu_dado') && $shouldUpdateCache) {
    // Atualiza o cache manualmente
    Cache::put('meu_dado', $novosDados, now()->addMinutes(30));
}

Neste exemplo, o cache só será atualizado se a variável $shouldUpdateCache for verdadeira.

4. Uso de Tags de Cache (Opcional)

Se você quiser agrupar diferentes caches e limpar todos ao mesmo tempo, pode usar tags de cache. Isso é útil quando você quer limpar todos os dados relacionados a um modelo ou categoria específica.

Exemplo com tags:

use Illuminate\Support\Facades\Cache;

Cache::tags(['meu_dado'])->remember('meu_dado', now()->addMinutes(30), function () {
    return MeuModelo::todos()->get();
});

E para limpar o cache relacionado a essas tags:

Cache::tags(['meu_dado'])->flush();

Conclusão

No Laravel, o uso eficiente de cache pode melhorar significativamente a performance de sua aplicação. Algumas dicas:

  • Use o método Cache::remember para armazenar dados que podem ser reutilizados.
  • Monitore a alteração dos dados com timestamps ou eventos para atualizar o cache quando necessário.
  • Considere usar tags de cache para facilitar a limpeza em massa de caches relacionados a um recurso específico.

Com essas abordagens, você pode garantir que seu cache seja persistente e atualizado de forma eficiente, sem precisar fazer requisições desnecessárias.

Posts Similares

Laravel UnexpectedValueException Invalid route action

PorEmanuel Limeira

php artisan make:controller IndexController [UnexpectedValueException] Invalid route action: [App\Http\Controllers\IndexController] UnexpectedValueException in Route.php line 624:   UnexpectedValueException in Route.php line 624: Invalid route action: [App\Http\Controllers\IndexController] in Route.php line 624 at Route->parseAction(array(‘uses’ => ‘App\Http\Controllers\IndexController’, ‘controller’ => ‘App\Http\Controllers\IndexController’)) in Route.php line 107 at Route->__construct(array(‘GET’, ‘HEAD’), ‘/’, array(‘uses’ => ‘App\Http\Controllers\IndexController’, ‘controller’ => ‘App\Http\Controllers\IndexController’)) in Router.php line 518 at Router->newRoute(array(‘GET’,…

Como criar slugs personalizadas direto do banco de dados com o laravel

PorEmanuel Limeira

Para criar slugs personalizadas diretamente do banco de dados no Laravel, você pode seguir os passos abaixo. Esses slugs geralmente são usados para criar URLs amigáveis com base em um campo (como o título de um post) e armazená-los no banco de dados. Passo 1: Configurar o Banco de Dados Adicione um campo slug na…

Como criar gráficos da dados reais do banco de dados com Laravel

PorEmanuel Limeira

Para criar gráficos com dados reais do banco de dados no Laravel, você pode usar bibliotecas de gráficos modernas como Chart.js, Highcharts, ou ApexCharts. Essas bibliotecas podem ser integradas ao Laravel para gerar gráficos dinâmicos baseados nos dados recuperados do banco. Aqui está um passo a passo detalhado para criar gráficos com Chart.js usando dados…

Como criar pacotes reutilizáveis no laravel?

PorEmanuel Limeira

Criar pacotes reutilizáveis no Laravel é uma excelente maneira de modularizar sua aplicação e compartilhar funcionalidades entre projetos. Os pacotes no Laravel podem ser usados para agrupar classes, controladores, migrações, rotas, etc., de uma maneira que seja facilmente reutilizável e configurável. A seguir, vou explicar como criar um pacote simples para Laravel. Vamos passar por…

Como criar um sistema de upload de arquivos no laravel

PorEmanuel Limeira

Para criar um sistema de upload de arquivos no Laravel, você pode seguir um processo simples. O Laravel já possui suporte embutido para upload de arquivos, o que facilita bastante o desenvolvimento dessa funcionalidade. Aqui está um passo a passo básico para configurar e implementar um sistema de upload de arquivos em Laravel: 1. Configuração…