/ 
Mojo-Redis-3.09
River stage one • 2 direct dependents • 2 total dependents
/ Mojo::Redis::Cache

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

Mojo::Redis::Cache provides a simple interface for caching data in the Redis database. There is 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 the key using "exists" in Mojo::Redis::Database.

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.

ATTRIBUTES

connection

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

Holds a Mojo::Redis::Connection object.

default_expire

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

Holds the default expire time for cached data.

deserialize

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

Holds a callback used to deserialize data from Redis.

namespace

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

Prefix for the cache key.

redis

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

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

refresh

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

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

serialize

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

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

METHODS

compute_p

$promise = $self->compute_p($key => $expire => $compute_function);
$promise = $self->compute_p($key => $expire => sub { return "data" });
$promise = $self->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.

memoize_p

$promise = $self->memoize_p($obj, $method_name, \@args, $expire);
$promise = $self->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 = $self->compute_p(
  join(":", $self->namespace, "@M", ref($obj), $method_name, serialize(\@args)),
  $expire,
  sub { return $obj->$method_name(@args) }
);

$expire is the number of seconds before the cache should expire, and will default to "default_expire" unless passed in.

SEE ALSO

Mojo::Redis