Web Services Runtime Framework Scalability
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing Web services message processing runtime framework is inefficient due to its reliance on a mapping registry and state-full protocols, which hampers scalability and performance, particularly in handling concurrent message processing and ensuring reliable messaging across networks.
Innovation Solution
The improved runtime framework eliminates the mapping registry and redesigns protocols to be state-less, allowing for direct communication between protocols and the runtime object, and supports hibernation to manage out-of-order messages effectively, incorporating message key-to-endpoint method mapping directly into Web service data and enabling efficient processing of Web services messages.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If a mapping registry is used to store message key-to-endpoint method mappings, then message routing can be achieved, but system complexity and memory consumption increase
Solution Approach 1:
The patent extracts the mapping functionality from a centralized registry and embeds it directly into the protocol implementation. Each protocol maintains its own mapping of message keys to endpoint methods, eliminating the need for a separate mapping registry and reducing system complexity while preserving message routing capability.
Solution Approach 2:
The protocol becomes self-sufficient by incorporating its own message key-to-endpoint method mappings. Instead of relying on an external registry, the protocol handles its own routing decisions autonomously, reducing dependencies and system complexity.
2Reliability
If state-full protocols are used to maintain message processing state, then reliable message processing is achieved, but scalability and concurrent processing capability are reduced
Solution Approach 1:
The patent segments the state management by creating separate, independent protocol instances for each message processing task. Instead of a single state-full protocol maintaining all state, multiple state-less protocol instances work concurrently, each handling its own message without sharing state, thereby enabling scalable concurrent processing while maintaining reliability through proper message handling.
Solution Approach 2:
The protocol instances are designed to be short-lived and disposable, created as needed for each message processing task and discarded afterward. This eliminates the need for persistent state management while enabling high concurrent processing capability, as each protocol instance is independent and can be rapidly instantiated and terminated.
3Productivity
If multiple protocol instances are created to handle concurrent messages, then processing capability increases, but memory consumption increases
Solution Approach 1:
The patent employs short-lived protocol instances that are created only when needed for message processing and immediately discarded afterward. This approach allows multiple concurrent instances to be created without significant memory overhead, as each instance exists briefly and releases its resources promptly, enabling high concurrent processing capability with controlled memory consumption.
4Ease of operation
If a centralized registry is used for message key mapping, then centralized control is maintained, but processing speed and efficiency are reduced
Solution Approach 1:
The patent extracts the mapping functionality from a centralized registry and distributes it to individual protocol implementations. This allows message key-to-endpoint method mappings to be resolved locally within each protocol instance, eliminating the need for centralized registry lookups and significantly improving message processing speed while maintaining proper routing control.
Data Source
AI summary
A system and method for Web service archive deployment is describe. An exemplary method includes searching the Web services archive for a metadata descriptor, processing descriptors from the metadata descriptor, and generating a set of objects to serialize and deserialize input parameters.