登录查看更多内容

How can you use the observer pattern in event-driven systems?

由人工智能和领英社区提供技术支持

Event-driven systems are a popular architectural style for building scalable, responsive, and decoupled applications. They rely on the communication of events between different components, such as services, modules, or objects, that react to changes in the system state or user actions. But how can you design your components to handle events effectively and avoid tight coupling or complex dependencies? One possible solution is to use the observer pattern, a well-known behavioral design pattern that defines a one-to-many relationship between a subject and multiple observers. In this article, you will learn what the observer pattern is, how it works, and how you can use it in event-driven systems.

此文章中的业界达人

由社区从 6 条内容中精选。了解更多

Yuvaraj Madheswaran

GM Financial

1 What is the observer pattern?

The observer pattern is a design pattern that allows an object, called the subject, to notify other objects, called the observers, about any changes in its state or behavior. The subject maintains a list of observers that register themselves to receive notifications, and the observers implement a common interface that defines how they react to the notifications. The subject does not need to know anything about the observers, and the observers do not need to know anything about the subject, except for its interface. This way, the observer pattern decouples the subject and the observers, and allows them to vary independently.

添加您的观点

2 How does the observer pattern work?

The observer pattern works by following four essential steps. Firstly, the subject offers a method or event that allows observers to subscribe or unsubscribe to notifications. Subsequently, observers must implement a method or handler that defines how they respond to the subject's notifications. The subject then changes its state or behavior and notifies all subscribed observers by calling their methods or triggering their handlers. Finally, the observers execute their logic based on the notification from the subject. For example, a subject representing a stock price and several observers displaying the stock price on different charts or widgets will have the subject expose an event for observers to subscribe to its price updates. The observers then implement a handler that updates their charts or widgets with the new price. When the subject changes its price, it notifies all subscribed observers by triggering their handlers, allowing them to update their charts or widgets with the new price.

添加您的观点

Paul Sweatte
(已编辑)
举报内容
The state of entities subscribing to the publisher are synchronized via the implementation, but syncing is controlled by each subscriber, so set clear expectations about latency, retry logic, caching and cache invalidation.

已翻译

赞

3 How can you use the observer pattern in event-driven systems?

The observer pattern is an ideal solution for event-driven systems, allowing components to exchange events without creating direct dependencies or coupling. This pattern can be used to facilitate a variety of scenarios, such as publishing and subscribing to events across different services or modules, creating custom events and handlers for specific domains or functionalities, and implementing the model-view-controller (MVC) pattern for user interfaces. For instance, in the MVC pattern, the model can act as a subject that notifies the view about any changes in the data, while the view can act as an observer that updates itself based on the notifications. The view can also act as a subject that notifies the controller about any user input, and the controller can act as an observer that updates the model based on the notifications.

添加您的观点

Paul Sweatte
举报内容
You can use the observer pattern through a library or by creating your own set of user defined functions. Otherwise, you can use a web service based on the observer pattern. The web service can be installed on your own server, in the cloud as a self-service installation, or in the cloud as a managed service.

已翻译

赞

4 What are the benefits of using the observer pattern in event-driven systems?

Implementing the observer pattern in event-driven systems can provide several advantages, such as improved scalability by allowing you to add or remove observers without affecting the subject, and enhanced responsiveness by allowing you to notify the observers asynchronously. It also increases modularity by encapsulating the logic of the subject and the observers in separate components, and supports extensibility by introducing new types of observers or subjects without modifying the existing ones. Additionally, it facilitates testing by enabling you to isolate and mock the subject and the observers, and verify their behavior independently.

添加您的观点

Paul Sweatte
举报内容
The pattern is more efficient than other more simplistic patterns on two levels. On a module level, it is more manageable than state management based on callbacks. On a network level, it is more efficient than polling.

已翻译

赞

5 What are the challenges of using the observer pattern in event-driven systems?

Using the observer pattern in event-driven systems can also pose some challenges, such as managing complexity due to a large number of observers or subjects, handling errors that arise from failures or exceptions in the subject or the observers, ensuring consistency between the subject and the observers, and maintaining performance by optimizing or balancing bottlenecks.

添加您的观点

Yuvaraj Madheswaran

GM Financial
举报内容
In high-throughput financial environments, performance optimization is a constant concern. When implementing event-driven systems, the overhead introduced by a large number of observers can become a bottleneck, impacting latency and throughput. For instance, in optimizing a real-time trading platform, we had to carefully balance the number of observers subscribed to market data feeds to avoid overwhelming the system with redundant updates. Techniques such as batching, caching, and asynchronous processing were employed to mitigate performance degradation.

已翻译

赞

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?

添加您的观点

Ramy Elanbaawy

Enterprise Integration Architect
举报内容
The observer pattern together with an event driven system can be used to efficiently manage cached data. Cached data can get be stored for too long (stale) or too short resulting into a wasted caching solution Using events plus observers can be used to refresh entries in the cache whenever a state is changed.

已翻译

赞
Paul Sweatte
举报内容
Replaying pubsub events in case of unhandled exceptions is important to ensure idempotency checks are working as expected. In addition, test code needs to take into consideration network, disk, and memory limits.

已翻译

赞

Application Development

+ 关注

给文章评分

我们借助人工智能创建了此文章。您认为这篇文章怎么样？

很棒不太好

举报此文章

查看全部

How can you use the observer pattern in event-driven systems?

1

2

3

4

5

6

1 What is the observer pattern?

2 How does the observer pattern work?

3 How can you use the observer pattern in event-driven systems?

4 What are the benefits of using the observer pattern in event-driven systems?

5 What are the challenges of using the observer pattern in event-driven systems?

6 Here’s what else to consider

Application Development

给文章评分

感谢您的反馈

更多Application Development相关文章

更多相关阅读内容