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
main.tsOrdersControllermain.tsOrderServiceOrderServiceBase de datosOrderRepoOrderRepoInvoicePdfInvoicePdfNotifierinterfazNotifierEmailNotifierEmailNotifierSmsNotifierSmsNotifierCheckoutCheckoutListinterfazListArrayListArrayListFixedListFixedListReadListinterfazReadListReportReportOrderStoreinterfazOrderStoreinterfazOrderReaderinterfazOrderStoreSqlOrdersSqlOrdersOrderWriterinterfazOrderWriterAdminAdmin3 motivos para cambiarconfirm(order)OrderService.tsclass OrderService {confirm(o: Order) {db.insert(o);if (o.channel === "sms") sendSms(o);else sendEmail(o);pdf.render(o);}}5 preguntas para esta claseLas cinco letrasSResponsabilidad únicaun motivo para cambiarOAbierto/cerradoañadir sin editarLSustitución de Liskovel subtipo cumpleISegregación de interfacespide solo lo que usasDInversión de dependenciasdepende de abstraccionesreunidos por Robert C. Martin (2000)solo coordinacambia si cambia el SQLcambia si cambia el PDFnuevo · sin tocar OrderServicesend(to, msg)intactoNotifier.tsinterface Notifier {send(to: string, msg: string): void;}+class SmsNotifier implements Notifier {+send(to: string, msg: string) { … }+}items.add("gift")UnsupportedOperationExceptionFixedList.javaclass FixedListextends AbstractList<String> {public String get(int i) { … }public int size() { … }}void addGift(List<String> items) {items.add("gift"); // throws}items.add("gift")cumple add()solo promete leerReadList.java+interface ReadList {+String get(int i);+int size();+}class FixedList+implements ReadList { … }usa 1 de 5 métodosfind(id)OrderStore.tsinterface OrderStore {find(id: string): Order;save(o: Order): void;delete(id: string): void;exportCsv(): string;importCsv(csv: string): void;}su fake: 1 métodosave(o)OrderReader.ts · OrderWriter.tsinterface OrderReader {find(id: string): Order;}interface OrderWriter {save(o: Order): void;delete(id: string): void;}class SqlOrders implements …elige la implementaciónno importa EmailNotifiersend(to, msg)OrderService.tsclass OrderService {constructor(private n: Notifier) {}confirm(id: string, to: string) {this.n.send(to, `order ${id}`);}}new OrderService(new EmailNotifier());no hace new: lo recibeOrderService inyectadoNestJS · Angular// NestJS@Controller("orders")class OrdersController {constructor(private s: OrderService) {}}// Angulars = inject(OrderService);1 implementación, 0 tests¿cambia alguna vez?más saltos para leerlocada letra, una preguntaLa pregunta y cuándo noS¿cuántos motivos para cambiar?script cortoO¿añado sin editar?un solo casoL¿el subtipo cumple todo?si heredas, siempreI¿uso todo lo que pido?un solo clienteD¿apunto a una abstracción?1 implementación, 0 tests
  • 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.

Aprenderás

  • Qué pregunta hace cada letra de SOLID
  • Cómo partir una clase que cambia por varios motivos
  • Cómo añadir un caso nuevo sin editar código que ya funciona
  • Cómo reconocer un subtipo que rompe a quien lo usa
  • Por qué conviene depender de abstracciones pequeñas
  • Cuándo seguir SOLID cuesta más de lo que aporta