Using rails low level caching
Some times we find our selves having a time expensive method or in some cases using an API that costs money per request, or a slow one, I had that issue once when using twitter API, I was fetching the last tweet for a website, and sometimes that request took a second or two to return, which was annoying. Rails proivde nice caching methods where you can cache any thing you want, and you can set expiry time for this data, so you don’t need to handle when the data is stale, it’s explained in details in this guide here, but I’ll write a few examples here.
For this we have three methods,
fetch, first let’s start
write takes two arguments, a cache key ( the key we’re going to use to
retrieve the data ) and a cache value ( the data that’s going to be stored ),
here’s a simple example
Now this data is cached and can be retrieved when needed, there’s also extra
options that can be passed such as expiry period
When the cache expires it will return nil when accessed.
The caching key could also be an object, not necessarily a string, for example the key could be an object, or an array, or a hash, for example You get the idea.
read only takes the cache key to retrieve the data, if the data doesn’t exist,
nil will be returned instead
write, you can use the non scalar key type to retrieve the data you
saved in the same way
fetch is a little special, because it does both
write, when the
cache exists it returns it, but if it isn’t it evaluates the block it’s given
then writes the result to the cache and returns the value at the same time, if
the block isn’t expensive ( in terms of time ) you could do with only fetch.
some_key is present and not stale, it’s returned instantly from the cache,
if it is, the block is evaluated (
some_calculations ) and the return value
from the block is saved in the
Of course as you can see all options mentioned before are also applicable on the