Implementacja podstawowych wzorców buforowania

Welcome! In this lesson, we'll dive into two fundamental caching patterns: Cache-Aside and Write-Through. These patterns help you integrate Redis into your applications to store and retrieve data efficiently.

Understanding them is key to building responsive and scalable systems.

The Cache-Aside pattern is one of the most common ways to use a cache. Here, your application is responsible for managing both the cache and the primary data store (like a database).

• When reading data, the app first checks the cache.
• If found (a 'cache hit'), it returns the cached data.
• If not found (a 'cache miss'), it fetches the data from the database, stores it in the cache, and then returns it.

Imagine your app needs user data. Here's how Cache-Aside works:

1. App requests data: Checks Redis for user:123.
2. Cache Miss: Redis replies 'not found'.
3. App queries DB: Fetches user:123 from the database.
4. App updates cache: Stores user:123 in Redis.
5. App returns data: Provides data to the user.
6. Subsequent requests: Now, Redis will have user:123, leading to a fast 'cache hit'!

Let's simulate a Cache-Aside read flow using Redis CLI. First, we'll try to get a key that isn't in the cache (miss), then retrieve it from a conceptual database and store it. Finally, we'll get it again (hit).

Benefits:

• Simplicity: Easy to implement.
• Read-Heavy Workloads: Excellent for data that is read often but changes infrequently.
• Data Freshness: New data is added to cache only when requested, reducing cache pollution.

Drawbacks:

• Initial Latency: First read for any data always results in a cache miss, making it slower.
• Stale Data: If the database is updated directly, the cache might hold old data until it expires or is explicitly invalidated.

The Write-Through pattern ensures that data is written to both the cache and the primary data store (database) at the same time. The application writes to the cache, and the cache is responsible for writing that data to the database.

• When data is written, it goes to the cache first.
• The cache then immediately writes the data to the database.
• The write operation is only considered complete after both operations succeed.

Consider updating a product's price. Here's how Write-Through works:

1. App writes data: Sends new product price for product:202 to Redis.
2. Cache writes to DB: Redis immediately writes the same update to the database.
3. Cache acknowledges: Redis confirms the write to the application only after the database write is complete.
4. App continues: The application proceeds, knowing both cache and DB are consistent.

In Write-Through, your application typically performs a single write operation to the cache, and the cache (or a client library implementing the pattern) handles the database persistence. Here, we simulate setting a value which would conceptually also update the DB.

Benefits:

• Data Consistency: Cache and database are always in sync.
• Reliability: Data is immediately persistent.
• Simpler Reads: All reads are cache hits (assuming data is always written through).

Drawbacks:

• Write Latency: Writes are slower because data must be written twice (cache + database).
• Cache Pollution: Data written to the cache might never be read, wasting cache space.
• Increased Load: Every write operation incurs a database write, potentially increasing database load.

Great job! You've learned about two fundamental caching strategies:

• Cache-Aside: Your application manages the cache. Reads check cache first; on a miss, data is fetched from the DB, cached, and then returned. Best for read-heavy data.
• Write-Through: Writes go to the cache, which then immediately writes to the database. Ensures strong consistency between cache and DB.

These patterns form the basis for more advanced caching techniques you'll explore in future lessons!