SOLID sin dogma
- Lección 4 de 32
- 14 min
- Inicial
- 12 pasos
Parte, letra a letra, una clase que lo hace todo y aprende a distinguir cuándo un principio te ayuda y cuándo solo añade archivos.
- Principio
- SOLID
- petición
- respuesta
- petición fallida
Paso 1 de 12
Problema
Una clase, tres motivos para cambiar
main.ts llama a OrderService.confirm(). Ese método guarda el pedido en la base de datos, decide si avisa por email o por SMS y además genera la factura en PDF.
Funciona. El problema llega con los cambios: el equipo de datos cambia una tabla, marketing quiere avisar por WhatsApp y contabilidad pide otro formato de factura. Los tres tocan la misma clase, y cada cambio puede romper lo de los otros.
Paso 2 de 12
Concepto
SOLID: cinco preguntas, no cinco leyes
SOLID junta cinco principios de diseño orientado a objetos. Robert C. Martin los reunió en su artículo «Design Principles and Design Patterns» (2000) y, según cuenta él mismo, fue Michael Feathers quien hacia 2004 propuso ordenarlos para formar la palabra.
Úsalos como preguntas de revisión de código: ¿cuántos motivos tiene esta clase para cambiar?, ¿puedo añadir un caso sin editarla?, ¿este subtipo cumple lo que promete? No son reglas para aplicar siempre y al máximo.
Paso 3 de 12
Solución
S: un motivo para cambiar por clase
La responsabilidad única no significa «una clase, un método». Una lectura práctica: si dos personas distintas pueden pedirte cambios en la misma clase por razones distintas, esa clase tiene dos responsabilidades.
Sacamos el SQL a OrderRepo y la factura a InvoicePdf. OrderService queda como coordinador: llama a cada pieza en orden y no sabe cómo trabaja ninguna.
Ahora un cambio de tabla toca OrderRepo y nada más, y su test no necesita generar un PDF.
Qué cambió
- OrderRepo: guarda el pedido
- InvoicePdf: genera la factura
- OrderService solo coordina
Paso 4 de 12
Solución
O: abierto a extender, cerrado a editar
Antes, cada canal era otra rama del if dentro de OrderService: para añadir WhatsApp había que editar y volver a probar una clase que ya funcionaba.
Definimos la interfaz Notifier con un solo método, send(). EmailNotifier y SmsNotifier la implementan (la flecha con triángulo apunta a la interfaz) y OrderService solo llama a send().
Un canal nuevo es una clase nueva y OrderService no se toca: está cerrada a la edición y abierta a la extensión.
Qué cambió
- Notifier (interfaz)
- EmailNotifier y SmsNotifier
- El if por canal de OrderService
Paso 5 de 12
Problema
L: el sustituto que lanza una excepción
En Java, AbstractList permite crear una lista que no se puede modificar implementando solo get() y size(). Su add() por defecto lanza UnsupportedOperationException.
FixedList hace justo eso y, como hereda de AbstractList, es un List. Checkout recibe un List y llama a items.add("gift"). El compilador no protesta; en ejecución, la llamada falla.
El error no está en Checkout, que usó el contrato tal como lo describe List. Está en un subtipo que no cumple ese contrato.
Qué cambió
- Checkout recibe un List
- ArrayList y FixedList implementan List
Paso 6 de 12
Solución
L: el subtipo debe poder ocupar el lugar del padre
La idea viene del trabajo de Barbara Liskov, que la formalizó con Jeannette Wing en «A Behavioral Notion of Subtyping» (1994): un subtipo debe comportarse como su tipo base en todo lo que el cliente espera de él.
Si FixedList no puede añadir, no debería prometerlo. Le damos un contrato más pequeño, ReadList, con get() y size(). Quien necesita añadir pide un List y recibe un ArrayList, que sí cumple.
La prueba práctica: ¿puedes pasar el subtipo a cualquier código escrito para el padre sin que ese código tenga que saberlo? Si no, la herencia miente.
Qué cambió
- ReadList: get() y size()
- FixedList implementa ReadList
- FixedList como List
Paso 7 de 12
Problema
I: depender de métodos que no usas
OrderStore tiene cinco métodos: buscar, guardar, borrar, exportar CSV e importar CSV. Report solo muestra pedidos, así que usa find() y nada más.
Aun así, Report depende de los cinco. Su doble de test tiene que implementar cinco métodos para usar uno, y un cambio en importCsv() te obliga a revisar un código que nunca importa nada.
Qué cambió
- Report usa OrderStore
- SqlOrders implementa OrderStore
Paso 8 de 12
Solución
I: una interfaz a la medida de quien la usa
Partimos OrderStore según quién la usa: OrderReader con find() para Report, y OrderWriter con save() y delete() para Admin. Los métodos de CSV irán a una tercera interfaz cuando alguien los necesite.
SqlOrders implementa las dos, así que el acceso a la base de datos no cambia. Lo que cambia es lo que ve cada cliente: el fake de Report ahora tiene un solo método.
Qué cambió
- OrderStore pasa a ser OrderReader
- OrderWriter para Admin
Paso 9 de 12
Técnica
D: las flechas apuntan a la abstracción
Mira las flechas: OrderService depende de Notifier, y EmailNotifier también apunta a Notifier porque la implementa. Nada de la lógica de negocio apunta a la clase que envía emails.
Eso es la inversión de dependencias: el código de alto nivel (confirmar un pedido) y el de bajo nivel (hablar con un proveedor de email) dependen los dos de una abstracción, y esa abstracción la define quien la usa.
Elegir la implementación es trabajo de main.ts, el único sitio que hace new EmailNotifier(). En un test pasas un notificador falso y no se envía nada.
Qué cambió
- main.ts elige la implementación
Paso 10 de 12
Técnica
Dónde te lo cruzas: NestJS y Angular
NestJS y Angular hacen el trabajo de main.ts por ti. En NestJS declaras el servicio como proveedor y lo pides en el constructor: el framework crea OrderService y te lo pasa. En Angular lo pides con inject() o en el constructor.
OrdersController nunca escribe new OrderService(). Qué implementación recibe se decide fuera de él, así que cambiarla no obliga a editarlo.
Qué cambió
- main.ts → OrdersController de NestJS o Angular
Paso 11 de 12
Compromiso
Cuándo SOLID cuesta más de lo que aporta
Cada principio añade tipos y saltos. Un Notifier con una sola implementación y ningún test que la sustituya es ceremonia: un archivo más que leer y ningún beneficio hoy.
En un script corto o un prototipo que vas a tirar, una clase con dos responsabilidades está bien. Parte cuando aparezca el segundo motivo para cambiar, no antes.
Los principios también chocan entre sí: partir por la S y por la I multiplica archivos, y quien lee paga en navegación.
Qué cambió
- SmsNotifier: en este ejemplo hay un solo canal
Paso 12 de 12
Resumen
Cinco preguntas para tu próxima revisión
S: ¿cuántos motivos tiene esta clase para cambiar? O: ¿puedo añadir un caso sin editarla? L: ¿el subtipo cumple todo lo que promete el padre?
I: ¿este cliente depende de métodos que no usa? D: ¿la lógica de negocio apunta a una abstracción o a un detalle?
Y una sexta: ¿la respuesta justifica la complejidad que añade? Si no, deja el código simple y vuelve a preguntar cuando cambie.
← → paso · R repetir · Espacio pausa
Aprenderás
- Qué pregunta hace cada letra de SOLID (visto)
- Cómo partir una clase que cambia por varios motivos (visto)
- Cómo añadir un caso nuevo sin editar código que ya funciona (visto)
- Cómo reconocer un subtipo que rompe a quien lo usa (visto)
- Por qué conviene depender de abstracciones pequeñas (visto)
- Cuándo seguir SOLID cuesta más de lo que aporta (visto)