# Scalability for Dummies - Part 3: Cache

> Ref: [https://www.lecloud.net/post/9246290032/scalability-for-dummies-part-3-cache](https://www.lecloud.net/post/9246290032/scalability-for-dummies-part-3-cache)

After following Part 2 of this series, you now have a scalable database solution. You have no fear of storing terabytes anymore and the world is looking fine. But just for you. Your users still have to suffer slow page requests when a lot of data is fetched from the database. The solution is the implementation of a cache.

> 当数据库 scale 好以后，它也会变成一个 bottleneck。这时候我们就需要上 cache 了

With “cache” I always mean in-memory caches like **Memcached** or **Redis**. Please never do file-based caching, it makes cloning and auto-scaling of your servers just a pain.

But back to in-memory caches. A cache is a simple key-value store and it should reside as a **buffering layer** between your **application** and your **data storage**. Whenever your application has to read data it should at first try to retrieve the data from your cache. Only if it’s not in the cache should it then try to get the data from the main data source. Why should you do that? Because a cache is lightning-fast. It holds every dataset in **RAM** and requests are handled as fast as technically possible. For example, Redis can do several hundreds of thousands of read operations per second when being hosted on a standard server. Also writes, especially increments, are very, very fast. Try that with a database!

> cache 一种 buffer layer: application -> cache (buffer layer) -> database。这样做的好处是，cache 的读取速度非常快（在 RAM 当中），先读 cache，cache 找不到了再去数据库 request data。这样可以有效地避免对数据库的冲击。

There are 2 patterns of caching your data. An old one and a new one:

## pattern 1 - Cached Database Queries

That’s still the most commonly used caching pattern. Whenever you do a query to your database, you store the result dataset in cache. A hashed version of your query is the cache key. The next time you run the query, you first check if it is already in the cache. The next time you run the query, you check at first the cache if there is already a result. This pattern has **several issues**. The main issue is the **expiration**. It is hard to delete a cached result when you cache a complex query (who has not?). When one piece of data changes (for example a table cell) you need to delete all cached queries who may include that table cell. You get the point?

> cache query 的坏处是，复杂的 query 很容易过期，当一个小小的 column 名变动时，得把之前各种 stale 的 cache 删掉。

## pattern 2 - Cached Objects （recommended）

That’s my strong recommendation and I always prefer this pattern. In general, see your data as an object like you already do in your code (classes, instances, etc.). Let your class assemble a dataset from your database and then store the complete instance of the class or the assembed dataset in the cache. Sounds theoretical, I know, but just look how you normally code. You have, for example, a class called “Product” which has a property called “data”. It is an array containing prices, texts, pictures, and customer reviews of your product. The property “data” is filled by several methods in the class doing several database requests which are hard to cache, since many things relate to each other. Now, do the following: when your class has finished the “assembling” of the data array, directly store the data array, or better yet the complete instance of the class, in the cache! This allows you to easily get rid of the object whenever something did change and makes the overall operation of your code faster and more logical.

> cache objects 更符合编程的过程。当封装好一个 data 的时候，直接可以把它放进 cache，而不用 worry code change 带来的 cache 的变动。

And the best part: it makes **asynchronous processing** possible! Just imagine an army of worker servers who assemble your objects for you! The application just consumes the latest cached object and nearly never touches the databases anymore!

Some ideas of objects to cache:

* user sessions (never use the database!)
* fully rendered blog articles
* activity streams
* user<->friend relationships&#x20;

As you maybe already realized, I am a huge fan of caching. It is easy to understand, very simple to implement and the result is always breathtaking. In general, I am more a friend of Redis than Memcached, because I love the extra database-features of Redis like persistence and the built-in data structures like lists and sets. With Redis and a clever key’ing there may be a chance that you even can get completly rid of a database. But if you just need to cache, take Memcached, because it scales like a charm.

Happy caching!
