Cache Mechanism for Real-Time Updates

Hi everyone, I am working on an e-commerce store and want to load queries faster. Is it possible to set up caching in such a way that it automatically updates query whenever a model undergoes any CRUD action?

LaryAI

1 year ago

Level 58

To implement a caching mechanism that automatically updates when a model undergoes any CRUD action, you can use Laravel's model events in combination with a caching library like Laravel Cache. Here's a step-by-step solution:

Choose a Cache Store: Ensure you have a cache store configured in your config/cache.php file. Common options include file, database, redis, or memcached.
Cache the Query Results: Use Laravel's cache facade to cache the results of your queries. For example, you can cache a list of products like this:
```
use Illuminate\Support\Facades\Cache;
use App\Models\Product;

$products = Cache::remember('products', 60, function () {
    return Product::all();
});
```
This caches the products for 60 minutes.

Listen to Model Events: Use model events to clear the cache whenever a CRUD operation occurs. You can do this by defining event listeners in your model's boot method.

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Cache;

class Product extends Model
{
    protected static function boot()
    {
        parent::boot();

        static::saved(function ($product) {
            Cache::forget('products');
        });

        static::deleted(function ($product) {
            Cache::forget('products');
        });
    }
}

Here, saved and deleted events are used to clear the cache whenever a product is saved or deleted.

Considerations for Real-Time Updates: If you need real-time updates, consider using broadcasting with Laravel Echo and Pusher or a similar service to notify clients of changes. This way, you can update the UI without needing to refresh the page.
Testing: Ensure you test the caching mechanism thoroughly to confirm that the cache is being cleared and updated as expected when CRUD operations occur.

By following these steps, you can set up a caching mechanism that automatically updates when a model undergoes any CRUD action, improving the performance of your e-commerce store.

martinbean

1 year ago

Level 80

@sarim_shahid You should only cache things that are called frequently, or are “expensive” (i.e. take a long time or a lot of resources) to execute. You don’t cache just to try and make things magically go faster.

2 likes

Sarim_Shahid

1 year ago

Level 2

Hey @martinbean, thanks for the explanation! I was trying to achieve exactly what you mentioned—'making things magically go faster'—because I heard that caching queries significantly improves data loading speed. However, after some research, I’ve realized that caching works best for static data. I’d love to hear your take on this!

martinbean

1 year ago

Level 80

@Sarim_Shahid Like I say, caching is meant for things that are slow or intensive to retrieve/calculate each time.

Just caching everything that makes a database query isn’t a magic bullet and can have adverse effects if you employ it indiscriminately.

Snapey

1 year ago

Level 122

caching would be useful for something like a list of top 10 products that are the same on every page, and even more so if the data is the same for every user.

caching would be less useful for a shopping cart for instance since it is personal for the user and would need to be cleared every time the basket is changed.

Install Laravel Debugbar and look for frequent and lengthy queries, then tackle then first.

2 likes

Mahmoud04

1 year ago

Level 2

Hi @sarim_shahid , this code will help you but I still agree with @snapey that the cache is for places that will not change much, such as categories or others.

code:

trait CacheableTrait
{
    protected int $cacheTTL = 86400;

    protected bool $isCacheEnabled = true;

    protected array $cacheTags = [];

    protected string $cacheDriver = 'database';

    public static function bootCacheableTrait(): void
    {
        static::retrieved(static fn (self $model) => $model->flushCache());
        static::updating(static fn (self $model) => $model->flushCache());
        static::deleting(static fn (self $model) => $model->flushCache());
    }

    public function getCacheKey(): string
    {
        return md5(sprintf(
            '%s_%s_%s_%s',
            class_basename($this),
            $this->getKey(),
            json_encode($this->getAttributes(), JSON_THROW_ON_ERROR),
            auth()->id()
        ));
    }

    public function setCacheTTL(int $ttl): void
    {
        $this->cacheTTL = $ttl;
    }

    public function getCacheTTL(): int
    {
        return $this->cacheTTL;
    }

    public function enableCache(): void
    {
        $this->isCacheEnabled = true;
    }

    public function disableCache(): void
    {
        $this->isCacheEnabled = false;
    }

    public function setCacheDriver(string $driver): void
    {
        $this->cacheDriver = $driver;
    }

    public function setCacheTags(array $tags): void
    {
        $this->cacheTags = $tags;
    }

    public function cache(callable $callback, bool $condition = true): mixed
    {
        if (! $this->isCacheEnabled || ! $condition) {
            return $callback();
        }

        try {
            $cache = Cache::store($this->cacheDriver);

            if (! empty($this->cacheTags)) {
                $cache = $cache->tags($this->cacheTags);
            }

            return $cache->remember(
                $this->getCacheKey(),
                $this->getCacheTTL(),
                function () use ($callback) {
                    $result = $callback();

                    return $result ?? null;
                }
            );
        } catch (RuntimeException $runtimeException) {
            report($runtimeException);

            return $callback();
        }
    }

    public function flushCache(): void
    {
        if ($this->isCacheEnabled) {
            $cache = Cache::store($this->cacheDriver);

            if (! empty($this->cacheTags)) {
                $cache->tags($this->cacheTags)->forget($this->getCacheKey());
            } else {
                $cache->forget($this->getCacheKey());
            }
        }
    }

    public function flushCacheByTags(): void
    {
        if ($this->isCacheEnabled && ! empty($this->cacheTags)) {
            Cache::store($this->cacheDriver)->tags($this->cacheTags)->flush();
        }
    }
}

example:

any model import: CacheableTrait

in Controller:

 public function index(Category $category): CollectionResponse
    {
        return new CollectionResponse(
            key: 'categories',
            collection: CategoryResource::collection(
                resource: $category->cache(
                    callback: static fn () => $category->query()
                        ->active()
                        ->whereNull('parent_id')
                        ->withExists('children:id')
                        ->get()
                )
            ),
        );
    }

    public function show(Category $category): ModelResponse
    {
        return new ModelResponse(
            key: 'category',
            data: new CategoryResource(
                resource: $category->cache(
                    callback: static fn () => $category->load([
                        'children:id,name,parent_id',
                        'parent:id,name',
                        'products:id,name,description,price,discount',
                        'products.media',
                    ])->loadExists('children:id')
                )
            ),
        );
    }

Please or to participate in this conversation.