अवधारणाओं

SOLID एक संक्षिप्त शब्द है जो रॉबर्ट सी. मार्टिन - अंकल बॉब द्वारा प्रस्तावित ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के पांच मूलभूत सिद्धांतों का प्रतिनिधित्व करता है। यहां आप उनके लेख के बारे में अधिक पढ़ सकते हैं।
इन सिद्धांतों का उद्देश्य कोड की संरचना और रखरखाव में सुधार करना है, जिससे इसे अधिक लचीला, स्केलेबल और समझने में आसान बनाया जा सके।

ये सिद्धांत प्रोग्रामर को अधिक संगठित कोड बनाने, जिम्मेदारियों को विभाजित करने, निर्भरता को कम करने, रीफैक्टरिंग प्रक्रिया को सरल बनाने और कोड पुन: उपयोग को बढ़ावा देने में मदद करते हैं।

संक्षिप्त नाम में "एस" का अर्थ है "एकल उत्तरदायित्व सिद्धांत"। इस सिद्धांत को परिभाषित करने के लिए अंकल बॉब ने जिस वाक्यांश का प्रयोग किया वह था:

"एक वर्ग में बदलाव का एक, और केवल एक ही कारण होना चाहिए।"

इस सिद्धांत के अनुसार, जब हम अपनी कक्षाएं विकसित करते हैं, तो हमें उनकी विशेष कार्यक्षमता को ध्यान में रखना होगा। यदि कोई वर्ग दो कार्यात्मकताओं से निपटता है तो सबसे अच्छी बात यह है कि उसे विभाजित कर दिया जाए।
ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग सीखते समय, तथाकथित गॉड क्लासेस का निर्माण करते हुए, एक ही क्लास को कई जिम्मेदारियाँ सौंपना आम बात है। हालाँकि यह दृष्टिकोण शुरू में कुशल लगता है, लेकिन यह जिम्मेदारियों को मिश्रित करता है, जिससे दूसरों को प्रभावित किए बिना एक को बदलना मुश्किल हो जाता है।

व्यावहारिक अनुप्रयोग

इस समस्या के व्यावहारिक अनुप्रयोग का उदाहरण देने के लिए, मैं 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;
    }
}

मुख्य समस्या जो हम यहां पा सकते हैं वह कोड रखरखाव है। यदि सत्यापन तर्क या डेटा सहेजने के तरीके में कोई बदलाव होता है, तो यह सीधे इस वर्ग को प्रभावित करेगा, जिससे इसे बनाए रखना मुश्किल हो जाएगा।

अब, हम इसे कैसे हल कर सकते हैं?
हमें गॉड क्लास "यूजरसर्विस" में निहित अपने तर्क को अच्छी तरह से परिभाषित कार्यात्मकताओं के साथ कई वर्गों में अलग करना होगा। चलो देखते हैं:

जावा

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

मजबूत और स्केलेबल सॉफ्टवेयर बनाने के लिए एकल जिम्मेदारी सिद्धांत को लागू करना महत्वपूर्ण है। यह सुनिश्चित करके कि प्रत्येक वर्ग की केवल एक जिम्मेदारी है, हम कोड जटिलता को कम करते हैं, रखरखाव और रीफैक्टरिंग की सुविधा देते हैं और त्रुटियों के जोखिम को कम करते हैं। यह सिद्धांत परियोजना की गुणवत्ता और दीर्घायु बनाए रखने, स्वच्छ और अधिक कुशल डिजाइन को बढ़ावा देने के लिए मौलिक है।