Caching Strategies: Redis + CDN + Edge Computing · 课时

用于缓存的 Redis 数据结构

探索如何有效利用 Redis 的字符串、哈希和有序集合等数据结构，应对不同的缓存场景

用于缓存的 Redis 数据结构 是 CoddyKit 上的免费 Caching Strategies: Redis + CDN + Edge Computing 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Caching Strategies: Redis + CDN + Edge Computing 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Caching Strategies: Redis + CDN + Edge Computing 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Redis Data Structures for Cache

Redis isn't just a simple key-value store! It offers a variety of powerful data structures, each optimized for different types of data and caching scenarios.

Understanding these structures is key to designing efficient and flexible caching solutions. You'll learn when to use strings, hashes, and sorted sets to store your application's data.

Strings for Basic Caching

The simplest Redis data type is a String. It's perfect for caching basic key-value pairs, like a user's session token, a page's HTML content, or a simple counter.

Think of it as a dictionary where keys map directly to a single value. It's fast and straightforward for common caching needs.

SET key value: Stores a string value.
GET key: Retrieves a string value.
DEL key: Removes a key and its value.

Caching User Session Data

Here's how you might cache a user's last login timestamp using a Redis string. Run this code to see it in action!

import redis
import time

r = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)

def main():
    user_id = "user:123"
    last_login_key = f"{user_id}:last_login"
    current_time = int(time.time())

    # Cache the current login time
    r.set(last_login_key, current_time)
    print(f"Cached last login for {user_id}: {current_time}")

    # Retrieve the cached login time
    cached_login = r.get(last_login_key)
    print(f"Retrieved cached last login: {cached_login}")

    # Clean up (optional)
    # r.delete(last_login_key)

if __name__ == "__main__":
    main()

Hashes for Object Caching

When you need to cache structured data, like an entire user profile or product details, Hashes are ideal. They let you store multiple field-value pairs under a single key.

This is more efficient than using separate string keys for each attribute of an object, as it groups related data logically together.

HSET key field value [field value ...]: Sets multiple fields and values in a hash.
HGETALL key: Retrieves all fields and values from a hash.
HGET key field: Retrieves a specific field's value.

Caching Product Information

Let's cache details for a product, like its name, price, and stock count. Run this code to see how hashes store structured data.

import redis

r = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)

def main():
    product_id = "product:456"
    
    # Cache product details as a Hash
    r.hset(product_id, mapping={
        "name": "Wireless Headphones",
        "price": "99.99",
        "stock": "500"
    })
    print(f"Cached product details for {product_id}")

    # Retrieve all product details
    product_details = r.hgetall(product_id)
    print(f"Retrieved product details: {product_details}")

    # Retrieve a specific field
    product_name = r.hget(product_id, "name")
    print(f"Retrieved product name: {product_name}")

    # Clean up (optional)
    # r.delete(product_id)

if __name__ == "__main__":
    main()

Sorted Sets: Ranked & Timed Data

Sorted Sets are unique because each member has an associated score, allowing Redis to keep the elements sorted. This is perfect for caching leaderboards, recently viewed items (by timestamp), or items ranked by popularity.

They combine the uniqueness of Sets with the ability to order elements. You can retrieve ranges of items by score or rank.

ZADD key score member [score member ...]: Adds members with scores.
ZRANGE key start stop [WITHSCORES]: Retrieves members by index (rank).
ZRANGEBYSCORE key min max [WITHSCORES]: Retrieves members by score range.

Caching a Game Leaderboard

Imagine caching a game's top scores. Sorted sets make this easy! The 'score' for each member determines its rank. Run the example.

import redis

r = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)

def main():
    leaderboard_key = "game:leaderboard"

    # Add players and their scores to the leaderboard
    r.zadd(leaderboard_key, {"Alice": 1500, "Bob": 1200, "Charlie": 1800, "David": 1500})
    print("Added players to leaderboard.")

    # Retrieve the top 3 players (highest score first)
    # ZREVRANGE is used for descending order by score
    top_players = r.zrevrange(leaderboard_key, 0, 2, withscores=True)
    print("Top 3 players:")
    for player, score in top_players:
        print(f"- {player}: {int(score)}") # scores are float by default

    # Clean up (optional)
    # r.delete(leaderboard_key)

if __name__ == "__main__":
    main()

Essential: Cache Expiration (TTL)

For any cached data, setting an expiration time (Time To Live - TTL) is crucial. This prevents stale data and manages memory usage.

Redis automatically removes keys once their TTL expires, ensuring your cache stays fresh and doesn't grow indefinitely.

EXPIRE key seconds: Sets a TTL for an existing key.
SETEX key seconds value: Sets a key with a value and a TTL in one command.
TTL key: Checks remaining TTL.

When to Use Which Structure?

Choosing the right data structure depends on your caching needs:

Strings: For simple, atomic key-value pairs (e.g., individual values, counters, rendered HTML snippets).
Hashes: For caching entire objects or records with multiple fields (e.g., user profiles, product attributes).
Sorted Sets: For ordered lists, rankings, leaderboards, or time-series data where elements need scores for sorting.

Always consider how you'll access and manage the data.

Caching Scenario Challenge

You need to cache the following two types of data for a social media application:

The current number of likes on a specific post.
A list of the 10 most recent comments on that post, ordered by timestamp.

Which Redis data structures would be most appropriate for each, respectively?

Redis Data Structures Recap

Great job! You've explored the core Redis data structures and their applications in caching:

Strings for simple key-value pairs.
Hashes for structured objects.
Sorted Sets for ordered, scored lists.

You also learned the importance of TTL for managing cache freshness.

In the next lesson, we'll dive into basic Redis cache operations, putting these structures to practical use!

常见问题解答

「用于缓存的 Redis 数据结构」课时是免费的吗？

是的 — 「用于缓存的 Redis 数据结构」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Caching Strategies: Redis + CDN + Edge Computing 课程的其余内容，请升级到 CoddyKit PRO。 Caching Strategies: Redis + CDN + Edge Computing 课程共包含 4 节课。

「用于缓存的 Redis 数据结构」这节课中我会学到什么？

探索如何有效利用 Redis 的字符串、哈希和有序集合等数据结构，应对不同的缓存场景你通过在浏览器中直接运行的动手代码来练习 Caching Strategies: Redis + CDN + Edge Computing，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Caching Strategies: Redis + CDN + Edge Computing 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Caching Strategies: Redis + CDN + Edge Computing 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「用于缓存的 Redis 数据结构」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Caching Strategies: Redis + CDN + Edge Computing 课中编写并运行代码吗？

能。每节 Caching Strategies: Redis + CDN + Edge Computing 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Caching Strategies: Redis + CDN + Edge Computing