Client-Side RMI-IIOP Load Balancing via JNDI SPI
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing solutions for load balancing RMI-IIOP requests are vendor-dependent and lack effective mechanisms, leading to performance issues and poor response times when a single application server instance is overwhelmed by multiple users.
Innovation Solution
A vendor-independent client-side load balancing mechanism using standards-based JNDI SPIs, specifically through the implementation of a Context Factory class that pre-creates multiple client-side ORBs and selects them using load balancing schemes like random, round-robin, or intelligent methods to distribute requests across multiple application server instances.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If a single application server instance is used to handle RMI-IIOP requests, then the system structure is simple and easy to manage, but the response time deteriorates and performance degrades when multiple users send requests simultaneously
Solution Approach 1:
The patent segments the application server into multiple independent instances (server1, server2, server3, etc.) that can handle requests concurrently. Each instance operates as an independent processing unit, allowing the system to distribute the load across multiple servers rather than having all requests queue up on a single server, thereby reducing response time while maintaining manageable complexity through standardized instance deployment
2Loss of time
If multiple application server instances are deployed to handle concurrent requests, then the response time and system performance improve, but the system complexity increases and vendor-dependent solutions are required
Solution Approach 1:
The patent creates a universal load balancer that is vendor-independent and can work with any application server instance. The load balancer implements a standardized interface that distributes requests across multiple instances without requiring vendor-specific proprietary solutions. This universal approach reduces system complexity by providing a single, standardized mechanism for managing multiple server instances rather than requiring different vendor-specific load balancing solutions
3Productivity
If multiple application server instances are deployed with vendor-dependent load balancing solutions, then the system can handle concurrent requests better, but the adaptability deteriorates due to vendor lock-in
Solution Approach 1:
The load balancer is designed as a vendor-independent universal solution that can distribute requests to application server instances from any vendor. It implements a standardized interface that is not tied to any specific vendor's proprietary protocol or architecture, thereby maintaining high adaptability and avoiding vendor lock-in while still providing effective load balancing for concurrent request handling
Data Source
AI summary
System and method for client-side RMI-IIOP request load balancing. Embodiments provide a vendor-independent mechanism for load balancing RMI-IIOP requests using standards-based JNDI (Java Naming and Directory Interface) SPIs. One embodiment may use an implementation of a Context Factory class such as the JNDI ContextFactory SPI (Service Provider Interface) for RMI-IIOP request load balancing. Using embodiments, a client may load-balance RMI-IIOP requests to application server instances in an application server cluster. A plurality of client-side Object Request Brokers (ORBs) may be created “up front” on a client system. After the client-side ORBs are initially created, the client-side ORBs may be selected according to a load balancing scheme in response to requests to access the application server. Note that embodiments may be adapted for use in client-side load balancing for other types of client-server systems.