A partir de 3.1, Spring introdujo el soporte para Cache. Su método y principio de uso son similares al soporte de Spring para la gestión de transacciones. Spring Cache funciona en métodos, y su idea central es esta: cuando llamamos a un método de caché, los parámetros del método y el resultado devuelto se almacenan en la caché como un par clave-valor, y la próxima vez que usemos los mismos parámetros para Cuando se llama a este método, el método ya no se ejecutará, pero el resultado se obtendrá directamente del caché y se devolverá. Por lo tanto, al usar Spring Cache, debemos asegurarnos de que nuestros métodos en caché tengan los mismos resultados de retorno para los mismos parámetros de método.
Usar Spring Cache requiere que hagamos dos cosas:
- Declarar ciertos métodos para usar caché
- Configurar el soporte de Spring para Cache
Al igual que el soporte de Spring para la gestión de transacciones, el soporte de Spring para Cache también se basa en anotaciones y configuración basada en XML. Primero echemos un vistazo al enfoque basado en anotaciones.
Soporte basado en anotaciones
Spring nos proporciona varias anotaciones para admitir Spring Cache. Su núcleo es principalmente @Cacheable y @CacheEvict. Los métodos marcados con @Cacheable almacenarán en caché los resultados devueltos después de la ejecución, mientras que los métodos marcados con @CacheEvict eliminarán algunos elementos en Spring Cache antes o después de que se ejecute el método. A continuación, presentaremos en detalle varias anotaciones proporcionadas por Spring basadas en el soporte de anotaciones para Cache.
1 、 @ Caché
@Cacheable se puede marcar en un método o una clase. Cuando se marca en un método, significa que el método admite el almacenamiento en caché. Cuando se marca en una clase, significa que todos los métodos en esta clase admiten el almacenamiento en caché. Para un método que admite el almacenamiento en caché, Spring almacenará en caché el valor de retorno después de que se lo llame, para garantizar que la próxima vez que use los mismos parámetros para ejecutar el método, pueda obtener directamente los resultados del caché sin tener que ejecutar el método nuevamente. Spring almacena en caché el valor de retorno del método con pares clave-valor. El valor es el resultado de retorno del método. En cuanto a la clave, Spring admite dos estrategias, la estrategia predeterminada y la estrategia personalizada, que se explicarán más adelante. Cabe señalar que cuando se llama a un método que admite el almacenamiento en caché dentro del objeto, la función de almacenamiento en caché no se activará. @Cacheable puede especificar tres atributos, valor, clave y condición.
1.1 El atributo de valor especifica el nombre de la caché
Se debe especificar el atributo de valor, que indica en qué caché se almacenará en caché el valor de retorno del método actual, correspondiente al nombre de la caché. Puede ser una Caché o varias Cachés, es una matriz cuando es necesario especificar varias Cachés.
@Cacheable("cache1") // Cache是发生在cache1上的
public User find(Integer id) {
returnnull;
}
@Cacheable({"cache1", "cache2"}) // Cache是发生在cache1和cache2上的
public User find(Integer id) {
returnnull;
}1.2 Use el atributo clave para personalizar la clave
El atributo de clave se utiliza para especificar la clave correspondiente cuando el método Spring cache devuelve el resultado. Este atributo admite expresiones SpringEL. Cuando no especificamos este atributo, Spring utilizará la estrategia predeterminada para generar la clave. Echemos un vistazo a la estrategia personalizada aquí, ya que la estrategia predeterminada se presentará por separado más adelante.
La estrategia personalizada significa que podemos especificar nuestra clave a través de la expresión EL de Spring. Aquí las expresiones EL pueden usar parámetros de método y sus atributos correspondientes. Al usar parámetros de método, podemos usar directamente "# nombre de parámetro" o "# índice de parámetro". Aquí hay algunos ejemplos del uso de parámetros como claves.
/**
* key 是指传入时的参数
*
*/
@Cacheable(value="users", key="#id")
public User find(Integer id) {
return null;
}
// 表示第一个参数
@Cacheable(value="users", key="#p0")
public User find(Integer id) {
return null;
}
// 表示User中的id值
@Cacheable(value="users", key="#user.id")
public User find(User user) {
return null;
}
// 表示第一个参数里的id属性值
@Cacheable(value="users", key="#p0.id")
public User find(User user) {
return null;
}Además de utilizar los parámetros del método anteriores como claves, Spring también nos proporciona un objeto raíz que se puede utilizar para generar claves. A través de este objeto raíz podemos obtener la siguiente información.
Cuando queremos usar el atributo del objeto raíz como la clave, también podemos omitir "#root", porque Spring usa el atributo del objeto raíz de forma predeterminada. Tales como:
// key值为: user中的name属性的值
@Cacheable(value={"users", "xxx"}, key="caches[1].name")
public User find(User user) {
return null;
}1.3 El atributo de condición especifica la condición que ocurre
A veces es posible que no queramos almacenar en caché todos los resultados devueltos por un método. Esta función se puede lograr a través del atributo de condición. El atributo de condición está vacío de forma predeterminada, lo que indica que todas las situaciones de invocación se almacenarán en caché. El valor se especifica mediante la expresión SpringEL. Cuando es verdadero, significa que se realiza el procesamiento de caché; cuando es falso, significa que no se realiza el procesamiento de caché, es decir, el método se ejecutará una vez cada vez que se llame al método. El siguiente ejemplo indica que la memoria caché solo se realiza cuando la identificación del usuario es par.
// 根据条件判断是否缓存
@Cacheable(value={"users"}, key="#user.id", condition="#user.id%2==0")
public User find(User user) {
System.out.println("find user by user " + user);
return user;
}
2 @CachePut
En el entorno que admite Spring Cache, para el método marcado con @Cacheable, Spring verificará si hay un elemento de caché con la misma clave en la caché antes de cada ejecución. Si existe, el método no se ejecutará y se obtendrá directamente de la caché Se devuelve el resultado; de lo contrario, se ejecutará y el resultado devuelto se almacenará en la memoria caché especificada. @CachePut también puede declarar un método para admitir la función de caché. La diferencia con @Cacheable es que el método marcado con @CachePut no verificará si hay un resultado ejecutado previamente en la memoria caché antes de la ejecución, pero ejecutará el método cada vez y almacenará el resultado de la ejecución en forma de pares clave-valor En el caché especificado.
// @CachePut也可以标注在类上和方法上。使用@CachePut时我们可以指定的属性跟@Cacheable是一样的。
@CachePut("users") // 每次都会执行方法，并将结果存入指定的缓存中
public User find(Integer id) {
return null;
}
3 @CacheEvict
@CacheEvict se usa para marcar métodos o clases que necesitan borrar elementos de caché. Cuando se marca en una clase, significa que la ejecución de todos los métodos en ella desencadenará la operación clara de la memoria caché. Los atributos que puede especificar @CacheEvict son value, key, condition, allEntries y beforeInvocation. La semántica de valor, clave y condición son similares a los atributos correspondientes de @Cacheable. Es decir, el valor indica en qué caché se produjo la operación de borrado (correspondiente al nombre del caché); la clave indica qué clave debe borrarse; si no se especifica, se utilizará la clave generada por la estrategia predeterminada; la condición indica la condición bajo la cual se produce la operación de borrado. Vamos a presentar los dos atributos recién aparecidos allEntries y beforeInvocation.
3.1 atributo allEntries
allEntries es un tipo booleano, que indica si todos los elementos en la memoria caché deben borrarse. El valor predeterminado es falso, lo que significa que no es necesario. Cuando allEntries se especifica como verdadero, Spring Cache ignorará la clave especificada. A veces necesitamos almacenar en caché para borrar todos los elementos, lo cual es más eficiente que borrar elementos uno por uno.
@CacheEvict(value="users", allEntries=true)
public void delete(Integer id) {
System.out.println("delete user by id: " + id);
}3.2 atributo beforeInvocation
De forma predeterminada, la operación de borrado se desencadena después de que el método correspondiente se ejecuta con éxito, es decir, si el método no puede regresar debido a una excepción, la operación de borrado no se disparará. El uso beforeInvocation puede cambiar el tiempo para activar la operación de borrado. Cuando especificamos que el valor de este atributo es verdadero, Spring borrará el elemento especificado en el caché antes de llamar a este método.
@CacheEvict(value="users", 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 la propia estrategia de expulsión de Ehcache, que se especifica a través del archivo de configuración de Ehcache. Dado que Ehcache no es el enfoque de este artículo, no entraré en detalles aquí. Para obtener más información sobre Ehcache, consulte mi columna sobre Ehcache.
4 @Caching
La anotación @Caching nos permite especificar varias anotaciones relacionadas con Spring Cache en un 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("users"), evict = { @CacheEvict("cache2"),
@CacheEvict(value = "cache3", allEntries = true) })
public User find(Integer id) {
return null;
}
5 Usa anotaciones personalizadas
Spring nos permite usar anotaciones personalizadas al configurar métodos almacenables en caché, siempre que las anotaciones personalizadas se marquen con las anotaciones correspondientes. Por ejemplo, tenemos la siguiente anotación personalizada marcada con @Cacheable.
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Cacheable(value="users")
public @interface MyCacheable {}Luego, usar @MyCacheable para etiquetar el método que necesitamos almacenar en caché también puede lograr el mismo efecto.
@MyCacheable
public User findById(Integer id) {
System.out.println("find user by id: " + id);
User user = new User();
user.setId(id);
user.setName("Name" + id);
return user;
}
