Caché Redis de Spring Boot

Caché Redis de Spring Boot

En esta publicación, configuraremos una aplicación de arranque Spring de muestra y la integraremos con Redis Cache. Si bien Redis es un almacén de estructuras de datos en memoria de código abierto que se utiliza como base de datos, caché y agente de mensajes, esta lección solo demostrará la integración del almacenamiento en caché. Usaremos la herramienta Spring Initializr para configurar rápidamente el proyecto.

Configuración del proyecto Redis de Spring Boot

Usaremos la herramienta Spring Initializr para configurar rápidamente el proyecto. Usaremos 3 dependencias como se muestra a continuación: Descargue el proyecto y descomprímalo. Hemos usado la dependencia de base de datos H2 ya que usaremos una base de datos incorporada que pierde todos los datos una vez que se detiene la aplicación.

Dependencias de Maven de Spring Boot Redis Cache

Aunque ya completamos la configuración con la herramienta, si desea configurarla manualmente, usamos el sistema de compilación Maven para este proyecto y estas son las dependencias que usamos:

parent  groupIdorg.springframework.boot/groupId  artifactIdspring-boot-starter-parent/artifactId  version1.5.9.RELEASE/version  relativePath/ !-- lookup parent from repository --/parentproperties  project.build.sourceEncodingUTF-8/project.build.sourceEncoding  project.reporting.outputEncodingUTF-8/project.reporting.outputEncoding  java.version1.8/java.version/propertiesdependencies  dependency     groupIdorg.springframework.boot/groupId     artifactIdspring-boot-starter-data-redis/artifactId  /dependency  dependency     groupIdorg.springframework.boot/groupId     artifactIdspring-boot-starter-web/artifactId  /dependency  dependency     groupIdorg.springframework.boot/groupId     artifactIdspring-boot-starter-test/artifactId     scopetest/scope  /dependency  !-- for JPA support --  dependency    groupIdorg.springframework.boot/groupId    artifactIdspring-boot-starter-data-jpa/artifactId  /dependency  !-- for embedded database support --  dependency    groupIdcom.h2database/groupId    artifactIdh2/artifactId    scoperuntime/scope  /dependency/dependenciesbuild  plugins     plugin        groupIdorg.springframework.boot/groupId        artifactIdspring-boot-maven-plugin/artifactId     /plugin  /plugins/build

Asegúrese de utilizar la versión estable de Spring Boot desde maven central .

Definición del modelo

Para guardar un objeto en la base de datos de Redis, definimos un objeto de modelo Persona con campos básicos:

package com.journaldev.rediscachedemo;import javax.persistence.*;import java.io.Serializable;@Entitypublic class User implements Serializable {    private static final long serialVersionUID = 7156526077883281623L;    @Id    @SequenceGenerator(name = "SEQ_GEN", sequenceName = "SEQ_USER", allocationSize = 1)    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_GEN")    private Long id;    private String name;    private long followers;    public User() {    }    public User(String name, long followers) {        this.name = name;        this.followers = followers;    }    //standard getters and setters    @Override    public String toString() {        return String.format("User{id=%d, name='%s', followers=%d}", id, name, followers);    }}

Es un POJO estándar con captadores y definidores.

Configuración de la caché de Redis

Con Spring Boot y la dependencia requerida ya funcionando con Maven, podemos configurar la instancia local de Redis con solo tres líneas en nuestro archivo application.properties como:

# Redis Configspring.cache.type=redisspring.redis.host=localhostspring.redis.port=6379

Además, utilice la @EnableCachinganotación en la clase principal de Spring Boot:

package com.journaldev.rediscachedemo;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.CommandLineRunner;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.cache.annotation.EnableCaching;@SpringBootApplication@EnableCachingpublic class Application implements CommandLineRunner {  private final Logger LOG = LoggerFactory.getLogger(getClass());  private final UserRepository userRepository;  @Autowired  public Application(UserRepository userRepository) {    this.userRepository = userRepository;  }  public static void main(String[] args) {    SpringApplication.run(Application.class, args);  }  @Override  public void run(String... strings) {    //Populating embedded database here    LOG.info("Saving users. Current user count is {}.", userRepository.count());    User shubham = new User("Shubham", 2000);    User pankaj = new User("Pankaj", 29000);    User lewis = new User("Lewis", 550);    userRepository.save(shubham);    userRepository.save(pankaj);    userRepository.save(lewis);    LOG.info("Done saving users. Data: {}.", userRepository.findAll());  }}

Hemos agregado un CommandLineRunner ya que queremos completar algunos datos de muestra en la base de datos H2 incorporada.

Definición del repositorio

Antes de mostrar cómo funciona Redis, simplemente definiremos un repositorio para la funcionalidad relacionada con JPA:

package com.journaldev.rediscachedemo;import org.springframework.data.jpa.repository.JpaRepository;import org.springframework.stereotype.Repository;@Repositorypublic interface UserRepository extends JpaRepository { }

No tiene llamadas a métodos por ahora ya que no necesitamos ninguna.

Definición del controlador

Los controladores son el lugar donde se solicita la acción de la caché de Redis. En realidad, este es el mejor lugar para hacerlo porque, como una caché está directamente asociada a ella, la solicitud ni siquiera tendrá que ingresar el código de servicio para esperar los resultados almacenados en caché. Aquí está el esqueleto del controlador:

package com.journaldev.rediscachedemo;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.cache.annotation.CacheEvict;import org.springframework.cache.annotation.CachePut;import org.springframework.cache.annotation.Cacheable;import org.springframework.web.bind.annotation.*;@RestControllerpublic class UserController {  private final Logger LOG = LoggerFactory.getLogger(getClass());  private final UserRepository userRepository;  @Autowired  public UserController(UserRepository userRepository) {    this.userRepository = userRepository;  }   ...}

Ahora, para poner algo en el caché, usamos @Cacheablela anotación:

@Cacheable(value = "users", key = "#userId", unless = "#result.followers  12000")@RequestMapping(value = "/{userId}", method = RequestMethod.GET)public User getUser(@PathVariable String userId) {  LOG.info("Getting user with ID {}.", userId);  return userRepository.findOne(Long.valueOf(userId));}

En la asignación anterior, getUserel método colocará a una persona en un caché llamado “usuarios”, identifica a esa persona por la clave “userId” y solo almacenará un usuario con más de 12000 seguidores. Esto garantiza que el caché se complete con usuarios que son muy populares y que se consultan con frecuencia. Además, hemos agregado intencionalmente una declaración de registro en la llamada API. Hagamos algunas llamadas API desde Postman en este momento. Estas son las llamadas que hicimos:

localhost:8090/1localhost:8090/1localhost:8090/2localhost:8090/2

Si nos fijamos en los registros, estos serán:

... : Getting user with ID 1.... : Getting user with ID 1.... : Getting user with ID 2.

¿Observa algo? Hicimos cuatro llamadas a la API, pero solo había tres declaraciones de registro. Esto se debe a que el usuario con ID 2 tiene 29 000 seguidores y, por lo tanto, sus datos se almacenaron en caché. Esto significa que cuando se realizó una llamada a la API, los datos se devolvieron desde la memoria caché y no se realizó ninguna llamada a la base de datos para esto.

Actualizando la caché

Los valores de la memoria caché también deben actualizarse siempre que se actualicen los valores de los objetos reales. Esto se puede hacer mediante la anotación @CachePut :

@CachePut(value = "users", key = "#user.id")@PutMapping("/update")public User updatePersonByID(@RequestBody User user) {  userRepository.save(user);  return user;}

Con esto la persona queda nuevamente identificada con su DNI y se actualiza con los resultados.

Borrar caché

Si se eliminan algunos datos de la base de datos actual, ya no tendrá sentido mantenerlos en caché. Podemos borrar los datos de la caché mediante @CacheEvictuna anotación:

@CacheEvict(value = "users", allEntries=true)@DeleteMapping("/{id}")public void deleteUserByID(@PathVariable Long id) {  LOG.info("deleting person with id {}", id);  userRepository.delete(id);}

En el último mapeo, simplemente eliminamos las entradas de caché y no hicimos nada más.

Ejecución de la aplicación Spring Boot Redis Cache

Podemos ejecutar esta aplicación simplemente usando un solo comando:

mvn spring-boot:run

Límites de caché de Redis

Aunque Redis es muy rápido, no tiene límites para almacenar cualquier cantidad de datos en un sistema de 64 bits. Solo puede almacenar 3 GB de datos en un sistema de 32 bits. Una mayor cantidad de memoria disponible puede resultar en una mayor tasa de aciertos, pero esto tenderá a desaparecer una vez que Redis ocupe demasiada memoria. Cuando el tamaño de la caché alcanza el límite de memoria, los datos antiguos se eliminan para dejar lugar a los nuevos.

Resumen

En esta lección, vimos qué poder nos brinda Redis Cache para una rápida interacción con los datos y cómo podemos integrarlo con Spring Boot con una configuración mínima pero potente. No dudes en dejar tus comentarios a continuación.

Descargar el proyecto Spring Boot Redis Cache