¿Qué marco utiliza Spring Cache?

? A partir de 3.1, Spring introdujo soporte para el almacenamiento en caché. Su uso y principios son similares al soporte de Spring para la gestión de transacciones. Spring Cache se usa en métodos. La idea central es la siguiente: cuando llamamos a un método de caché, los parámetros y los resultados devueltos del método se guardarán en el caché como pares clave-valor hasta la próxima vez que se llame al método con el mismo. parámetros El método ya no se ejecutará cuando se llame al método, pero el resultado devuelto se obtendrá directamente del caché. Por lo tanto, cuando utilizamos Spring caché, debemos asegurarnos de que los mismos parámetros del método en el método de caché tengan el mismo resultado de retorno.

Usar el almacenamiento en caché de Spring requiere que hagamos dos cosas:

Declarar ciertos métodos para usar el almacenamiento en caché

Configurar el soporte de Spring para el almacenamiento en caché

Me gusta El soporte de Spring para la gestión de transacciones y el soporte de Spring para el almacenamiento en caché también vienen en formatos basados ​​en anotaciones y XML. Hay dos formas de configurar el almacenamiento en caché: basado en anotaciones y basado en XML. Veamos primero el enfoque basado en anotaciones.

1 Soporte basado en anotaciones Spring nos proporciona múltiples anotaciones para admitir Spring Cache, de las cuales las anotaciones principales son @Cacheable y @CacheEvict. Spring Cache almacenará en caché los resultados de los métodos marcados con @Cacheable después de la ejecución, mientras que los métodos marcados con @CacheEvict eliminarán ciertos elementos de Spring Cache antes o después de la ejecución. A continuación, presentaremos en detalle varias anotaciones proporcionadas por Spring según el soporte de anotaciones para Cache.

1.1 @Cacheable @Cacheable se puede marcar en un método o clase. Cuando está marcado en un método, significa que el método se puede almacenar en caché; cuando está marcado en una clase, significa que todos los métodos de la clase se pueden almacenar en caché. Para los métodos que admiten el almacenamiento en caché, Spring almacenará en caché el valor de retorno después de llamar al método, lo que garantiza que la próxima vez que el método se ejecute con los mismos parámetros, los resultados se puedan recuperar directamente del caché sin tener que ejecutar el método nuevamente. Spring almacena en caché el valor de retorno de un método como un par clave-valor, donde el valor es el resultado del método y la clave es el resultado del método. Spring admite dos estrategias, la estrategia predeterminada y la estrategia personalizada. En cuanto a las claves, Spring admite dos estrategias, la estrategia predeterminada y la estrategia personalizada, que se explicarán más adelante. Tenga en cuenta que el almacenamiento en caché no se activará cuando se llame a un método habilitado para caché desde dentro del objeto. @Cacheable puede especificar tres atributos: valor, clave y condición.

1.1.1? El atributo de valor especifica el nombre del caché. El atributo de valor es un atributo obligatorio e indica el nombre del caché del valor de retorno del método actual. El atributo de valor es un atributo obligatorio y se utiliza para indicar el caché que almacena en caché el valor de retorno del método actual. Puede ser una caché única o varias cachés, o una matriz si se especifican varias cachés. @Cacheable("cache1")//El caché se produce en el caché1

public?User?find(Integer?id)?{ returnnull;

}

@ Cacheable({"cache1", ?" cache2"})//El caché se está procesando en cache1 y cache2

public?User?find(Integer?id)?{ returnnull;

}

1.1.2 Utilice el atributo clave para personalizar el valor clave. El atributo clave se utiliza para especificar el valor clave correspondiente al resultado de retorno del método de caché Spring. Esta propiedad admite expresiones SpringEL.

Cuando no especificamos esta propiedad, Spring utilizará la estrategia predeterminada para generar claves. Primero cubriremos las estrategias personalizadas aquí, las estrategias predeterminadas se cubrirán por separado más adelante.

Una estrategia personalizada significa que podemos especificar nuestras claves a través de expresiones EL de Spring, que pueden tomar parámetros de método y sus propiedades correspondientes. Cuando usamos parámetros de método, solo necesitamos usar "#nombre de parámetro" o "índice de parámetro #p". A continuación se muestran algunos ejemplos del uso de parámetros como claves. @Cacheable(value="usuarios",?key="#id")

public?User?find(Integer?id)?{ returnnull;

}

@Cacheable(value="usuarios",?key="#p0")

público?Usuario?find(Integer?id)?{ returnnull;

}

@Cacheable(value="usuarios",?key="#user.id")

¿público?Usuario?{ returnnull;

}

@Cacheable(value="usuarios",?key="#p0.id")

¿público?Usuario?{ returnnull;

}

Además de usar parámetros de método como claves como se mencionó anteriormente, Spring también nos proporciona un objeto raíz que se puede usar para generar claves, que nos proporciona la siguiente información.

También podemos omitir "#root" cuando queremos usar las propiedades del objeto raíz como claves, porque Spring usa las propiedades del objeto raíz de forma predeterminada. Por ejemplo, @Cacheable(value={"users",?" xxx"},?key="caches[1].name")

public?User?find(User?user)?{ returnnull ;

}

1.1.3? El atributo condicional especifica las condiciones bajo las cuales ocurre esta operación.

A veces es posible que no queramos almacenar en caché todos los resultados de un método. . Esto se logra mediante el atributo de condición, cuyo valor predeterminado está vacío, lo que indica que todas las llamadas se almacenarán en caché. Su valor está especificado por una expresión SpringEL. Cuando esta propiedad es verdadera, el método se almacenará en caché; cuando esta propiedad es falsa, el método no se almacenará en caché, es decir, se ejecutará cada vez que se llame al método. El siguiente ejemplo muestra que el almacenamiento en caché solo se producirá si la identificación del usuario es un número par. @Cacheable(value={"usuarios"},?key="#user.id",?condition="#user.id2==0")

público?Usuario?find(Usuario?usuario )?{ System.out.println("¿buscar?usuario?por?usuario?? ?usuario; Devolver ?usuario;

}.

1.2?@CachePut

En un entorno que admite Spring caché, para los métodos anotados con @Cacheable, Spring comprobará si hay un método con la misma clave en el caché antes de cada uno. ejecución Si el elemento de caché existe, el método ya no se ejecutará, pero el resultado se devolverá directamente desde el caché. De lo contrario, el método se ejecutará y el resultado devuelto se almacenará en el caché especificado. @CachePut también puede declarar un método para admitir la funcionalidad de almacenamiento en caché.

A diferencia de @Cacheable, un método anotado con @CachePut no verificará los resultados de ejecuciones anteriores en el caché antes de la ejecución. En cambio, el método se ejecutará cada vez y los resultados de la ejecución se almacenarán en el caché especificado como pares clave-valor. @CachePut también se puede marcar en clases y métodos. Cuando usamos @CachePut, las propiedades que podemos especificar son las mismas que @Cacheable. @CachePut("usuarios")//Ejecuta el método cada vez y almacena los resultados en el caché especificado

public?User?find(Integer?id)?{ returnnull;

}

1.3?@CacheEvict @CacheEvict se utiliza para marcar métodos o clases que necesitan borrar elementos de caché. Cuando se etiqueta a una clase, significa que la ejecución de todos los métodos de esa clase activará el borrado del caché. Los atributos que se pueden especificar en @CacheEvict son valor, clave, condición, allEntries y beforeInvocation, donde la semántica de valor, clave y condición es similar a @Cacheable. Es decir, el valor representa el caché que debe borrarse (correspondiente al nombre del caché); la clave representa la clave que debe borrarse; si no se especifica, se utiliza la clave generada por la política predeterminada; bajo el cual se produce la operación de compensación.

1.3.1?allEntries atributo allEntries es un tipo booleano que indica si es necesario borrar todos los elementos del caché. El valor predeterminado es falso, lo que significa que no es obligatorio. Cuando allEntries se especifica como verdadero, Spring cache ignorará las claves especificadas. A veces, necesitamos que el caché borre todos los elementos a la vez, lo cual es más eficiente que borrar los elementos uno por uno. @CacheEvict(value="usuarios",?allEntries=true)

public?void?delete(Integer?id)?{ System.out.println("delete?user?by?id:?" ) ?id);

}

?

1.3.2?beforeInvocation atributo

Por defecto, después de ejecutar el método con éxito Se activará la limpieza, es decir, si el método no puede regresar debido a que se genera una excepción, no se activará la limpieza. Usando beforeInvocation podemos cambiar cuándo se activa la limpieza. Cuando especificamos un valor verdadero para esta propiedad, Spring borrará el elemento especificado del caché antes de llamar al método. @CacheEvict(value="usuarios",?beforeInvocation=true)

public?void?delete(Integer?id)?{ System.out.println("delete?user?by?id:?" ) ?id);

}

De hecho, además de usar @CacheEvict para borrar elementos de caché, cuando usamos Ehcache como implementación, también podemos configurar el desalojo propio de Ehcache. Estrategia, que se especifica a través del archivo de configuración de Ehcache. Dado que Ehcache no es el tema central de este artículo, no entraré en detalles aquí. Para obtener más información sobre Ehcache, consulte mi columna Ehcache.

1.4?@Caching La anotación @Caching nos permite especificar múltiples anotaciones relacionadas con Spring Cache en un solo método o clase al mismo tiempo.

Tiene tres atributos: cacheable, put y evict, que se utilizan para especificar @Cacheable, @CachePut y @CacheEvict respectivamente. @Caching(cacheable?=?@Cacheable("usuarios"),?evict?=?{@CacheEvict("cache2"), @CacheEvict(valor?=?" cache3",?allEntries?=?true)?})

public?User?find(Integer?id)?{ returnnull;

}

1.5 Uso de anotaciones personalizadas que Spring nos permite usar al configurar métodos de caché personalizados anotación, siempre que la anotación personalizada tenga una anotación correspondiente. Por ejemplo, anotamos la siguiente anotación personalizada usando @Cacheable. @Target({ElementType.TYPE,?ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

@Cacheable(value="usuarios")

@RetentionPolicy.p>público?@MyCacheable

público?User?findById(Integer?id)?{ System.out.println("find?user?by?id：?") ?id ); Usuario?usuario?=?nuevo?Usuario(); usuario.setId(id); usuario.setName("Nombre"? ?id);

2 ¿Configurar el soporte de Spring para el almacenamiento en caché

2.1? ¿Declarar soporte de caché

2.1.1? admitir el almacenamiento en caché basado en anotaciones, primero debemos introducir el espacio de nombres de caché en el archivo de configuración de Spring y, en segundo lugar, podemos habilitar el soporte de Spring para el almacenamiento en caché basado en anotaciones a través de

lt;beans?xmlns=".xxx.UserService.*(...))" p>

lt;/aop:configgt;

La configuración anterior significa que cualquier método **** público en com.xxx.UserService llamará al cacheAdvice correspondiente a cache:advice para Spring Procesamiento de caché. Más información sobre Spring Aop está fuera del alcance de este artículo.

2.2 Configurando CacheManager CacheManager es una interfaz definida por Spring para administrar Cache. Si necesitamos utilizar otros tipos de caché, podemos implementar la interfaz CacheManager de Spring o la clase abstracta AbstractCacheManager. Los siguientes son dos ejemplos de configuración de CacheManager implementados por Spring para nosotros.

2.2.1?Configuración basada en ConcurrentMaplt;bean?id="cacheManager"?class="org.springframework.cache.support.SimpleCacheManager"?SimpleCacheManager"gt;lt;property?name=" cachés "gt;lt;setgt;

lt;beanclass="org.springframework.cache..ConcurrentMapCacheFactoryBean"?p: name="xxx"/gt;lt;/setgt;lt;/propertygt;

lt;/beangt;

La configuración anterior utiliza SimpleCacheManager, que contiene un ConcurrentMapCache llamado "xxx". --?Implementación de Ehcache? --gt;

lt;bean?id="cacheManager"?class="org.springframework.cache.ehcache.EhCacheCacheManager "p:cache-manager-ref=" ehcacheManager "/gt;

lt; bean?id="ehcacheManager "class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"?p. config-location="ehcache-spring.xml"/gt ;

La configuración anterior utiliza el EhCacheCacheManager proporcionado por Spring para generar Spring CacheManager, que utiliza Ehcache CacheManager, porque el CacheManager de Ehcache se puede generar especificando la ubicación del archivo de configuración de ehcache. Si no se especifica, obtendrá el. ehcache.xml en la ruta raíz del classpath de acuerdo con las reglas predeterminadas de Ehcache. Si el archivo no existe, obtendrá el archivo ehcache-failsafe.xml en el paquete jar correspondiente de Ehcache como archivo de configuración. No diré más sobre Ehcache aquí. No pertenece al contenido de este artículo. Si desea saber más sobre Ehcache, puede consultar la serie de artículos de Ehcache que publiqué antes y también puede consultar el artículo oficial. documentos, etc