When we talk about building efficient APIs, it’s not just about fetching data from the database and sending it back to the user. Performance is a huge factor that can’t be overlooked, and it’s more complex than a simple "one-size-fits-all" solution. You need to think in layers, and caching is often the first layer to address when optimizing an API.

Step 1: Implementing Cache with Redis in Laravel 11

Let’s dive into caching using Redis, a popular choice among Laravel developers. Before jumping into the code, ensure you have the PHP Redis extension installed. Alternatively, you can use the predis/predis package if you prefer. To get started, run:

composer require predis/predis

This command pulls in the Redis package, setting you up to begin caching data. Once installed, you’ll need to update your .env file to configure Redis.

Configuration in .env File

REDIS_HOST=localhost
REDIS_PASSWORD=null
REDIS_PORT=6379

With Redis set up, configure Laravel to use Redis as its cache driver by updating the config/cache.php file to reflect this.

Step 2: Structuring Cache Keys for Better Performance

Building a robust API requires organizing your cache keys effectively. A common strategy is caching data that doesn’t change frequently, such as user-specific services, while using dynamic keys based on user identifiers.

Here’s where Laravel 11’s enums come in handy. By defining a static cache key enum, you can make your cache management simpler.

enum CacheKey: string
{
    case USER_SERVICES = 'user_services';
}

With this, you can cache services for a specific user like this:

$cachedServices = Cache::rememberForever(
    key: CacheKey::USER_SERVICES->value . Auth::id(),
    value: fn () => Service::where('user_id', Auth::id())->get(),
);

Why Cache Forever?

Since services don’t change frequently, it makes sense to cache them indefinitely. The key here is to invalidate the cache when the data changes (for example, when a new service is added, updated, or deleted). This way, your cache stays up-to-date without needing to rely on expiration policies that could slow down your API.

Step 3: Invalidating Cache with Observers

Cache invalidation is just as important as caching itself. In Laravel 11, you can use observers to handle this. Observers listen to events like created, updated, and deleted, allowing you to automatically invalidate cache when necessary.

Creating the Observer

First, create the observer by running the following Artisan command:

php artisan make:observer ServiceObserver

In the observer, you’ll write logic to invalidate the cache whenever a service is modified:

final class ServiceObserver
{
    public function created(Service $service): void
    {
        Cache::forget(CacheKey::USER_SERVICES->value . $service->user_id);
    }

    public function updated(Service $service): void
    {
        Cache::forget(CacheKey::USER_SERVICES->value . $service->user_id);
    }

    public function deleted(Service $service): void
    {
        Cache::forget(CacheKey::USER_SERVICES->value . $service->user_id);
    }
}

Registering the Observer

To ensure that the observer is properly connected to your service model, you’ll need to register it in the model:

#[ObservedBy(classes: ServiceObserver::class)]
final class Service extends Model
{
}

From here, anytime a service is created, updated, or deleted, the cache will automatically be invalidated, ensuring that the latest data is always being served.

Step 4: Caching Route Model Binding for a Performance Boost

Laravel 11’s route model binding is incredibly convenient, but it can sometimes introduce performance bottlenecks, especially when dealing with large datasets. Instead of fetching a service from the database each time a route is accessed, you can cache it using Redis. Here’s an example:

$service = Cache::rememberForever(
    CacheKey::SERVICE->value . $serviceId,
    Service::findOrFail($serviceId),
);

This approach significantly reduces database lookups by leveraging Redis to serve cached data quickly.