spring-boot
Memorizzazione nella cache con Redis utilizzando Spring Boot per MongoDB

Perché il caching?

Oggi, le prestazioni sono una delle metriche più importanti che dobbiamo valutare durante lo sviluppo di un servizio / un'applicazione web. Mantenere i clienti coinvolti è fondamentale per qualsiasi prodotto e per questo motivo è estremamente importante migliorare le prestazioni e ridurre i tempi di caricamento della pagina.

Quando si esegue un server Web che interagisce con un database, le sue operazioni potrebbero diventare un collo di bottiglia. MongoDB non fa eccezione qui, e man mano che il nostro database MongoDB si ingrandisce, le cose possono davvero rallentare. Questo problema può persino peggiorare se il server del database è scollegato dal server web. In tali sistemi, la comunicazione con il database può causare un grande sovraccarico.

Fortunatamente, possiamo usare un metodo chiamato caching per velocizzare le cose. In questo esempio, introdurremo questo metodo e vediamo come possiamo utilizzarlo per migliorare le prestazioni della nostra applicazione utilizzando Spring Cache, Spring Data e Redis.

Il sistema di base

Come primo passo, costruiremo un server Web di base che memorizza i dati in MongoDB. Per questa dimostrazione, la chiameremo "fast Library". Il server avrà due operazioni di base:

POST /book : questo endpoint riceverà il titolo, l'autore e il contenuto del libro e creerà una voce di libro nel database.

GET /book/ {title} : questo endpoint otterrà un titolo e restituirà il suo contenuto. Supponiamo che i titoli identifichino in modo univoco i libri (quindi, non ci saranno due libri con lo stesso titolo). Un'alternativa migliore sarebbe, ovviamente, utilizzare un ID. Tuttavia, per semplificare le cose, utilizzeremo semplicemente il titolo.

Questo è un semplice sistema di libreria, ma aggiungeremo capacità più avanzate in seguito.

Ora, creiamo il progetto utilizzando Spring Tool Suite (generazione utilizzando eclipse) e Spring starter Project

Stiamo costruendo il nostro progetto usando Java e per costruire stiamo usando Maven, selezionare i valori e fare clic su Avanti

Seleziona MongoDB, Redis da NOSQL e Web dal modulo web e fai clic su Fine. Usiamo Lombok per la generazione automatica di setter e getter di valori di modello, quindi dobbiamo aggiungere la dipendenza di Lombok al POM

MongoDbRedisCacheApplication.java contiene il metodo principale che viene utilizzato per eseguire l'applicazione Spring Boot Application

Crea un class book Book che contiene id, titolo del libro, autore, descrizione e annotazione con @Data per generare setter e getter automatici dal progetto 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 automaticamente tutte le operazioni CRUD di base, quindi creiamo BookRepository.Java che trova il libro per titolo e cancella il 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);
}

Creiamo webservicesController che salva i dati su MongoDB e recupera i dati da idTitle (@PathVariable String title).

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;
    }
}

Aggiungere la cache Finora abbiamo creato un servizio web di libreria di base, ma non è affatto sorprendente. In questa sezione, cercheremo di ottimizzare il metodo findBookByTitle () memorizzando nella cache i risultati.

Per avere un'idea migliore di come raggiungeremo questo obiettivo, torniamo all'esempio delle persone che siedono in una biblioteca tradizionale. Diciamo che vogliono trovare il libro con un certo titolo. Prima di tutto, guarderanno intorno al tavolo per vedere se l'hanno già portato lì. Se hanno, è fantastico! Hanno appena avuto un colpo di cache che sta trovando un elemento nella cache. Se non l'hanno trovato, hanno avuto un errore di cache, nel senso che non hanno trovato l'elemento nella cache. Nel caso di un articolo mancante, dovranno cercare il libro nella biblioteca. Quando lo troveranno, lo terranno sul loro tavolo o lo inseriranno nella cache.

Nel nostro esempio, seguiremo esattamente lo stesso algoritmo per il metodo findBookByTitle (). Quando ti viene chiesto un libro con un certo titolo, lo cercheremo nella cache. Se non viene trovato, lo cercheremo nella memoria principale, ovvero il nostro database MongoDB.

Uso di Redis

L'aggiunta di spring-boot-data-redis al nostro percorso di classe consentirà all'avvio primaverile di eseguire la sua magia. Creerà tutte le operazioni necessarie mediante la configurazione automatica

Annotiamo ora il metodo con la riga sottostante nella cache e lasciamo che l'avvio a molla faccia la sua magia

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

Per eliminare dalla cache quando viene cancellato un record, annotare semplicemente con la riga sottostante in BookRepository e lasciare che Spring Boot gestisca l'eliminazione della cache per noi.

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

Per aggiornare i dati abbiamo bisogno di aggiungere la linea sottostante al metodo e lasciare che l'avvio di avvio gestisca

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

Puoi trovare il codice completo del progetto su GitHub