SIN POSTUREOCatamos y probamos a fondo antes de recomendarte nada
Cinco gatos negros con gafas, corbata o pajarita sentados en fila tras una mesa de madera, mirando un portátil con cara de póker a la luz dorada de la tarde

S: responsabilidad única, una clase con una sola razón para cambiar

domin7 min de lectura

Lección 3 de 11 de Principios SOLID

Temario

Abres Factura.php para cambiar cómo se calcula el IVA y te encuentras con una consulta SQL y la maquetación del PDF en la misma clase. Cambias una línea y no sabes si acabas de romper el guardado.

Una clase que hace de todo

Esta Factura calcula el total, se guarda en base de datos y genera el PDF (por simplicidad, el IVA va fijo en el código y el «PDF» es el HTML que luego se convertiría):

<?php
class Factura
{
public function __construct(private array $lineas) {}
public function total(): float { return array_sum($this->lineas) * 1.21; }
public function guardar(PDO $pdo): void
{
$pdo->prepare('INSERT INTO facturas (total) VALUES (?)')->execute([$this->total()]);
}
public function generarPdf(): string { return '<h1>Factura</h1><p>' . $this->total() . ' €</p>'; }
}

Una clase debería tener una sola razón para cambiar. Esta tiene tres:

  • Contabilidad, cuando cambia el IVA.
  • El equipo técnico, si se migra de base de datos.
  • Diseño, cuando se retoca el PDF.

Cada razón la plantea una persona o un equipo distinto. Cada vez que abres la clase para uno puedes estropear lo que necesitaban los otros dos, y los tres pueden acabar editando el mismo fichero a la vez.

Cada tarea, en su clase

La salida es repartir el trabajo. La factura se queda con sus datos y su cálculo, y lo demás se va fuera:

<?php
class Factura
{
public function __construct(private array $lineas) {}
public function total(): float
{
return array_sum($this->lineas) * 1.21;
}
}
class FacturaRepositorio
{
public function __construct(private PDO $pdo) {}
public function guardar(Factura $factura): void
{
$this->pdo->prepare('INSERT INTO facturas (total) VALUES (?)')->execute([$factura->total()]);
}
}
class FacturaPdf
{
public function generar(Factura $factura): string { return '<h1>Factura</h1><p>' . $factura->total() . ' €</p>'; }
}

Ahora el cambio de base de datos solo toca FacturaRepositorio, y el nuevo diseño del PDF, solo FacturaPdf. Para comprobar que el total sale bien ya no necesitas base de datos ni generador de PDF.

Quién llama a las tres

Alguien tiene que coordinar las clases. Su único trabajo es llamar a las otras en orden:

<?php
class EmitirFactura
{
public function __construct(private FacturaRepositorio $repositorio, private FacturaPdf $pdf) {}
public function emitir(Factura $factura): string
{
$this->repositorio->guardar($factura);
return $this->pdf->generar($factura);
}
}

El código que coordina sigue existiendo, pero queda recogido en un solo método, cuya única razón para cambiar es el propio flujo de emisión.

Cómo notar que una clase hace demasiado

No hace falta contar métodos. Fíjate en estas señales:

  • Para describirla necesitas la palabra «y»: «calcula el total y lo guarda y genera el PDF».
  • El nombre lleva un And o varios verbos: ValidarYGuardar, GestorDeTodo.
  • Tienes que tocarla por motivos que no tienen nada que ver entre sí.
  • Para probarla hay que montar media aplicación (base de datos, correo, ficheros).
  • El constructor recibe cinco o seis dependencias.

El otro extremo: una clase por método

Separar el SQL y el PDF no obliga a sacar el cálculo: Factura conserva total(). También puede haber objetos que solo transporten datos. Lo que conviene evitar es separar reglas que cambian juntas por el mismo motivo.

También ocurre al revés. Dos trozos que se parecen por casualidad, pero que piden dos interesados distintos, no deberían compartir código: el día que uno cambie, arrastrarás al otro.

Ejercicio

Separa el registro de usuarios

Esta clase valida, guarda y prepara el mensaje de bienvenida:

<?php
class RegistroUsuario
{
public function registrar(string $email, string $clave, PDO $pdo): string
{
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException('Email no válido');
}
$pdo->prepare('INSERT INTO usuarios (email, clave) VALUES (?, ?)')
->execute([$email, password_hash($clave, PASSWORD_DEFAULT)]);
return "<p>Bienvenido, $email</p>";
}
}

Sepárala pensando en quién pediría cada cambio: reglas de entrada, seguridad, el equipo de datos y el de comunicación.

Ver una solución
<?php
class ValidadorRegistro
{
public function validar(string $email): void
{
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException('Email no válido');
}
}
}
class PoliticaClave
{
public function hash(string $clave): string { return password_hash($clave, PASSWORD_DEFAULT); }
}
class UsuarioRepositorio
{
public function __construct(private PDO $pdo) {}
public function guardar(string $email, string $hash): void
{
$this->pdo->prepare('INSERT INTO usuarios (email, clave) VALUES (?, ?)')->execute([$email, $hash]);
}
}
class MensajeBienvenida
{
public function crear(string $email): string { return "<p>Bienvenido, $email</p>"; }
}

Un quinto objeto, RegistrarUsuario, recibe los cuatro y los llama por orden, igual que EmitirFactura. Así las reglas del email, la política de contraseñas, el SQL y el HTML de bienvenida pueden cambiar por separado.

Un poco de historia

Lo formuló Robert C. Martin: «una clase debería tener una y solo una razón para cambiar». Se apoya en una idea más vieja, la cohesión, que pide que lo que cambia por el mismo motivo esté junto. Años después, Martin lo reformuló en términos de personas: un módulo debe responder ante un único interesado, que es lo que hemos visto con contabilidad, el equipo técnico y diseño.

Pon a prueba lo aprendido

1. ¿Qué dice el principio de responsabilidad única?

Ver la respuesta

C. Que una clase debe tener una sola razón para cambiar.

Una clase puede tener varios métodos si todos responden al mismo motivo de cambio.

2. La Factura calcula el total, se guarda en MySQL y genera el PDF. ¿Cuántas razones para cambiar tiene?

Ver la respuesta

C. Tres: el cálculo, el guardado y el PDF.

Cada tarea puede cambiar por un motivo distinto (la ley del IVA, la base de datos, el diseño del PDF), así que la clase tiene tres razones para abrirse.

3. ¿Cuál de estas señales sugiere que una clase hace demasiado?

Ver la respuesta

D. Que para describir lo que hace necesitas decir «y» varias veces.

Si la descripción va enlazando tareas con «y», probablemente hay varias responsabilidades mezcladas. Tener varios métodos coherentes entre sí no es un problema.

4. cobrar() y emitirTicket() cambian siempre juntos y por los mismos motivos. ¿Qué conviene hacer?

Ver la respuesta

B. Dejarlos en la misma clase, porque son la misma responsabilidad.

Una responsabilidad es un motivo de cambio, no un método. Si dos métodos cambian siempre juntos, separarlos solo añade ficheros.

5. Tras separar Factura, FacturaRepositorio y FacturaPdf, cambias de base de datos. ¿Qué clase tocas?

Ver la respuesta

B. FacturaRepositorio.

Es justo lo que se gana al dividir: cada cambio queda acotado a la clase responsable de esa tarea.

En calidad de Afiliado de Amazon, obtengo ingresos por las compras adscritas que cumplen los requisitos aplicables. Más detalles en el aviso de afiliados.