مفهوم tight coupling

منبع: chatgpt

Tight coupling (وابستگی شدید) به وضعیتی در طراحی نرم‌افزار اشاره دارد که در آن کلاس‌ها یا ماژول‌ها وابستگی زیادی به یکدیگر دارند، به طوری که تغییر در یکی از آن‌ها به‌سادگی بر بقیه تأثیر می‌گذارد. در این حالت، کلاس‌ها برای انجام کارهایشان نیاز به دانستن جزئیات و پیاده‌سازی‌های داخلی یکدیگر دارند و انعطاف‌پذیری سیستم کاهش می‌یابد.

ویژگی‌های tight coupling:

1. وابستگی زیاد بین کلاس‌ها یا ماژول‌ها: اگر کلاس A تغییر کند، احتمالاً باید کلاس B نیز تغییر کند، زیرا A و B به شدت به هم وابسته هستند.
2. تداخل زیاد بین پیاده‌سازی‌ها: کلاس‌ها یا ماژول‌ها اطلاعاتی از ساختار داخلی یکدیگر دارند و به جزئیات خاصی متکی هستند، مثلاً کلاس A ممکن است نیاز داشته باشد که جزئیات خاصی از کلاس B را بداند تا کار کند.
3. کاهش انعطاف‌پذیری و قابلیت نگهداری: به دلیل وابستگی بالا، تغییرات در کد پیچیده‌تر و احتمال بروز خطا بیشتر می‌شود. به همین دلیل، گسترش و اضافه کردن ویژگی‌های جدید سخت می‌شود.

مثال از tight coupling:

فرض کنید شما یک برنامه ساده برای پردازش سفارشات دارید. یک کلاس OrderProcessor دارید که به طور مستقیم از یک کلاس PaymentService برای پردازش پرداخت استفاده می‌کند.

class PaymentService {
    public function processPayment($amount) {
        // کد پردازش پرداخت
        echo "Payment of $amount processed.";
    }
}

class OrderProcessor {
    private $paymentService;

    public function __construct() {
        $this->paymentService = new PaymentService();
    }

    public function processOrder($amount) {
        // پردازش سفارش
        $this->paymentService->processPayment($amount); // وابستگی مستقیم به PaymentService
    }
}

در این مثال، کلاس OrderProcessor به شدت به PaymentService وابسته است:

• اگر تغییر کوچکی در PaymentService ایجاد کنید، باید OrderProcessor هم تغییر کند.
• این وابستگی شدید مانع از این می‌شود که بتوانید به‌راحتی سرویس‌های پرداخت دیگر را اضافه یا جایگزین کنید.

معایب tight coupling:

• کاهش انعطاف‌پذیری: با tight coupling، اگر بخواهید یک قسمت از کد را تغییر دهید، احتمالاً باید بخش‌های زیادی از سیستم را هم تغییر دهید.
• سخت‌تر شدن تست و اشکال‌زدایی: به دلیل این وابستگی شدید، تست مستقل هر جزء سخت‌تر می‌شود، چون بخش‌های دیگر سیستم هم باید با آن هماهنگ باشند.
• قابلیت نگهداری پایین: افزایش پیچیدگی در نگهداری و ارتقا نرم‌افزار به دلیل وابستگی‌های زیاد و گسترده.

جلوگیری از tight coupling:

یکی از بهترین روش‌ها برای جلوگیری از tight coupling استفاده از Dependency Injection و Interface Segregation است. با این کار، کلاس‌ها به جای این‌که مستقیماً به هم وابسته باشند، به یک رابط (interface) یا سرویس انتزاعی وابسته می‌شوند.

مثال با استفاده از Dependency Injection:

در مثال قبلی، می‌توانیم وابستگی به PaymentService را از طریق تزریق وابستگی (Dependency Injection) مدیریت کنیم و از یک interface برای کاهش وابستگی استفاده کنیم:

interface PaymentInterface {
    public function processPayment($amount);
}

class PaymentService implements PaymentInterface {
    public function processPayment($amount) {
        echo "Payment of $amount processed.";
    }
}

class OrderProcessor {
    private $paymentService;

    public function __construct(PaymentInterface $paymentService) {
        $this->paymentService = $paymentService;
    }

    public function processOrder($amount) {
        $this->paymentService->processPayment($amount);
    }
}

// در برنامه اصلی یا تست
$paymentService = new PaymentService();
$orderProcessor = new OrderProcessor($paymentService);
$orderProcessor->processOrder(100);

در این مثال:

• کلاس OrderProcessor دیگر به PaymentService وابستگی مستقیم ندارد و به جای آن از PaymentInterface استفاده می‌کند.
• این باعث می‌شود که بتوانید هر سرویس پرداخت دیگری که از PaymentInterface پیروی می‌کند را بدون نیاز به تغییر در OrderProcessor استفاده کنید.

نتیجه‌گیری:

Tight coupling باعث کاهش انعطاف‌پذیری و سخت‌تر شدن نگهداری کد می‌شود. برای بهبود این وضعیت، باید از تکنیک‌هایی مانند Dependency Injection و استفاده از Interfaces بهره ببرید تا وابستگی بین اجزای سیستم کاهش یابد و کد منعطف‌تر و قابل نگهداری‌تر شود.