docs: update registry

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<String, Customer> 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)

registry/src/main/java/com/iluwatar/registry/CustomerRegistry.java

@@ -26,18 +26,16 @@
 
 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<String, Customer> customerMap;
 
   private CustomerRegistry() {