Universal Message Service Middleware With Dynamic Plug-in Parsers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing middleware software components require updates to both client and server applications whenever new messages or features are implemented, leading to maintenance challenges, especially when deployed across numerous devices.
Innovation Solution
The implementation of a universal message service (UMS) that interprets messages transparently and efficiently, using plug-in libraries to handle messages in various formats like XML, JDF, and JSON without needing to know the actual keywords, allowing seamless communication between server applications and destination devices.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If middleware software component is modified to support new messages, then new message functionality is enabled, but re-installation is required on all client devices
Solution Approach 1:
The middleware software is segmented into a core engine and separate message format modules (XML parser, JDF parser, JSON parser). Each message format is handled by an independent module that can be loaded dynamically. When new message formats are needed, only the corresponding module needs to be updated or added, not the entire middleware software, thus avoiding re-installation on client devices.
Solution Approach 2:
The middleware message interpreter is designed with universal parsing capabilities that can handle multiple message formats (XML, JDF, JSON) through a common interface. The core engine remains format-agnostic and works with any message type by dynamically loading the appropriate parser module, enabling the system to adapt to new formats without structural changes or re-installation.
2Adaptability or versatility
If middleware software is updated to include new features, then functionality is improved, but maintenance complexity increases across numerous devices
Solution Approach 1:
The software is divided into a stable core middleware engine and separable feature modules. Each message format parser and processing capability is an independent module that can be developed, tested, and updated separately. This segmentation isolates maintenance complexity to specific modules rather than the entire system, making it manageable across numerous client devices.
Solution Approach 2:
A standardized interface layer acts as an intermediary between the core middleware engine and various message format handlers. This interface absorbs the complexity of different formats and protocols, presenting a uniform interaction model to the core engine. When new features are added, they integrate through this interface without disrupting the core system or requiring complex updates across all devices.
3Productivity
If message format keywords are hardcoded in middleware, then message interpretation is efficient, but format flexibility is reduced
Solution Approach 1:
The message format keywords and structures are not hardcoded but dynamically loaded from external sources (XML schemas, JDF specifications, JSON schemas). The parser modules read format definitions at runtime and adapt their interpretation logic accordingly. This dynamic approach maintains processing efficiency through optimized parsing routines while enabling flexible support for any message format by simply updating the external definitions.
Solution Approach 2:
The middleware uses configurable parameters and metadata to define message formats rather than fixed hardcoding. Format-specific keywords, data types, and validation rules are stored as parameters that can be changed without modifying the core parsing logic. This allows the system to efficiently process messages in any format by changing parameters rather than rewriting interpretation code.
Data Source
AI summary
A method and apparatus for an extensible, format-independent middleware message interpreter is disclosed in which a host machine is configured with a universal message service (UMS). The UMS communicates with local and cloud servers and destination devices. The UMS is configured with a plug-in service that can accommodate plug-in libraries of plug-in modules. The UMS receives formatted messages from the local and cloud server applications and destination devices, parses the messages, and identifies a command message type. Based on the command message type, the UMS performs actions including executing the local command on the host machine, relaying the embedded-sub-message data to the at least one destination device as indicated by the destination identification, and relaying the embedded-sub-message data to the plug-in service.