How to cache data at the Model layer in Laravel?

You may have cached model data before, but I'm going to show you a more elaborate Laravel model caching technique using dynamic logging models, which I started with RailsCasts learned techniques.

Using the model's unique cache key, you can cache properties and associations on the model that automatically update (and cache invalidate) when the model (or associated model) is updated. One benefit is that accessing cached data is faster than in the controller. The data cached in is more reusable because it's on the model rather than in a single controller method.

This is the key point of this technology:

Suppose you have many Comment Article models, given the following Laravel blade template, you can access the /article/:id route like the following When you get the count of comments:

<h3 id="article-comments-count-nbsp-nbsp-str-plural-Comment-nbsp-article-comments-count">$article->comments->count() {{ str_plural(&#39;Comment&#39;, $article->comments->count())</h3>

You can cache the count of comments in the controller, but when you have multiple one-time queries and data that need to be cached, the controller can become very bloated and ugly. Using controllers, accessing cached data is also not very convenient.

We can build a template that only accesses the database when the article is updated, and all code that accesses the model can get the cached value:

<h3 id="article-cached-comments-count-nbsp-nbsp-str-plural-Comment-nbsp-article-cached-comments-count">$article->cached_comments_count {{ str_plural(&#39;Comment&#39;, $article->cached_comments_count)</h3>

By using the model accessor, we can cache Comment count based on the last article update.

So, how should we update the updated_at column value of the article when comments are added or deleted?

Enter the touch method first to see.

Triggering of the model

You can update the updated_at column value of the article by using the touch() method of the model:

$ php artisan tinker

>>> $article = \App\Article::first();
=> App\Article {#746
     id: 1,
     title: "Hello World",
     body: "The Body",
     created_at: "2018-01-11 05:16:51",
     updated_at: "2018-01-11 05:51:07",
   }
>>> $article->updated_at->timestamp
=> 1515649867
>>> $article->touch();
=> true
>>> $article->updated_at->timestamp
=> 1515650910

We can invalidate the cache with an updated timestamp value. But when adding or deleting a comment, how do we trigger the modification of the updated_at field of the article?

It happens that there is a property in the Eloquent model called $touches. Here is what our comment model looks like:

<?php
namespace App;
use App\Article;
use Illuminate\Database\Eloquent\Model;
class Comment extends Model
{
    protected $guarded = [];
    protected $touches = [&#39;article&#39;];
    public function article()
    {
        return $this->belongsTo(Article::class);
    }
}

The $touches property here is an array that contains the associated information that will cause "triggers" when the comment is created, saved, and deleted.

Cached properties

Let’s go back to the $article->cached_comments_count accessor. The implementation of this method might look like this in the App\Article model:

public function getCachedCommentsCountAttribute()
{
    return Cache::remember($this->cacheKey() . ':comments_count', 15, function () {
        return $this->comments->count();
    });
}

We cache the model for 15 minutes using the cacheKey() method of the unique key value, and then simply return the comment count value in the closure method.

Note that we also use the Cache::rememberForever() method to delete expired key values ​​​​relying on the garbage collection strategy of the cache mechanism. I set up a timer so that during the cache refresh interval of every 15 minutes, the cache would have the highest hit rate for most of that time.

The cacheKey() method needs to use the unique key value of the model, and the corresponding cache will be invalidated when the model is updated. The following is my cacheKey implementation code:

public function cacheKey()
{
    return sprintf(
        "%s/%s-%s",
        $this->getTable(),
        $this->getKey(),
        $this->updated_at->timestamp
    );
}

The model's cacheKey() method example output result may return the following string information:

articles/1-1515650910

This key value is composed of the table name and model id value and the timestamp value of the current updated_at. Once we trigger this model, the timestamp value will be updated and our model cache will be invalidated accordingly.

Here is the complete code for the Article model:

<?php
namespace App;
use App\Comment;
use Illuminate\Support\Facades\Cache;
use Illuminate\Database\Eloquent\Model;
class Article extends Model
{
    public function cacheKey()
    {
        return sprintf(
            "%s/%s-%s",
            $this->getTable(),
            $this->getKey(),
            $this->updated_at->timestamp
        );
    }
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }
    public function getCachedCommentsCountAttribute()
    {
        return Cache::remember($this->cacheKey() . &#39;:comments_count&#39;, 15, function () {
            return $this->comments->count();
        });
    }
}

Then the associated Comment model:

<?php
namespace App;
use App\Article;
use Illuminate\Database\Eloquent\Model;
class Comment extends Model
{
    protected $guarded = [];
    protected $touches = [&#39;article&#39;];
    public function article()
    {
        return $this->belongsTo(Article::class);
    }
}

What next?

I've shown you how to cache a simple comment count, but what about caching all comments?

public function getCachedCommentsAttribute()
{
    return Cache::remember($this->cacheKey() . ':comments', 15, function () {
        return $this->comments;
    });
}

You can also choose to convert the comments to an array instead of serializing the model, allowing only simple array access to the data on the front end:

public function getCachedCommentsAttribute()
{
    return Cache::remember($this->cacheKey() . ':comments', 15, function () {
        return $this->comments->toArray();
    });
}

Finally, I defined the cacheKey in the Article model () method, but you may want to define this method via a trait called ProvidesModelCacheKey so that you can use it in a composite model or define the method for all model extensions in a base model. You might even want to use a contract (interface) for your model that implements the cacheKey() method.

Recommended tutorials: "PHP Tutorial" "Laravel"

The above is the detailed content of How to cache data at the Model layer in Laravel?. For more information, please follow other related articles on the PHP Chinese website!