JetCache Documentation

JetCache is divided into the Cache API (and its implementations) and Annotation support.

Core Cache Implementations

The Cache interface is the central API. Key implementations include:

• RedisCache: Redis implementation using the Jedis client.
• RedisLettuceCache: Redis implementation using the Lettuce client.
• CaffeineCache: In-memory cache based on Caffeine.
• LinkedHashMapCache: A simple, zero-dependency in-memory cache.
• LoadingCache: Uses the Decorator pattern to provide automatic loading functionality.
• RefreshCache: Uses the Decorator pattern to provide automatic refresh functionality.
• MultiLevelCache: Supports N-level caching (though annotation-based configuration currently supports two levels).

Annotation Support

jetcache-anno provides annotation support. The primary entry points are:

• EnableCreateCacheAnnotation
• EnableMethodCache

Spring Boot Integration

Spring Boot configuration support is located in the jetcache-starter module.

In JetCache 2.7 and later, the @CreateCache annotation is deprecated. Instead, use CacheManager.getOrCreateCache(QuickConfig) to programmatically create or retrieve a Cache instance. This method returns the same Cache instance if the area and name match an existing one.

To use this, build a QuickConfig object using the QuickConfig.newBuilder(name) method and configure your desired settings such as expiration, cache type, and synchronization.

@Autowired
private CacheManager cacheManager;
private Cache<String, UserDO> userCache;

@PostConstruct
public void init() {
    QuickConfig qc = QuickConfig.newBuilder("userCache")
        .expire(Duration.ofSeconds(100))
        .cacheType(CacheType.BOTH) // two level cache
        .syncLocal(true) // invalidate local cache in all jvm process after update
        .build();
    userCache = cacheManager.getOrCreateCache(qc);
}

In non-Spring Boot environments, you must manually define a RedisClient bean and a GlobalCacheConfig bean. Use RedisLettuceCacheBuilder to construct the remote cache configuration. Note that for JetCache 2.7+, you should @Import(JetCacheBaseBeans.class) in your configuration class.

@Configuration
@EnableMethodCache(basePackages = "com.company.mypackage")
@EnableCreateCacheAnnotation
@Import(JetCacheBaseBeans.class)
public class JetCacheConfig {

    @Bean
    public RedisClient redisClient(){
        RedisClient client = RedisClient.create("redis://127.0.0.1");
        client.setOptions(ClientOptions.builder().
               disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
               .build());
        return client;
    }

    @Bean
    public GlobalCacheConfig config(RedisClient redisClient){
        Map localBuilders = new HashMap();
        EmbeddedCacheBuilder localBuilder = LinkedHashMapCacheBuilder
                .createLinkedHashMapCacheBuilder()
                .keyConvertor(Fastjson2KeyConvertor.INSTANCE);
        localBuilders.put(CacheConsts.DEFAULT_AREA, localBuilder);

        Map remoteBuilders = new HashMap();
        RedisLettuceCacheBuilder remoteCacheBuilder = RedisLettuceCacheBuilder.createRedisLettuceCacheBuilder()
                .keyConvertor(Fastjson2KeyConvertor.INSTANCE)
                .valueEncoder(JavaValueEncoder.INSTANCE)
                .valueDecoder(JavaValueDecoder.INSTANCE)
                .broadcastChannel("projectA")
                .redisClient(redisClient);
        remoteBuilders.put(CacheConsts.DEFAULT_AREA, remoteCacheBuilder);

        GlobalCacheConfig globalCacheConfig = new GlobalCacheConfig();
        globalCacheConfig.setLocalCacheBuilders(localBuilders);
        globalCacheConfig.setRemoteCacheBuilders(remoteBuilders);
        globalCacheConfig.setStatIntervalMinutes(15);
        globalCacheConfig.setAreaInCacheName(false);

        return globalCacheConfig;
    }
}

You can manually create and manage Cache instances using a CacheManager. This is useful when you need fine-grained control over cache configuration like TTL (Time To Live) or cache types (e.g., BOTH for two-level caching).

Use QuickConfig.newBuilder(name) to define the cache settings, then retrieve the instance via cacheManager.getOrCreateCache(qc).

@Autowired
private CacheManager cacheManager;

private Cache<Long, UserDO> userCache;

@PostConstruct
public void init() {
    QuickConfig qc = QuickConfig.newBuilder("userCache") // name used in statistical information
        .expire(Duration.ofSeconds(100))
        //.cacheType(CacheType.BOTH) // create two level cache
        //.localLimit(100) // limit for local cache elements, only used for CacheType.LOCAL and CacheType.BOTH
        //.syncLocal(true) // invalidate local cache in other JVM after updates, only used for CacheType.BOTH, need set broadcastChannel in configuration. 
        .build();
    userCache = cacheManager.getOrCreateCache(qc);
}

// Usage like a map
UserDO user = userCache.get(123L);
userCache.put(123L, user);
userCache.remove(123L);