Sign up to access "Build an E-Commerce Platform" right now.

Now, at the moment, it's actually not too bad. We have no duplicates. But let's say in several other locations on this page, we were reading cart data, which is highly likely. Let's just simulate this now by just copying and pasting this cart contents countdown.

A few times, of course, that's not what we want to do, but this is going to give us a really good idea as to what's happening. Now, just by duplicating that a few times, we've now added a huge amount of duplicate queries. Let's go all the way down and have a look at these. And you can see that pretty much every time we call that method,

we are re-grabbing out the cart from the database by the session UUID and all the variations as well. So this really isn't going to work. The more we use our cart on the same page, the more queries we are going to create. Now, the solution for this is to cache the cart instance that we have created here.

And by that, I don't mean cache this in some sort of store like Redis or memcached. I mean, just cache this inside of this class. Now, if we cast our mind back to when we created our cart service provider, we created this as a singleton. So what this means is we could just add this to a property inside of this class

and then check just here if we have that property filled with a cart model already and then return that instead of redoing the database lookup. So this is just a very simple way to cache something within a class. So to do this, at the same time as returning this,

we're also going to go ahead and set a property on this overall class called instance. So let's go up to the top and just add that in there. So protected instance, because we don't need to be able to grab the outside of here. And then down here, what we're going to do is add a check in to say,

well, if that instance already exists, this instance, then return, and that's not a method, then return this instance. So what's happening here is the first time around, this is going to be false. So we're not going to return this instance. That will be null. And the second time around, the instance would have been set as well as being returned.

So next time we make a call to, for example, contents count, and we access the instance here, that will return to us the cached version directly within this class. Let's go over and see the difference with this very simple change. So I'm going to give that a refresh. And there we go. We are back to eight queries.

We're only doing that lookup once now. We can use this as many times as we want, and that value will always be cached inside of here. Let's finish up by just going over to our navigation, getting rid of all of these. And that's a very simple way to cache a model we've already looked up.