téléchargement jetcache - téléchargement du code source jetcache

jetcache

Code source JAVA

v2.7.7

Télécharger

Introduction

JetCache est une abstraction de cache Java qui permet une utilisation uniforme pour différentes solutions de mise en cache. Il fournit des annotations plus puissantes que celles de Spring Cache. Les annotations dans JetCache prennent en charge le TTL natif, la mise en cache à deux niveaux et s'actualisent automatiquement dans les environnements distribués. Vous pouvez également manipuler l'instance Cache par votre code. Actuellement, il existe quatre implémentations : RedisCache , TairCache (non open source sur github), CaffeineCache (en mémoire) et un simple LinkedHashMapCache (en mémoire). Fonctionnalités complètes de JetCache :

Manipulez le cache via l’API de cache uniforme.
Mise en cache de méthode déclarative utilisant des annotations avec TTL (Time To Live) et prise en charge de la mise en cache à deux niveaux
Créer et configurer une instance Cache avec le gestionnaire de cache
Collectez automatiquement les statistiques d'accès pour l'instance Cache et le cache au niveau de la méthode
La stratégie de génération de clés et de sérialisation de la valeur peut être personnalisée
Convertisseur de clé de cache pris en charge : fastjson / fastjson2 / jackson ; Convertisseur de valeur pris en charge : java / kryo / kryo5
Actualisation automatique du cache distribué et verrouillage distribué. (2,2+)
Accès asynchrone à l'aide de l'API Cache (2.2+, avec client redis lettuce)
Invalider les caches locaux (dans tous les processus JVM) après les mises à jour (2.7+)
Prise en charge de Spring Boot

exigences:

JDK1.8
Spring Framework4.0.8+ (facultatif, avec prise en charge des annotations) ， jetcache 2.7 nécessite 5.2.4+
Spring Boot1.1.9+ (facultatif), jetcache 2.7 nécessite 2.2.5+

Consultez la documentation pour plus de détails.

Commencer

Cache de méthodes

Déclarez le cache de méthodes à l’aide de l’annotation @Cached .
expire = 3600 indique que les éléments expireront dans 3600 secondes après avoir été définis. JetCache génère automatiquement la clé de cache avec tous les paramètres.

 public interface UserService {
    @ Cached ( expire = 3600 , cacheType = CacheType . REMOTE )
    User getUserById ( long userId );
}

Utilisation de l'attribut key pour spécifier la clé de cache à l'aide du script SpEL.

 public interface UserService {
    @ Cached ( name = "userCache-" , key = "#userId" , expire = 3600 )
    User getUserById ( long userId );

    @ CacheUpdate ( name = "userCache-" , key = "#user.userId" , value = "#user" )
    void updateUser ( User user );

    @ CacheInvalidate ( name = "userCache-" , key = "#userId" )
    void deleteUser ( long userId );
}

Afin d'utiliser un nom de paramètre tel que key="#userId" , la cible du compilateur javac doit être 1.8 ou supérieure, et les -parameters doivent être définis. Sinon, utilisez index pour accéder à des paramètres tels que key="args[0]"

Rafraîchissement automatique :

 public interface SummaryService {
    @ Cached ( expire = 3600 , cacheType = CacheType . REMOTE )
    @ CacheRefresh ( refresh = 1800 , stopRefreshAfterLastAccess = 3600 , timeUnit = TimeUnit . SECONDS )
    @ CachePenetrationProtect
    BigDecimal summaryOfToday ( long categoryId );
}

L'annotation CachePenetrationProtect indique que le cache sera chargé de manière synchrone dans un environnement multithread.

API de cache

Créez une instance Cache avec CacheManager :

 @ 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
        . localLimit ( 50 )
        . syncLocal ( true ) // invalidate local cache in all jvm process after update
        . build ();
    userCache = cacheManager . getOrCreateCache ( qc );
}

Le code ci-dessus crée une instance Cache . cacheType = CacheType.BOTH définit un cache à deux niveaux (un cache local en mémoire et un système de cache distant) avec des éléments locaux limités à 50 (expulsion basée sur LRU). Vous pouvez l'utiliser comme une carte :

 UserDO user = userCache . get ( 12345L );
userCache . put ( 12345L , loadUserFromDataBase ( 12345L ));
userCache . remove ( 12345L );

userCache . computeIfAbsent ( 1234567L , ( key ) -> loadUserFromDataBase ( 1234567L ));

API avancée

API asynchrone :

 CacheGetResult r = cache . GET ( userId );
CompletionStage < ResultData > future = r . future ();
future . thenRun (() -> {
    if ( r . isSuccess ()){
        System . out . println ( r . getValue ());
    }
});

Serrure distribuée :

 cache . tryLockAndRun ( "key" , 60 , TimeUnit . SECONDS , () -> heavyDatabaseOperation ());

Lecture complète et actualisation automatique :

 @ Autowired
private CacheManager cacheManager ;
private Cache < String , Long > orderSumCache ;

@ PostConstruct
public void init () {
    QuickConfig qc = QuickConfig . newBuilder ( "userCache" )
        . expire ( Duration . ofSeconds ( 3600 ))
        . loader ( this :: loadOrderSumFromDatabase )
        . refreshPolicy ( RefreshPolicy . newPolicy ( 60 , TimeUnit . SECONDS ). stopRefreshAfterLastAccess ( 100 , TimeUnit . SECONDS ))
        . penetrationProtect ( true )
        . build ();
    orderSumCache = cacheManager . getOrCreateCache ( qc );
}

Configuration avec Spring Boot

pompon :

< dependency >
    < groupId >com.alicp.jetcache</ groupId >
    < artifactId >jetcache-starter-redis</ artifactId >
    < version >${jetcache.latest.version}</ version >
</ dependency >

Classe d'application :

 @ SpringBootApplication
@ EnableMethodCache ( basePackages = "com.company.mypackage" )
@ EnableCreateCacheAnnotation // deprecated in jetcache 2.7, can be removed if @CreateCache is not used
public class MySpringBootApp {
    public static void main ( String [] args ) {
        SpringApplication . run ( MySpringBootApp . class );
    }
}

configuration de l'application.yml de démarrage au printemps :

 jetcache :
  statIntervalMinutes : 15
  areaInCacheName : false
  local :
    default :
      type : linkedhashmap # other choose：caffeine
      keyConvertor : fastjson2 # other choose：fastjson/jackson
      limit : 100
  remote :
    default :
      type : redis
      keyConvertor : fastjson2 # other choose：fastjson/jackson
      broadcastChannel : projectA
      valueEncoder : java # other choose：kryo/kryo5
      valueDecoder : java # other choose：kryo/kryo5
      poolConfig :
        minIdle : 5
        maxIdle : 20
        maxTotal : 50
      host : ${redis.host}
      port : ${redis.port}