primavera utilizando algunas de las principales cuestiones de gestión RedisCacheManager

primavera así puede manejar una variedad de la memoria caché rápida.

Estas implementaciones biblioteca de caché de memoria común tienen Redis, Ehcache.

Este artículo trata de un Redis, después de todo, esto es bastante fácil de usar.

 

primavera por org.springframework.cache.Cache y org.springframework.cache.CacheManager dos interfaces para gestionar la memoria caché

Redis la clase de implementación de caché es RedisCacheManager, su relación es la siguiente:

objeto

   <-AbstractCacheManager => ( CacheManager , InitializingBean )

       <-AbstractTransactionSupportingCacheManager

          <- RedisCacheManager

Se puede observar aperos RedisCacheManager la interfaz interfaz CacheManager.

En primer lugar, la forma de personalizar los Redis clave

Si se utiliza el modo por defecto para registrar RedisCacheManager, de la siguiente manera:

RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig () 
                .entryTtl (Duration.ofHours ( este .cacheTimeOutHour))

Supongamos comentario es el siguiente:

@Cacheable (valor = "getUserPoJoById", key = "# ID de usuario")

La clave generada es entonces ReDiS la forma siguiente:

getUserPoJoById :: 103

Donde el doble de dos puntos (:) es el delimitador.

Esto se debe a RedisCacheConfiguration.defaultCacheConfig () el código fuente como sigue:

 

pública  estática RedisCacheConfiguration defaultCacheConfig () {
         retorno defaultCacheConfig ( nula ); 
    } 
Pública  estática RedisCacheConfiguration defaultCacheConfig (@Nullable cargador de clases de cargador de clases) { 

        DefaultFormattingConversionService conversionService = nueva DefaultFormattingConversionService (); 

        registerDefaultConverters (conversionService); 

        volver  nueva RedisCacheConfiguration (Duration.ZERO, cierto , cierto , CacheKeyPrefix. sencilla () , 
                SerializationPair.fromSerializer (RedisSerializer.string ()),
                SerializationPair.fromSerializer (RedisSerializer.java (cargador de clases)), conversionService); 
    }

 

Se puede ver en la clave de código de prefijo anterior se utiliza CacheKeyPrefix.simple () , CacheKeyPrefix. (Simple) se lleva a cabo de la siguiente manera:

 

@FunctionalInterface
 pública  interfaz CacheKeyPrefix { 

    / ** 
     * Calcular el prefijo para la {real @literal clave} almacenada en Redis. 
     * 
     * @Param cacheName nunca será { @literal null}. 
     * @Return Nunca { @literal null}.
     * / 
    Compute String (cadena cacheName); 

    / ** 
     * Crea un defecto { @ link CacheKeyPrefix} esquema que prefijos caché de claves con { @code cacheName} seguido de dobles 
     * dos puntos. Una caché llamado { @codemyCache} va delante de todos los claves de caché con { @code myCache ::}. 
     * 
     * @Return el valor predeterminado { @ link CacheKeyPrefix} esquema.
     * / 
    Static CacheKeyPrefix sencilla () {
         retorno nombre -> + nombre "::" ; 
    } 
}

 implementación simple CacheKeyPrefix el método de cálculo es equivalente a:

compute String (cadena cacheName) {

   retorno cacheName + "::";

}

 

Por lo que el valor predeterminado es utilizar el doble de colon para separarlos.

 

Pero en muchos casos, no queremos Redis la clave está en esta forma, es posible que queramos:

1. Antes de que todo el prefijo clave
2. El uso de diferentes delimitador

¿Cómo hacerlo? Llamada personalización CacheKeyPrefix se puede lograr.

Echemos un vistazo a CacheKeyPrefix el único método de interfaz (no estático):

compute String (cadena cacheName);

Que sea necesario especificar logrado a través de cómputo.

Con la idea, a continuación, la siguiente es la implementación:

 

RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig () 
                .entryTtl (Duration.ofHours ( este . .CacheTimeOutHour)) computePrefixWith ( cacheName -> cacheName + este .keyPrefix ); 
        RedisCacheManager cm = RedisCacheManager.builder (redisConnectionFactory) .cacheDefaults (redisCacheConfiguration) .build (); 
        cm.setTransactionAware ( verdadero );

 

sección de código crítico anterior: computePrefixWith ( cacheName -> + cacheName la presente .keyPrefix);

Nos fijamos en computePrefixWith de código de implementación RedisCacheConfiguration:

pública RedisCacheConfiguration computePrefixWith (CacheKeyPrefix cacheKeyPrefix) { 

        Assert.notNull (cacheKeyPrefix, "Función para calcular prefijo debe ser nula, no!" ); 

        volver  nuevo RedisCacheConfiguration (ttl, cacheNullValues, verdadero , cacheKeyPrefix, keySerializationPair, 
                valueSerializationPair, conversionService); 
    }

Por lo tanto Código: cacheName -> + cacheName la presente .keyPrefix es construir CacheKeyPrefix el método de cálculo

 

Cadena de cómputo (String cacheName) { 

   volver cacheName + esta .keyPrefix; 

}

 

 

Si desea agregar un prefijo, que puede ser:

computePrefixWith ( cacheName -> this.getCachePrefix + "->" + + cacheName la presente .keyPrefix)
 que es equivalente al método de cálculo se convierte en: retorno this.getCachePrefix + "->" + + cacheName la presente .keyPrefix

 

 

5.1.x primavera después de un uso intensivo de lambda, si no está familiarizado con, usted no puede leer este código.

 

En segundo lugar, la definición de otros aspectos clave que requieren atención

1. Cuando una pluralidad de aplicaciones comparten ejemplo un tiempo de redis, tenga en cuenta el uso del prefijo

2. Si hay una gran cantidad de valor, se recomienda clave más corta, y forman un documento clave en el nombre