概念

SOLID 是一个缩写词，代表面向对象编程的五个基本原则，由 Robert C. Martin（鲍勃大叔）提出。在这里您可以阅读有关他的文章的更多信息。
这些原则旨在改进代码的结构和维护，使其更加灵活、可扩展且更易于理解。

这些原则帮助程序员创建更有组织的代码、划分职责、减少依赖、简化重构过程并促进代码重用。

缩写词中的“S”代表“单一责任原则”。 Bob叔叔用来定义这个原则的短语是：

“一个类必须有一个且只有一个改变的理由。”

根据这个原则，当我们开发类时，我们需要牢记它们的特定功能。如果一个类处理两个功能，最好的办法就是将其拆分。
在学习面向对象编程时，通常会将多个职责分配给单个类，从而创建所谓的上帝类。尽管这种方法最初看起来很有效，但它混合了职责，因此很难在不影响其他职责的情况下改变一个职责。

实际应用

为了举例说明这个问题的实际应用，我将创建一个名为 UserService 的类。它将处理与用户相关的各种需求。

首先，我们来看看这个类在不使用单一职责原则的情况下的应用。这里我们的类做了几件事：操作用户数据，验证该数据，并在数据库中创建用户。

爪哇

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());
    }
}

打字稿

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;
    }
}

我们在这里可以发现的主要问题是代码维护。如果验证逻辑或者数据保存方式发生变化，会直接影响这个类，导致维护困难。

现在，我们该如何解决这个问题？
我们必须将上帝类“UserService”中包含的逻辑分成几个具有明确功能的类。让我们来看看：

爪哇

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();
    }
}

打字稿

// 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();
    }
}

应用单一职责原则对于创建健壮且可扩展的软件至关重要。通过确保每个类只有一个职责，我们可以降低代码复杂性，方便维护和重构，并最大限度地降低错误风险。这一原则对于保持项目的质量和寿命、促进更清洁、更高效的设计至关重要。