From e731bdb9983bd1eb67f4f03f6b80d74438db83d2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ilkka=20Sepp=C3=A4l=C3=A4?= Date: Sat, 18 May 2024 16:49:36 +0300 Subject: [PATCH] docs: update registry --- registry/README.md | 121 +++++++++++++++--- .../iluwatar/registry/CustomerRegistry.java | 6 +- 2 files changed, 105 insertions(+), 22 deletions(-) diff --git a/registry/README.md b/registry/README.md index 7f4e447a8..87e495fda 100644 --- a/registry/README.md +++ b/registry/README.md @@ -3,25 +3,47 @@ title: Registry category: Creational language: en tag: - - Instantiation + - API design + - Data access + - Decoupling + - Dependency management + - Enterprise patterns + - Instantiation --- ## Intent -Stores the objects of a single class and provide a global point of access to them. -Similar to Multiton pattern, only difference is that in a registry there is no restriction on the number of objects. + +To centralize the creation and management of a global set of objects, providing a single point of access and ensuring controlled instantiation. ## Explanation +Real-world example + +> In a large corporation, managing IT assets such as laptops, desktops, servers, and software licenses can be challenging. To streamline this process, the company uses a centralized IT Asset Management System, which functions as a Registry. +> +> * The system provides a single point of access for registering, tracking, and retrieving information about all IT assets. +> * When a new device or software is procured, it is registered in the system with details such as serial number, purchase date, warranty period, and assigned user. +> * IT staff can query the system to get details about any asset, check its current status, and update information as needed. +> * This centralized management promotes efficient utilization and maintenance of assets, ensures compliance with software licenses, and helps in planning for upgrades or replacements. +> +> In this analogy, the IT Asset Management System acts as a Registry, managing the lifecycle and providing global access to information about IT assets within the organization. + In Plain Words > Registry is a well-known object that other objects can use to find common objects and services. +wiki.c2.com says + +> A registry is a global association from keys to objects, allowing the objects to be reached from anywhere. It involves two methods: one that takes a key and an object and add objects to the registry and one that takes a key and returns the object for the key. It's similar to the MultitonPattern, but doesn't restrict instances to only those in the registry. + **Programmatic Example** -Below is a `Customer` Class + +The Registry design pattern is a well-known pattern used in software design where objects are stored and provide a global point of access to them. This pattern is particularly useful when you need to manage a global collection of objects, decouple the creation of objects from their usage, ensure a controlled lifecycle for objects, and avoid redundant creation of objects. + +First, we have the `Customer` class. This class represents the objects that will be stored in the registry. Each `Customer` has an `id` and a `name`. ```java public class Customer { - private final String id; private final String name; @@ -30,35 +52,43 @@ public class Customer { this.name = name; } - public String getId() { + public String id() { return id; } - public String getName() { + public String name() { return name; } + @Override + public String toString() { + return "Customer{" + + "id='" + id + '\'' + + ", name='" + name + '\'' + + '}'; + } } ``` -This registry of the `Customer` objects is `CustomerRegistry` +Next, we have the `CustomerRegistry` class. This class is the actual registry where `Customer` objects are stored. It provides methods to add and retrieve customers. The `CustomerRegistry` is a singleton, meaning there is only one instance of it in the application. + ```java public final class CustomerRegistry { private static final CustomerRegistry instance = new CustomerRegistry(); - public static CustomerRegistry getInstance() { - return instance; - } - private final Map customerMap; private CustomerRegistry() { customerMap = new ConcurrentHashMap<>(); } + public static CustomerRegistry getInstance() { + return instance; + } + public Customer addCustomer(Customer customer) { - return customerMap.put(customer.getId(), customer); + return customerMap.put(customer.id(), customer); } public Customer getCustomer(String id) { @@ -68,17 +98,72 @@ public final class CustomerRegistry { } ``` +Finally, we have the `App` class. This class demonstrates how to use the `CustomerRegistry`. It creates two `Customer` objects, adds them to the `CustomerRegistry`, and then retrieves them. + +```java +public class App { + + private static final Logger LOGGER = LoggerFactory.getLogger(App.class); + + public static void main(String[] args) { + CustomerRegistry customerRegistry = CustomerRegistry.getInstance(); + var john = new Customer("1", "John"); + customerRegistry.addCustomer(john); + var julia = new Customer("2", "Julia"); + customerRegistry.addCustomer(julia); + + LOGGER.info("John {}", customerRegistry.getCustomer("1")); + LOGGER.info("Julia {}", customerRegistry.getCustomer("2")); + } + +} +``` + +In this example, the `CustomerRegistry` provides a global point of access to `Customer` objects. This allows us to manage these objects in a centralized way, promoting reuse and sharing, and facilitating decoupling between components. + ## Class diagram + ![Registry](./etc/registry.png) ## Applicability -Use Registry pattern when -* client wants reference of some object, so client can lookup for that object in the object's registry. +* When you need to manage a global collection of objects. +* When you need to decouple the creation of objects from their usage. +* When you need to ensure a controlled lifecycle for objects, such as services or resources. +* When you want to avoid redundant creation of objects. + +## Known Uses + +* Managing database connections in an enterprise application. +* Providing a central place to register and retrieve services or components in a modular application. +* Creating a central configuration registry that various parts of an application can access. ## Consequences -Large number of bulky objects added to registry would result in a lot of memory consumption as objects in the registry are not garbage collected. + +Benefits: + +* Centralizes object management, making the application easier to maintain. +* Promotes reuse and sharing of objects, which can reduce memory footprint and initialization time. +* Facilitates decoupling between components. + +Trade-offs: + +* Can become a bottleneck if not implemented efficiently. +* May introduce a single point of failure if the registry is not designed to be fault-tolerant. +* Increases complexity in managing the lifecycle of objects. + +## Related Patterns + +* [Singleton](https://java-design-patterns.com/patterns/singleton/): Often used in conjunction with the Registry to ensure there is a single instance of the Registry. +* [Factory](https://java-design-patterns.com/patterns/factory/): Used to encapsulate the instantiation logic that might be needed when objects are retrieved from the Registry. +* [Service Locator](https://java-design-patterns.com/patterns/service-locator/): A pattern that is similar in intent and structure, often used interchangeably with the Registry. +* [Dependency Injection](https://java-design-patterns.com/patterns/dependency-injection/): Provides an alternative method for managing dependencies, which can sometimes replace the need for a Registry. +* [Multiton](https://java-design-patterns.com/patterns/multiton/): Similar to the Registry in that it manages multiple instances, but does so based on keys, ensuring only one instance per key. ## Credits -* https://www.martinfowler.com/eaaCatalog/registry.html -* https://wiki.c2.com/?RegistryPattern + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI) +* [Patterns of Enterprise Application Architecture](https://amzn.to/3WfKBPR) +* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3yhh525) +* [Registry - Martin Fowler](https://www.martinfowler.com/eaaCatalog/registry.html) +* [Registry pattern - wiki.c2.com](https://wiki.c2.com/?RegistryPattern) diff --git a/registry/src/main/java/com/iluwatar/registry/CustomerRegistry.java b/registry/src/main/java/com/iluwatar/registry/CustomerRegistry.java index 14039ca8b..ff5609911 100644 --- a/registry/src/main/java/com/iluwatar/registry/CustomerRegistry.java +++ b/registry/src/main/java/com/iluwatar/registry/CustomerRegistry.java @@ -26,18 +26,16 @@ package com.iluwatar.registry; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import lombok.Getter; /** * CustomerRegistry class used to store/access {@link Customer} objects. */ public final class CustomerRegistry { + @Getter private static final CustomerRegistry instance = new CustomerRegistry(); - public static CustomerRegistry getInstance() { - return instance; - } - private final Map customerMap; private CustomerRegistry() {