1. ¿Qué es el caché caché?
La palabra caché primero vino del diseño de la CPU
Cuando la CPU quiere leer un datos, primero busca el caché de la CPU y lo lee inmediatamente y lo envía a la CPU para su procesamiento si se encuentra; Si no se encuentra, se lee desde la memoria relativamente lenta y se envía a la CPU para su procesamiento. Al mismo tiempo, el bloque de datos donde se encuentran estos datos se llama al caché, para que todo el bloque de datos se pueda leer desde el caché en el futuro sin llamar a la memoria. Es este mecanismo de lectura el que hace que la tasa de accesorios de caché de la CPU lea sea muy alta (la mayoría de las CPU pueden alcanzar aproximadamente el 90%), lo que significa que el 90% de los datos que la CPU leerá la próxima vez está en la caché de la CPU, y solo alrededor del 10% necesita ser leído de la memoria. Esto guarda enormemente el tiempo de la CPU para leer la memoria directamente, y también hace que la CPU lea los datos sin esperar. En general, el orden en el que la CPU lee datos se almacena en caché primero y luego la memoria.
Más tarde, primero fuimos a la caché de disco duro, luego a la memoria caché de la aplicación, al caché del navegador, al caché web, etc.!
¡El caché es el rey! !
Caché de primavera
Spring Cache es un conjunto completo de soluciones de almacenamiento en caché de aplicaciones dadas por Spring Aplications.
Spring Cache en sí no proporciona implementación de caché, pero utiliza interfaces unificadas y especificaciones de código, configuraciones, anotaciones, etc. para permitirle usar varios cachés en aplicaciones de primavera sin tener que prestar demasiada atención a los detalles del caché. Con Spring Cache, puede usarlo fácilmente
Varias implementaciones de caché, incluyendo concurrentMap, ehcache 2.x, jcache, redis, etc.
La definición de caché en primavera
La definición de caché en primavera, incluida la interfaz org.springframework.cache.cache.
Proporciona principalmente los siguientes métodos
// Obtenga el valor de acuerdo con la tecla especificada <T> t get (clave de objeto, clase <t> type) // Guardar el valor especificado en el caché de acuerdo con la clave de la clave correspondiente (clave de objeto, valor de objeto); // Recicla el valor especificado void desalojo (clave de objeto)
No es difícil ver en la definición que el caché es en realidad una estructura de valor clave. Operamos el valor correspondiente a través de una clave especificada.
Gerente de caché
El caché es una colección de valores clave, pero en nuestro proyecto, puede haber diferentes cachés de varios temas comerciales, como cachés de usuarios, cachés de departamento, etc. Estos cachés están lógicamente separados. Para distinguir estos cachés, se proporciona org.springframework.cache.cachemanager para administrar varios cachés. Esta interfaz contiene solo dos métodos
// Obtenga el caché del tema correspondiente de acuerdo con el nombre Cache GetCache (nombre de cadena); // Obtenga el caché de todos los temas Collection <String> getCachenames ();
En esta interfaz, no se permite que las operaciones de agregar y eliminar se realicen en caché. Estas operaciones deben ser completadas internamente por varias implementaciones de Cachemanager y no deben revelarse.
Caché basado en la anotación
En teoría, la operación de los datos de caché no es muy relevante para el negocio en sí. Debemos separar las operaciones de lectura y escritura de caché de la lógica del código principal. La forma en que la primavera se separa se basa en la anotación (por supuesto, como JSR-107, etc., también se basa en la anotación).
Spring proporciona una serie de anotaciones, que incluyen @Cachable, @Cacheput, @CacheEvict y otras anotaciones para simplificar nuestro funcionamiento de los cachés. Estas anotaciones se encuentran en el paquete de org.springframework.cache.annotation.
2. Ejemplos
Un ejemplo simple de usar la bota de primavera usando el caché de primavera
Construyamos un ejemplo basado en el caché de arranque de primavera paso a paso
Cree un nuevo proyecto de arranque de primavera e introduzca las siguientes dependencias
<pendencies> <Spendency> <MoupRoD> org.springframework.boot </groupId> <artifactID> spring-boot-starter-cache </artifactid> </pendency> <pendency> <MoupRupId> org.springframework.boot </groupid> <artifactid> spring-boot-starter-web </artifactid> </////dependency> </dependency> <pendency> <MoupRid> org.springframework.boot </groupid> <artifactID> spring-boot-starter-test </artifactid> <cope> test </cope> </pendency> </dependencias>
Entre ellos, Spring-Boot-Starter-Cache es la dependencia clave de la caché.
Modifique la clase de aplicación y agregue la anotación que habilita caché @enablecaching
@SpringBootApplication@EnlecachingPublic Class CachesimpleApplication {public static void main (string [] args) {springApplication.run (CachesimpleApplication.class, args); }}@EnableCache Annotation comienza el mecanismo de almacenamiento en caché de Spring, que permitirá que la aplicación detecte todas las anotaciones relacionadas con el caché y comience a funcionar. También creará un frijol Cachemanager que puede ser inyectado y utilizado por nuestra aplicación.
Crea una nueva clase RestController
@RestController @requestmapping ("/") clase pública Cachecontroller {@aUtowired private CachetService CachetestService; / ** * Obtenga información basada en la id * * @param id * @return */ @getmapping ("{id}") public string test (@PathVariable ("id") ID de cadena) {return CachetestService.get (id); } / ** * Eliminar información sobre una id * * @param id * @return * / @deletemapping ("{id}") public String delete (@PathVariable ("id") ID de cadena) {return CachetService.delete (id); } / ** * Guardar información sobre una id * * @param id * @return * / @postmapping public string save (@RequestParam ("id") ID de cadena, @RequestParam ("valor") Valor de cadena) {return CachetestService.save (id, valor); } / ** * Información sobre una nueva id * * @param id * @return * / @putmapping ("{id}") public string update (@PathVariable ("id") ID de cadena, @RequestParam ("valor") Valor de cadena) {return CachetestService.Update (id, valor); }}Esta clase llama a un servicio para implementar la operación real de agregar, eliminar, modificar y verificar.
Implementación del servicio
A continuación, queremos implementar nuestro servicio
@ServicePublic Class SimpleCachetestServiceImpl implementa CachetestService {private static final logger logger = loggerFactory.getLogger (simplecachetestserviceImpl.class); mapa final privado <string, string> entidades = new Hashmap <> (); public SimpleCachetestServiceImpl () {entity.put ("1", "este no 1"); } @AUtowired privado Cachemanager Cachemanager; @Override @Cachable (Cachenames = "Test") public String get (ID de cadena) {// Registre el tiempo de generación de datos, utilizado para probar y comparar largo tiempo = nuevo date (). GetTime (); // Imprima el Cachemanager usado Logger.info ("El Cachemanager es" + Cachemanager); // Imprime el registro logger.info ("Get Value by id =" + id + ", el tiempo es" + tiempo); return "get value by id =" + id + ", el valor es" + entidades.get (id); } @Override public String Delete (ID de cadena) {return entity.remove (id); } @Override public String Save (ID de cadena, valor de cadena) {logger.info ("Guardar valor" + valor + "con la clave" + id); entidades.put (id, valor); valor de retorno; } @Override public String Update (ID de cadena, valor de cadena) {return entity.put (id, valor); }}cache
Primero, agregue la anotación @Cachable al método GET y ejecute la prueba de código.
Usamos Postman para probar, la dirección de prueba es http: // localhost: 8080/1, el navegador responde para obtener valor por id = 1, el valor es este No 1, la consola del servidor imprime dos líneas de registros
Obtener valor por id = 1, el valor es que no 1 obtiene valor por id = 1, el tiempo es 1516004770216
Pero cuando actualizamos nuevamente la dirección del navegador, el navegador regresa normalmente, pero la consola ya no se imprime. La razón es que cuando lo llamamos la segunda vez, Spring ya no ejecuta el método, sino que obtiene directamente el valor en caché. Spring Cache almacena el valor de retorno de la función como la clave en la prueba de caché llamado.
Aquí usamos la anotación @cachable, y los nombres de cachenaje en la anotación especifican qué caché se lee aquí. Aquí, buscaremos el objeto Cache cuya clave es ID en Cachename = "Test".
Eliminar datos en caché
En el programa anterior, si eliminamos el valor especificado a través de la solicitud de eliminación y enviamos la solicitud Eliminar a http: // localhost: 8080/1, en este momento, el valor se ha eliminado del mapa, pero cuando recibimos la solicitud a http: // localhost: 8080/1, aún podemos obtener el valor. Esto se debe a que cuando eliminamos los datos, no eliminamos los datos en el caché. En el método GET anterior, el resultado de la operación del método aún se guarda. Spring no lo volverá a leer, pero leerá directamente el caché. En este momento, agregamos anotaciones antes del método
@Anular@cacheEvict (cachenames = "test") public String Delete (ID de cadena) {return entity.remove (id);}Después de las pruebas, primero llame a la solicitud GET, el valor de retorno se mostrará correctamente como valor get por id = 1, el valor es 1
Luego llame a la solicitud de eliminación. Elimine los datos del caché y el mapa, y llame a la solicitud GET nuevamente. En este momento, el valor Get por id = 1, el valor es nulo, lo que significa que el valor se ha eliminado de la memoria caché.
Aquí usamos la anotación @CacheEvict. Cachenames especifica qué datos de caché se eliminarán. Por defecto, los parámetros del método se utilizarán como la clave eliminada.
Actualizar caché
Cuando el programa llega a este punto, si ejecutamos la solicitud posterior, el cuerpo de la solicitud es ID = 1 & Value = New1. En este momento, las impresiones de la consola guardan Valor New Value1 con la clave 1, y el código guardará el valor en el mapa, pero cuando ejecutemos la solicitud GET, encontraremos que el valor de retorno todavía está en el estado anterior. Esto es lo que podemos usar
@Anulación@cacheput (cachenames = "test", key = "#id") public string save (string id, string value) {logger.info ("guardar valor" + valor + "con clave" + id); devolver entidades.put (id, valor);}Vuelva a ejecutar el código, primero enviamos una solicitud de eliminación para eliminar los datos del mapa y el caché. Luego envíe una solicitud de publicación y escriba los datos al mapa. Finalmente, si envía una solicitud GET, encontrará que el valor se puede recuperar correctamente ahora, y la consola no imprime el registro de los datos obtenidos del mapa.
La anotación @Cacheput se usa aquí. La función de esta anotación es escribir el valor de retorno del método en el caché especificado por Cachenames de acuerdo con la clave dada.
Del mismo modo, necesitamos agregar la anotación @Cacheput al método PUT para que la modificación también pueda actualizar los datos en caché.
En este punto, se completa una aplicación de caché simple que incluye adición, eliminación, modificación y consulta.
3. Puntos clave
Algunas notas
Aviso
@Cacheable y @Cacheput pondrán el resultado de ejecución del método en el caché de acuerdo con la clave especificada. Cuando se ejecuta @Cacheable, primero detectará si hay datos en el caché. Si es así, se leerá directamente desde el caché. De lo contrario, ejecute el método y coloque el valor de retorno en el caché, @Cacheput ejecutará el método primero y luego escribirá el resultado de ejecución en el caché. El método que usa @cacheput definitivamente se ejecutará
El código de muestra completo está en https://github.com/ldwqh0/cache-test
Resumir
Lo anterior es el método de usar caché de caché en el arranque de primavera introducido por el editor. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!