Principio de responsabilidad única.

Principio de responsabilidad única.

Ya he comentado varias veces que, existen una serie de principios y patrones de diseño que, una vez los asimilé, me han mejorado mucho la vida. El principio de responsabilidad única (o SRP por sus siglas en inglés) entra sin duda en ésta categoría.

¿Qué es el principio de responsabilidad única?

El principio de responsabilidad única es otro nombre (un poco largo) para la cohesión. Éste principio nos dice que cada elemento (o artefacto), debe encargarse de una sola cosa, o lo que es lo mismo, tener un solo motivo para cambiar. Si eres como yo... ésto te sonará demasiado abstracto y estarás pensando "Vale pero ... ¿Qué significa que tiene un solo motivo para cambiar?" Pues he de decirte que depende del nivel de abstracción:

  • Para una función: La responsabilidad a nivel de función puede ser limpiar una cadena, generar una cadena aleatoria ...
  • Para una clase: Para una clase la responsabilidad puede ser, por ejemplo. Encapsular los datos y las operaciones para trabajar con la ficha de un empleado.
  • Para un módulo o microservicio: Puede ser gestionar las facturas o los pagos...

Más adelante veremos que, esta distinción es algo simplista y que una función puede tener una responsabilidad más compleja y un microservicio puede tener una responsabilidad más simple. Pero, por el momento, para que te hagas una idea yo creo que está bien.

Vamos con un ejemplo

Has llegado hasta aquí y seguramente estarás pensando ... "Sigo sin saber exactamente como identificar lo que es una responsabilidad" y si es así lo entiendo, en su momento me pasó lo mismo, pero vamos a ver un ejemplo muy sencillo.
Imaginemos que tenemos la clase siguiente

La clase anterior es muy simple. Vemos que es una clase que se encarga de gestionar los datos de un empleado y de almacenarlos en la base de datos. Vamos a parar un momento porque acabo de darte la clave para determinar si la clase tiene una responsabilidad o más de una, piénsalo unos segundos antes de continuar.

La clase que he mostrado gestiona al usuario y lo almacena en base de datos por lo que, si cambia el algoritmo para calcular el salario, he de tocar esta función, pero si cambiamos de sistema de bases de datos, también he de tocar esta clase. Son dos cosas que realmente no tienen ninguna relación una es un cambio a nivel de negocio y otra a nivel de infraestructura, sin embargo, ambas provocan que esta clase deje de funcionar correctamente.

Una forma más correcta de separar las responsabilidades en este caso sería separar la ficha del usuario de la gestión del almacenamiento en base de datos (o dicho de otra forma, gestión de la persistencia).

Ojo, una responsabilidad no quiere decir que las clases solo deban tener un método. Como ya he mencionado anteriormente, lo que es una responsabilidad a nivel de clase no es lo mismo que a nivel de método. Todo comportamiento que suponga gestionar la información relativa a la ficha del empleado puede encapsularse en la clase Employee, podríamos tener datos como la fecha de nacimiento o la fecha de alta en la empresa y añadir métodos para calcular su edad o su antigüedad y seguiríamos pudiendo describir la responsabilidad de la clase como "Gestionar los datos de la ficha del empleado". Lo mismo sucede con la nueva clase EmployeeRepository, podemos añadir métodos para recuperar un usuario dado su identificador y seguiríamos pudiendo describir la responsabilidad de la clase como "Gestionar la persistencia del usuario en base de datos".

La forma más común de saber que un elemento tiene más de una responsabilidad, es comprobando la frecuencia con la que sufre modificaciones, los elementos que más modifiquemos, lo más probable es que tengan más de una responsabilidad.

¿Como y cuando aplicar el principio de responsabilidad única?

Èste principio y cualquier otro principio de diseño debes utilizar en un momento concreto y no antes. Èste momento es, cuando tengas un problema. Si si, lo se, si eres de los que te gusta leer libros sobre diseño ágil ésto tal vez no te guste pero permíteme que tras 15 años desarrollando software te de mi punto de vista. Soluciona los problemas cuando los tengas, no antes. Si has escrito una clase como la clase empleado que hemos descrito antes, tienes 2 métodos y todo funciona correctamente, no la rompas. ¿Para qué, que ibas a conseguir? Rompe la clase empleado cuando cambies la base de datos o cuando te veas añadiendo más métodos que hagan consultas, o cuando detectes que necesitas hacer una importación circular... Divídela cuando tengas un problema y no antes o puede que caigas en el problema contrario, la "Responsabilidad dividida".

Un ejemplo un poco más difícil

Un poco más arriba, al describir la diferencia de lo que es una responsabilidad, dependiendo de la capa en la que nos encontremos te he dicho que, la responsabilidad para una función podría ser algo más difícil de identificar. Vamos a ver un ejemplo más.

Revisa el siguiente ejemplo y dime ¿Este código tiene una responsabilidad única o tiene varias responsabilidades?

Antes que nada, he utilizado una función para ilustrarte que esto de la cohesión es aplicable a cualquier elemento de software que creemos.

Pero a lo que íbamos, que el artículo está quedando algo largo. Mirando a simple vista la función anterior, podemos pensar que hace varias cosas; limpia los datos del usuario, genera un password, lo crea en base de datos y luego envía el email para confirmar el email, Pero ... ¿que tiene que cambiar realmente para que necesitemos modificar éste código? . Si cambia la condición para limpiar los datos, no se hace aquí, lo mismo sucede con generar el password, se hace en otro lugar. Crear el usuario en base de datos o crear el email de confirmación, tampoco se hacen en ésta función, entonces ¿Que responsabilidad tiene ésta función , es una función sin responsabilidad propia?. Pues no, no es una función sin responsabilidad propia. La responsabilidad de ésta función es ejecutar todos los pasos necesarios para registrar a un usuario y su único motivo de cambio es que ese flujo cambie porque se añadan o eliminen pasos, pero la función "signup_user" no conoce los detalles de ninguno de esos pasos, que quedan encapsulados en las funciones a las que llama.

Ahora puede que estés pensando que el comportamiento de ésta función también puede describirse encadenando "y" cosa que, hace un momento te he dicho que significa que hay más de una responsabilidad. Pero recuerda que también te he dicho que debe haber más de un motivo de cambio. Para que la regla del "y" funcione debes aplicarla solamente a las funciones que implementan la lógica de cada acción. Esta función realiza varias acciones pero no es responsable de como se realiza ninguna de ellas. Los cambios en los detalles de cada acción no implican motivo de cambio para "signup_user".

Por qué aplicar el Principio de responsabilidad única

El principio de responsabilidad única es un principio muy simple pero muy potente cuando estamos desarrollando software entre sus beneficios principales tenemos :

  1. Mejora la legibilidad del código
  2. Favorece la modularidad y por lo tanto la escalabilidad.
  3. Mejora la escritura de test automáticos y su calidad (queda fuera del alcance de éste artículo el hablar de test automáticos).

En general, seguir éste principio ha hecho mi vida mucho más fácil, permitiéndome construir sistemas complejos uniendo piezas simples y acotadas.

Resumiendo

Si tienes que quedarte con una definición de éste artículo, quédate conque un elemento tiene una única responsabilidad cuando tiene un comportamiento concreto, pequeño y bien definido haciendo lo mínimo posible y teniendo sentido por sí mismo. Sigue éste principio cuando tu código empiece a "enredarse" y te aseguro que tu vida (como desarrollador) mejorará considerablemente.

Si quieres saber más te dejo por aquí el enlace al artículo original del "Tio Bob"

Clean Coder Blog



              

Subscribe to A Developer's Notebook

Don’t miss out on the latest issues. Sign up now to get access to the library of members-only issues.
jamie@example.com
Subscribe