المفاهيم

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 إلى عدة فئات ذات وظائف محددة جيدًا. دعونا نرى:

جافا

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

يعد تطبيق مبدأ المسؤولية الفردية أمرًا بالغ الأهمية لإنشاء برامج قوية وقابلة للتطوير. من خلال التأكد من أن كل فئة لديها مسؤولية واحدة فقط، فإننا نقوم بتقليل تعقيد التعليمات البرمجية، وتسهيل الصيانة وإعادة البناء، وتقليل مخاطر الأخطاء. يعد هذا المبدأ أساسيًا للحفاظ على جودة المشروع وطول عمره، وتعزيز تصميم أنظف وأكثر كفاءة.