事件驱动架构
探索 Redis 发布/订阅如何促进事件驱动的微服务通信和通知
事件驱动架构 是 CoddyKit 上的免费 Redis Caching & Messaging (Pub/Sub, Streams) 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Redis Caching & Messaging (Pub/Sub, Streams) 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Redis Caching & Messaging (Pub/Sub, Streams) 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
What is Event-Driven Architecture?
Welcome! In this lesson, we'll explore Event-Driven Architecture (EDA) and how Redis Pub/Sub is perfect for it.
EDA is a software design pattern where components communicate by reacting to changes in state, known as events.
- Think of it like a news channel: producers publish news (events), and anyone interested (consumers) can tune in.
Key Concepts of EDA
EDA revolves around three main components:
- Events: A record of something that happened (e.g., 'user registered', 'order placed'). They are immutable facts.
- Event Producers: Services that detect an event and publish it to an event channel.
- Event Consumers: Services that subscribe to event channels and react to specific events.
These components communicate indirectly.
Why Use EDA?
EDA offers significant benefits, especially for complex systems:
- Loose Coupling: Producers don't need to know about consumers, making services independent.
- Scalability: You can easily add new consumers without changing producers.
- Real-time Responsiveness: Events are processed as they occur, enabling immediate reactions.
- Flexibility: New features can be added by simply creating new consumers.
Redis Pub/Sub as the Event Bus
Redis Pub/Sub acts as an ideal event bus for EDA.
- An event bus is the central communication channel for events.
- In Redis, channels serve as these event buses.
Producers publish events to a Redis channel, and all interested consumers subscribed to that channel receive the event.
Decoupling Microservices
One of the biggest advantages of EDA with Redis Pub/Sub is decoupling microservices.
Imagine a user registration service. Without EDA, it might directly call an email service, a logging service, etc.
With EDA, the registration service just publishes a 'user registered' event. Email and logging services subscribe and react independently. This makes services easier to build and maintain!
Example: User Registration Event
Let's consider a practical scenario: a user registers on your application.
The User Service (producer) registers the user and then publishes a user:registered event to a Redis channel.
Other services, like a Notification Service or a Analytics Service (consumers), can then subscribe to this channel and perform their tasks.
Producer: Publishing an Event
Here's how a Python service might publish a user:registered event after a new user signs up. Make sure Redis is running!
import redis
import json
import time
r = redis.Redis(decode_responses=True)
def register_user(u_id, name, mail):
print(f"User {name} registering...")
event_data = {
"user_id": u_id,
"username": name,
"email": mail,
"timestamp": time.time()
}
r.publish("user_events", json.dumps(event_data))
print(f"Published 'user:registered' for {name}")
if __name__ == "__main__":
register_user("101", "alice", "alice@example.com")
time.sleep(0.5)
register_user("102", "bob", "bob@example.com")Consumer: Reacting to an Event
Now, let's see how a Notification Service (consumer) could subscribe to the user_events channel and send a welcome email.
Run this code in a separate terminal after starting the producer.
import redis
import json
import time
r = redis.Redis(decode_responses=True)
p = r.pubsub()
def send_welcome_email(user_data):
print(f"Sending email to {user_data['email']}")
time.sleep(0.3) # Simulate sending
print(f"Email sent to {user_data['username']}.")
if __name__ == "__main__":
print("Notification Service started.")
print("Subscribing to 'user_events'...")
p.subscribe('user_events')
for msg in p.listen():
if msg['type'] == 'message':
try:
data = json.loads(msg['data'])
print(f"Received: {data['username']}")
send_welcome_email(data)
except json.JSONDecodeError:
print(f"Error decoding: {msg['data']}")
time.sleep(0.01)Notifications & Real-time Updates
Beyond microservice communication, Redis Pub/Sub in an EDA is excellent for real-time notifications.
- Chat applications: Send new messages instantly to all participants.
- Live dashboards: Update metrics or status for users in real time.
- Alerts: Notify administrators of critical system events.
The immediate nature of Pub/Sub makes these scenarios simple to implement.
Quick Check: EDA with Redis
Which of the following best describes the role of Redis Pub/Sub in an Event-Driven Architecture?
Recap: EDA & Redis Pub/Sub
You've learned how Redis Pub/Sub is a powerful tool for building Event-Driven Architectures!
- EDA relies on events, producers, and consumers for communication.
- Redis Pub/Sub acts as an efficient event bus.
- It enables loose coupling and scalability for microservices.
- It's perfect for real-time notifications and inter-service communication.
This pattern makes your applications more resilient and flexible. Well done!
常见问题解答
「事件驱动架构」课时是免费的吗？
是的 — 「事件驱动架构」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Redis Caching & Messaging (Pub/Sub, Streams) 课程的其余内容，请升级到 CoddyKit PRO。 Redis Caching & Messaging (Pub/Sub, Streams) 课程共包含 4 节课。
「事件驱动架构」这节课中我会学到什么？
探索 Redis 发布/订阅如何促进事件驱动的微服务通信和通知 你通过在浏览器中直接运行的动手代码来练习 Redis Caching & Messaging (Pub/Sub, Streams)，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Redis Caching & Messaging (Pub/Sub, Streams) 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Redis Caching & Messaging (Pub/Sub, Streams) 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。
「事件驱动架构」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Redis Caching & Messaging (Pub/Sub, Streams) 课中编写并运行代码吗？
能。每节 Redis Caching & Messaging (Pub/Sub, Streams) 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。
此课程中的所有课时
- 按模式匹配订阅
- 设计实时聊天
- 事件驱动架构
- 在线状态与在线用户跟踪