Principios SOLID en Laravel: Cómo mejorar tu código

01.04.2025 — laravel, solid, programacion, buenas practicas — 4 minutos de lectura

SOLID es un acrónimo para cinco principios de diseño que ayudan a los desarrolladores a escribir software mantenible y escalable. Estos principios son particularmente útiles en aplicaciones Laravel, asegurando que tu código sea modular, fácil de probar y extender.

1. Principio de Responsabilidad Única (SRP)

Definición

Una clase debe tener solo una razón para cambiar.

Cada clase debe tener una única responsabilidad, es decir, debe realizar una sola tarea y no estar sobrecargada con múltiples funciones.

Ejemplo (Controlador en Laravel)

❌ Mal Ejemplo:

1class UserController extends Controller
2{
3    public function store(Request $request)
4    {
5        $user = User::create($request->all()); // Crea un nuevo usuario
6        Mail::to($user->email)->send(new WelcomeMail($user)); // Envía correo de bienvenida
7        Log::info('Usuario registrado: ' . $user->email); // Registra en logs
8    }
9}

✅ Buen Ejemplo:

1class UserController extends Controller
2{
3    protected $userService;
4
5    public function __construct(UserService $userService)
6    {
7        $this->userService = $userService; // Inyecta el servicio de usuario
8    }
9
10    public function store(Request $request)
11    {
12        $this->userService->registerUser($request->all()); // Llama al método del servicio
13    }
14}

1class UserService
2{
3    public function registerUser(array $data)
4    {
5        $user = User::create($data); // Crea un nuevo usuario
6        Mail::to($user->email)->send(new WelcomeMail($user)); // Envía correo de bienvenida
7        Log::info('Usuario registrado: ' . $user->email); // Registra en logs
8    }
9}

2. Principio de Abierto/Cerrado (OCP)

Definición

Las entidades de software deben estar abiertas para su extensión pero cerradas para su modificación.

Ejemplo (Sistema de Pagos en Laravel)

❌ Mal Ejemplo (Viola el OCP):

1class PaymentProcessor
2{
3    public function process($paymentMethod)
4    {
5        if ($paymentMethod == 'paypal') {
6            // Procesa pago con PayPal
7        } elseif ($paymentMethod == 'stripe') {
8            // Procesa pago con Stripe
9        }
10    }
11}

✅ Buen Ejemplo (Cumple con el OCP):

1interface PaymentGateway
2{
3    public function process(); // Define el método para procesar pagos
4}
5
6class PayPalPayment implements PaymentGateway
7{
8    public function process()
9    {
10        // Procesa pago con PayPal
11    }
12}
13
14class StripePayment implements PaymentGateway
15{
16    public function process()
17    {
18        // Procesa pago con Stripe
19    }
20}
21
22class PaymentProcessor
23{
24    public function process(PaymentGateway $gateway)
25    {
26        $gateway->process(); // Usa el gateway para procesar el pago
27    }
28}

3. Principio de Sustitución de Liskov (LSP)

Definición

Los objetos de una clase derivada deben poder reemplazar a los objetos de la clase base sin afectar la corrección del programa.

Ejemplo (Patrón Repositorio en Laravel)

❌ Mal Ejemplo:

1class UserRepository
2{
3    public function getUsers()
4    {
5        return User::all(); // Obtiene todos los usuarios
6    }
7}
8
9class AdminRepository extends UserRepository
10{
11    public function getUsers()
12    {
13        return Admin::all(); // Obtiene todos los administradores
14    }
15}

✅ Buen Ejemplo:

1interface UserRepositoryInterface
2{
3    public function getUsers(); // Define el método para obtener usuarios
4}
5
6class UserRepository implements UserRepositoryInterface
7{
8    public function getUsers()
9    {
10        return User::all(); // Obtiene todos los usuarios
11    }
12}
13
14class AdminRepository implements UserRepositoryInterface
15{
16    public function getUsers()
17    {
18        return Admin::all(); // Obtiene todos los administradores
19    }
20}

4. Principio de Segregación de Interfaces (ISP)

Definición

Una clase no debe verse obligada a implementar interfaces que no utiliza.

Ejemplo (Interfaces de Notificaciones en Laravel)

❌ Mal Ejemplo:

1interface NotificationInterface
2{
3    public function sendEmail(); // Define el método para enviar correo
4    public function sendSMS(); // Define el método para enviar SMS
5}
6
7class EmailNotification implements NotificationInterface
8{
9    public function sendEmail() {}
10    public function sendSMS() { throw new Exception("No implementado"); } // Método no utilizado
11}

✅ Buen Ejemplo:

1interface EmailNotificationInterface
2{
3    public function sendEmail(); // Define el método para enviar correo
4}
5
6interface SMSNotificationInterface
7{
8    public function sendSMS(); // Define el método para enviar SMS
9}
10
11class EmailNotification implements EmailNotificationInterface
12{
13    public function sendEmail() {}
14}

5. Principio de Inversión de Dependencias (DIP)

Definición

Depende de abstracciones, no de implementaciones concretas.

Ejemplo (Contenedor de Servicios en Laravel)

❌ Mal Ejemplo:

1class OrderService
2{
3    protected $paymentGateway;
4
5    public function __construct()
6    {
7        $this->paymentGateway = new PayPalPayment(); // Instancia directamente PayPal
8    }
9}

✅ Buen Ejemplo:

1class OrderService
2{
3    protected $paymentGateway;
4
5    public function __construct(PaymentGateway $paymentGateway)
6    {
7        $this->paymentGateway = $paymentGateway; // Inyecta el gateway de pagos
8    }
9}

Conclusión

Seguir los principios SOLID en Laravel lleva a un mejor diseño de software, facilita la depuración y crea aplicaciones más escalables. Ignorarlos resulta en código acoplado, difícil de mantener y propenso a errores.