Spring Boot 4:n kattava opas · Oppitunti

Välimuistin käyttö Spring Cachessa

Toteuttakaa välimuistimekanismeja Springin `@Cacheable`-annotaation ja siihen liittyvien annotaatioiden avulla vastausaikojen parantamiseksi.

Oppitunti 3/411 vaihetta

Välimuistin käyttö Spring Cachessa on ilmainen Spring Boot 4:n kattava opas-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Spring Boot 4:n kattava opas-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Spring Boot 4:n kattava opas-kurssilla on yhteensä 4 oppituntia.

Suorituskyvyn parantaminen välimuistilla!

Kuvittele, että sovelluksesi hakee jatkuvasti samoja tietoja hitaasta tietokannasta. Tämä voi tehdä sovelluksesta tahmean! Välimuisti on kuin erittäin nopea oikotie usein käytettyihin tietoihin.

Tietokantaan siirtymisen sijaan sovellus tallentaa tiedoista kopion väliaikaiseen, nopeasti käytettävään sijaintiin eli välimuistiin. Kun tietoja pyydetään uudelleen, sovellus tarkistaa ensin välimuistin.

Nopeammat vastaukset: Käyttäjät saavat tiedot nopeammin.
Pienempi kuormitus: Tietokanta tai ulkoiset palvelut kuormittuvat vähemmän.

Spring Cache: helppoutta ja tehokkuutta

Spring Framework tarjoaa tehokkaan abstraktion välimuistien käyttöön. Se yksinkertaistaa välimuistin integrointia sovelluksiisi, joten sinun ei tarvitse kirjoittaa monimutkaista välimuistilogiikkaa itse.

Spring Cachen avulla voit käyttää yksinkertaisia annotaatioita välimuistitoimintojen lisäämiseen metodeihin. Se tukee useita välimuistin taustalla toimivia toteutuksia, kuten EhCachea, Redisiä ja Caffeinea, joten voit vaihtaa niiden välillä helposti ilman koodin muuttamista.

Aloittaminen: riippuvuuksien lisääminen

Springin välimuistiabstraktion käyttämiseksi sinun on lisättävä spring-boot-starter-cache-riippuvuus. Tämä starter tuo oletusarvoisesti käyttöön Springin välimuisti-infrastruktuurin ja yksinkertaisen muistissa toimivan välimuistinhallinnan.

Vankempaa muistissa toimivaa välimuistia varten lisäämme myös Caffeinen, joka on suorituskykyinen Java-välimuistikirjasto.

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>

Välimuistin käyttöönotto ja @Cacheable

Ensin välimuisti on otettava käyttöön Spring Boot -sovelluksessa lisäämällä @EnableCaching-annotaatio sovelluksen pääluokkaan tai määritysluokkaan.

Sen jälkeen @Cacheable-annotaatiolla merkitään metodi, jonka tulos halutaan tallentaa välimuistiin. Kun metodia kutsutaan ensimmäisen kerran, sen tulos tallennetaan. Myöhemmät kutsut samoilla argumenteilla palauttavat välimuistissa olevan tuloksen suorittamatta metodia.

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 käytännössä: palvelukerros

Katsotaan @Cacheable-annotaation käyttöä palvelumetodissa. Huomaa cacheNames-attribuutti, joka määrittää sen välimuistin nimen, johon tulokset tallennetaan (esimerkiksi "products").

Kun getProductById-metodia kutsutaan, Spring tarkistaa "products"-välimuistin. Jos välimuistista löytyy kyseisen tunnisteen tuote, se palautetaan. Muussa tapauksessa metodi suoritetaan (simuloiden tietokantakutsua) ja sen tulos tallennetaan välimuistiin.

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

Pidä välimuisti ajan tasalla @CachePutilla

Mitä tapahtuu, jos päivität tuotteen? Välimuistissa saattaa edelleen olla vanha versio! @CachePut-annotaatiota käytetään välimuistin päivittämiseen metodin suorituksen tuloksella.

Toisin kuin @Cacheable, @CachePut suorittaa metodin aina ja tallentaa sen jälkeen tuloksen välimuistiin. Tämä sopii erinomaisesti päivitystoimintoihin, joissa haluat välimuistin vastaavan uusimpia tietoja.

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 + "'}";
  }
}

Välimuistin tyhjentäminen @CacheEvictillä

Kun kohde poistetaan, haluat poistaa sen myös välimuistista, jotta vanhentuneita tietoja ei vahingossa palauteta. Tähän käytetään @CacheEvict-annotaatiota.

allEntries = true: Tyhjentää kaikki tietyn välimuistin merkinnät (esimerkiksi "products").
Ilman asetusta allEntries = true: Poistaa tietyn merkinnän metodin argumenttien perusteella (esimerkiksi tietyn tuotetunnisteen).

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 + "'}";
  }
}

Välimuistien nimeäminen ja mukautetut avaimet

Jokainen välimuistimerkintä edellyttää vähintään yhtä cacheNames- tai value-arvoa sen määrittämiseksi, mitä välimuistia käytetään. Spring luo välimuistiavaimet oletusarvoisesti automaattisesti metodin parametrien perusteella.

Voitte kuitenkin mukauttaa avainta key-attribuutilla, joka hyväksyy Spring Expression Language (SpEL) -lausekkeita. Näin voitte hallita tarkasti, miten välimuistissa olevat merkinnät tunnistetaan.

key = "#id": Käyttää id-parametria välimuistiavaimena.
key = "#product.id": Käyttää product-olion id-ominaisuutta.

Välimuistinhallinnan määrittäminen (Caffeine)

Spring Boot käyttää oletusarvoisesti yksinkertaista muistipohjaista välimuistinhallintaa. Edistyneempiä ominaisuuksia, kuten aikaperusteista poistamista tai enimmäiskokoa, varten voitte määrittää tietyn CacheManager-olion.

Näin määritätte Caffeinen, suositun ja suorituskykyisen muistipohjaisen välimuistin, luomalla CaffeineCacheManager-pavun. Määritämme välimuistin nimeltä "products" sekä sille enimmäiskoon ja vanhenemisen kirjoituksen jälkeen.

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

Pikatarkistus: välimuistimerkinnät

Olette tutustuneet Springin keskeisiin välimuistimerkintöihin. Testataan, kuinka hyvin ymmärsitte asian.

Vastaa interaktiivisessa oppitunnissa

Välimuistin tehostartti: kertaus

Olette oppineet toteuttamaan välimuistinnin Spring Boot -sovelluksessa ja parantamaan suorituskykyä merkittävästi!

Käyttäkää @EnableCaching-merkintää välimuistinnin aktivoimiseen.
@Cacheable tallentaa metodien tulokset välimuistiin nopeampia lukuja varten.
@CachePut päivittää välimuistimerkinnät metodin suorituksen jälkeen.
@CacheEvict poistaa merkintöjä välimuistista.
Määrittäkää cacheNames ja käyttäkää SpEL-kieltä mukautettujen key-avainten luomiseen.
Määrittäkää mukautettu CacheManager (kuten Caffeine), jotta voitte hallita välimuistia edistyneemmin.

Käyttämällä näitä merkintöjä harkitusti voitte vähentää tietokantaan kohdistuvaa kuormitusta ja tarjota käyttäjille sujuvamman käyttökokemuksen.

Aloita maksutta

Opi Java tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 21
Oppitunnit: 84

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Välimuistin käyttö Spring Cachessa” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Spring Boot 4:n kattava opas-oppimispolun 3 oppituntia, myös oppitunnin “Välimuistin käyttö Spring Cachessa”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Spring Boot 4:n kattava opas-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Välimuistin käyttö Spring Cachessa”?

Toteuttakaa välimuistimekanismeja Springin `@Cacheable`-annotaation ja siihen liittyvien annotaatioiden avulla vastausaikojen parantamiseksi. Harjoittelet Spring Boot 4:n kattava opas-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Spring Boot 4:n kattava opas-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Spring Boot 4:n kattava opas-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”Välimuistin käyttö Spring Cachessa”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Spring Boot 4:n kattava opas-oppitunnilla?

Kyllä. Jokainen Spring Boot 4:n kattava opas-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Spring Boot 4:n kattava opas