0Pricing
Spring Boot 4 Complete Guide · レッスン

Spring Cacheによるキャッシュ

Springの`@Cacheable`などのアノテーションを使用してキャッシュ機構を実装し、応答時間を短縮します。

「Spring Cacheによるキャッシュ」はCoddyKit上の無料Spring Boot 4 Complete Guideレッスンです。 これはレッスン3/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはSpring Boot 4 Complete Guide学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Spring Boot 4 Complete Guideコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Boost Performance with Caching!

Imagine your app constantly fetching the same data from a slow database. This can make it sluggish! Caching is like having a super-fast shortcut for frequently accessed data.

Instead of going to the database every time, the app stores a copy of the data in a temporary, quick-access location (the cache). When the data is requested again, it checks the cache first.

  • Faster Responses: Users get data quicker.
  • Reduced Load: Less strain on your database or external services.

Spring Cache: Simplicity & Power

Spring Framework provides an amazing abstraction for caching. It simplifies integrating caching into your applications, so you don't have to write complex caching logic yourself.

With Spring Cache, you can use simple annotations to apply caching behavior to your methods. It supports various underlying cache providers like EhCache, Redis, or Caffeine, letting you swap them out easily without changing your code.

Getting Started: Add Dependencies

To use Spring's caching abstraction, you need to add the spring-boot-starter-cache dependency. This starter brings in Spring's caching infrastructure and a simple in-memory cache manager by default.

For a more robust in-memory cache, we'll also add Caffeine, a high-performance Java caching library.

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>

Enable Caching & @Cacheable

First, you need to enable caching in your Spring Boot application by adding the @EnableCaching annotation to your main application class or a configuration class.

Then, the @Cacheable annotation is used on a method to indicate that its result should be cached. The first time the method is called, its result is stored. Subsequent calls with the same arguments will return the cached result without executing the method.

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 in Action: Service Layer

Let's see @Cacheable on a service method. Notice the cacheNames attribute, which specifies the name of the cache where results will be stored (e.g., "products").

When getProductById is called, Spring checks the "products" cache. If a product with that ID is found, it's returned. Otherwise, the method executes (simulating a database call), and its result is cached.

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

Keep Your Cache Fresh with @CachePut

What if you update a product? The old version might still be in the cache! The @CachePut annotation is used to update the cache with the result of a method execution.

Unlike @Cacheable, @CachePut always executes the method and then places the result into the cache. This is perfect for update operations where you want the cache to reflect the latest data.

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

Clearing Cache with @CacheEvict

When an item is deleted, you want to remove it from the cache so that no stale data is accidentally served. The @CacheEvict annotation is used for this.

  • allEntries = true: Clears all entries in the specified cache (e.g., "products").
  • Without allEntries = true: Clears a specific entry based on the method's arguments (e.g., a specific product 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 + "'}";
  }
}

Naming Caches & Custom Keys

Each caching annotation requires one or more cacheNames (or value) to specify which cache to use. Spring automatically generates cache keys based on method parameters by default.

However, you can customize the key using the key attribute, which accepts Spring Expression Language (SpEL). This gives you fine-grained control over how cached entries are identified.

  • key = "#id": Uses the id parameter as the cache key.
  • key = "#product.id": Uses the id property of the product object.

Configuring a Cache Manager (Caffeine)

Spring Boot uses a simple in-memory cache manager by default. For more advanced features like time-based eviction or maximum size, you can configure a specific CacheManager.

Here's how to configure Caffeine, a popular high-performance in-memory cache, by creating a CaffeineCacheManager bean. We define a cache named "products" with a maximum size and expiration after write.

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

Quick Check: Cache Annotations

You've learned about the core caching annotations in Spring. Let's test your understanding.

Caching Power-Up: Recap

You've successfully learned how to implement caching in your Spring Boot application to dramatically improve performance!

  • Use @EnableCaching to activate caching.
  • @Cacheable caches method results for faster reads.
  • @CachePut updates cache entries after method execution.
  • @CacheEvict removes entries from the cache.
  • Specify cacheNames and use SpEL for custom key generation.
  • Configure a custom CacheManager (like Caffeine) for advanced control.

By intelligently using these annotations, you can reduce database load and provide a snappier experience for your users.

よくある質問

「Spring Cacheによるキャッシュ」レッスンは無料ですか？

はい。「Spring Cacheによるキャッシュ」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Spring Boot 4 Complete Guideコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Spring Boot 4 Complete Guideコースには全4レッスンが含まれています。

「Spring Cacheによるキャッシュ」で何を学びますか？

Springの`@Cacheable`などのアノテーションを使用してキャッシュ機構を実装し、応答時間を短縮します。 ブラウザで直接実行するハンズオンコードでSpring Boot 4 Complete Guideを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Spring Boot 4 Complete Guideを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのSpring Boot 4 Complete Guideは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン3/4です。

「Spring Cacheによるキャッシュ」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このSpring Boot 4 Complete Guideレッスンでコードを書いて実行できますか？

はい。すべてのSpring Boot 4 Complete Guideレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. カスタムSpring Dataリポジトリ
  2. NoSQLデータベースの統合
  3. Spring Cacheによるキャッシュ
  4. Flywayによるデータベースマイグレーション
← Spring Boot 4 Complete Guideに戻る