Learn …

Singleton

Intro

The Singleton design pattern is a crucial concept in Java programming that ensures the existence of only one instance of a class and provides a global point of access to it. This pattern is particularly useful in scenarios where you want to control access to resources, manage configuration settings, or implement logging functionalities efficiently. In this post, we will explore the Singleton pattern in Java and discuss how it can enhance resource management in your applications.

Understanding the Singleton Pattern

The Singleton pattern follows several key principles:

1. Private Constructor: The class with the Singleton pattern has a private constructor, preventing external classes from creating instances.
2. Static Method for Instance Retrieval: The class provides a static method to access the single instance. If the instance doesn’t exist, it creates one; otherwise, it returns the existing instance.

Benefits of Singleton Pattern in Java:

1. Resource Management: The Singleton pattern is valuable when managing resources such as database connections, thread pools, or file systems. By having a single point of control, you can avoid resource contention and efficiently allocate resources.
2. Configuration Settings: If your application relies on configuration settings, a Singleton instance can ensure that these settings are loaded only once and are easily accessible throughout the application.
3. Logging and Tracing: Singleton is beneficial for implementing logging and tracing mechanisms. A single instance can manage log files or maintain a centralized log repository.

Implementing Singleton in Real-world Scenarios:

Consider the following example of a Logger class using the Singleton pattern:

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // private constructor
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    // other methods and properties
}

Factory Method Pattern

The Factory Method is a creational design pattern that provides an interface for creating objects but allows subclasses to alter the type of objects that will be created. Instead of instantiating objects directly using the new keyword, the Factory Method delegates this responsibility to subclasses or specialized creator classes.

This pattern is especially useful when a system needs to be independent of how its objects are created, composed, or represented. It helps to follow the Open/Closed Principle: classes are open for extension but closed for modification.

---

Key Concepts

1. Creator (Factory)
   Declares the factory method that returns objects of a certain type. The base implementation may provide a default product, but subclasses can override the method to change the product type.
2. Concrete Creator
   Implements the factory method and specifies which concrete class will be instantiated.
3. Product
   Defines the interface of the objects the factory method creates.
4. Concrete Product
   Implements the product interface.

---

Example

Suppose you are building a system that generates different types of dialog boxes (Windows dialog, Web dialog, etc.). Each dialog needs to create a button, but the button style depends on the environment.

• Product: Button interface
• Concrete Products: WindowsButton, HTMLButton
• Creator: Dialog (abstract class with createButton() method)
• Concrete Creators: WindowsDialog, WebDialog

The Dialog class relies on createButton() but doesn’t know what specific button it gets. Each subclass decides what button to create.

---

Benefits

• Promotes loose coupling by relying on abstractions instead of concrete classes.
• Makes code more flexible and extensible without modifying existing classes.
• Centralizes object creation logic.

---

Drawbacks

• Introduces additional classes and complexity.
• May be overkill if there is only one or very few concrete products.

// Product interface
interface Button {
    void render();
    void onClick();
}

// Concrete Product 1
class WindowsButton implements Button {
    public void render() {
        System.out.println("Rendering a Windows-style button.");
    }

    public void onClick() {
        System.out.println("Windows button clicked!");
    }
}

// Concrete Product 2
class HTMLButton implements Button {
    public void render() {
        System.out.println("<button>HTML Button</button>");
    }

    public void onClick() {
        System.out.println("HTML button clicked!");
    }
}

// Creator (defines the Factory Method)
abstract class Dialog {
    // Factory Method
    public abstract Button createButton();

    // Some business logic that uses the factory method
    public void renderWindow() {
        Button okButton = createButton();
        okButton.render();
        okButton.onClick();
    }
}

// Concrete Creator 1
class WindowsDialog extends Dialog {
    public Button createButton() {
        return new WindowsButton();
    }
}

// Concrete Creator 2
class WebDialog extends Dialog {
    public Button createButton() {
        return new HTMLButton();
    }
}

// Client code
public class FactoryMethodDemo {
    private static Dialog dialog;

    public static void main(String[] args) {
        // Configuration could come from settings/environment
        String osType = System.getProperty("os.name").toLowerCase();

        if (osType.contains("win")) {
            dialog = new WindowsDialog();
        } else {
            dialog = new WebDialog();
        }

        dialog.renderWindow();
    }
}