
Principio de Responsabilidad Única (Single Responsibility Principle)

Victor Arana Flores
12 May 2025

El Principio de Responsabilidad Única (SRP), parte de los principios SOLID, es uno de los pilares fundamentales para escribir código limpio, mantenible y escalable. Este principio establece que una clase debe tener una, y solo una, razón para cambiar, es decir, debe encargarse de una única responsabilidad.
En este artículo, exploraremos en profundidad qué es el SRP, por qué es importante y cómo aplicarlo correctamente en tus proyectos de desarrollo de software. Si quieres dominar este y otros principios de diseño, te recomiendo mi curso Patrones de Diseño con PHP, donde aprenderás a aplicar las mejores prácticas en programación orientada a objetos.
¿Qué es el Principio de Responsabilidad Única?
El SRP fue introducido por Robert C. Martin (Uncle Bob) y forma parte de los 5 principios SOLID. Su definición clave es:
“Una clase debe tener una única responsabilidad, es decir, solo una razón para cambiar.”
Esto significa que si una clase realiza múltiples tareas, cualquier modificación en una de ellas podría afectar a las demás, generando acoplamiento y dificultando el mantenimiento.
Ejemplo de Violación del SRP
Imagina una clase User
que no solo gestiona la información del usuario, sino que también se encarga de enviar correos electrónicos y guardar registros en la base de datos:
class User {
private string $name;
private string $email;
public function __construct(string $name, string $email) {
$this->name = $name;
$this->email = $email;
}
public function saveToDatabase() {
// Lógica para guardar en la base de datos
}
public function sendWelcomeEmail() {
// Lógica para enviar un correo
}
public function logUserActivity() {
// Lógica para registrar actividad
}
}
Este diseño viola el SRP porque la clase User
tiene múltiples responsabilidades: gestión de datos, envío de emails y logging.
Refactorización Aplicando SRP
Para cumplir con el SRP, dividimos las responsabilidades en clases separadas:
class User {
private string $name;
private string $email;
public function __construct(string $name, string $email) {
$this->name = $name;
$this->email = $email;
}
}
class UserRepository {
public function save(User $user) {
// Guardar en la base de datos
}
}
class EmailService {
public function sendWelcomeEmail(User $user) {
// Enviar correo de bienvenida
}
}
class Logger {
public function logActivity(string $activity) {
// Registrar actividad
}
}
Ahora que tenemos nuestras clases bien organizadas (¡cada una con su única misión!), usarlas juntas es pan comido. Imagina este escenario:
// Creamos nuestro usuario
$user = new User("Ana", "ana@example.com");
// Cada servicio hace lo suyo sin interferir
(new UserRepository)->save($user); // Guarda en DB
(new EmailService)->sendWelcomeEmail($user); // Envía el correo
(new Logger)->logActivity("Nuevo registro"); // Registra la acción
Beneficios de Aplicar el SRP
- Código más legible y mantenible: Las clases pequeñas y enfocadas son más fáciles de entender y modificar.
- Menos acoplamiento: Al separar responsabilidades, los cambios en una clase no afectan a otras.
- Facilita las pruebas unitarias: Las clases con una sola responsabilidad son más fáciles de testear.
- Promueve la reutilización: Las funcionalidades bien separadas pueden ser reutilizadas en otros contextos.
Conclusión
El Principio de Responsabilidad Única (SRP) es esencial para desarrollar software robusto y escalable. Al aplicarlo correctamente, mejoramos la estructura de nuestro código y reducimos la complejidad.
Si quieres profundizar en este y otros principios de diseño de software, te invito a revisar mi curso Patrones de Diseño con PHP, donde aprenderás a aplicar SOLID, patrones de diseño y buenas prácticas en tus proyectos.
¡Empieza a escribir código más limpio y profesional hoy mismo! 🚀
2 comentarios
Inicia sesión para comentar
Comentarios:
-
Alvaro Claro hace 2 meses
Excelente, muy clara la info!
-
Eddy Joel Barranzuela Maldonado hace 2 meses
Genial!