Komplett guide til Spring Boot 4 · leksjon

Bufring med Spring Cache

Implementer bufremekanismer ved hjelp av Spring sin `@Cacheable`-annotasjon og relaterte annotasjoner for å forbedre svartidene.

Leksjon 3 av 411 trinn

Bufring med Spring Cache er en gratis leksjon i Komplett guide til Spring Boot 4 på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Komplett guide til Spring Boot 4, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Komplett guide til Spring Boot 4 inneholder totalt 4 leksjoner.

Øk ytelsen med hurtigbufring!

Se for deg at appen stadig henter de samme dataene fra en treg database. Det kan gjøre appen langsom! Hurtigbufring er som å ha en supersnarvei til data som brukes ofte.

I stedet for å gå til databasen hver gang lagrer appen en kopi av dataene på et midlertidig sted med rask tilgang (hurtigbufferet). Når dataene etterspørres igjen, sjekkes hurtigbufferet først.

Raskere svar: Brukerne får dataene raskere.
Mindre belastning: Databasen eller eksterne tjenester belastes mindre.

Spring Cache: Enkelhet og kraft

Spring Framework tilbyr en fantastisk abstraksjon for hurtigbufring. Den forenkler integreringen av hurtigbufring i applikasjonene dine, slik at du slipper å skrive kompleks hurtigbufferlogikk selv.

Med Spring Cache kan du bruke enkle annotasjoner for å legge til hurtigbufferfunksjonalitet i metodene dine. Det støtter ulike underliggende hurtigbufferleverandører, som EhCache, Redis og Caffeine, slik at du enkelt kan bytte mellom dem uten å endre koden.

Kom i gang: Legge til avhengigheter

For å bruke Springs abstraksjon for hurtigbufring må du legge til avhengigheten spring-boot-starter-cache. Denne starteren tar med Springs infrastruktur for hurtigbufring og en enkel hurtigbufferbehandler i minnet som standard.

For en mer robust hurtigbuffer i minnet legger vi også til Caffeine, et Java-bibliotek for hurtigbufring med høy ytelse.

pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

Aktivere hurtigbufring og @Cacheable

Først må du aktivere hurtigbufring i Spring Boot-applikasjonen ved å legge til annotasjonen @EnableCaching i hovedklassen for applikasjonen eller i en konfigurasjonsklasse.

Deretter brukes annotasjonen @Cacheable på en metode for å angi at resultatet skal hurtigbufres. Første gang metoden kalles, lagres resultatet. Ved senere kall med de samme argumentene returneres det hurtigbufrede resultatet uten at metoden kjøres.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching // Enable caching for the app
public class CachingApp {
  public static void main(String[] args) {
    SpringApplication.run(CachingApp.class, args);
  }
}

@Cacheable i praksis: Tjenestelaget

La oss se @Cacheable på en tjenestemetode. Legg merke til attributtet cacheNames, som angir navnet på hurtigbufferet der resultatene skal lagres (for eksempel "products").

Når getProductById kalles, sjekker Spring hurtigbufferet "products". Hvis et produkt med denne ID-en finnes, returneres det. Ellers kjøres metoden (som simulerer et databasekall), og resultatet hurtigbufres.

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

// Imagine this is a simple data class
class Product {
  private Long id;
  private String name;
  public Product(Long id, String name) {
    this.id = id; this.name = name;
  }
  public Long getId() { return id; }
  public String getName() { return name; }
  @Override
  public String toString() {
    return "Product{" + id + ", " + name + "}";
  }
}

@Service
public class ProductService {
  @Cacheable(cacheNames = "products")
  public Product getProductById(Long id) {
    System.out.println(
      "Fetching product " + id + " from DB...");
    // Simulate a slow database call
    try { Thread.sleep(1000); } 
    catch (InterruptedException e) {}
    return new Product(id, "Product-" + id);
  }
}

// Main Application (from previous scene)
// Add a runner to demonstrate
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;

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

  @Bean
  public CommandLineRunner run(ProductService service) {
    return args -> {
      System.out.println("First call:");
      System.out.println(service.getProductById(1L));

      System.out.println("Second call (cached):");
      System.out.println(service.getProductById(1L));

      System.out.println("Third call (new ID):");
      System.out.println(service.getProductById(2L));
    };
  }
}

Holde hurtigbufferet oppdatert med @CachePut

Hva skjer hvis du oppdaterer et produkt? Den gamle versjonen kan fortsatt ligge i hurtigbufferet! Annotasjonen @CachePut brukes til å oppdatere hurtigbufferet med resultatet av en metodekjøring.

I motsetning til @Cacheable kjører @CachePut alltid metoden og legger deretter resultatet i hurtigbufferet. Dette passer perfekt for oppdateringsoperasjoner der du vil at hurtigbufferet skal gjenspeile de nyeste dataene.

import org.springframework.cache.annotation.CachePut;
import org.springframework.stereotype.Service;

// Product and CachingApp classes as before

@Service
public class ProductService {
  // ... getProductById as before ...

  @CachePut(cacheNames = "products", key = "#product.id")
  public Product updateProduct(Product product) {
    System.out.println(
      "Updating product " + product.getId() + " in DB...");
    // Simulate DB update
    try { Thread.sleep(500); } 
    catch (InterruptedException e) {}
    return product; // Return updated product
  }
}

// Main Application
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

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

  @Bean
  public CommandLineRunner run(ProductService service) {
    return args -> {
      System.out.println("--- @CachePut Demo ---");
      Product p1 = service.getProductById(1L); // Cached
      System.out.println("Fetched: " + p1);

      Product updatedP1 = new Product(1L, "Updated Product 1");
      service.updateProduct(updatedP1); // Updates cache
      System.out.println("Updated: " + updatedP1);

      Product p1AfterUpdate = service.getProductById(1L); // Fetches from updated cache
      System.out.println("After update: " + p1AfterUpdate);
    };
  }
}

// Product class (same as before)
class Product {
  private Long id;
  private String name;
  public Product(Long id, String name) {
    this.id = id; this.name = name;
  }
  public Long getId() { return id; }
  public String getName() { return name; }
  public void setName(String name) { this.name = name; }
  @Override
  public String toString() {
    return "Product{" + id + ", '" + name + "'}";
  }
}

Tømme hurtigbufferet med @CacheEvict

Når et element slettes, vil du fjerne det fra hurtigbufferet slik at foreldede data ikke blir levert ved et uhell. Annotasjonen @CacheEvict brukes til dette.

allEntries = true: Tømmer alle oppføringer i det angitte hurtigbufferet (for eksempel "products").
Uten allEntries = true: Tømmer en bestemt oppføring basert på metodens argumenter (for eksempel en bestemt produkt-ID).

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;

// Product and CachingApp classes as before

@Service
public class ProductService {
  // ... getProductById and updateProduct as before ...

  @CacheEvict(cacheNames = "products", key = "#id")
  public void deleteProduct(Long id) {
    System.out.println(
      "Deleting product " + id + " from DB...");
    // Simulate DB delete
    try { Thread.sleep(500); } 
    catch (InterruptedException e) {}
  }

  @CacheEvict(cacheNames = "products", allEntries = true)
  public void clearAllProductsCache() {
    System.out.println("Clearing all products from cache...");
  }
}

// Main Application
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

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

  @Bean
  public CommandLineRunner run(ProductService service) {
    return args -> {
      System.out.println("--- @CacheEvict Demo ---");
      service.getProductById(1L); // Cache product 1
      service.getProductById(2L); // Cache product 2

      System.out.println("Before delete: " + 
        service.getProductById(1L));
      service.deleteProduct(1L); // Evict product 1
      System.out.println("After delete, calling product 1 again:");
      service.getProductById(1L); // Will hit DB again

      System.out.println("Clearing all cache entries...");
      service.clearAllProductsCache();
      System.out.println("Calling product 2 after full clear:");
      service.getProductById(2L); // Will hit DB again
    };
  }
}

// Product class (same as before)
class Product {
  private Long id;
  private String name;
  public Product(Long id, String name) {
    this.id = id; this.name = name;
  }
  public Long getId() { return id; }
  public String getName() { return name; }
  public void setName(String name) { this.name = name; }
  @Override
  public String toString() {
    return "Product{" + id + ", '" + name + "'}";
  }
}

Navngi hurtigbuffere og egendefinerte nøkler

Hver hurtigbufringsannotasjon krever ett eller flere cacheNames (eller value) for å angi hvilken hurtigbuffer som skal brukes. Som standard genererer Spring automatisk hurtigbuffernøkler basert på metodeparametere.

Du kan imidlertid tilpasse nøkkelen ved hjelp av attributtet key, som godtar Spring Expression Language (SpEL). Dette gir detaljert kontroll over hvordan hurtigbufrede oppføringer identifiseres.

key = "#id": Bruker id-parameteren som hurtigbuffernøkkel.
key = "#product.id": Bruker egenskapen id i objektet product.

Konfigurere en hurtigbufferbehandler (Caffeine)

Spring Boot bruker som standard en enkel hurtigbufferbehandler i minnet. Hvis du trenger mer avanserte funksjoner, for eksempel tidsbasert fjerning eller maksimal størrelse, kan du konfigurere en bestemt CacheManager.

Slik konfigurerer du Caffeine, en populær høyytelses-hurtigbuffer i minnet, ved å opprette en CaffeineCacheManager-bean. Vi definerer en hurtigbuffer kalt "products" med en maksimal størrelse og utløp etter skriving.

import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;

@Configuration
public class CacheConfig {
  @Bean
  public CacheManager cacheManager() {
    CaffeineCacheManager cacheManager =
      new CaffeineCacheManager("products");
    cacheManager.setCaffeine(caffeineBuilder());
    return cacheManager;
  }

  Caffeine<Object, Object> caffeineBuilder() {
    return Caffeine.newBuilder()
      .initialCapacity(100)
      .maximumSize(500)
      .expireAfterWrite(10, TimeUnit.MINUTES)
      .recordStats();
  }
}

Rask sjekk: hurtigbufringsannotasjoner

Du har lært om de viktigste hurtigbufringsannotasjonene i Spring. La oss teste forståelsen din.

Besvar den i den interaktive leksjonen

Hurtigbufring: oppsummering

Du har lært hvordan du implementerer hurtigbufring i Spring Boot-applikasjonen din for å forbedre ytelsen betydelig!

Bruk @EnableCaching for å aktivere hurtigbufring.
@Cacheable hurtigbufrer resultatene fra metoder for raskere lesing.
@CachePut oppdaterer hurtigbufferoppføringer etter at metoden er kjørt.
@CacheEvict fjerner oppføringer fra hurtigbufferen.
Angi cacheNames, og bruk SpEL til å generere egendefinerte key-verdier.
Konfigurer en egendefinert CacheManager (for eksempel Caffeine) for mer avansert styring.

Ved å bruke disse annotasjonene på en gjennomtenkt måte kan du redusere belastningen på databasen og gi brukerne en raskere opplevelse.

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 21
Leksjoner: 84

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Bufring med Spring Cache» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Komplett guide til Spring Boot 4, inkludert «Bufring med Spring Cache», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Komplett guide til Spring Boot 4 inneholder totalt 4 leksjoner.

Hva lærer jeg i «Bufring med Spring Cache»?

Implementer bufremekanismer ved hjelp av Spring sin `@Cacheable`-annotasjon og relaterte annotasjoner for å forbedre svartidene. Du øver på Komplett guide til Spring Boot 4 med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Komplett guide til Spring Boot 4?

Ingen tidligere erfaring er nødvendig. Komplett guide til Spring Boot 4 på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Bufring med Spring Cache»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Komplett guide til Spring Boot 4-leksjonen?

Ja. Alle Komplett guide til Spring Boot 4-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Komplett guide til Spring Boot 4