spring-boot
Caching met Redis Springveer gebruiken voor MongoDB

Waarom caching?

Tegenwoordig zijn prestaties een van de belangrijkste statistieken die we moeten evalueren bij het ontwikkelen van een webservice / applicatie. Klanten betrokken houden is van cruciaal belang voor elk product en om deze reden is het uiterst belangrijk om de prestaties te verbeteren en de laadtijden van pagina's te verminderen.

Bij het uitvoeren van een webserver die interacteert met een database, kunnen de activiteiten een knelpunt worden. MongoDB is hier geen uitzondering, en naarmate onze MongoDB-database opschaalt, kunnen dingen echt vertragen. Dit probleem kan zelfs erger worden als de databaseserver is losgekoppeld van de webserver. In dergelijke systemen kan de communicatie met de database een grote overhead veroorzaken.

Gelukkig kunnen we een methode genaamd caching gebruiken om dingen te versnellen. In dit voorbeeld introduceren we deze methode en kijken we hoe we deze kunnen gebruiken om de prestaties van onze applicatie te verbeteren met behulp van Spring Cache, Spring Data en Redis.

Het basissysteem

Als eerste stap bouwen we een eenvoudige webserver die gegevens opslaat in MongoDB. Voor deze demonstratie noemen we het "snelle bibliotheek". De server zal twee basisbewerkingen uitvoeren:

POST /book : dit eindpunt ontvangt de titel, de auteur en de inhoud van het boek en maakt een boekingang in de database.

GET /book/ {title} : dit eindpunt krijgt een titel en retourneert de inhoud. We gaan ervan uit dat titels op unieke wijze boeken identificeren (er zullen dus geen twee boeken met dezelfde titel zijn). Een beter alternatief zou natuurlijk zijn om een ID te gebruiken. Om het simpel te houden, gebruiken we gewoon de titel.

Dit is een eenvoudig bibliotheeksysteem, maar we zullen later meer geavanceerde mogelijkheden toevoegen.

Laten we nu het project maken met behulp van Spring Tool Suite (bouwen met behulp van eclipse) en springstarter Project

We bouwen ons project met behulp van Java en om te bouwen gebruiken we maven, selecteer waarden en klik op volgende

Selecteer MongoDB, Redis van NOSQL en Web van de webmodule en klik op voltooien. We gebruiken Lombok voor het automatisch genereren van Setters en getters van modelwaarden, dus we moeten de Lombok-afhankelijkheid toevoegen aan de POM

MongoDbRedisCacheApplication.java bevat de belangrijkste methode die wordt gebruikt om de Spring Boot Application toe te voegen

Maak een modelklasse-boek dat id, boektitel, auteur, beschrijving bevat en annoteer met @Data om automatische setters en getters te genereren uit jar project 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 maakt automatisch alle basis CRUD-bewerkingen voor ons, dus laten we BookRepository.Java maken die boek op titel vindt en boek verwijdert

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

Laten we webservicesController maken die gegevens opslaat in MongoDB en gegevens ophaalt via idTitle (@PathVariable String-titel).

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

De cache toevoegen Tot nu toe hebben we een eenvoudige bibliotheekwebservice gemaakt, maar deze is helemaal niet verbazingwekkend snel. In dit gedeelte proberen we de methode findBookByTitle () te optimaliseren door de resultaten in het cachegeheugen op te slaan.

Om een beter idee te krijgen van hoe we dit doel zullen bereiken, gaan we terug naar het voorbeeld van de mensen die in een traditionele bibliotheek zitten. Laten we zeggen dat ze het boek met een bepaalde titel willen vinden. Allereerst zullen ze rond de tafel kijken om te zien of ze het al daar hebben gebracht. Als ze dat hebben gedaan, is dat geweldig! Ze hebben zojuist een cache-hit gehad waarbij een item in de cache wordt gevonden. Als ze het niet hebben gevonden, hebben ze een cache missen, wat betekent dat ze het item niet in de cache hebben gevonden. In het geval van een ontbrekend item moeten ze het boek in de bibliotheek zoeken. Wanneer ze het vinden, bewaren ze het op hun tafel of plaatsen het in de cache.

In ons voorbeeld volgen we exact hetzelfde algoritme voor de methode findBookByTitle (). Wanneer om een boek met een bepaalde titel wordt gevraagd, zoeken we het op in de cache. Als het niet wordt gevonden, zoeken we het in de hoofdopslag, dat is onze MongoDB-database.

Redis gebruiken

Door spring-boot-data-redis toe te voegen aan ons klassepad, kan Spring Boot zijn magie uitvoeren. Het maakt alle benodigde bewerkingen door automatisch te configureren

Laten we nu de methode annoteren met de onderstaande regel om te cachen en Spring Boot zijn magie laten doen

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

Om uit de cache te verwijderen wanneer een record is verwijderd, maakt u een aantekening met de onderstaande regel in BookRepository en laat Spring Boot de cache verwijderen voor ons.

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

Om de gegevens bij te werken, moeten we de onderstaande regel aan de methode toevoegen en Spring Boot laten verwerken

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

Je kunt de volledige projectcode vinden op GitHub