jetcache -Download – Download jetcache Quellcodes

jetcache

JAVA-Quellcode

v2.7.7

Herunterladen

Einführung

JetCache ist eine Java-Cache-Abstraktion, die eine einheitliche Nutzung für verschiedene Caching-Lösungen ermöglicht. Es bietet leistungsfähigere Anmerkungen als die in Spring Cache. Die Anmerkungen in JetCache unterstützen natives TTL, zweistufiges Caching und werden in verteilten Umgebungen automatisch aktualisiert. Außerdem können Sie Cache Instanz durch Ihren Code manipulieren. Derzeit gibt es vier Implementierungen: RedisCache , TairCache (nicht Open Source auf Github), CaffeineCache (im Speicher) und einen einfachen LinkedHashMapCache (im Speicher). Vollständige Funktionen von JetCache:

Manipulieren Sie den Cache über eine einheitliche Cache-API.
Deklaratives Methoden-Caching mithilfe von Annotationen mit TTL (Time To Live) und Unterstützung für zweistufiges Caching
Erstellen und konfigurieren Sie Cache Instanz mit dem Cache-Manager
Erfassen Sie automatisch Zugriffsstatistiken für Cache auf Instanz- und Methodenebene
Die Strategie der Schlüsselgenerierung und Wertserialisierung kann individuell angepasst werden
Unterstützter Cache-Schlüsselkonverter: fastjson / fastjson2 / jackson ; Unterstützter Wertkonverter: java / kryo / kryo5
Automatische Aktualisierung des verteilten Caches und verteilte Sperre. (2.2+)
Asynchroner Zugriff über die Cache-API (2.2+, mit Redis-Salat-Client)
Lokale Caches (in allen JVM-Prozessen) nach Updates ungültig machen (2.7+)
Spring Boot-Unterstützung

Anforderungen:

JDK1.8
Spring Framework4.0.8+ (optional, mit Anmerkungsunterstützung), Jetcache 2.7 benötigt 5.2.4+
Spring Boot 1.1.9+ (optional), Jetcache 2.7 benötigt 2.2.5+

Weitere Informationen finden Sie in der Dokumentation.

Erste Schritte

Methodencache

Deklarieren Sie den Methodencache mithilfe @Cached Annotation.
expire = 3600 gibt an, dass die Elemente 3600 Sekunden nach dem Festlegen ablaufen. JetCache generiert automatisch den Cache-Schlüssel mit allen Parametern.

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

Verwenden key zum Angeben des Cache-Schlüssels mithilfe des SpEL-Skripts.

 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 );
}

Um Parameternamen wie key="#userId" verwenden zu können, muss Ihr Javac-Compiler-Ziel 1.8 oder höher sein und die -parameters sollten festgelegt sein. Andernfalls verwenden Sie den Index, um auf Parameter wie key="args[0]" zuzugreifen.

Automatische Erfrischung:

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

Die Annotation „CachePenetrationProtect“ gibt an, dass der Cache in einer Multithread-Umgebung synchron geladen wird.

Cache-API

Erstellen Sie eine Cache Instanz mit 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 );
}

Der obige Code erstellt eine Cache Instanz. cacheType = CacheType.BOTH definiert einen zweistufigen Cache (einen lokalen In-Memory-Cache und ein Remote-Cache-System) mit einer Begrenzung lokaler Elemente auf mehr als 50 (LRU-basierte Evict). Sie können es wie eine Karte verwenden:

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

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

Erweiterte API

Asynchrone API:

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

Verteilte Sperre:

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

Vorlesen und automatische Aktualisierung:

 @ 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 );
}

Konfiguration mit Spring Boot

pom:

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

App-Klasse:

 @ 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 );
    }
}

Spring Boot application.yml-Konfiguration:

 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}