Teoría#

Definición ☝️#

El patrón Singleton es un patrón de diseño creacional que garantiza que una clase tenga una sola instancia en toda la aplicación y proporciona un punto de acceso global a ella.

Es como tener una única llave maestra 🔑 para un recurso específico: no importa quién la pida, siempre recibirá la misma llave.

Problema#

Hay situaciones en las que necesitas asegurarte de que solo exista un objeto de un tipo particular. Algunos ejemplos comunes son:

Gestión de Configuración: Cargar la configuración de la aplicación una sola vez y que todos los componentes accedan a la misma versión.
Conexiones a Recursos: Administrar un pool de conexiones a una base de datos o un gestor de logging centralizado.
Servicios del Sistema Operativo: Interactuar con un gestor de ventanas o un sistema de archivos, donde solo debe haber una instancia controladora.

Si permitieras crear múltiples instancias de estas clases, podrías causar inconsistencias, consumir recursos innecesariamente o tener comportamientos inesperados (imagina dos objetos intentando escribir en el mismo archivo de log de forma descoordinada). Además, necesitarías una forma fácil para que cualquier parte del código acceda a esa única instancia.

Solución#

El patrón Singleton resuelve esto implementando tres elementos clave dentro de la propia clase:

Constructor Privado: Se impide que otras clases creen instancias directamente usando el operador new (o su equivalente).
Instancia Estática Privada: La clase guarda su única instancia en un campo estático y privado.
Método Estático Público (getInstance): La clase proporciona un método estático público que devuelve la instancia única. La primera vez que se llama, crea la instancia; las siguientes veces, simplemente devuelve la instancia ya existente.

Estructura (Mermaid UML)#

El diagrama es muy simple: la clase Singleton se referencia a sí misma para guardar su única instancia y ofrece un método estático para obtenerla.

1
classDiagram
2
    direction TB
3

4
    class Singleton {
5
        -Singleton instance
6
        -Singleton()
7
        +getInstance(): Singleton
8
        +someBusinessLogic()
9
    }
10
    note for Singleton "Guarda su propia instancia única\ny proporciona un método para acceder a ella."
11

12
    Singleton -- Singleton : instance

Cuándo usar#

Cuando necesitas exactamente una instancia de una clase, y esta debe ser accesible desde un punto bien conocido.
Cuando el objeto único debe ser extensible mediante subclases, y los clientes deben poder usar una instancia extendida sin cambiar su código (aunque esto es menos común y más complejo).

Cuándo no usar#

Viola el Principio de Responsabilidad Única: La clase se encarga tanto de su lógica de negocio como de gestionar su propia instanciación única.
Introduce Acoplamiento Global: Hace que el código cliente dependa de una clase concreta global, dificultando las pruebas unitarias (no puedes reemplazar fácilmente el Singleton con un mock).
Problemas en Multihilo: La implementación simple (lazy initialization) puede fallar si varios hilos intentan crear la instancia al mismo tiempo. Requiere sincronización cuidadosa.
Frameworks Modernos: Frameworks como Spring ya gestionan el ciclo de vida de los objetos y proporcionan Singletons por defecto (beans con scope singleton), haciendo la implementación manual a menudo innecesaria.

Ejemplo en Java (Implementación Clásica)#

1
public class ConfiguracionGlobal {
2
    // 2. Instancia estática privada (inicialización temprana - thread-safe)
3
    private static final ConfiguracionGlobal instancia = new ConfiguracionGlobal();
4

5
    private String urlBaseDatos;
6

7
    // 1. Constructor privado
8
    private ConfiguracionGlobal() {
9
        // Simula la carga costosa de configuración
10
        System.out.println("Cargando configuración...");
11
        this.urlBaseDatos = "jdbc:mysql://localhost/produccion";
12
    }
13

14
    // 3. Método estático público para obtener la instancia
15
    public static ConfiguracionGlobal getInstance() {
16
        return instancia;
17
    }
18

19
    // Métodos de negocio
20
    public String getUrlBaseDatos() {
21
        return urlBaseDatos;
22
    }
23
}
24

25
// Cliente
26
public class Main {
27
    public static void main(String[] args) {
28
        ConfiguracionGlobal config1 = ConfiguracionGlobal.getInstance();
29
        ConfiguracionGlobal config2 = ConfiguracionGlobal.getInstance();
30

31
        System.out.println("URL: " + config1.getUrlBaseDatos());
32

33
        if (config1 == config2) {
34
            System.out.println("config1 y config2 son la misma instancia.");
35
        }
36
    }
37
}

Ejemplo en Python (Usando Módulos - Idiomático)#

En Python, la forma más sencilla y común de tener un Singleton es usar un módulo. Los módulos en Python se importan una sola vez por sesión, por lo que su estado es compartido globalmente.

1
# config.py (Este módulo actúa como Singleton)
2
print("Cargando configuración...")
3
url_base_datos = "jdbc:mysql://localhost/produccion"
4

5
def get_url():
6
    return url_base_datos
7

8
# main.py (Cliente 1)
9
import config
10

11
print(f"Main 1 - URL: {config.get_url()}")
12

13
# otro_modulo.py (Cliente 2)
14
import config
15

16
print(f"Otro Módulo - URL: {config.get_url()}")
17

18
# Ejecución (simulada):
19
# Cargando configuración...  <-- Solo se imprime una vez
20
# Main 1 - URL: jdbc:mysql://localhost/produccion
21
# Otro Módulo - URL: jdbc:mysql://localhost/produccion

Resumen#

El patrón Singleton asegura una única instancia de una clase.
Proporciona un punto de acceso global a esa instancia.
Se implementa con un constructor privado y un método estático getInstance.
Debe usarse con precaución debido a sus posibles desventajas (acoplamiento global, dificultad para pruebas).
En frameworks modernos como Spring, la gestión de Singletons suele estar integrada.

Práctica con Spring Boot#

En Spring Boot, los beans son Singletons por defecto. No necesitas implementar el patrón manualmente. Spring se encarga de crear una única instancia de tus componentes (@Component, @Service, @Repository, @Controller, @Configuration) y de inyectar esa misma instancia donde sea requerida.

Paso 1: Creación del Proyecto en IntelliJ IDEA 🚀#

Abre IntelliJ IDEA y ve a File > New > Project….
Selecciona Spring Initializr.
Configura los metadatos:
- Name: singleton-spring-ejemplo
- Language: Java
- Type: Gradle - Groovy
- Group: com.example.solid
- JDK: 17 o superior
Haz clic en Next.
Añade la dependencia Spring Web.
Haz clic en Create.

Paso 2: Estructura de Paquetes 📂#

Dentro de src/main/java/com/example/solid/singletonspringejemplo, crea estos paquetes:

config: Para nuestra clase de configuración Singleton.
service: Para un servicio que usará la configuración.
controller: Para un controlador que también usará la configuración.

Paso 3: Codificación del “Singleton” Gestionado por Spring ⚙️#

3.1. Crear la Clase Singleton#

Dentro del paquete config, crea la clase. Spring la convertirá en Singleton.

AppConfig.java

1
package com.example.solid.singletonspringejemplo.config;
2

3
import org.springframework.stereotype.Component;
4
import jakarta.annotation.PostConstruct;
5

6
@Component // ¡Esta anotación le dice a Spring que gestione esta clase como un bean Singleton!
7
public class AppConfig {
8

9
    private String databaseUrl;
10
    private int maxConnections;
11

12
    public AppConfig() {
13
        System.out.println("****** AppConfig CONSTRUCTOR LLAMADO ******");
14
        // Simula la carga de configuración
15
        this.databaseUrl = "jdbc:h2:mem:testdb";
16
        this.maxConnections = 10;
17
    }
18

19
    @PostConstruct // Se ejecuta después de que el constructor termina
20
    public void init() {
21
        System.out.println("****** AppConfig INICIALIZADO (@PostConstruct) ******");
22
        System.out.println("Configuración cargada: DB URL=" + databaseUrl + ", Max Conexiones=" + maxConnections);
23
    }
24

25
    // Getters
26
    public String getDatabaseUrl() { return databaseUrl; }
27
    public int getMaxConnections() { return maxConnections; }
28
}

@Component: Es la clave. Le indica a Spring: “Crea una única instancia de esta clase y guárdala”.

Paso 4: Crear Clientes que Usen el Singleton#

4.1. Crear un Servicio#

Dentro del paquete service, crea una clase que pida la configuración.

UserService.java

1
package com.example.solid.singletonspringejemplo.service;
2

3
import com.example.solid.singletonspringejemplo.config.AppConfig;
4
import org.springframework.stereotype.Service;
5

6
@Service
7
public class UserService {
8

9
    private final AppConfig appConfig;
10

11
    // Spring inyecta la ÚNICA instancia de AppConfig aquí
12
    public UserService(AppConfig appConfig) {
13
        System.out.println("****** UserService CONSTRUCTOR - Recibiendo AppConfig: " + appConfig.hashCode() + " ******");
14
        this.appConfig = appConfig;
15
    }
16

17
    public String getUserConfigInfo() {
18
        return "UserService usando DB URL: " + appConfig.getDatabaseUrl();
19
    }
20
}

4.2. Crear un Controlador#

Dentro del paquete controller, crea otra clase que también pida la configuración.

ConfigController.java

1
package com.example.solid.singletonspringejemplo.controller;
2

3
import com.example.solid.singletonspringejemplo.config.AppConfig;
4
import com.example.solid.singletonspringejemplo.service.UserService;
5
import org.springframework.web.bind.annotation.GetMapping;
6
import org.springframework.web.bind.annotation.RequestMapping;
7
import org.springframework.web.bind.annotation.RestController;
8

9
@RestController
10
@RequestMapping("/api/config")
11
public class ConfigController {
12

13
    private final AppConfig appConfig;
14
    private final UserService userService;
15

16
    // Spring inyecta la MISMA instancia de AppConfig aquí
17
    public ConfigController(AppConfig appConfig, UserService userService) {
18
        System.out.println("****** ConfigController CONSTRUCTOR - Recibiendo AppConfig: " + appConfig.hashCode() + " ******");
19
        this.appConfig = appConfig;
20
        this.userService = userService;
21
    }
22

23
    @GetMapping("/info")
24
    public String getConfigInfo() {
25
        String controllerInfo = "ConfigController usando Max Conexiones: " + appConfig.getMaxConnections();
26
        String serviceInfo = userService.getUserConfigInfo();
27

28
        // Comprobaremos si ambas clases recibieron la misma instancia
29
        return controllerInfo + " | " + serviceInfo +
30
               " | HashCode de AppConfig en Controller: " + appConfig.hashCode();
31
    }
32
}

hashCode(): Usamos hashCode() para obtener un identificador único del objeto en memoria. Si los hash codes son iguales, significa que es la misma instancia.

Paso 5: Probar la Aplicación ✅#

Ejecuta la aplicación desde SingletonSpringEjemploApplication.
Observa la Consola: Verás los mensajes ****** ... ******. Notarás que el constructor de AppConfig y su método init se llaman solo una vez al inicio. Luego, verás que tanto UserService como ConfigController reciben un AppConfig con el mismo hash code.
Usa tu navegador o curl para probar el endpoint: http://localhost:8080/api/config/info

Respuesta esperada (el hash code puede variar):
```
1
ConfigController usando Max Conexiones: 10 | UserService usando DB URL: jdbc:h2:mem:testdb | HashCode de AppConfig en Controller: 123456789
```
El hash code mostrado será el mismo que viste en la consola, confirmando que ambos componentes usan la única instancia de AppConfig creada por Spring.

Práctica con Django (Python)#

Como mencionamos en la teoría, en Python la forma más idiomática de lograr un Singleton es usando módulos. Cuando importas un módulo, Python lo carga en memoria una sola vez y reutiliza esa misma instancia cada vez que se importa de nuevo.

Paso 1: Creación del Proyecto en PyCharm 🚀#

En PyCharm, ve a File > New Project… y selecciona Django.
Nombra el proyecto singleton_django y crea una app inicial core.

Paso 2: Estructura de la App Django 📂#

En la terminal, crea una nueva app:

1
python manage.py startapp config_app

Añade 'config_app' a INSTALLED_APPS en singleton_django/settings.py.

Paso 3: Codificación del “Singleton” como Módulo ⚙️#

Dentro de la app config_app, crea un archivo para nuestra configuración.

config_app/app_config.py

1
# Este módulo completo actúa como un Singleton.
2
# El código aquí solo se ejecuta UNA VEZ cuando se importa por primera vez.
3

4
print("****** Cargando app_config.py (¡Debería pasar solo una vez!) ******")
5

6
# Estado global compartido
7
_database_url = "jdbc:h2:mem:testdb_django"
8
_max_connections = 5
9
_carga_inicial_completa = False
10

11
def inicializar_configuracion():
12
    global _carga_inicial_completa
13
    if not _carga_inicial_completa:
14
        print("****** Realizando inicialización costosa... ******")
15
        # Simula una carga pesada
16
        import time
17
        time.sleep(1) # Espera 1 segundo
18
        _carga_inicial_completa = True
19
        print("****** Inicialización completada ******")
20

21
def get_database_url():
22
    inicializar_configuracion() # Asegura que la inicialización ocurra antes de usar
23
    return _database_url
24

25
def get_max_connections():
26
    inicializar_configuracion()
27
    return _max_connections
28

29
# Llama a la inicialización al cargar el módulo si es necesario
30
# inicializar_configuracion() # Opcional: podrías llamarla aquí directamente

Todo lo que está definido en este archivo (_database_url, get_database_url, etc.) existirá en una única instancia en memoria una vez que el módulo sea importado.

Paso 4: Crear Clientes que Usen el Módulo Singleton#

Crearemos dos vistas diferentes que importen y usen app_config.

config_app/views.py

1
from django.http import JsonResponse
2
# Importamos nuestro módulo Singleton
3
from . import app_config
4
import random
5

6
def vista_uno(request):
7
    print(f"****** Vista Uno - Usando app_config ID: {id(app_config)} ******")
8

9
    # Accede a la configuración
10
    db_url = app_config.get_database_url()
11

12
    # Simulamos un cambio (aunque no es buena práctica modificar config global así)
13
    # Solo para demostrar que es el mismo objeto
14
    if random.random() < 0.5:
15
         app_config._database_url = "jdbc:h2:mem:testdb_django_MODIFICADO"
16
         print("****** Vista Uno - URL MODIFICADA ******")
17

18
    return JsonResponse({
19
        "vista": "uno",
20
        "db_url": db_url,
21
        "max_conn": app_config.get_max_connections(),
22
        "config_id": id(app_config) # ID del objeto módulo en memoria
23
    })
24

25
def vista_dos(request):
26
    print(f"****** Vista Dos - Usando app_config ID: {id(app_config)} ******")
27

28
    # Accede a la configuración (la misma instancia que vista_uno)
29
    db_url = app_config.get_database_url()
30

31
    return JsonResponse({
32
        "vista": "dos",
33
        "db_url": db_url,
34
        "max_conn": app_config.get_max_connections(),
35
        "config_id": id(app_config) # Debería ser el mismo ID que en vista_uno
36
    })

id(app_config): Devuelve el identificador único del objeto app_config en memoria. Si es el mismo en ambas vistas, confirma que es la misma instancia.

Paso 5: Configurar las URLs y Probar ✅#

Crea config_app/urls.py:

1
from django.urls import path
2
from . import views
3

4
urlpatterns = [
5
    path('vista1/', views.vista_uno),
6
    path('vista2/', views.vista_dos),
7
]

Incluye estas URLs en singleton_django/urls.py:

1
from django.urls import path, include
2
urlpatterns = [path('api/config/', include('config_app.urls'))]

Ejecuta python manage.py runserver.
Observa la Consola del Servidor: Al iniciar, deberías ver el mensaje "****** Cargando app_config.py ... ******" una sola vez. También verás el mensaje de inicialización costosa la primera vez que una vista lo llame.
Prueba los endpoints en tu navegador varias veces y en diferente orden:
- http://127.0.0.1:8000/api/config/vista1/
- http://127.0.0.1:8000/api/config/vista2/
Respuestas esperadas (JSON, los IDs serán iguales):
```
1
// Para vista1
2
{
3
    "vista": "uno",
4
    "db_url": "jdbc:h2:mem:testdb_django", // O la versión modificada
5
    "max_conn": 5,
6
    "config_id": 1401234567890
7
}
```
```
1
// Para vista2
2
{
3
    "vista": "dos",
4
    "db_url": "jdbc:h2:mem:testdb_django", // Verás la versión modificada si vista1 la cambió
5
    "max_conn": 5,
6
    "config_id": 1401234567890 // MISMO ID que en vista1
7
}
```
El hecho de que el config_id sea el mismo y que los cambios hechos en vista_uno (la modificación de la URL) se reflejen en vista_dos demuestra que ambas están interactuando con la única instancia del módulo app_config.