Service-Oriented Modular Architecture Reducing Deployment Complexity
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Service-oriented architecture (SOA) systems face challenges with complex deployment and configuration, high resource consumption due to IPC communications, and difficulties in maintenance and extension due to high inter-dependence among components, while All-in-One (AIO) architectures simplify deployment but struggle with reusability and replaceability.
Innovation Solution
The service-oriented modular system architecture (μSOA) employs cross-platform plugins with hot-plugging and hot-unplugging capabilities, using API Nexus for dynamic interface registration and unregistration, and abstracts functions into pluggable business modules, allowing for simplified deployment and configuration, reduced IPC consumption, and improved maintainability.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If SOA divides application into independent services, then reusability and maintainability are improved, but deployment complexity and resource consumption increase
Solution Approach 1:
The patent merges multiple independent services into a single process address space, creating a hybrid architecture that combines SOA's service independence with AIO's deployment simplicity. Services communicate through shared memory instead of network IPC, reducing deployment complexity while maintaining service reusability.
Solution Approach 2:
The patent creates a universal service container that can host multiple services with different functions within a single process. This multi-functional container approach allows services to be reused across different applications while simplifying deployment infrastructure.
2Ease of manufacture
If AIO restricts application within separate unit, then deployment is simplified, but reusability and replaceability deteriorate
Solution Approach 1:
The patent segments the monolithic AIO architecture into independent service modules that can be dynamically loaded and unloaded within the single process space. Each service maintains its own code space and can be independently replaced or updated, preserving reusability while keeping deployment simple.
3Reliability
If SOA uses messaging middleware for service communication, then service independence is maintained, but throughput decreases and delays increase
Solution Approach 1:
The patent replaces the mechanical messaging middleware system with a shared memory communication mechanism. Services communicate directly through memory pointers and references, eliminating the overhead of message serialization, network transmission, and disk I/O while maintaining service independence through interface definitions.
4Reliability
If SOA implements cross-service distributed transactions, then consistency is achieved, but implementation complexity increases
Solution Approach 1:
The patent extracts the distributed transaction management complexity from the service implementation layer and handles it at the gateway level. The gateway coordinates transactions across services using simplified protocols, while services themselves remain unaware of distributed transaction mechanisms, reducing implementation complexity.
Data Source
AI summary
A service-oriented modular system architecture. The service-oriented modular system architecture has plugins and an application programming interface (API) Nexus. The plugins abstract different functions in servers into pluggable business modules. Any numbers of API dispatchers can be registered on the API Nexus so that one business module in the plugins dynamically exposes the services, which can be provided at present, to other business modules in the plugins in a manner of API. Different functions in the server application are independently abstracted into different pluggable business modules, the separating effect of respectively encapsulating and separating different functions to obtain subservices is achieved, and different business modules are allowed to expose interfaces with each other for use.