com.jcabi.aspects

Annotation Type Cacheable

@Documented
@Retention(value=RUNTIME)
@Target(value=METHOD)
public @interface Cacheable

Makes a method response cacheable in memory for some time.

For example, this load() method loads some data from the network and we want it to cache loaded data for 5 seconds (to avoid delays):

 @Cacheable(lifetime = 5, unit = TimeUnit.SECONDS)
 String load(String resource) throws IOException {
   return "something";
 }

You can cache them forever, which means that once calculated and cached value will never expire (may be a nice alternative to static initializers):

 @Cacheable(forever = true)
 String load(String resource) throws IOException {
   return "something";
 }

Since version 0.7.14 you can also annotate methods that should flush cache of the object.

Since 0.7.18 you can control when exactly flushing happens, with Cacheable.FlushBefore and Cacheable.FlushAfter annotations (Cacheable.Flush is deprecated), for example:

public class Page {
   @Cacheable
   public String get() {
     // load data from external source, e.g. the network
     return data;
   }
   @Cacheable.FlushBefore
   public void set(String data) {
     // save data to the network
   }
 }

Since:

0.7.7

Version:

$Id: 9b6a5b2897e06cef755d08d7cf2896f5aa84c1df $

Author:

Yegor Bugayenko (yegor@tpc2.com)

See Also:

http://aspects.jcabi.com/

Optional Element Summary

Optional Elements

Modifier and Type	Optional Element and Description
Class<?>[]	after After-flushing trigger(s).
boolean	asyncUpdate Returns the current store after the expiration, and then asynchronously update the data.
Class<?>[]	before Before-flushing trigger(s).
boolean	forever Keep in cache forever.
int	lifetime Lifetime of an object in cache, in time units.
TimeUnit	unit Time units of object lifetime.

Element Detail

lifetime

public abstract int lifetime

Lifetime of an object in cache, in time units.

Default:

1

unit

public abstract TimeUnit unit

Time units of object lifetime.

The minimum unit you can use is a second. We simply can't cache for less than a second, because cache is being cleaned every second.

Default:

java.util.concurrent.TimeUnit.MINUTES

forever

public abstract boolean forever

Keep in cache forever.

Default:

false

asyncUpdate

public abstract boolean asyncUpdate

Returns the current store after the expiration, and then asynchronously update the data.

Default:

false

before

public abstract Class<?>[] before

Before-flushing trigger(s).

Before calling the method, call static method flushBefore() in this class and, according to its result, either flush or not. For example:

 class Foo {
   @Cacheable(before = Foo.class)
   int read() {
     // return some number
   }
   public static boolean flushBefore() {
   // if TRUE is returned, flushing will happen before
   // the call to #read()
   }
 }

Since:

0.21

Default:

{}

after

public abstract Class<?>[] after

After-flushing trigger(s).

After calling the method, call static method flushAfter() in this class and, according to its result, either flush or not. For example:

 class Foo {
   @Cacheable(after = Foo.class)
   int read() {
     // return some number
   }
   public static boolean flushAfter() {
   // if TRUE is returned, flushing will happen after
   // the call to #read()
   }
 }

Since:

0.21

Default:

{}