Please enable JavaScript.
Coggle requires JavaScript to display documents.
IMPLICIT ASYNCHRONOUS COMMUNICATION SOFTWARE ARCHITECTURE - Coggle Diagram
IMPLICIT ASYNCHRONOUS COMMUNICATION SOFTWARE ARCHITECTURE
Asynchronous implicit invocation communications
Two different modes:
Non-buffered
Buffered.
Also called publisher-subscriber or producer-consumer patterns
Non-Buffered Event-Based Implicit Invocations
The event registration process connects these two partitions.
There is no buffer available between these two parties.
The non-buffered event-based implicit invocation architecture breaks the software system into two partitions: Event sources and event listeners.
Observer pattern
The Observer pattern is another name used for this type of architecture.
Subscribers is an event listener and register themselves with the event source.
Once an event is fired off by an event source, all corresponding subscribers are notified, which then take corresponding actions.
Applicable Domain of Non-Buffered Event-Driven Architecture:
Benefits:
System maintenance and evolution: Easy to update both of event sources and targets.
Independency and flexible connectivity: Dynamic registration and deregistration can be done dynamically at run-time.
Reusability of components: Easy to plug-in new event handlers without affecting the rest of the system.
Framework availability: Many vendor APIs such as Java AWT and Swing components available.
Possibility of parallel execution of event handlings.
Limitations:
The event source cannot determine
Difficult to test and debug the system
Reliability and overhead of indirect invocations may be an issue.
There is more tight coupling between event sources and their listeners than in buffer-based implicit invocation.
Applicable Domain of Message-Based Architecture:
Benefits:
The message consumer does not know who produced the message (user independence), where the producer lives on the network (location independence), or when the message was produced (time independence).
Supporting for concurrency among consumers and between producer and consumers.
Providing high degree of anonymity between message producer and consumer.
Providing scalability and reliability of message delivery; reliability mechanisms include
Supporting batch processing.
Supporting loose coupling between message producers and consumers and between legacy systems and modern systems for integration development.
Limitations:
Increased complexity of the system design and implementation
A message receiver can still receive messages even if it is not running at the time the message was sent.
However, there is an absolute limit based on available memory. It is also difficult to determine the numbers of agents needed to satisfy the loose couplings between agents.
In an event-based invocation system the event handler must be ready in order to be able to intercept an event and take an action upon that event.
Complete separation of presentation and abstraction by control in each agent generate development complexity since communications between agents only take place between the control of agents.
This architectural style is commonly used in the connection between the Model sub-system and the View sub-system in an MVC or PAC architecture.
Capacity limit of message queue. This is not an inherent limitation but an implementation issue that can be eased if the queue is implemented as a dynamic data structure (e.g., linked lists).
Publish-Subscribe Messaging (P&S)
The P&S messaging architecture is a hub-like architecture, where publisher clients send messages to a message topic that acts like a bulletin board.
Message topic publishers and subscribers are not aware of each other.
One difference between P&S from P2P is that each topic message can have multiple consumers.
The system delivers the messages to all its multiple subscribers instead of single receiver as in the message queue system.
Buffered Message-Based Software Architecture
They are connected asynchronously by either a:message queue : one-to-one,message topic: one-to-many
This architecture is also considered data-centric.
The buffered message-based software architecture breaks the software system into three partitions:Message Producers,Message customers,Message service providers.
Point-to-Point Messaging (P2P)
The message queue architecture is a point-to-point structure between producer and consumer.
A P2P messaging architecture is composed of message queues, senders, and receivers.
Each message is sent to a destination (a specific queue) which is maintained by the consumer; consumer clients extract messages from these queues.