jetcache

Introducción

JetCache es una abstracción de caché de Java que proporciona un uso uniforme para diferentes soluciones de almacenamiento en caché. Proporciona anotaciones más potentes que las de Spring Cache. Las anotaciones en JetCache admiten TTL nativo, almacenamiento en caché de dos niveles y actualización automática en entornos distribuidos; también puede manipular la instancia Cache mediante su código. Actualmente, hay cuatro implementaciones: RedisCache , TairCache (no de código abierto en github), CaffeineCache (en memoria) y un LinkedHashMapCache simple (en memoria). Funciones completas de JetCache:

• Manipule el caché a través de una API de caché uniforme.
• Almacenamiento en caché de método declarativo usando anotaciones con TTL (Time To Live) y soporte de almacenamiento en caché de dos niveles
• Crear y configurar una instancia Cache con el administrador de caché
• Recopile automáticamente estadísticas de acceso para instancias Cache y caché a nivel de método
• La estrategia de generación de claves y serialización de valor se puede personalizar.
• Convertidor de claves de caché compatible: fastjson / fastjson2 / jackson ; Conversor de valores compatible: java / kryo / kryo5
• Actualización automática de caché distribuida y bloqueo distribuido. (2.2+)
• Acceso asincrónico usando Cache API (2.2+, con cliente redis lechuga)
• Invalidar cachés locales (en todos los procesos JVM) después de las actualizaciones (2.7+)
• Soporte de arranque de primavera

requisitos:

• JDK1.8
• Spring Framework4.0.8+ (opcional, con soporte para anotaciones), jetcache 2.7 necesita 5.2.4+
• Spring Boot1.1.9+ (opcional), jetcache 2.7 necesita 2.2.5+

Visite los documentos para obtener más detalles.

Empezando

Caché de métodos

Declare el caché del método usando la anotación @Cached .
expire = 3600 indica que los elementos caducarán en 3600 segundos después de su configuración. JetCache genera automáticamente la clave de caché con todos los parámetros.

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

Usando el atributo key para especificar la clave de caché usando el 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 );
}

Para utilizar un nombre de parámetro como key="#userId" , el destino del compilador javac debe ser 1.8 y superior, y se deben configurar los -parameters . De lo contrario, utilice el índice para acceder a parámetros como key="args[0]"

Refresco automático:

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

La anotación CachePenetrationProtect indica que el caché se cargará sincrónicamente en un entorno multiproceso.

API de caché

Cree una instancia Cache con 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 );
}

El código anterior crea una instancia Cache . cacheType = CacheType.BOTH define un caché de dos niveles (un caché en memoria local y un sistema de caché remoto) con elementos locales limitados a 50 (desalojo basado en LRU). Puedes usarlo como un mapa:

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

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

API avanzada

API asincrónica:

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

Cerradura distribuida:

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

Leer y actualizar automáticamente:

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

Configuración con Spring Boot

pompón:

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

Clase de aplicación:

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

Configuración de Spring Boot Application.yml:

 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}

Visite la configuración detallada para obtener más instrucciones.

Más documentos

Visite los documentos para obtener más detalles.

Para actualizar, consulte el registro de cambios y las notas de compatibilidad.