Unified Java Application Server Supporting Multiple Component Models
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing Java-based application server environment is inflexible and complex, struggling to adapt to changing development needs due to varied requirements for scalability, manageability, high availability, and security across different business applications, leading to high costs and difficulty in management.
Innovation Solution
A Java-based application server that supports multiple component models by integrating components through a microcontainer, using a chain of deployers and controller contexts to manage dependencies and state transitions, allowing components from different models to cross-reference and interact at runtime, with a classloading module for resolving dependencies and a state machine for lifecycle management.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If a single application platform is designed for a specific programming model, then the platform provides specialized support for that model, but the platform becomes inflexible and cannot adapt to changing Java development requirements
Solution Approach 1:
The application server is designed to support multiple component models (Java EE, OSGi, Spring, Guice, POJO) within a single unified platform. The server includes a microcontainer that can instantiate and manage components from different component models, and a controller that can deploy and coordinate applications using various programming approaches, making the platform universally applicable to different Java development needs without requiring separate specialized platforms for each model
2Adaptability or versatility
If multiple application platforms are used to meet varied business application requirements, then each requirement can be satisfied with a dedicated platform, but the application environment becomes highly complex and difficult to manage
Solution Approach 1:
The invention merges the functionality of multiple separate application platforms into a single unified application server. The server consolidates the microcontainer, deployers, and controller into one integrated system that can handle Java EE, OSGi, Spring, Guice, and POJO component models simultaneously, eliminating the need for maintaining and coordinating multiple separate platforms while reducing overall system complexity
Solution Approach 2:
The application server is segmented into modular functional components: a microcontainer for component instantiation, multiple deployers for different component models (javaee-deployer, osgi-deployer, spring-deployer, guice-deployer, pojo-deployer), and a controller for coordination. This segmentation allows each component to specialize in specific tasks while working together as an integrated system, making the complex environment manageable through clear functional separation
3Adaptability or versatility
If components from different component models are integrated into a single application server, then flexibility and adaptability improve, but dependency management and state transition coordination become more complex
Solution Approach 1:
The controller acts as an intermediary between components from different component models. It receives deployment information from various deployers, resolves dependencies among components regardless of their model, and coordinates state transitions by triggering appropriate deployers. The controller maintains a unified view of all components and their relationships, simplifying dependency management by centralizing coordination logic rather than requiring each component to manually manage cross-model dependencies
Data Source
AI summary
A Java-based application server supports runtime operations of components that belong to multiple component models. The components may cross-reference each other. A component of a source component model can be integrated into a target component model to form an integrated component. State transitions of the integrated component can be managed according to the target component model with reference to the libraries of the source component model. The integrated component can be installed in the application server for execution by a Java virtual machine.