Singleton y por qué evitarlo

  • Lección 9 de 32
  • 10 min
  • Inicial
  • 13 pasos

Un Singleton garantiza que una clase tenga una sola instancia, accesible desde cualquier parte del código. Suena práctico, pero ese acceso global esconde dependencias y hace que los tests se pisen entre sí.

Instancias de Config
1
Dependencias ocultas
0
Tests
—
PedidosPedidosorders.jsPedidosPagosPagosapp Javapayments.jsPagosCorreoCorreoemail.jsCorreocopias de ConfigConfigConfigRuntimeconfig.jsConfigServiceConfigConfig.jsConfig.jstest Atest BSettingsSettingsfakefakemain.tsmain.tscontenedorNestmain.ts10 copiasCada módulo, su copia// orders.tsconst config = new Config();// payments.tsconst config = new Config();// email.tsconst config = new Config();…y 7 módulos más (ejemplo)1 instanciaConfig.get()new Config(): errorConfig.tsclass Config {private static instance?: Config;private constructor(readonly env: string) {}static get(): Config {Config.instance ??= new Config(readEnv());return Config.instance;}}readEnv() lee process.env.NODE_ENV1 por aplicaciónJavaRuntime rt = Runtime.getRuntime();long free = rt.freeMemory();int cpus = rt.availableProcessors();// la app no puede crear su Runtimeen cachéNode.js// config.jsmodule.exports = { env: readEnv() };// orders.js, payments.js, email.jsconst config = require("./config");// los tres reciben el mismo objeto2.ª instanciaDos nombres, dos módulos// orders.jsconst a = require("./Config");// payments.jsconst b = require("./config");// disco que ignora mayúsculas:a === b; // falseno lo declaraDependencia ocultafunction greeting() {return `env=${Config.get().env}`;}// la firma no dice que usa Configgreeting(); // ¿de dónde sale env?debug = truefallaconfig.test.ts// Config ahora tiene: debug = falsetest("A", () => {Config.get().debug = true;});test("B", () => {expect(Config.get().debug).toBe(false);}); // falla si A corrió antes¿hace falta global?¿Singleton?único de verdad (Runtime)sísolo lectura tras arrancaraceptableguarda estado que cambiaevítalolos tests lo modificanevítalocrea 1 Configmain.ts// main.ts: se crea una vez al arrancarconst config = new Config(readEnv());const orders = new Orders(config);const payments = new Payments(config);const email = new Email(config);interfazpasaDependencia explícitainterface Settings { env: string }function greeting(s: Settings) {return `env=${s.env}`;}greeting(config); // en la appgreeting({ env: "test" }); // en el testsingleton por defectoNestJS@Injectable()export class ConfigService {}@Injectable()export class OrdersService {constructor(private config: ConfigService) {}}una instancia, explícitaSeñal y qué hacerConfig.get() dentro de una funciónrecíbelo por parámetroun test cambia el estado globaluna instancia por testnecesitas una sola instanciacréala en main y pásalausas NestJS o Angulardeja que la inyecte
  • petición
  • respuesta
  • petición fallida

Paso 1 de 13

Problema

Cada módulo crea su propia configuración

Tu app lee su configuración (entorno, URLs, banderas) de process.env. Pedidos, pagos y correo hacen cada uno new Config(), y en este ejemplo hay 10 módulos así: 10 objetos iguales en memoria.

Mientras nadie los cambie, no pasa nada. Pero si un módulo cambia un valor, los otros 9 no se enteran: cada uno ve su propia versión de la configuración.

Paso 2 de 13

Concepto

Singleton: una sola instancia y un acceso global

El patrón Singleton, uno de los 23 del libro de Gamma, Helm, Johnson y Vlissides (1994), promete dos cosas: que una clase tenga una única instancia y que cualquier parte del código llegue a ella desde un punto de acceso global.

Ya no hay new Config() en cada módulo: todos piden Config.get() y reciben el mismo objeto. Si uno cambia un valor, los demás lo ven.

Qué cambió

  • 10 copias de Config
  • 1 instancia compartida
  • new Config() → Config.get()

Paso 3 de 13

Técnica

Constructor privado y un método estático

El constructor es private: fuera de la clase, new Config() no compila. La única puerta de entrada es el método estático get().

get() crea la instancia la primera vez (??= asigna solo si el campo está vacío) y después devuelve siempre la misma. Por eso Config.get() === Config.get() da true.

Paso 4 de 13

Concepto

Runtime: un singleton de la biblioteca estándar de Java

En Java, cada aplicación tiene una sola instancia de Runtime, que conecta tu programa con el entorno donde corre. La obtienes con Runtime.getRuntime(), y la documentación aclara que una aplicación no puede crear la suya.

Aquí la unicidad tiene sentido: tu proceso corre en un solo entorno, así que dos Runtime no representarían nada real.

Paso 5 de 13

Concepto

En Node, un módulo que exporta un objeto ya es un singleton

Node guarda en caché cada módulo la primera vez que lo carga. Si orders.js, payments.js y email.js hacen require("./config"), los tres reciben el mismo objeto y el archivo no vuelve a ejecutarse.

Sin clase, sin private y sin get(): exportar una instancia desde un módulo te da, en la práctica, un singleton. Con los mismos costos que verás en unos pasos.

Paso 6 de 13

Problema

La caché distingue los módulos por su nombre de archivo resuelto

La caché de Node usa como clave el nombre de archivo resuelto. Si dos require resuelven a nombres distintos, Node carga el módulo dos veces y obtienes dos instancias.

La documentación de Node da este ejemplo: en un sistema de archivos que no distingue mayúsculas, require("./config") y require("./Config") apuntan al mismo archivo, pero devuelven dos objetos distintos. Lo mismo puede pasar con un paquete que se resuelve desde carpetas node_modules distintas.

Qué cambió

  • Segunda instancia: Config.js
  • Instancias: 1 → 2

Paso 7 de 13

Problema

La firma no cuenta lo que la función necesita

greeting() no recibe nada, pero por dentro llama a Config.get(). Quien lee su firma, o quien la prueba, no tiene forma de saber que depende de la configuración.

Con un acceso global, cualquier función puede depender de cualquier cosa sin declararlo. En este ejemplo, pedidos, pagos y correo suman 3 dependencias ocultas: para encontrarlas hay que leer todo su código.

Qué cambió

  • 3 dependencias que no aparecen en ninguna firma

Paso 8 de 13

Problema

Dos tests comparten la misma instancia

Ahora Config tiene un campo que cambia: debug. El test A lo pone en true y no lo restaura. El test B espera false y falla, aunque el código que prueba está bien.

El fallo depende del orden: B pasa si corre solo y falla si A corre antes. Como los dos comparten la única instancia, el estado de un test se filtra al siguiente.

Qué cambió

  • Campo mutable debug
  • El test B falla según el orden

Paso 9 de 13

Compromiso

Cuándo tiene sentido y cuándo no

Tiene sentido cuando la unicidad es un hecho del entorno, como el Runtime de un proceso Java, y el objeto no guarda estado que tus tests vayan a cambiar.

En el código de tu aplicación casi nunca hace falta: tener una sola instancia no exige el patrón Singleton. Basta con crear una al arrancar y pasarla a quien la necesite. Evítalo sobre todo si guarda estado que cambia.

Paso 10 de 13

Solución

Una instancia, creada al arrancar y pasada por parámetro

El constructor de Config vuelve a ser público. main.ts crea una configuración al arrancar y se la pasa a pedidos, pagos y correo en su constructor.

Sigue habiendo una sola instancia, pero ahora cada clase declara que la necesita: las dependencias ocultas bajan de 3 a 0. El lugar donde se arma todo se llama raíz de composición; lo verás en la próxima lección, inyección de dependencias.

Qué cambió

  • main.ts crea la instancia
  • Config.get() → parámetro del constructor
  • Dependencias ocultas: 3 → 0

Paso 11 de 13

Solución

En cada test pasas tu propio objeto

greeting() ahora recibe algo que cumpla la interfaz Settings. En la app le pasas la instancia que creó main.ts; en el test, un objeto literal { env: "test" }.

Cada test arma lo que necesita y nada se comparte entre tests: el orden deja de importar y el test B vuelve a verde.

Qué cambió

  • Interfaz Settings
  • Objeto de test: fake
  • Tests: rojo → verde

Paso 12 de 13

Concepto

NestJS y Angular: singleton por defecto, pero inyectado

En NestJS, una clase marcada con @Injectable() es un proveedor: por defecto, el contenedor de Nest crea una instancia y la comparte con todas las clases que la piden en su constructor.

Angular hace lo mismo con @Injectable({ providedIn: 'root' }): una instancia para toda la app, que pides con inject(). Tienes la unicidad sin el acceso global, y como la dependencia llega desde fuera, un test puede pasar otra.

Paso 13 de 13

Resumen

Una instancia, sí; acceso global, mejor no

Un Singleton asegura una sola instancia con un constructor privado y un acceso estático como get(). Lo ves en Runtime.getRuntime() de Java y en cualquier módulo de Node que exporta un objeto.

Su costo es el acceso global: dependencias que no aparecen en ninguna firma y estado que se filtra entre tests. Si necesitas una sola instancia, créala al arrancar y pásala como parámetro, o deja que tu framework la inyecte.

Aprenderás

  • Cómo un Singleton garantiza una sola instancia
  • Dónde lo encuentras: Runtime de Java y módulos de Node
  • Por qué el acceso global rompe tus tests
  • Cuándo tiene sentido y cuándo no
  • La alternativa: crear una instancia y pasarla