종속성 역전 원칙을 사용할 가치가 있는 이유

종속성 반전은 SOLID의 D이며 SOLID가 무엇인지 궁금할 수 있습니다.

SOLID are 5 software development principles or guidelines based on Object-Oriented design making it easier for you to make your projects scalable and maintainable.

규칙과 관례는 그 자리를 차지합니다. 코드에서 SOLID 디자인은 컨벤션/모범 사례로 간주됩니다.

이제 종속성 반전이란 무엇입니까?

원래

High-Level Modules Should Not Depend Upon Low-Level Modules. Both Should Depend Upon Abstractions.

그리 어렵지 않습니다. 오른쪽? 여기 더 있습니다

Abstractions Should Not Depend Upon Details. Details
Should Depend Upon Abstractions.

너무 혼란스럽나요? 이것은 도움이 될 수 있습니다

이게 무슨 뜻이야

✔️ 고수준 모듈과 저수준 모듈 모두 동일한 추상화에 의존해야 합니다.
✔️ 고수준 모듈은 저수준 모듈을 구현하는 추상화를 구현해야 하며 그 반대도 마찬가지입니다.
✔️ 추상화는 작업의 다른 세부 사항을 구현할 수 있습니다.
❌ 고수준 모듈은 추상화를 능가하는 세부 사항을 구현할 수 있습니다.

목표

추상/파사드/래퍼 패턴을 따릅니다.

상위 수준 구현에서 하위 수준 구현을 숨깁니다.

간단한 사용 사례

의 지불 예를 계속하겠습니다. 하지만 이 예시에서는 현재 현금 결제만 가능합니다.

interface Payment {
    pay(): boolean
}

class CashPayment implements Payment {
    public pay(amount){
        // handle cash payment logic
    }
}

function makePayment(amount: number, paymentMethod: Payment){
    if(paymentMethod.pay(amount)){
        return true;
    }
    return false;
}

이 특정 예에서 makePayment()는 고수준 모듈이고 CashPayment는 저수준 모듈입니다. 분명히 래퍼/추상화 레이어가 없습니다.

이제 신용카드 결제를 추가하려면 어떻게 해야 할까요? 다음과 같이 코드를 수정할 수 있습니다.

interface Payment {
    pay(): boolean
}

// (low-level module)
class CashPayment implements Payment {
    constructor(user){
        this.user = user
    }

    public pay(amount){
        // handle cash payment logic
    }
}

// (low-level module)
class CreditCardPayment implements Payment {
    constructor(user){
        this.user = user
    }

    public pay(amount, creditCardId){
        // handle creditCard payment logic
    }
}


// (High-level Module)
function makePayment(amount: number, paymentMethod: Payment){

    if(paymentMethod instanceof CashPayment){
        if(paymentMethod.pay(amount)){
            return true;
        }
    }

    if(paymentMethod instanceof CreditCardPayment){
        if(paymentMethod.pay(amount,paymentMethod.user.creditCardId)){
            return true;
        }
    }

    return false;
}

이는 상위 수준 모듈이 하위 수준 모듈에 대한 세부 정보를 구현하기 때문에 종속성 역전 원칙을 명백히 위반합니다. 를 위반하기도 합니다.


종속성 반전을 사용하여 현금 및 신용 지불 구현에 대한 래퍼 클래스 또는 추상화를 만듭니다.

interface Payment {
    pay(): boolean
}

// (Wrapper/Abstraction around cash payment)
class CashHandler implements Payment {
    constructor(user){
        this.user = user
        this.CashPayment = new CashPayment();
    }

    pay(amount){
        this.CashPayment.pay(amount)
    }
}

// (low-level module)
class CashPayment {
    public pay(amount){
        // handle cash payment logic
    }
}


// (Wrapper/Abstraction around credit card payment)
class CreditCardHandler implements Payment {
    constructor(user){
        this.user = user
        this.CreditCardPayment = new CreditCardPayment();
    }

    pay(amount){
        this.CreditCardPayment.pay(amount, this.user.creditCardId)
    }
}

// (low-level module)
class CreditCardPayment {
    public pay(amount, creditCardId){
        // handle creditCard payment logic
    }
}


// (High-level Module)
function makePayment(amount: number, paymentMethod: Payment){
    if(paymentMethod.pay(amount)){
        return true;
    }
    return false;
}

이제 볼 수 있듯이 상위 수준 모듈은 하위 수준 구현의 세부 정보를 숨기는 추상 계층으로 구분됩니다. 우리는 종속성을 뒤집었습니다.

종속성 역전이 유용한 이유는 무엇입니까?

이걸 고려하세요

We want to add PayPal and WireTransfer Payment Options to our existing code (the example we just did). It can be done easily without touching our existing code. We only have to add low-level and wrapper implementations for PayPal and WireTransfer Payments. Thus, our High-level implementations never break since we are not touching it.

또한

탄력적이고 재사용 가능한 코드를 생성합니다.

유지 관리가 더 쉬운 코드입니다.

개별 코드 구성 요소를 더 쉽게 테스트할 수 있습니다.

높은 수준의 구현을 건드리지 않음으로써 코드 손상을 방지합니다

.

다른 SOLID 원칙에 대한 패턴은 코드 파손 측면에서 매우 유사합니다. 즉, 장기적으로 피하십시오.


여기 있습니다. 종속성 반전을 사용합니까? 댓글에 의견을 남겨주시고 이 글이 마음에 드셨다면 하트 💖를 눌러주세요.