Solid prensipleri, yazılım tasarımında önemli bir rol oynar ve kodun sürdürülebilirliğini, esnekliğini ve okunabilirliğini artırmayı hedefler. Bu prensiplerden ilki olan Single Responsibility prensibi, bir sınıfın sadece bir sorumluluğu olması gerektiğini belirtir.
Single Responsibility prensibi (SRP), bir sınıfın yalnızca bir nedeni olması gerektiğini ifade eder. Bir sınıfın tek bir sorumluluğu olması, onun üzerinde değişiklik yapma ihtimalini en aza indirir ve sınıfın içindeki değişikliklerin diğer bileşenlere minimum etkisi olur. Bu, kodun bakımını kolaylaştırır, anlaşılabilirliğini artırır ve gelecekteki gereksinimlere daha iyi uyum sağlar.
Bir sınıfın tek bir sorumluluğu olduğundan emin olmak için, sınıfın ne yaptığını ve hangi işlemleri gerçekleştirdiğini anlamak önemlidir. Eğer bir sınıfın farklı işlevleri veya sorumlulukları varsa, bu işlevleri ayrı sınıflara bölebiliriz. Böylece her sınıfın tek bir sorumluluğu olur ve kodumuz daha okunabilir hale gelir.
Örneğin, kullanıcı kaydını gerçekleştiren ve kullanıcı verilerini işleyen bir sınıfımız varsa, bu sınıfı ikiye bölebiliriz. Biri kullanıcı kaydını gerçekleştiren sınıf, diğeri ise kullanıcı verilerini işleyen sınıf olabilir. Bu şekilde, her sınıfın ayrı bir sorumluluğu olur ve kodumuz daha modüler hale gelir.
Ben örnekleri Php üzerinden yazacağım. Diğer yazılım dillerinde de mantık benzer şekilde işlemektedir.
class UserRegistration {
public function register() {
// Kullanıcı kaydı işlemleri
$this->sendWelcomeEmail();
}
private function sendWelcomeEmail() {
// Hoş geldiniz e-postası gönderme işlemleri
}
}
class UserDataProcessor {
public function processData($data) {
// Kullanıcı verilerini işleme işlemleri
}
}
Yukarıdaki örnekte, UserRegistration sınıfı kullanıcı kaydı işlemlerini gerçekleştirir ve sendWelcomeEmail metodu ile hoş geldiniz e-postasını gönderir. UserDataProcessor sınıfı ise kullanıcı verilerini işleyen işlemleri gerçekleştirir.
Bir sınıfın içinde çok sayıda işlev veya metot olduğunda, bu işlevleri mantıksal gruplara ayırmak önemlidir. Her işlevin tek bir sorumluluğu olmalı ve sadece belirli bir işi yapmalıdır. İşlevlerin tek bir amacı olduğunda, sınıf daha spesifik ve daha az bağımlı hale gelir.
class User {
public function register() {
// Kullanıcı kaydı işlemleri
$this->sendWelcomeEmail();
}
public function login() {
// Kullanıcı girişi işlemleri
}
private function sendWelcomeEmail() {
// Hoş geldiniz e-postası gönderme işlemleri
}
}
Yukarıdaki örnekte, User sınıfı, register ve login metotları ile kullanıcı kaydı ve girişi işlemlerini gerçekleştirir. sendWelcomeEmail metodu ise hoş geldiniz e-postasını gönderir. Her metot, sadece belirli bir işi yapar ve sınıfın sorumluluğu net bir şekilde ayrılır.
Bir sınıfın diğer sınıflara veya bileşenlere bağımlılığı varsa, bu bağımlılıkların da tek bir sorumluluğu olmalıdır. Eğer bir sınıf birden fazla sorumluluğa sahip olan başka sınıflara bağımlıysa, bu durumda bağımlılıkları azaltmak için gerektiğinde ilgili sınıfların arayüzlerini kullanabiliriz.
interface DatabaseInterface {
public function save($data);
}
class User {
private $database;
public function __construct(DatabaseInterface $database) {
$this->database = $database;
}
public function register() {
// Kullanıcı kaydı işlemleri
$this->database->save($userData);
}
}
class MySQLDatabase implements DatabaseInterface {
public function save($data) {
// Verileri MySQL veritabanına kaydetme işlemleri
}
}
Yukarıdaki örnekte, User sınıfı DatabaseInterface arayüzüne bağımlıdır. Bu sayede, farklı veritabanı sınıflarıyla değiştirilebilirlik sağlanır. MySQLDatabase sınıfı, DatabaseInterface arayüzünü uygular ve verileri MySQL veritabanına kaydeder. Bağımlılıkların yönetilmesi sayesinde, User sınıfı tek bir sorumluluğa sahip olur ve veritabanı işlemleri başka bir sınıfa taşınır.
Single Responsibility prensibi, yazılım tasarımında önemli bir prensiptir ve kodun sürdürülebilirliğini, okunabilirliğini ve esnekliğini artırmayı hedefler. PHP'de bu prensibi uygulamak için sınıfları bölümleyebilir, işlevleri ayrıştırabilir ve bağımlılıkları yönetebiliriz. Bu sayede daha modüler, daha okunabilir ve daha sürdürülebilir bir kod tabanı oluşturabiliriz. Single Responsibility prensibini takip etmek, kodunuzun gelecekteki değişikliklere daha iyi uyum sağlamasını sağlar ve daha kaliteli bir yazılım geliştirmenize yardımcı olur.
