Gängige Caching-Patterns

Welcome! In this lesson, we'll explore common caching patterns. These patterns are structured ways your application interacts with a cache to improve performance and manage data.

Think of them as blueprints for how data flows between your application, the cache, and the main data store (like a database).

Cache-Aside (also known as Lazy Loading) is a very popular caching pattern. In this approach, your application is responsible for directly managing the cache.

• The application checks the cache first for data.
• If data is found (a "cache hit"), it's returned immediately.
• If data is not found (a "cache miss"), the application fetches it from the database, stores it in the cache, and then returns it.

Here's how a read operation typically works with Cache-Aside:

// Pseudocode for reading data
function getData(key):
  data = cache.get(key)
  if data is null:
    data = database.get(key)
    cache.put(key, data)
  return data

This ensures the cache only stores data that is actually requested, saving memory for less frequently accessed items.

When data is updated in a Cache-Aside pattern, the application first writes to the database, then invalidates (removes) the corresponding entry from the cache.

// Pseudocode for writing data
function updateData(key, newData):
  database.update(key, newData)
  cache.invalidate(key) // Remove from cache
  return success

By invalidating, the next read request for this data will be a cache miss, forcing it to fetch the fresh data from the database and update the cache.

With the Read-Through pattern, the cache acts as an intermediary for all read requests. The application doesn't directly interact with the database for reads.

• The application requests data from the cache.
• If the cache has the data (hit), it returns it.
• If the cache doesn't have it (miss), the cache itself fetches the data from the database, stores it internally, and then returns it to the application.

The application only talks to the cache, simplifying its logic.

While similar in read behavior, the key difference is who fetches on a miss:

• Cache-Aside: Application handles the cache miss and fetches from the database.
• Read-Through: The cache provider (e.g., a caching library or service) handles the miss and fetches from the database.

Read-Through often leads to cleaner application code as caching logic is centralized within the cache layer.

The Write-Through pattern ensures data consistency by writing data synchronously to both the cache and the database.

• The application writes data to the cache.
• The cache then immediately writes that same data to the database.
• Only after both operations succeed does the cache confirm the write to the application.

This guarantees that the cache and database are always in sync, but it can introduce higher write latency.

Write-Back (also called Write-Behind) prioritizes write performance. When the application writes data:

• The data is written to the cache immediately, and the cache confirms success to the application.
• The write to the underlying database happens asynchronously in the background at a later time.

This offers very low write latency but carries a risk of data loss if the cache fails before data is persisted to the database.

Selecting a pattern depends on your needs:

• Cache-Aside: Good for read-heavy workloads where stale data is acceptable for a short period after writes. App controls complexity.
• Read-Through: Simplifies app code for reads; cache handles database interaction.
• Write-Through: Ensures strong consistency between cache and DB; higher write latency.
• Write-Back: Best for high-volume, low-latency writes; risk of data loss on cache failure.

Your e-commerce application needs to display product details. Reads are frequent, but updates are less common. You want to minimize database load for reads and ensure that when a product is updated, the cache reflects the change for subsequent reads without delay. Which pattern best fits the read and write requirements?

Great job! You've learned about essential caching patterns:

• Cache-Aside: Application manages cache, lazy loading, write-through invalidation.
• Read-Through: Cache acts as data source, fetches from DB on miss.
• Write-Through: Synchronous writes to cache and DB for consistency.
• Write-Back: Asynchronous writes to DB for performance, higher risk.

Each pattern has its strengths; choose wisely based on your application's needs for read/write frequency, consistency, and latency.