PricingLoginStart free
Komplett guide til Spring Boot 4 · leksjon

Hurtigbufring i minnet med justering av Caffeine

Konfigurer Caffeine-policyer for utkastelse, utløp og størrelse for lokale hurtigbuffere med høy gjennomstrømming.

Leksjon 2 av 413 trinn

Hurtigbufring i minnet med justering av Caffeine er en gratis leksjon i Komplett guide til Spring Boot 4 på CoddyKit. Dette er leksjon 2 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.

Hvorfor Caffeine for lokale cacher

Caffeine er et Java-bibliotek for bufring med høy ytelse og nesten optimal effektivitet, og er Springs standard minnebaserte cache når det finnes på classpath.

  • Det bruker tømmingsstrategien Window TinyLFU, som gir bedre treffrater enn vanlig LRU i virkelige scenarier.
  • Det støtter tømming basert på størrelse, tid og referanser.
  • Det er fullt samtidig og låsefritt ved lesing, noe som passer godt for tjenester med høy gjennomstrømning.

I denne leksjonen skal de finjustere Caffeine-reglene for tømming, utløp og størrelse, slik at en lokal cache holder seg rask uten å bruke opp heapen.

Legge til Caffeine i en Spring Boot 4-app

Spring Boot konfigurerer Caffeine automatisk når både spring-boot-starter-cache- og caffeine-avhengighetene finnes.

Aktiver deretter bufring med @EnableCaching på en konfigurasjonsklasse. Metoder merket med @Cacheable vil bruke den Caffeine-baserte CacheManager.

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class CacheConfig {
    // CaffeineCacheManager is auto-configured
    // when com.github.ben-manes.caffeine:caffeine is on the classpath
}

Tømming basert på maksimal størrelse

Den vanligste strategien for en lokal cache er begrenset størrelse. Bruk maximumSize til å begrense antallet oppføringer; Caffeine tømmer de minst verdifulle oppføringene (Window TinyLFU) når grensen overskrides.

  • Velg en størrelse som får god plass i heapen, med tanke på størrelsen på verdiobjektene.
  • Tømming skjer ikke umiddelbart ved grensen; den skjer raskt, men asynkront.
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;

@Bean
public CaffeineCacheManager cacheManager() {
    CaffeineCacheManager manager = new CaffeineCacheManager("products");
    manager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(10_000)
            .recordStats());
    return manager;
}

Tømming basert på vekt

Når oppføringene varierer mye i størrelse, kan cachen begrenses etter vekt i stedet for antall. Oppgi en maximumWeight og en Weigher som returnerer kostnaden for hver oppføring.

  • De kan ikke kombinere maximumSize og maximumWeight i samme cache.
  • Vekter beregnes ved innsetting og oppdateres ikke senere.
import com.github.benmanes.caffeine.cache.Caffeine;

Caffeine.newBuilder()
        .maximumWeight(50_000_000) // ~50MB budget
        .weigher((String key, byte[] value) -> value.length)
        .build();

expireAfterWrite kontra expireAfterAccess

Tidsbasert utløp finnes i to varianter:

  • expireAfterWrite: Oppføringen utløper etter en fast varighet fra den ble opprettet eller sist erstattet. Dette passer best for data med et kjent ferskhetsintervall (for eksempel en pris som er gyldig i 5 minutter).
  • expireAfterAccess: Oppføringen utløper etter en viss tid fra siste lesing eller skriving. Dette passer best for å holde aktive data i live og fjerne inaktive oppføringer.

De kan kombinere begge; oppføringen utløper når den første av betingelsene inntreffer.

import com.github.benmanes.caffeine.cache.Caffeine;
import java.time.Duration;

Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(Duration.ofMinutes(5))
        .expireAfterAccess(Duration.ofMinutes(2))
        .build();

Konfigurere via application.properties

For én felles spesifikasjon lar Spring Boot Dem hoppe over Java-konfigurasjon og bruke egenskapen spring.cache.caffeine.spec. Den godtar Caffeine-spesifikasjonen som en kommaseparert streng.

Dette er praktisk, men bruker den samme spesifikasjonen for alle cache-navn. Justering per cache krever fortsatt en programmatisk CaffeineCacheManager eller en egendefinert CacheLoader.

spring.cache.type=caffeine
spring.cache.cache-names=products,prices
spring.cache.caffeine.spec=maximumSize=10000,expireAfterWrite=5m,recordStats

refreshAfterWrite for Stale-While-Revalidate

refreshAfterWrite skiller seg fra utløping: I stedet for å fjerne oppføringen laster den den inn på nytt asynkront etter tidsintervallet, samtidig som den gamle verdien fortsatt leveres. Dermed unngår De en latenstopp ved den første forespørselen etter at verdien er blitt foreldet.

  • Dette krever en LoadingCache (en cache som er bygget med en CacheLoader).
  • Bare én tråd utløser oppdateringen; de andre fortsetter å lese den eksisterende verdien.
  • Kombiner dette med en lengre expireAfterWrite som en absolutt øvre grense.
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import java.time.Duration;

LoadingCache<String, String> cache = Caffeine.newBuilder()
        .refreshAfterWrite(Duration.ofMinutes(1))
        .expireAfterWrite(Duration.ofMinutes(10))
        .build(key -> loadFromDatabase(key));

En frittstående Caffeine-demo

Her er et komplett program uten rammeverk som demonstrerer utkastelse med maximumSize. Sett inn flere oppføringer enn grensen, og se at cachen aldri overskrider størrelsen etter opprydding.

Dette er et eksempel på en mikrobenchmark De kan kjøre for å validere et justeringsvalg før De kobler det inn i Spring.

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

public class CaffeineDemo {
    public static void main(String[] args) {
        Cache<Integer, String> cache = Caffeine.newBuilder()
                .maximumSize(3)
                .build();

        for (int i = 0; i < 10; i++) {
            cache.put(i, "value-" + i);
        }
        cache.cleanUp(); // force pending eviction work

        System.out.println("Estimated size: " + cache.estimatedSize());
        System.out.println("Get key 9: " + cache.getIfPresent(9));
    }
}

Justering per cache med egendefinerte spesifikasjoner

Reelle tjenester trenger ulike strategier for hver cache: en liten tabell med hyppige oppslag kontra et stort datasett som ligger varmt i cachen. Utvid eller konfigurer CaffeineCacheManager slik at hvert navn får sin egen builder.

En ryddig fremgangsmåte er å registrere individuelle native cacher med navn i manageren.

import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import java.time.Duration;

@Bean
public CaffeineCacheManager cacheManager() {
    CaffeineCacheManager manager = new CaffeineCacheManager();
    manager.registerCustomCache("prices", Caffeine.newBuilder()
            .maximumSize(1_000)
            .expireAfterWrite(Duration.ofSeconds(30))
            .build());
    manager.registerCustomCache("catalog", Caffeine.newBuilder()
            .maximumSize(100_000)
            .expireAfterAccess(Duration.ofHours(1))
            .build());
    return manager;
}

Måle treffraten med recordStats

De kan ikke justere noe De ikke måler. Aktiver recordStats() for å eksponere CacheStats: antall treff, antall bom, antall utkastelser og gjennomsnittlig lastingskostnad.

  • En lav treffrate tyder på at cachen er for liten, eller at nøklene har for høy kardinalitet.
  • Mange utkastelser kombinert med mange bom betyr at maximumSize ikke gir arbeidssettet nok plass.
  • Spring Boots Micrometer-integrasjon publiserer disse som måleverdier når statistikk er aktivert.
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.stats.CacheStats;

public class StatsDemo {
    public static void main(String[] args) {
        Cache<String, Integer> cache = Caffeine.newBuilder()
                .maximumSize(2)
                .recordStats()
                .build();

        cache.put("a", 1);
        cache.getIfPresent("a"); // hit
        cache.getIfPresent("b"); // miss

        CacheStats stats = cache.stats();
        System.out.printf("hits=%d misses=%d rate=%.2f%n",
                stats.hitCount(), stats.missCount(), stats.hitRate());
    }
}

Unngå vanlige fallgruver ved justering

Her er noen fallgruver De bør være oppmerksom på ved høy gjennomstrømning:

  • Ubegrensede cacher: Bygg aldri en cache uten en grense for størrelse eller utløping, ellers risikerer De en OutOfMemoryError.
  • initialCapacity: Sett den nær forventet stabil størrelse for å unngå gjentatte størrelsesendringer i den lesetunge banen.
  • Soft/weak-referanser: softValues() knytter utkastelse til belastningen på GC, noe som er uforutsigbart. Foretrekk eksplisitte grenser for størrelse eller tid i cacher der latenstid er viktig.
  • refreshAfterWrite uten en loader: Dette har i praksis ingen effekt på en manuell cache.

Kort kontroll: Velge en utløpingsstrategi

De cacher produktpriser som oppstrømssystemet garanterer er gyldige i nøyaktig 5 minutter etter publisering. Det leses ofte, men De må aldri levere en pris som er eldre enn 5 minutter. Hvilken Caffeine-policy passer best?

Besvar den i den interaktive leksjonen

Oppsummering

De har justert Caffeine for lokal caching med høy gjennomstrømning i Spring Boot 4:

  • Størrelse: maximumSize for ensartede oppføringer, maximumWeight + Weigher for variabel kostnad.
  • Tid: expireAfterWrite for krav til ferskhet, expireAfterAccess for å beholde ofte brukte data; kombiner dem for å ha begge typer grenser.
  • Oppdatering: refreshAfterWrite på en LoadingCache for Stale-While-Revalidate uten latenstopper.
  • Konfigurasjon: spring.cache.caffeine.spec for én felles spesifikasjon, eller registerCustomCache for justering per cache.
  • Måling: Aktiver alltid recordStats(), og følg med på treffrate og antall utkastelser for å styre videre justering.
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 gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Hurtigbufring i minnet med justering av Caffeine» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Komplett guide til Spring Boot 4, inkludert «Hurtigbufring i minnet med justering av Caffeine», 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 «Hurtigbufring i minnet med justering av Caffeine»?

Konfigurer Caffeine-policyer for utkastelse, utløp og størrelse for lokale hurtigbuffere med høy gjennomstrømming. 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 2 av 4.

Hvor lang tid tar leksjonen «Hurtigbufring i minnet med justering av Caffeine»?

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

  1. Grunnleggende om Spring Cache-abstraksjonen
  2. Hurtigbufring i minnet med justering av Caffeine
  3. Distribuert hurtigbufring med Redis og TTL-er
  4. Cache-stampede, ugyldiggjøring og konsistens
← Tilbake til Komplett guide til Spring Boot 4