SOA Schema Type Library Management
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional systems have not adequately addressed the management and reuse of schema type definitions in Services Oriented Architecture (SOA) services, leading to inefficiencies in service re-use and version management due to inadequate handling of underlying data types.
Innovation Solution
A computer-implemented system and method for creating, managing, and reusing schema type definitions in the form of libraries, utilizing XML schema-based data types translated to Java code under the JAXB v2 approach, with tooling support for creating and managing type libraries, managing dependencies, and inlining types in WSDLs to optimize data type reuse.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If schema type definitions are managed individually in each service, then each service has full control over its data types, but service re-use efficiency decreases and version management becomes complex
Solution Approach 1:
The patent segments schema type definitions into reusable library components that can be independently versioned and managed. Type libraries are divided into modular units that can be selectively imported by services, allowing efficient re-use while maintaining clear version boundaries through the dependency file mechanism.
Solution Approach 2:
The patent creates universal type libraries that can be shared across multiple services and reused in different contexts. The same type definition can be imported by multiple services through standardized mechanisms (XML schema imports, WSDL inline types, or code generation), providing multi-functional re-use while centralizing version management.
2Adaptability or versatility
If multiple translation layers are introduced for schema type management, then flexibility in handling different data formats is improved, but system complexity and processing overhead increase
Solution Approach 1:
The patent extracts the translation and conversion logic into separate, manageable components. By using XML schema imports and WSDL inline type mechanisms, the system separates type definition storage from type usage, allowing translation layers to be selectively applied only where needed rather than universally across all service interactions.
Solution Approach 2:
The patent introduces intermediary mechanisms (type libraries, dependency files, and code generation tools) that mediate between schema definitions and service implementations. These intermediaries provide standardized interfaces for type management, reducing the need for ad-hoc translation layers while maintaining flexibility through the JAXB v2 annotation system.
3Stability of the object's composition
If schema types are tightly coupled with service implementations, then type consistency within services is maintained, but reusability across services decreases
Solution Approach 1:
The patent adds a new dimension to type management by introducing type libraries as a separate organizational layer. Instead of flat service-local type definitions, types are arranged in a hierarchical library structure that services can reference. This dimensional change allows types to maintain consistency through centralized library versioning while enabling reusability through library imports.
Solution Approach 2:
The patent enables services to copy type definitions from libraries into their own implementation context through standardized import mechanisms. Services can import XML schema types, use WSDL inline type definitions, or generate code from library types, creating local copies that maintain consistency with the source library while allowing independent deployment and versioning.
Data Source
AI summary
A computer-implemented system and method for creating, managing, and reusing schema type definitions in SOA services, grouped in the form of libraries are disclosed. The method in an example embodiment includes: grouping a plurality of Extensible Mark-up Language (XML) schema (XSD) types, each XSD type defined in an individual XSD file; using a processor to bundle the plurality of individual XSD types into a type library, the type library including a type information file to register the individual XSD types in the type library, the type library further including a type dependencies file to register dependencies between the individual XSD types in the same or different type library; importing types from a different type library, when defining derived types or aggregated types; generating Java artifacts from the XSD types; and associating the Java artifacts with corresponding XSD types in the type information file of the type library.