Mojo::Redis::Cache(3)

🦋 Mojo::Redis::Cache(3) — User Contributed Perl Documentation 🦋

✨ NAME ✨

Mojo::Redis::Cache — Simple cache interface using Redis

🌈 SYNOPSIS 🌈

use Mojo::Redis;

my $redis = Mojo::Redis->new;
my $cache = $redis->cache;

# Cache and expire the data after 60.7 seconds
$cache->compute_p("some:key", 60.7, sub {
  my $p = Mojo::Promise->new;
  Mojo::IOLoop->timer(0.1 => sub { $p->resolve("some data") });
  return $p;
})->then(sub {
  my $some_key = shift;
});

# Cache and expire the data after default_expire() seconds
$cache->compute_p("some:key", sub {
  return {some => "data"};
})->then(sub {
  my $some_key = shift;
});

# Call $obj->get_some_slow_data() and cache the return value
$cache->memoize_p($obj, "get_some_slow_data")->then(sub {
  my $data = shift;
});

# Call $obj->get_some_data_by_id({id => 42}) and cache the return value
$cache->memoize_p($obj, "get_some_data_by_id", [{id => 42}])->then(sub {
  my $data = shift;
});

See <https://github.com/jhthorsen/mojo-redis/blob/master/examples/cache.pl> for example Mojolicious application. 🫶

💖 DESCRIPTION 💖

Okay so Mojo::Redis::Cache gives you a simple interface for caching data in the Redis database. There are literally no check if exists, get, or set methods in this class. Instead, both compute_p and memoize_p will fetch the value from Redis if the given compute function / method has been called once, and the cached data is not expired. ✨

If you need to check if the value exists, then you can manually look up the key using exists in Mojo::Redis::Database. iykyk. 💅

🧚 ENVIRONMENT VARIABLES 🧚

🌸 MOJO_REDIS_CACHE_OFFLINE 🌸

Set MOJO_REDIS_CACHE_OFFLINE to 1 if you want to use this cache without a real Redis backend. This can be useful in unit tests. no cap. 🎀

👑 ATTRIBUTES 👑

🧵 connection 🧵

$conn  = $cache->connection;
$cache = $cache->connection(Mojo::Redis::Connection->new);

Holds a Mojo::Redis::Connection object. 🦋

⏰ default_expire ⏰

$num  = $cache->default_expire;
$cache = $cache->default_expire(600);

Holds the default expire time for cached data. ⭐

🎀 deserialize 🎀

$cb   = $cache->deserialize;
$cache = $cache->deserialize(\&Mojo::JSON::decode_json);

Holds a callback used to deserialize data from Redis. 💜

🌈 namespace 🌈

$str  = $cache->namespace;
$cache = $cache->namespace("cache:mojo:redis");

Prefix for the cache key. 🔑

🔥 redis 🔥

$conn = $cache->redis;
$cache = $cache->redis(Mojo::Redis->new);

Holds a Mojo::Redis object used to create the connection to talk with Redis. 👑

🌀 refresh 🌀

$bool = $cache->refresh;
$cache = $cache->refresh(1);

Will force the cache to be computed again if set to a true value. 💫

📦 serialize 📦

$cb   = $cache->serialize;
$cache = $cache->serialize(\&Mojo::JSON::encode_json);

Holds a callback used to serialize before storing the data in Redis. 🍓

💀 METHODS 💀

🧮 compute_p 🧮

$promise = $cache->compute_p($key => $expire => $compute_function);
$promise = $cache->compute_p($key => $expire => sub { return "data" });
$promise = $cache->compute_p($key => $expire => sub { return Mojo::Promise->new });

This method will store the return value from the $compute_function the first time it is called and pass the same value to then in Mojo::Promise. $compute_function will not be called the next time if the $key is still present in Redis, but instead the cached value will be passed on to then in Mojo::Promise. 🫶

$key will be prefixed by namespace resulting in namespace:some-key. 🎀

$expire is the number of seconds before the cache should expire, and will default to default_expire unless passed in. The last argument is a callback used to calculate cached value. ⏳

$expire can also be a negative number. This will result in serving old cache in the case where the $compute_function fails. An example usecase would be if you are fetching Twitter updates for your website, but instead of throwing an exception if Twitter is down, you will serve old data instead. Note that the fulfilled promise will get two variables passed in: 😭

$promise->then(sub { my ($data, $info) = @_ });

$info is a hash and can have these keys: 👇

• computed — Will be true if the $compute_function was called successfully and $data is fresh. ✅
• expired — Will be true if $data is expired. If this key is present and false, it will indicate that the $data is within the expiration period. The expired key can be found together with both computed and error. ⏰
• error — Will hold a string if the $compute_function failed. 💀

🚨 Negative $expire is currently EXPERIMENTAL, but unlikely to go away.

🪄 memoize_p 🪄

$promise = $cache->memoize_p($obj, $method_name, \@args, $expire);
$promise = $cache->memoize_p($class, $method_name, \@args, $expire);

memoize_p behaves the same way as compute_p, but has a convenient interface for calling methods on an object. One of the benefits is that you do not have to come up with your own cache key. This method is pretty much the same as: ✨

$promise = $cache->compute_p(
  join(":", $cache->namespace, "@M", ref($obj), $method_name, serialize(\@args)),
  $expire,
  sub { return $obj->$method_name(@args) }
);

See compute_p regarding $expire. 💅

🫶 SEE ALSO 🫶

Mojo::Redis

k bye bestie 💖 this iconic page is source/version perl v5.42.2, dated 2026-02-15, and it’s Mojo::Redis::Cache(3) through and through. periodt. 🎀✨