How to Implement the Singleton Design Pattern

Introduction

Recently, while working on a Next.js application and connecting to my database, I made the mistake of not having a single connection point to the database. As a result, the database was instantiated multiple times — if I remember correctly, about five instances within the same app. My computer started to heat up, becoming less efficient, and I began to see strange errors when handling entities. After much thought, I realized that the issue was due to the multiple instances created to connect to the database. So, how can I avoid this problem in the future — and help you avoid it too?

To solve this problem, after a lot of research into how the community addressed it, I discovered the perfect solution: the Singleton creation pattern. Singleton ensures that a class A can only be instantiated once and that this single instance is shared across the entire application — providing a single connection point to the database. This approach avoids any risk of duplication and system overload.

In this article, we will explore how the Singleton works, why it is so effective in situations where a single instance is needed, and how to implement it correctly to avoid similar errors in the future.

Sections We Will Cover

1. What is the Singleton Pattern?
2. How to Implement the Singleton
3. Real-World Examples of Singleton Use
4. Why is the Singleton Design Pattern so Important
5. Conclusion ## What is the Singleton Pattern? The Singleton design pattern is one of the five creation patterns introduced by the Gang of Four in their book "Design Patterns: Elements of Reusable Object-Oriented Software". It ensures that a class cannot be instantiated more than once in an application, meaning that the instance is shared throughout the application. This is useful in cases where resources are shared, such as the database connection issue I encountered personally, or any centralized configuration.

By limiting the number of instances to one, Singleton helps avoid duplication and better manage resources, thereby reducing the risk of overload and inconsistencies in the application.

How to Implement the Singleton

After examining the issue of ensuring that there is only one unique instance for a given class and having a single global access point to that instance, the potential solution lies in using the Singleton design pattern. Now, let's look at the logic we will use to implement this optimal solution:

1. Define a Static Variable for the Instance
   
   The first step is to declare a private static variable that will hold the unique instance of the class.

2. Protect the Constructor
   
   The class constructor must be made private so that other classes cannot instantiate the class directly.

here is the class diagram exemple to clarify:

and here is the implementation in typescript :

class DatabaseConnection {
  // Step 1: Declare a static private instance
  private static instance: DatabaseConnection;

  // Private variable to hold the database connection
  private connection: string;

  // Step 2: Private constructor to prevent direct instantiation
  private constructor() {
    // Simulate establishing a database connection
    this.connection = 'Database connection established!';
    console.log(this.connection);
  }

  // Step 3: Public static method to get the single instance
  public static getInstance(): DatabaseConnection {
    if (!DatabaseConnection.instance) {
      DatabaseConnection.instance = new DatabaseConnection();
    }
    return DatabaseConnection.instance;
  }

  // You can add other methods
}

Now let's create instances and see what will happen:

const db1 = DatabaseConnection.getInstance(); 
const db2 = DatabaseConnection.getInstance(); 
console.log(db1 === db2);

let's see now what will be printed in the console:

It printed true, confirming that the DatabaseConnection class was instantiated only once.

Why is the Singleton Design Pattern so Important

The Singleton Design Pattern is crucial for avoiding several future issues, including:

1. Ensures a Single Instance
   
   It guarantees that a class has only one instance throughout the entire application, which is vital for shared resources like configurations or database connections. Multiple instances can lead to inconsistencies or excessive resource consumption.

2. Global Access to the Instance
   
   The Singleton pattern provides global access to the instance, allowing all parts of the application to interact with the same object, ensuring consistency across the entire application.

3. Resource Management
   
   Creating a new instance every time can be costly in terms of memory and performance. The Singleton ensures only one instance is created, reducing overhead, for example, with a database connection.

4. Prevents Redundant Work
   
   When multiple components need access to the same resource, the Singleton ensures only one instance is used, optimizing resource utilization.

Conclusion

In this blog, we discussed a problem I faced while working on a Next.js application, where multiple instances of the database connection were created, leading to system inefficiency and strange errors. The solution I found to this problem was the Singleton Design Pattern, which ensures that a class can only be instantiated once, providing a single, shared instance throughout the entire application. This pattern helps avoid redundancy, resource overload, and inconsistencies by maintaining centralized control.

The blog covered:

1. What the Singleton Pattern is:
2. How to Implement the Singleton:
3. Why the Singleton is Important:
4. Real-World Examples: