Classloading Module Enforcing Dependencies in Java Application Servers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing Java-based application server environment is inflexible and complex due to varied requirements for scalability, manageability, high availability, and security across different business applications, leading to increased costs and difficulty in management.
Innovation Solution
A Java-based application server with a classloading module that enforces dependencies among classes and components, utilizing pluggable classloading policies and a microcontainer to integrate components of different component models, manage their lifecycle, and perform classloading operations, allowing for flexible adaptation to changing development needs.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If multiple application platforms with different programming models are used to support varied business application requirements, then adaptability to different operational capabilities is improved, but device complexity and difficulty of management increase
Solution Approach 1:
The patent implements a universal classloading framework that can handle multiple component models (OSGi, Java EE, servlet containers) through a single unified interface. The classloading module provides pluggable policies that can be configured to support different programming models without requiring separate infrastructure for each, thereby reducing overall system complexity while maintaining adaptability.
Solution Approach 2:
The patent segments the classloading functionality into independent, pluggable policy modules. Each component model can have its own classloading policy that is independently configurable and manageable. This segmentation allows the system to support multiple programming models while keeping each model's complexity isolated and manageable through separate policy configurations.
2Adaptability or versatility
If each business application requires different operational capabilities for scalability, manageability, high availability and security, then adaptability to specific requirements is improved, but ease of operation and management deteriorate
Solution Approach 1:
The patent enables dynamic configuration of classloading policies through parameters and metadata associated with each component model. Administrators can adjust classloading behavior, delegation rules, and policy priorities without changing the underlying system architecture. This parameter-based configuration allows tailored operational capabilities for different applications while maintaining ease of management through centralized policy control.
3Ease of operation
If a unified classloading framework with pluggable policies is implemented, then ease of operation and manageability are improved, but device complexity increases due to the need to manage multiple component models
Solution Approach 1:
The patent introduces a classloading module as an intermediary layer between the application server and multiple component models. This mediator handles the complexity of integrating different component models by providing a unified classloading interface that abstracts away the underlying model-specific complexities. The pluggable policies act as intermediaries that translate between different component model requirements and the unified framework, thereby improving manageability while containing complexity within the intermediary layer.
4Productivity
If classloading operations are automated with dependency enforcement, then productivity and deployment efficiency are improved, but device complexity increases due to the need for dependency management mechanisms
Solution Approach 1:
The patent performs dependency analysis and classloading policy configuration in advance during the deployment phase. The system pre-determines classloading dependencies, resolves conflicts, and configures appropriate policies before runtime execution. This preliminary action automates the deployment process and improves productivity by eliminating manual configuration, while the complexity of dependency management is contained within the pre-processing phase rather than during runtime operations.
Data Source
AI summary
A Java-based application server, which supports multiple component models, includes a classloading module to enforce dependencies among classes and among the components that uses the classes. The classloading module determines whether a classloader created at deployment can share a version of a class with other classloaders. The classloading module also uses dependency information to determine which of the other classloaders on which the classloader depends. The classloading module uses pluggable classloading policies to determine the rules to be followed during classloading operations. The same state machine is used for classloading and for controlling the lifecycle of multiple component modules. The classloading module also utilizes abstraction of interfaces to communicate requirements and capabilities among the classloaders and with the system.