Caché de SpringBoot

El framework Spring proporciona caché de manera transparente en aplicaciones Spring. En Spring,Abstracción de cachéEs un mecanismo que permite usar consistentemente varios métodos de caché sin afectar el código.

Abstracción de caché

El mecanismo de abstracción de caché es adecuado para Métodos Java. El objetivo principal de usar la abstracción de caché es, según la información existente en la cachéReducciónVeces de ejecución. Se aplica a métodos costosos, como CPU o Ligado a IO.

Cada vez que se llama al método, la abstracción aplica el comportamiento de caché a ese método. Verifica si el método ya se ha ejecutado para los parámetros dados.

Si es así, no se ejecuta el método real y se devuelve el resultado de la caché.Si no, primero ejecuta este método, almacena el resultado en la caché y lo devuelve al usuario.

Los desarrolladores prestan atención a dos cosas al manejar la abstracción de caché.

Declaración de caché: Identifica los métodos que necesitan caché. Configuración de caché: Caché de respaldo para almacenar y leer datos.

caché

La caché es una parte de la memoria temporal (RAM). Se encuentra entre la aplicación y la base de datos persistente. Almacena los datos utilizados recientemente, reduciendo así al máximo el número de veces que se debe acudir a la base de datos. En otras palabras, la caché es para almacenar datos para futuras referencias.

¿Por qué usar la caché?

La razón principal para usar la caché es para acceder a los datos más rápido y más barato. Cuando se solicitan recursos altamente solicitados múltiples veces, para los desarrolladores, la caché de recursos suele ser beneficiosa, ya que puede proporcionar respuestas rápidas. El uso de caché en la aplicación puede mejorar el rendimiento de la aplicación. En comparación con obtener datos de la base de datos, el acceso a datos desde la memoria siempre es más rápido. Reduce los costos monetarios y los costos de oportunidad.

¿Qué datos deben cachearse?

Datos que no se cambian con frecuencia.Consultas de lectura utilizadas con frecuencia, cuyos resultados no cambian al menos durante un tiempo en cada llamada.

Tipos de caché

HayCuatroLos tipos de caché son los siguientes:

Caché en memoriael caché de la base de datos el caché del servidor web el mecanismo de caché de CDN

Caché en memoria

La caché en memoria puede mejorar el rendimiento de la aplicación. Este es el área utilizada con frecuencia. Memcached y Redis Es un ejemplo de caché en memoria. Almacena claves y valores entre la aplicación y la base de datos. Redis es unDistribuida en memoriaHerramienta de caché avanzada, utilizada para funciones de respaldo y restauración. También podemos gestionar la caché en clústeres distribuidos.

el caché de la base de datos

El caché de la base de datos es un mecanismo que genera páginas web dinámicamente (sobre demanda) al obtener datos de la base de datos. Desde la base de datos. En el contexto del cliente, el servidor de aplicación web y la base de datos,capasentornos. Al asignar el trabajo de consulta, mejoraescalabilidadyrendimiento. El caché de nivel uno más popular de la base de datos es el caché de Hibernate.

el caché del servidor web

El caché del servidor web es una forma de almacenar datos parareutilización. Por ejemplo, la copia de la página web proporcionada por el servidor web se almacena en caché cuando el usuario visita la página por primera vez. Si el usuario solicita nuevamente el mismo contenido, la caché proporciona una copia de la página. Esto evita la sobrecarga del servidor. El caché del servidor web puede acelerar la entrega de la página y reducir el trabajo que debe hacer el servidor backend.

el mecanismo de caché de CDN

CDN representared de entrega de contenido. Es un componente utilizado en aplicaciones web modernas. A través dereplicaciónarchivos comunes (por ejemplo, páginas HTML, hojas de estilo), lo que puede mejorar la transmisión del contenido. , JavaScript, imágenes, videos, etc.) se distribuyen en un grupo de copias en un grupo globalmente distribuidoel servidor de caché cercano.

por eso CDN es cada vez más popular. CDN alivia la carga de la fuente de la aplicación y mejora la experiencia del usuario. Se toma desdela orilla de la caché(más cerca del usuario final, el servidor de caché de caché) opunto de presencia (PoP)proporciona una copia local del contenido.

la caché y el buffer

las anotaciones de caché de Spring Boot

@EnableCaching

Esta es una anotación de nivel de clase. Podemos usar la anotación @EnableCaching habilita la caché en la aplicación de Spring Boot.En org.springframework.cache.annotation definidas en el paquete. Con él, @Configuration clases juntas.

Si no hay una instancia de CacheManager definida, la configuración automática habilitará la caché y configurará CacheManager Ela escanea proveedores específicos, y si no los encuentra, utiliza el HashMap crea la caché en la memoria.

Ejemplo

En el siguiente ejemplo: @EnableCaching La anotación habilita el mecanismo de caché.

@SpringBootApplication
@EnableCaching　
public class SpringBootCachingApplication　
{
public static void main(String[] args)　
{
SpringApplication.run(SpringBootCachingApplication.class, args);
}
}

@CacheConfig

Es una anotación de nivel de clase, que proporciona configuraciones comunes relacionadas con la caché. Indica a Spring dónde almacenar la caché de la clase. Cuando se añade una anotación a una clase utilizando la anotación, proporciona un conjunto de configuraciones predeterminadas para cualquier operación de caché definida en la clase. Con la anotación, no es necesario declarar varias veces.

Ejemplo

En el siguiente ejemplo,empleadoes el nombre de la caché.

@CacheConfig(cacheNames={"employee"})　
public class UserService
{
//alguno de código
}

@Caching

cuando necesitamos dos anotaciones @CachePut o @CacheEvict usando el mismo método. En otras palabras, cuando queremos usar múltiples anotaciones del mismo tipo, usamos.

pero Java no permite que se declaren múltiples anotaciones del mismo tipo para una declaración dadamétodo. Para evitar este problema, utilizamos @Caching anotación.

Ejemplo

En el siguiente ejemplo, hemos utilizado la anotación @Caching y todos @CacheEvict grupo de anotaciones.

@Caching(evict = {@CacheEvict("phone_number"), @CacheEvict(value="directory", key="#student.id")})public String getAddress(Student student)　
{
//alguno de código
}

@Cacheable

Es una anotación de nivel de método. Define una caché para el valor de retorno del método. El framework Spring gestiona las solicitudes y respuestas de la caché especificada en las propiedades de la anotación. La anotación @Cacheable contiene más opciones. Por ejemplo, podemos usar value o cacheNames del comentariopropiedad。

También podemos especificar clave propiedad, utilizada para identificar de manera única cada entrada en la caché. Si no se especifica la clave, Spring utilizará el mecanismo predeterminado para crear la clave.

Ejemplo

En el siguiente ejemplo, hemos almacenado en caché < cacheStudentInfo,y id método studentInfo()El valor de retorno es la clave única, utilizada para identificar la caché.

@Cacheable(value="cacheStudentInfo", key="#id")public List studentInfo()
{
//alguno de código　
return studentDetails;
}

También podemos aplicar condiciones utilizando la propiedad condition en los comentarios. Cuando aplicamos condiciones en los comentarios, se llamacaché condicional。

Por ejemplo, si la longitud del nombre del parámetro es más corta que20, entonces se cacheará el siguiente método.

@Cacheable(value="student", condición="#name.length<20)public Student findStudent(String name)
{
//alguno de código
}

@CacheEvict

es una anotación de nivel de método. Cuando queramos eliminar datos antiguos o no utilizados del caché, utilizaremos esta. Necesita una o más cachés afectados por la operación. También podemos especificar una clave o condiciones en ella. Si queremos una expulsión de caché amplia, la anotación @CacheEvict proporciona un nombre allEntries los parámetros.驱逐所有条目，而不是根据密钥驱逐一个条目。

Un punto importante sobre la anotación @CacheEvict es que puede utilizarse con métodos void, ya que actúa como disparador. Evita el retorno de valores. Por otro lado, la anotación @Cacheable necesita un valor de retorno, que se utiliza para agregar/Actualizar los datos en el caché. Podemos usar la anotación @CacheEvict de la siguiente manera:

expulsar todo el caché:

@CacheEvict(allEntries=true)

expulsar entradas mediante clave:

@CacheEvict(clave="#student.stud_name")

Ejemplo

Los siguientes métodos con anotaciones se extraen del caché student_data eliminar todos los datos.

@CacheEvict(value="student_data", allEntries=true)　//eliminar todas las entradas del caché
public String getNames(Student student)　
{
//alguno de código
}

@CachePut

es una anotación de nivel de método. Cuando queramosactualizarutilícelo cuando desee cachear sin interrumpir la ejecución del método. Esto significa que este método siempre se ejecutará y sus resultados se pondrán en el caché. Soporta las propiedades de la anotación @Cacheable.

Es importante tener en cuenta que debido a que los comportamientos de @Cacheable y @CachePut son diferentes, son diferentes. Hay una ligera diferencia entre @Cacheable y @CachePut, es decir, Cacheable Comentariossaltar la ejecución del métodomientras que @CachePut ComentariosEjecutar este métodoluego colocarán los resultados en el caché.

Ejemplo

Los siguientes métodos actualizarán el caché en sí.

@CachePut(cacheNames="employee", clave="#id")　　//actualizando cachepublic Employee actualizarEmp(ID id, EmployeeData data)
{
//alguno de código
}

dependencia de caché de Spring Boot

Si desea habilitar el mecanismo de caché en la aplicación Spring Boot, debe agregar la dependencia de caché al archivo pom.xml. Esto habilita la caché y configura el CacheManager.

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>

ejemplo de caché de Spring Boot

creamos una aplicación Spring Boot y implementamos el mecanismo de caché.

pasos1: abrir Spring Initializr http://start.spring.io 。

pasos2: seleccionar la versión de Spring Boot 2.3.0.M1。

pasos2: proporcionargruponombre. Hemos proporcionado com.w3codebox。

pasos3: proporcionarobra ID. Hemos proporcionado spring-boot-cache-ejemplo。

pasos5: añadir dependencias Spring Web y abstracción de Spring Cache.

pasos6: hacer clic Generar (generado) haciendo clic en el botón "generar", se empaquetará la especificación Jar archivo, y descárguelo en el sistema local.

pasos7: extraer un archivo Jar y péguelo en el área de trabajo de STS.

pasos8: importar carpeta de proyectos en STS.

archivo->importar->proyecto Maven existente->navegar->seleccionar carpeta spring-boot-cache-ejemplo->completado

la importación lleva un tiempo.

Vamos a abrir pom.xml archivo, echemos un vistazo a las dependencias que hemos añadido.

pom.xml

<?xml　version="1.0"　encoding="UTF-8"?>
<project　xmlns="http://maven.apache.org/POM/4.0.0"　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instancia
　　xsi:schemaLocation="http://maven.apache.org/POM/4.0.0　https://maven.apache.org/xsd/maven-4.0.0.xsd">
　　<modelVersion>4.0.0</modelVersion>
　　<parent>
　　　　<groupId>org.springframework.boot</groupId>
　　　　<artifactId>spring-boot-starter-parent</artifactId>
　　　　<version>2.3.0.M1</version>
　　　　<relativePath/>　<!--　buscar padre desde el repositorio　-->
　　</parent>
　　<groupId>com.w3codebox</groupId>
　　<artifactId>spring-boot-cache-ejemplo</artifactId>
　　<version>0.0.1-SNAPSHOT</version>
　　<name>spring-boot-cache-ejemplo</name>
　　<description>Proyecto de demostración para Spring Boot</description>
　　<properties>
　　　　<java.version>1.8</java.version>
　　</properties>
　　<dependencies>
　　　　<dependency>
　　　　　　<groupId>org.springframework.boot</groupId>
　　　　　　<artifactId>spring-boot-starter-cache</artifactId>
　　　　</dependency>
　　　　<dependency>
　　　　　　<groupId>org.springframework.boot</groupId>
　　　　　　<artifactId>spring-boot-starter-web</artifactId>
　　　　</dependency>
　　　　<dependency>
　　　　　　<groupId>org.springframework.boot</groupId>
　　　　　　<artifactId>spring-boot-starter-test</artifactId>
　　　　　　<scope>test</scope>
　　　　　　<exclusions>
　　　　　　　　<exclusion>
　　　　　　　　　　<groupId>org.junit.vintage</groupId>
　　　　　　　　　　<artifactId>junit-vintage-engine</artifactId>
　　　　　　　　</exclusion>
　　　　　　</exclusions>
　　　　</dependency>
　　</dependencies>
　　<build>
　　　　<plugins>
　　　　　　<plugin>
　　　　　　　　<groupId>org.springframework.boot</groupId>
　　　　　　　　<artifactId>spring-boot-maven-plugin</artifactId>
　　　　　　</plugin>
　　　　</plugins>
　　</build>
　　<repositories>
　　　　<repository>
　　　　　　<id>spring-milestones</id>
　　　　　　<name>Spring Milestones</name>
　　　　　　<url>https://repo.spring.io/milestone</url>
　　　　</repository>
　　</repositories>
　　<pluginRepositories>
　　　　<pluginRepository>
　　　　　　<id>spring-milestones</id>
　　　　　　<name>Spring Milestones</name>
　　　　　　<url>https://repo.spring.io/milestone</url>
　　　　</pluginRepository>
　　</pluginRepositories>
</project>

pasos9: abrir SpringBootCacheExampleApplication.java archivo, y añadiendo la anotación @EnableCaching habilita la caché.

SpringBootCacheExampleApplication.java
package　com.w3codebox;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
//habilitando el caché
@EnableCaching
public class SpringBootCacheExampleApplication　
{
public static void main(String[] args)　
{
SpringApplication.run(SpringBootCacheExampleApplication.class, args);
}
}

pasos10: En el nombre com.w3la carpeta codebox.model src/main/java Cree un paquete en

pasos11: En el paquete modelo, cree un nombre de Customer clases y definir el siguiente contenido:

definir tresaccountno, customername, acounttypeybalance。Usar Constructor para generarConstructor 。
Haga clic con el botón derecho en el archivo->Fuente->Usar campos para generar constructor->Seleccionar todo->GenerarGenerarGetters and Setters。
Haga clic con el botón derecho en el archivo->Fuente->Generar Getter y Setter->Seleccionar todo->Generar

Customer.java

package　com.w3codebox.model;
public class Customer　
{
　　　　private int accountno;
　　　　private String customername;
　　　　private String accounttype;
　　　　private double balance;
　　　　public Customer(int accountno, String customername, String accounttype, double balance)　
　　　　{
　　　　　　　　this.accountno = accountno;
　　　　　　　　this.customername = customername;
　　　　　　　　this.accounttype　=　accounttype;
　　　　　　　　this.balance　=　balance;
　　　　}
　　　　public int getAccountno()　
　　　　{
　　　　　　　　return accountno;
　　　　}
　　　　public void setAccountno(int accountno)　
　　　　{
　　　　　　　　this.accountno = accountno;
　　　　}
　　　　public String getCustomername()　
　　　　{
　　　　　　　　return customername;
　　　　}
　　　　public void setCustomername(String customername)　
　　　　{
　　　　　　　　this.customername = customername;
　　　　}
　　　　public　String　getAccounttype()　
　　　　{
　　　　　　　　return　accounttype;
　　　　}
　　　　public　void　setAccounttype(String　accounttype)　
　　　　{
　　　　　　　　this.accounttype　=　accounttype;
　　　　}
　　　　public　double　getBalance()　
　　　　{
　　　　　　　　return　balance;
　　　　}
　　　　public　void　setBalance(double　balance)　
　　　　{
　　　　　　　　this.balance　=　balance;
　　　　}
}

pasos11: en la carpeta src/main/java crea un paquete llamado com.w3codebox.controller

pasos12: en el paquete Controller, crea un paquete llamado CustomerController clase controladora, luego realiza las siguientes operaciones:

usar la anotación @RestController marca la clase como Controller 。 usar la anotación @RequestMapping define el controladormapeo。Hemos definido el mapeo/customerinfo 。crearcachépara usar la anotación @Cacheable para obtener los datos. Hemos utilizado la anotación value definimos el nombre de la caché de la propiedad.Estamosse agregaron dos detalles de información de cliente

CustomerController.java

package　com.w3codebox.controller;
import　java.util.Arrays;
import　java.util.List;
import　org.springframework.cache.annotation.Cacheable;
import　org.springframework.web.bind.annotation.RequestMapping;
import　org.springframework.web.bind.annotation.RestController;
import　com.w3codebox.model.Customer;
@RestController
public　class　CustomerController　
{
　　　　@RequestMapping("/customerinfo")
　　　　//define una caché para el valor de retorno del método
　　　　@Cacheable(value="customerInfo")
　　　　public　List　customerInformation()
　　　　{
　　　　　　　　System.out.println("información del cliente desde la caché");
　　　　　　　　//agregando detalles del cliente a la Lista
　　　　　　　　　　List　detail=Arrays.asList(new　Customer(5126890,"Charlie　Puth","Current　A/c",　450000.00),
　　　　　　　　　　　　　　　　　　　　　　　　new　Customer(7620015,"Andrew　Flintoff","Saving　A/c",　210089.00)
　　　　　　　　　　　　　　　　　　　　　　　);
　　　　　　　　return　detail;
　　　　}
}

Ahora ejecuta la aplicación.

pasos13: abrir SpringBootCacheExampleApplication.java archivo y ejecutarlo como aplicación Java.

pasos14: abrirPostman, y envía con la URL http: //locahost: 8080/custmerinfo de GET Solicitud. Regresa los detalles del cliente, como se muestra a continuación.