Service Locator Design Pattern - Class and Sequence Diagram

🚀 Master Object-Oriented Architecture!

Subscribe to Ram N Java for clean diagrams, enterprise design patterns, and clear step-by-step programming guides!

🔔 Subscribe to Ram N Java

Understanding the Service Locator Architecture

In distributed and enterprise Java systems, resolving business services repeatedly through JNDI directory lookups can introduce significant network latency and tight coupling. The Service Locator Design Pattern solves this challenge by centralizing lookup logic and maintaining an in-memory cache of service instances. Understanding its static structure through a Class Diagram and runtime interactions through a Sequence Diagram makes mastering this pattern simple and practical.

Class Diagram: Participants and Structural Roles

The class diagram represents the core structural components and how they relate to one another:

• Client: The application object or controller that requires access to a business service.
• ServiceLocator: The central facade holding a static lookup method (e.g., getService(String jndiName)) and maintaining references to both the InitialContext and the Cache.
• InitialContext: The object that performs the low-level lookup or instantiation of the requested service via naming directories.
• Cache: A dedicated repository (such as a map or list) used by the locator to store and retrieve previously resolved service references.
• Service (Interface): The common interface that defines the operations provided by concrete business services.
• Concrete Services: Implementations (such as Service1 and Service2) that fulfill the business requests.

Sequence Diagram: Execution Flow Step-by-Step

The sequence diagram illustrates how messages travel dynamically when a client requests a service:

1. Request Initiation: The Client calls ServiceLocator.getService("serviceName").
2. Cache Inspection: The ServiceLocator checks the Cache to see if the requested service object already exists in memory.
3. Case A (Cache Hit): If found, the Cache returns the service instance directly to the locator, which passes it immediately back to the client. No directory lookup is performed.
4. Case B (Cache Miss): If not found, the locator invokes the InitialContext to resolve and instantiate the concrete service.
5. Cache Update: The newly created service instance is registered into the Cache for future lookups.
6. Execution: The locator hands the service instance to the client, which then invokes the required business methods (e.g., execute()).

Key Architectural Benefits

• Significant Performance Optimization: Caching resolved objects prevents repetitive, expensive remote network lookups.
• Loose Coupling: The client depends strictly on the Service interface, completely isolated from vendor-specific directory naming mechanisms.
• Simplified Client Code: Eliminates boilerplate lookup try-catch blocks across multiple presentation and business components.

Recommended Next Videos

Expand your knowledge of enterprise UML diagrams and design patterns with these tutorials from our channel:

• Observer Design Pattern: Class and Sequence Diagram Explained
• Memento Design Pattern: Sequence Diagram Explained
• Decorator Design Pattern: Sequence Diagram Explained

---

Click here to watch in Youtube : https://www.youtube.com/watch?v=a-JeUQwjUGY

Click the below Image to Enlarge

See also :

Service Locator Design Pattern - Introduction

Service Locator Design Pattern - Implementation

Service Locator Design Pattern - KeyPoints

All Design Patterns Links