Spring Boot 4 Microservices & REST APIs · บทเรียน

กลยุทธ์แคชสำหรับไมโครเซอร์วิส

สำรวจและนำกลไกแคชอย่าง Redis มาใช้เพื่อเพิ่มประสิทธิภาพไมโครเซอร์วิส

บทเรียน 5 จาก 912 ขั้นตอน

กลยุทธ์แคชสำหรับไมโครเซอร์วิส เป็นบทเรียน Spring Boot 4 Microservices & REST APIs ฟรีบน CoddyKit นี่คือบทเรียนที่ 5 จากทั้งหมด 9 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Spring Boot 4 Microservices & REST APIs และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Spring Boot 4 Microservices & REST APIs มีบทเรียนทั้งหมด 9 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

Why Use Caching?

Imagine your microservice frequently fetches the same data from a database or another slow service. Each request means waiting, consuming resources, and slowing things down.

Performance Boost: Caching stores frequently accessed data closer to your application.
Reduced Load: Less pressure on databases and external services.
Faster Responses: Users experience quicker interactions.

Caching is a powerful technique for optimizing microservice performance.

Understanding Cache Basics

A cache is a temporary storage area that holds copies of data. When your application needs data, it first checks the cache.

Cache Hit: Data is found in the cache, retrieved quickly.
Cache Miss: Data is not in the cache, so it's fetched from the original source (e.g., database) and then stored in the cache for future use.

Think of it like remembering a phone number you dial often!

In-Memory vs. Distributed Cache

There are two main types of caches:

In-Memory Cache: Stored directly within a single application instance. Fast, but data is lost if the instance restarts, and not shared across multiple microservice instances.
Distributed Cache: A separate service (like Redis) that multiple microservice instances can connect to. Data is shared and persistent across instances, crucial for scalable microservices.

For microservices, distributed caching is usually preferred.

Introducing Redis for Caching

Redis (Remote Dictionary Server) is a popular, open-source, in-memory data store. It's often used as a distributed cache due to its speed and versatility.

Key-Value Store: Stores data as simple key-value pairs.
Blazingly Fast: Operations are very quick, often in microseconds.
Versatile: Supports various data structures like strings, hashes, lists, sets, and more.

It's an excellent choice for shared caching in a microservices architecture.

Spring Boot & Redis Setup

To integrate Redis with Spring Boot, you'll need the spring-boot-starter-data-redis dependency.

Add this to your pom.xml (Maven) or build.gradle (Gradle):

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Spring Boot auto-configures Redis if it finds a running instance (e.g., via Docker) or connection properties in application.properties.

Spring's Caching Magic

Spring Boot provides a powerful Cache Abstraction layer. This means you can add caching to your application with simple annotations, without directly interacting with Redis code.

To enable caching in your Spring Boot application, simply add the @EnableCaching annotation to your main application class:

@SpringBootApplication
@EnableCaching
public class MyServiceApplication { ... }

This tells Spring to look for caching annotations on your methods.

Reading from Cache: @Cacheable

The @Cacheable annotation is used on methods whose results you want to cache. When a method annotated with @Cacheable is called:

Spring checks if the result for the given arguments is already in the cache.
If found, the cached value is returned (cache hit).
If not found, the method is executed, its result is stored in the cache, and then returned (cache miss).

Specify a value (cache name) and optionally a key expression.

Live Demo: Caching Concept

This simple Java program demonstrates the core idea behind caching. Notice how the 'database' call count increases only for new IDs, while repeated calls retrieve data instantly from the 'cache'.

import java.util.HashMap;
import java.util.Map;

// A simple in-memory cache
class SimpleProductCache {
    private Map<String, String> cache = new HashMap<>();

    public String get(String key) {
        return cache.get(key);
    }

    public void put(String key, String value) {
        cache.put(key, value);
    }

    public void remove(String key) {
        cache.remove(key);
    }
}

class ProductFetcher {
    private SimpleProductCache productCache;
    private int dbCallCount = 0;

    public ProductFetcher(SimpleProductCache cache) {
        this.productCache = cache;
    }

    public String fetchProductName(String productId) {
        // Try to get from cache first
        String cachedName = productCache.get(productId);
        if (cachedName != null) {
            System.out.println("--> Retrieved '" + productId + "' from cache.");
            return cachedName;
        }

        // If not in cache, simulate database call
        dbCallCount++;
        System.out.println("--> Fetching '" + productId + "' from database (Call #" + dbCallCount + ").");
        try {
            Thread.sleep(100); // Simulate delay
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        String productName = "Product " + productId + " Name";

        // Store in cache
        productCache.put(productId, productName);
        return productName;
    }
}

public class Main {
    public static void main(String[] args) {
        SimpleProductCache cache = new SimpleProductCache();
        ProductFetcher fetcher = new ProductFetcher(cache);

        System.out.println("--- First requests ---");
        System.out.println(fetcher.fetchProductName("A1"));
        System.out.println(fetcher.fetchProductName("B2"));

        System.out.println("\n--- Repeat requests ---");
        System.out.println(fetcher.fetchProductName("A1")); // Should be from cache
        System.out.println(fetcher.fetchProductName("B2")); // Should be from cache

        System.out.println("\n--- New request ---");
        System.out.println(fetcher.fetchProductName("C3")); // Should be from DB
    }
}

Updating Cache: @CachePut

Sometimes you want to update the cache with the result of a method call, even if the data was already in the cache. This is where @CachePut comes in.

@CachePut(value = "products", key = "#product.id")
public Product updateProduct(Product product) {
  // ... update product in database ...
  return product;
}

Unlike @Cacheable, the method is always executed.
Its result is then placed into the cache.

Use it for methods that modify data and you want the cache to reflect the latest state.

Removing Stale Data: @CacheEvict

When data changes in your database, you need to remove the old, stale data from the cache. The @CacheEvict annotation handles this.

@CacheEvict(value = "products", key = "#id")
public void deleteProduct(String id) {
  // ... delete product from database ...
}

When this method is called, the entry for the specified key in the products cache will be removed.
You can also use allEntries = true to clear the entire cache.

Use it after delete or update operations to ensure data consistency.

Cache Strategy Quiz

You are building a microservice that manages customer data. Which caching strategy would you use for the following scenarios?

ตอบคำถามในบทเรียนแบบโต้ตอบ

Caching for Performance: Recap

Congratulations! You've learned about caching strategies for microservices.

Caching boosts performance and reduces database load.
Distributed caches like Redis are ideal for microservices.
Spring's Cache Abstraction simplifies caching with annotations.
Use @Cacheable for read-heavy operations.
Use @CachePut to update cached entries.
Use @CacheEvict to remove stale cache entries.

Mastering caching helps you build highly scalable and responsive microservices.

เริ่มต้นได้ฟรี

เรียนรู้ Java ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 24
บทเรียน: 93

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “กลยุทธ์แคชสำหรับไมโครเซอร์วิส” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “กลยุทธ์แคชสำหรับไมโครเซอร์วิส” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Spring Boot 4 Microservices & REST APIs ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Spring Boot 4 Microservices & REST APIs มีบทเรียนทั้งหมด 9 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “กลยุทธ์แคชสำหรับไมโครเซอร์วิส”

สำรวจและนำกลไกแคชอย่าง Redis มาใช้เพื่อเพิ่มประสิทธิภาพไมโครเซอร์วิส คุณปฏิบัติ Spring Boot 4 Microservices & REST APIs ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Spring Boot 4 Microservices & REST APIs หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Spring Boot 4 Microservices & REST APIs บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 5 จากทั้งหมด 9 บทเรียน

บทเรียน “กลยุทธ์แคชสำหรับไมโครเซอร์วิส” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Spring Boot 4 Microservices & REST APIs นี้ได้ไหม

ได้ บทเรียน Spring Boot 4 Microservices & REST APIs ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Spring Boot 4 Microservices & REST APIs