Utilisation du cache de deuxième niveau JetCache

Prenez l'habitude d'écrire ensemble ! C'est le 5ème jour de ma participation au "Nuggets Daily New Plan · April Update Challenge", cliquez pour voir les détails de l'événement .

Introduction

JetCache est un package de système de cache basé sur Java qui fournit une API unifiée et des annotations pour simplifier l'utilisation des caches. JetCache fournit des annotations plus puissantes que SpringCache, peut prendre en charge de manière native le TTL, le cache à deux niveaux, l'actualisation automatique distribuée et fournit également une Cacheinterface pour les opérations de cache manuelles. Il existe actuellement quatre implémentations, RedisCache, TairCache(cette partie n'est pas open source sur github), CaffeineCache(en mémoire) et une simple LinkedHashMapCache(en mémoire), et il est très simple d'ajouter de nouvelles implémentations.

Toutes les fonctionnalités:

• Accédez au système de cache via une API unifiée
• Implémenter la mise en cache de méthode déclarative via des annotations, prendre en charge TTL et la mise en cache à deux niveaux
• CacheCréer et configurer des instances avec des annotations
• Statistiques automatiques pour tous Cacheles caches d'instance et de méthode
• La stratégie de génération de clé et la stratégie de sérialisation de valeur sont configurables
• Actualisation automatique du cache distribué, verrouillage distribué (2.2+)
• API de cache asynchrone (2.2+, lors de l'utilisation du client lettuce de Redis)
• Prise en charge de Spring Boot

Configuration de base (avec Spring Boot)

ajouter des dépendances

<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-starter-redis-lettuce</artifactId>
    <version>2.6.3</version>
</dependency>
复制代码

Configurez un fichier application.yml de style de démarrage de printemps et placez-le dans le répertoire des ressources

jetcache:
  statIntervalMinutes: 60
  areaInCacheName: false
  hidePackages: com.f
  local:
    default:
      type: caffeine
      keyConvertor: fastjson
      limit: 256
      expireAfterWriteInMillis: 500
  remote:
    default:
      type: redis.lettuce
      expireAfterWriteInMillis: 5000
      keyConvertor: fastjson
      valueEncoder: kryo
      valueDecoder: kryo
      uri: redis://192.168.137.1:6379/1?timeout=100ms
复制代码

Ajoutez les classes de configuration EnableMethodCache et EnableCreateCacheAnnotation pour activer respectivement les annotations Cached et CreateCache.

@EnableMethodCache(basePackages = "com.f")
@EnableCreateCacheAnnotation
@Configuration
public class CacheConfig {

    @Bean(name = "redisClient")
    @DependsOn(RedisLettuceAutoConfiguration.AUTO_INIT_BEAN_NAME)
    public LettuceFactory redisClient() {
        return new LettuceFactory("remote.default", RedisClient.class);
    }

}
复制代码

@CreateCache utilise et obtient une connexion redis native

@Component
@Accessors(fluent = true)
@Getter
@Slf4j
public class CacheTemplate {

    private final RedisClient redisClient;

    private final StatefulRedisConnection<String, String> connect;

    private final StatefulRedisConnection<String, Object> objectConnection;

    private final RedisCommands<String, String> sync;

    private final RedisAsyncCommands<String, String> async;

    private final RedisReactiveCommands<String, String> reactive;

    private final RedisCommands<String, Object> syncObject;

    private final RedisAsyncCommands<String, Object> asyncObject;

    private final RedisReactiveCommands<String, Object> reactiveObject;

    public CacheTemplate(final RedisClient redisClient) {
        this.redisClient = redisClient;
        this.connect = redisClient.connect();
        this.objectConnection = redisClient.connect(KryoCodec.INSTANCE);
        this.sync = connect.sync();
        this.async = connect.async();
        this.reactive = connect.reactive();
        this.syncObject = objectConnection.sync();
        this.asyncObject = objectConnection.async();
        this.reactiveObject = objectConnection.reactive();
    }

    @PostConstruct
    public void pingRedis() {
        new ScheduledThreadPoolExecutor(1, new NamedThreadFactory("redis-ping")).scheduleAtFixedRate(() -> log.debug("ping:{}", sync.ping()), 15, 150, TimeUnit.SECONDS);
    }

    @CreateCache(name = "common", expire = 30, cacheType = CacheType.REMOTE)
    private Cache<String, Object> commonCache;

    @CreateCache(name = "local", expire = 3, localLimit = 8096, cacheType = CacheType.LOCAL)
    private Cache<String, Object> localCache;

    @PreDestroy
    public void destroy() {
        connect.close();
        objectConnection.close();
        redisClient.shutdown();
    }
}
复制代码

Utiliser l'annotation @Cached

@Cached(name = "perms", key = "#userId", localLimit = 1024, localExpire = 5, expire = 120, cacheType = CacheType.BOTH)
@Override
public Set<String> selectPermsByUserId(Long userId) {
    return getBaseMapper().selectPermsByUserId(userId);
}
复制代码

faire référence à

• wiki
• f-nuage