This post looks at how applications components typically interact. Event-based programming, also called event-driven architecture (EDA) is an architectural style in which one or more components in a software system execute in response to receiving one or more event notifications.
1. Request-response interactions
Client formulate a request, It is sent across the internet to a web server. Client wait while the server constructs a response. This response is returned across the internet to client.
In a synchronous interaction the provider is expected to send a response back
2. Events and the principle of decoupling
Events are sometimes used to represent changes of state. The system being monitored is represented as a set of resources each of which is associated with state information. Event producers send events then internal state values change. This allows monitoring applications to be notified immediately when something happens, without their having to continually poll all the resources.
In a decoupled event processing system an event producer does not depend on a particular processing or course of action being taken by an event consumer. Moreover, an event consumer does not depend on processing performed by the producer other than the production of the event itself.
Above chart shows Decoupling of Entities from Object-Orientation to Event-Driven Architecture.
3. Push-style event interactions
In here events are often sent as one-way messages. It pushes the event to each consumer as a one-way message as below diagram. Event producer wait for a response from the consumer
4. Channel-based event distribution
In 3 model, producer has to send multiple copies of the same event to consumers. The event producer can find their identities by consulting an external information source.
5. Request-response interactions to distribute events
pull-style distribution, the consumer uses the standard
request-response pattern to request an event from a producer, or from an
intermediary channel.To avoid having to hold on to events and to avoid
having to service requests from multiple consumers, event consumer 1
sending a pull request directly to the event producer (message 1).
producer uses a regular push (message 3) to send the event to the channel, and consumer 2 requests it (message 3.1) from the channel. This approach can be extended to send multiple events in
the response messages.
Where is this useful
- A consumer that is only available occasionally
- A producer that is unable to distribute events
- A consumer that is physically unable to receive unsolicited incoming events(eg: due to firewall)
- A consumer that wants to regulate its processing of events and have control
over exactly when it receives them