[Clean Architecture][DIP] 클린 아키텍처에 의존성 역전 원칙이 시스템에 미치는 영향

출처 

ChatGPT

---

의존성 역전 원칙(Dependency Inversion Principle, DIP)은 SOLID 원칙 중 하나로, 클린 아키텍처(Clean Architecture)에서 매우 중요한 역할을 한다. DIP는 소프트웨어의 모듈 간 의존성을 효과적으로 관리하여 시스템의 유연성과 확장성을 높이고, 코드의 변경으로 인한 영향을 최소화하는 데 기여한다.

의존성 역전 원칙(Dependency Inversion Principle, DIP)

정의

의존성 역전 원칙은 두 가지 주요 규칙으로 정의된다.

1. 고수준 모듈(High-level Modules)은 저수준 모듈(Low-level Modules)에 의존해서는 안 된다. 둘 다 추상화(Abstractions)에 의존해야 한다.
2. 추상화는 구체적인 것(Details, 세부 사항)에 의존해서는 안 된다. 구체적인 것(세부 사항)이 추상화에 의존해야 한다.

 

목표

구조적인 유연성을 확보하고, 모듈 간의 의존성을 효과적으로 관리하여 모듈의 독립성과 재사용성을 높이는 것이다.

클린 아키텍처에서의 역할

클린 아키텍처는 주로 다음과 같은 4가지 원칙을 따른다.

1. 엔터프라이즈 비즈니스 규칙
2. 애플리케이션 비즈니스 규칙
3. 인터페이스 어댑터
4. 프레임워크 및 드라이버

의존성 역전 원칙은 이러한 아키텍처 레이어에서 의존성을 역전시켜, 비즈니스 로직이 프레임워크, 데이터베이스, UI 등에 영향을 받지 않도록 설계한다.

DIP가 시스템에 미치는 영향

1. 유연성과 확장성 향상

•  DIP를 통해 시스템을 구성하는 모듈 간의 의존성을 제거하거나 줄일 수 있다. 이로 인해 시스템의 유연성이 증가하고, 새로운 기능 추가 및 기존 기능 수정이 용이해진다.
• 예를 들어, 특정 데이터베이스를 사용하는 코드가 직접 의존하는 대신 인터페이스를 통해 간접적으로 의존하게 하면, 데이터베이스를 교체할 때 코드 변경을 최소화할 수 있다.

2. 변경 용이성

• 고수준 모듈(비즈니스 로직)과 저수준 모듈(데이터베이스, UI 등)의 독립성을 유지함으로써, 한쪽의 변경이 다른 쪽에 미치는 영향을 최소화할 수 있다.
• 이는 코드 유지보수성을 높이고, 변경의 리스크를 줄이는 데 기여한다.

3. 재사용성 증가

• 추상화된 인터페이스를 통해 모듈 간 통신이 이루어지므로, 고수준 모듈이 저수준 모듈의 세부 구현에 의존하지 않게 된다. 이를 통해 고수준 모듈은 다양한 환경에서 재사용이 가능합니다.
• 예를 들어, 비즈니스 로직 모듈은 특정 웹 프레임워크에 의존하지 않기 때문에 다양한 UI 프레임워크에서 재사용할 수 있다.

4. 테스트 용이성

• DIP는 테스트하기 쉬운 코드를 만든다. 의존성을 주입받는 모듈은 테스트 시 Mock 객체나 스텁을 사용하여 독립적으로 테스트할 수 있다.
• 이는 단위 테스트의 신뢰성을 높이고, 테스트 커버리지를 향상시키는 데 중요한 역할을 한다.

5. 결합도 감소

• DIP는 모듈 간의 결합도를 줄이고 응집도를 높이는 데 기여한다. 모듈이 추상화에 의존함으로써, 특정 구현에 의존하는 문제를 피할 수 있다.
• 이는 시스템을 더 유연하고 확장 가능하게 만들어 준다.

 

의존성 역전 원칙의 구현 예시

 

Java 예

// 추상화(인터페이스) 정의
public interface PaymentProcessor {
    void processPayment(double amount);
}

// 저수준 모듈
public class PayPalPaymentProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        // PayPal 결제 처리 로직
        System.out.println("Processing payment of $" + amount + " through PayPal.");
    }
}

// 고수준 모듈
public class ShoppingCart {
    private final PaymentProcessor paymentProcessor;

    // 생성자 주입을 통한 의존성 역전
    public ShoppingCart(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }

    public void checkout(double amount) {
        // 비즈니스 로직 처리
        paymentProcessor.processPayment(amount);
    }
}

// 사용 예시
public class Main {
    public static void main(String[] args) {
        PaymentProcessor paymentProcessor = new PayPalPaymentProcessor();
        ShoppingCart cart = new ShoppingCart(paymentProcessor);
        cart.checkout(100.0);
    }
}

Kotlin 예

// 추상화(인터페이스) 정의
interface PaymentProcessor {
    fun processPayment(amount: Double)
}

// 저수준 모듈
class PayPalPaymentProcessor : PaymentProcessor {
    override fun processPayment(amount: Double) {
        // PayPal 결제 처리 로직
        println("Processing payment of \$$amount through PayPal.")
    }
}

// 고수준 모듈
class ShoppingCart(private val paymentProcessor: PaymentProcessor) {
    
    fun checkout(amount: Double) {
        // 비즈니스 로직 처리
        paymentProcessor.processPayment(amount)
    }
}

// 사용 예시
fun main() {
    val paymentProcessor: PaymentProcessor = PayPalPaymentProcessor()
    val cart = ShoppingCart(paymentProcessor)
    cart.checkout(100.0)
}

 

DIP의 이점과 주의사항

이점

• 유연한 아키텍처 : DIP를 통해 시스템 구조를 보다 유연하게 유지할 수 있다.
• 확장성 : 새로운 기능을 쉽게 추가하고, 기존 기능을 변경하는 데 드는 노력을 줄일 수 있다.
• 테스트 가능성 : 모듈을 독립적으로 테스트할 수 있어 품질 보증에 유리하다.

주의사항

• 복잡성 증가 : 지나치게 추상화를 사용하면 코드의 복잡성이 증가할 수 있다.
• 과도한 설계 : 프로젝트의 크기나 요구사항에 맞지 않는 과도한 설계는 오히려 유지보수를 어렵게 할 수 있다.