Концепции

SOLID — это аббревиатура, обозначающая пять фундаментальных принципов объектно-ориентированного программирования, предложенных Робертом К. Мартином — дядей Бобом. Здесь вы можете прочитать больше о его статье.
Эти принципы направлены на улучшение структуры и обслуживания кода, делая его более гибким, масштабируемым и простым для понимания.

Эти принципы помогают программисту создавать более организованный код, разделяя обязанности, уменьшая зависимости, упрощая процесс рефакторинга и способствуя повторному использованию кода.

Буква «S» в аббревиатуре означает «Принцип единой ответственности». Фраза, которую дядя Боб использовал для определения этого принципа, была:

"У класса должна быть одна и только одна причина для изменения."

Согласно этому принципу, когда мы разрабатываем наши классы, нам необходимо учитывать их особую функциональность. Если класс имеет две функциональные возможности, лучше всего разделить его.
При изучении объектно-ориентированного программирования обычно на один класс возлагают несколько обязанностей, создавая так называемые классы Бога. Хотя этот подход на первый взгляд кажется эффективным, он смешивает обязанности, что затрудняет изменение одного без ущерба для других.

Практическое применение

Чтобы проиллюстрировать практическое применение этой проблемы, я создам класс 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;
    }
}

Основная проблема, с которой мы здесь столкнулись, — это обслуживание кода. Если произойдут изменения в логике проверки или способе сохранения данных, это напрямую повлияет на этот класс, что затруднит его обслуживание.

Теперь, как мы можем решить эту проблему?
Мы должны разделить нашу логику, содержащуюся в классе God «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();
    }
}

Применение принципа единой ответственности имеет решающее значение для создания надежного и масштабируемого программного обеспечения. Гарантируя, что каждый класс несет только одну ответственность, мы уменьшаем сложность кода, облегчаем обслуживание и рефакторинг и минимизируем риск ошибок. Этот принцип имеет основополагающее значение для поддержания качества и долговечности проекта, содействия созданию более чистого и эффективного дизайна.