spring-boot
Almacenamiento en caché con Redis usando Spring Boot para MongoDB

¿Por qué caching?

Hoy en día, el rendimiento es una de las métricas más importantes que debemos evaluar al desarrollar un servicio / aplicación web. Mantener a los clientes comprometidos es fundamental para cualquier producto y, por esta razón, es extremadamente importante mejorar el rendimiento y reducir los tiempos de carga de la página.

Al ejecutar un servidor web que interactúa con una base de datos, sus operaciones pueden convertirse en un cuello de botella. MongoDB no es una excepción aquí y, a medida que nuestra base de datos MongoDB se amplía, las cosas realmente pueden disminuir. Este problema puede empeorar incluso si el servidor de la base de datos se separa del servidor web. En tales sistemas, la comunicación con la base de datos puede causar una gran sobrecarga.

Afortunadamente, podemos usar un método llamado almacenamiento en caché para acelerar las cosas. En este ejemplo, presentaremos este método y veremos cómo podemos usarlo para mejorar el rendimiento de nuestra aplicación utilizando Spring Cache, Spring Data y Redis.

El sistema basico

Como primer paso, construiremos un servidor web básico que almacena datos en MongoDB. Para esta demostración, lo llamaremos "Biblioteca rápida". El servidor tendrá dos operaciones básicas:

POST /book : este punto final recibirá el título, el autor y el contenido del libro, y creará una entrada de libro en la base de datos.

GET /book/ {title} : este punto final obtendrá un título y devolverá su contenido. Asumimos que los títulos identifican de forma única los libros (por lo tanto, no habrá dos libros con el mismo título). Una mejor alternativa sería, por supuesto, usar una identificación. Sin embargo, para mantener las cosas simples, simplemente usaremos el título.

Este es un sistema de biblioteca simple, pero agregaremos habilidades más avanzadas más adelante.

Ahora, vamos a crear el proyecto utilizando Spring Tool Suite (compilación con eclipse) y el proyecto de inicio de primavera

Estamos construyendo nuestro proyecto usando Java y para construir estamos usando maven, seleccionamos valores y hacemos clic en siguiente

Seleccione MongoDB, Redis desde NOSQL y Web desde el módulo web y haga clic en Finalizar. Estamos utilizando Lombok para la generación automática de Setters y getters de valores de modelo, por lo que necesitamos agregar la dependencia de Lombok al POM

MongoDbRedisCacheApplication.java contiene el método principal que se utiliza para ejecutar la aplicación Spring Boot add

Cree un modelo de libro de clase que contenga id, título del libro, autor, descripción y anote con @Data para generar configuradores automáticos y captadores del proyecto jar lombok

package com.example;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.Indexed;
import lombok.Data;
@Data
public class Book {
    @Id
    private String id;
    @Indexed
    private String title;
    private String author;
    private String description;
}

Spring Data crea todas las operaciones básicas de CRUD para nosotros automáticamente, así que vamos a crear BookRepository.Java que encuentra libro por título y elimina libro

package com.example;
import org.springframework.data.mongodb.repository.MongoRepository;
public interface BookRepository  extends MongoRepository<Book, String>
{
    Book findByTitle(String title);
    void delete(String title);
}

Vamos a crear webservicesController que guarda los datos en MongoDB y recuperamos los datos por idTitle (título de la cadena de variable de la variable de usuario).

package com.example;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class WebServicesController {
    @Autowired
    BookRepository repository;
    @Autowired
    MongoTemplate mongoTemplate;
    @RequestMapping(value = "/book", method = RequestMethod.POST)
    public Book saveBook(Book book) 
    {
        return repository.save(book);
    }
    @RequestMapping(value = "/book/{title}", method = RequestMethod.GET)
    public Book findBookByTitle(@PathVariable String title) 
    {
        Book insertedBook = repository.findByTitle(title);
        return insertedBook;
    }
}

Agregar el caché Hasta ahora hemos creado un servicio web de biblioteca básico, pero no es sorprendentemente rápido. En esta sección, intentaremos optimizar el método findBookByTitle () almacenando en caché los resultados.

Para tener una mejor idea de cómo lograremos este objetivo, volvamos al ejemplo de las personas sentadas en una biblioteca tradicional. Digamos que quieren encontrar el libro con un título determinado. En primer lugar, mirarán alrededor de la mesa para ver si ya la han llevado allí. Si lo han hecho, eso es genial! Acaban de tener un hit de caché que está encontrando un elemento en el caché. Si no lo encontraron, tuvieron una falla de caché, lo que significa que no encontraron el elemento en el caché. En el caso de que falte un artículo, tendrán que buscar el libro en la biblioteca. Cuando lo encuentren, lo mantendrán en su mesa o lo insertarán en el caché.

En nuestro ejemplo, seguiremos exactamente el mismo algoritmo para el método findBookByTitle (). Cuando se le solicite un libro con un título determinado, lo buscaremos en el caché. Si no lo encuentra, lo buscaremos en el almacenamiento principal, que es nuestra base de datos MongoDB.

Usando redis

Agregar spring-boot-data-redis a nuestra ruta de clase permitirá que Spring Boot realice su magia. Creará todas las operaciones necesarias mediante la configuración automática.

Anotemos ahora el método con la siguiente línea para almacenar en caché y dejar que Spring Boot haga su magia

@Cacheable (value = "book", key = "#title")

Para eliminar de la memoria caché cuando se elimina un registro, simplemente haga una anotación con la línea inferior en BookRepository y deje que Spring Boot maneje la eliminación de la memoria caché por nosotros.

@CacheEvict (value = "book", key = "#title")

Para actualizar los datos, debemos agregar la siguiente línea al método y dejar que Spring Boot se maneje

@CachePut(value = "book", key = "#title")

Puedes encontrar el código completo del proyecto en GitHub