Conceptos

SOLID es un acrónimo que representa cinco principios fundamentales de la programación orientada a objetos, propuesto por Robert C. Martin - Uncle Bob. Aquí puedes leer más sobre su artículo.
Estos principios tienen como objetivo mejorar la estructura y el mantenimiento del código, haciéndolo más flexible, escalable y fácil de entender.

Estos principios ayudan al programador a crear códigos más organizados, dividiendo responsabilidades, reduciendo dependencias, simplificando el proceso de refactorización y promoviendo la reutilización de código.

La "S" del acrónimo significa "Principio de Responsabilidad Única". La frase que usó el tío bob para definir este principio fue:

"Una clase debe tener una, y sólo una, razón para cambiar."

De acuerdo con este principio, cuando desarrollamos nuestras clases, debemos tener en cuenta su funcionalidad particular. Si una clase trata con dos funcionalidades lo mejor que puedes hacer es dividirla.
Al aprender programación orientada a objetos, es común asignar múltiples responsabilidades a una sola clase, creando las llamadas Clases Dios. Aunque este enfoque inicialmente parece eficiente, combina responsabilidades, lo que dificulta cambiar una sin afectar a las demás.

Aplicación práctica

Para ejemplificar una aplicación práctica de este problema, crearé una clase llamada UserService. Manejará diversas necesidades relacionadas con los usuarios.

Primero, veamos la aplicación de esta clase sin utilizar el principio de responsabilidad única. Aquí nuestra clase hace varias cosas: manipula los datos del usuario, valida estos datos y crea usuarios en la base de datos.

Java

import java.util.ArrayList;
import java.util.List;

class User {
    private int id;
    private String name;
    private String email;

    public User(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{id="   id   ", name='"   name   "', email='"   email   "'}";
    }
}

class UserService {
    private List users = new ArrayList();

    public void addUser(String name, String email) {
        if (this.validateEmail(email)) {
            User newUser = new User(users.size()   1, name, email);
            users.add(newUser);
            saveToDatabase(newUser);
        } else {
            throw new IllegalArgumentException("E-mail inválido");
        }
    }

    private boolean validateEmail(String email) {
        return email.matches("\\S @\\S \\.\\S ");
    }

    private void saveToDatabase(User user) {
        System.out.println("Salvando usuário no banco de dados "   user);
    }

    public List getUsers() {
        return users;
    }

    public static void main(String[] args) {
        UserService userService = new UserService();
        userService.addUser("John Doe", "[email protected]");
        System.out.println(userService.getUsers());
    }
}

Mecanografiado

type User = { id: number, name: string, email: string }

class UserService {
    private users: User[] = [];

    addUser(name: string, email: string) {
        if (this.validateEmail(email)) {
            const newUser = {
                id: this.users.length   1,
                name: name,
                email: email
            };
            this.users.push(newUser);
            this.saveToDatabase(newUser);
        } else {
            throw new Error("E-mail inválido");
        }
    }

    private validateEmail(email: string): boolean {
        const emailRegex = /\S @\S \.\S /;
        return emailRegex.test(email);
    }

    private saveToDatabase(user: User) {
        console.log("Salvando usuário no banco de dados", user);
    }

    getUsers() {
        return this.users;
    }
}

El principal problema que podemos encontrar aquí es el mantenimiento del código. Si hay un cambio en la lógica de validación o en la forma en que se guardan los datos, afectará directamente a esta clase, dificultando su mantenimiento.

Ahora, ¿cómo podemos solucionar esto?
Debemos segregar nuestra lógica contenida en la clase Dios "UserService" en varias clases con funcionalidades bien definidas. Vamos a ver:

Java

import java.util.ArrayList;
import java.util.List;

// validador
class EmailValidator {
    public boolean validate(String email) {
        return email.matches("\\S @\\S \\.\\S ");
    }
}

// Repositório que manipula os dados no banco de dados
class UserRepository {
    private List users = new ArrayList();

    public void save(User user) {
        System.out.println("Salvando usuário no banco de dados "   user);
        users.add(user);
    }

    public List getAll() {
        return users;
    }
}

// Aplicamos as regras do domain com injeção de dependências
class UserService {
    private EmailValidator emailValidator;
    private UserRepository userRepository;

    public UserService(EmailValidator emailValidator, UserRepository userRepository) {
        this.emailValidator = emailValidator;
        this.userRepository = userRepository;
    }

    public void addUser(String name, String email) {
        if (emailValidator.validate(email)) {
            User newUser = new User(userRepository.getAll().size()   1, name, email);
            userRepository.save(newUser);
        } else {
            throw new IllegalArgumentException("E-mail inválido");
        }
    }

    public List getUsers() {
        return userRepository.getAll();
    }
}

Mecanografiado

// validador
class EmailValidator {
    validate(email: string): boolean {
        const emailRegex = /\S @\S \.\S /;
        return emailRegex.test(email);
    }
}

// Repositório que manipula os dados no banco de dados
class UserRepository {
    private users: { id: number, name: string, email: string }[] = [];

    save(user: { id: number, name: string, email: string }) {
        console.log("Salvando usuário no banco de dados", user);
        this.users.push(user);
    }
    getAll() {
        return this.users;
    }
}

// Aplicamos as regras do domain com injeção de dependências
class UserService {
    constructor(
        private emailValidator: EmailValidator,
        private userRepository: UserRepository
    ) {}

    addUser(name: string, email: string) {
        if (this.emailValidator.validate(email)) {
            const newUser = {
                id: this.userRepository.getAll().length   1,
                name: name,
                email: email
            };
            this.userRepository.save(newUser);
        } else {
            throw new Error("E-mail inválido");
        }
    }

    getUsers() {
        return this.userRepository.getAll();
    }
}

Aplicar el principio de responsabilidad única es crucial para crear un software robusto y escalable. Al garantizar que cada clase tenga una sola responsabilidad, reducimos la complejidad del código, facilitamos el mantenimiento y la refactorización y minimizamos el riesgo de errores. Este principio es fundamental para mantener la calidad y longevidad del proyecto, promoviendo un diseño más limpio y eficiente.