[DIP] 의존성 역전 원칙을 적용한 시스템에서 모듈 간의 상호작용

출처

ChatGPT

---

의존성 역전 원칙(Dependency Inversion Principle, DIP)을 적용한 시스템에서는 모듈 간의 상호작용이 전통적인 방식과는 다르게 설계된다. 이 원칙을 통해 고수준 모듈이 저수준 모듈에 직접 의존하지 않고, 추상화 계층을 통해 간접적으로 의존함으로써 모듈 간의 결합도를 낮추고 유연성을 높일 수 있다. 

 

전통적인 상호작용 방식

전통적인 소프트웨어 설계에서는 고수준 모듈이 저수준 모듈에 직접적으로 의존한다. 이로 인해 다음과 같은 문제가 발생할 수 있다.

• 변경의 어려움 : 저수준 모듈의 변경이 고수준 모듈에 직접적인 영향을 미친다.
• 테스트의 어려움 : 모듈을 독립적으로 테스트하기 어려워진다.
• 재사용성의 감소 : 고수준 모듈은 특정 저수준 구현에 의존하므로 다른 프로젝트에서 재사용하기 어렵다.

예를 들어, 전통적인 구조에서 쇼핑카트 애플리케이션은 특정 결제 처리 클래스에 직접 의존할 수 있다.

 

Java 예

// 고수준 모듈
public class ShoppingCart {
    private final PayPalPaymentProcessor paymentProcessor; // 특정 저수준 모듈에 직접 의존

    public ShoppingCart() {
        this.paymentProcessor = new PayPalPaymentProcessor(); // PayPal 결제 처리
    }

    public void checkout(double amount) {
        paymentProcessor.processPayment(amount);
    }
}

이와 같은 구조에서는 `PayPalPaymentProcessor`의 변경이 `ShoppingCart` 모듈에 직접적인 영향을 미치게 된다.

의존성 역전 원칙을 적용한 상호작용 방식

의존성 역전 원칙을 적용하면 모듈 간의 상호작용은 추상화 계층을 통해 이루어집니다. 즉, 고수준 모듈은 추상화(인터페이스)에 의존하고, 저수준 모듈이 이 추상화를 구현하여 고수준 모듈에 주입됩니다.

1. 추상화 계층 생성

우선, 고수준 모듈과 저수준 모듈 간의 상호작용을 위한 인터페이스 또는 추상 클래스를 정의한다. 이는 고수준 모듈이 필요로 하는 기능을 정의한 것이다.

 

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

 

2. 저수준 모듈이 추상화 계층 구현

저수준 모듈은 이 인터페이스를 구현하여 구체적인 동작을 정의한다.

 

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

public class StripePaymentProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        // Stripe 결제 처리 로직
        System.out.println("Processing payment of $" + amount + " through Stripe.");
    }
}

3. 고수준 모듈이 추상화 계층에 의존

고수준 모듈은 이제 구체적인 저수준 모듈이 아닌 인터페이스에 의존한다. 이는 고수준 모듈이 저수준 모듈의 변경에 영향을 받지 않도록 한다.

 

// 고수준 모듈
public class ShoppingCart {
    private final PaymentProcessor paymentProcessor; // 추상화 계층에 의존

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

    public void checkout(double amount) {
        paymentProcessor.processPayment(amount);
    }
}

4. 의존성 주입(Dependency Injection)

의존성 주입을 통해 고수준 모듈에 필요한 저수준 모듈의 구체적인 구현체를 주입한다. 이를 통해 고수준 모듈과 저수준 모듈 간의 결합도를 낮출 수 있다.

1) 생성자 주입

생성자 주입은 고수준 모듈의 생성자에서 필요한 의존성을 주입받는 방법이다. 이는 객체가 생성될 때 모든 의존성이 주입되므로 객체의 상태가 불변하게 유지될 수 있다.

 

public class Main {
    public static void main(String[] args) {
        PaymentProcessor paymentProcessor = new PayPalPaymentProcessor(); // 또는 new StripePaymentProcessor();
        ShoppingCart cart = new ShoppingCart(paymentProcessor);
        cart.checkout(100.0);
    }
}

 

2) 세터 주입

세터 주입은 고수준 모듈의 세터 메서드를 통해 필요한 의존성을 주입받는 방법이다. 이는 객체 생성 후에도 의존성을 변경할 수 있는 유연성을 제공한다.

 

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

    public void setPaymentProcessor(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }

    public void checkout(double amount) {
        paymentProcessor.processPayment(amount);
    }
}

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

        // 다른 결제 처리기로 변경
        cart.setPaymentProcessor(new StripePaymentProcessor());
        cart.checkout(200.0);
    }
}

 

3) 인터페이스 주입

인터페이스 주입은 특정 프레임워크나 라이브러리가 사용하는 방식으로, 프레임워크가 직접 의존성을 주입하는 방식이다. 이는 주로 IoC(Inversion of Control) 컨테이너에서 사용된다.

DIP를 적용한 시스템의 상호작용 이점

1. 유연한 아키텍처

DIP를 통해 시스템의 구조가 유연해진다. 고수준 모듈은 다양한 저수준 모듈을 사용할 수 있고, 쉽게 교체할 수 있다.

2. 변경의 용이성

저수준 모듈의 변경이 고수준 모듈에 영향을 미치지 않으므로, 저수준 모듈의 구현을 자유롭게 변경할 수 있다.

3. 테스트 가능성

고수준 모듈은 인터페이스에 의존하기 때문에 테스트 시 Mock 객체를 사용하여 독립적으로 테스트할 수 있다. 이는 테스트의 신뢰성을 높이고, 테스트 커버리지를 향상시킨다.

4. 재사용성 증가

고수준 모듈은 특정 구현에 의존하지 않으므로, 다양한 환경에서 재사용할 수 있다. 이는 코드의 재사용성을 높이는 데 기여한다.

5. 결합도 감소

모듈 간의 결합도가 낮아지고, 응집도가 높아져 유지보수와 확장이 용이해집니다.

DIP와 클린 아키텍처의 상호작용

의존성 역전 원칙은 클린 아키텍처에서 시스템의 계층 간 상호작용을 설계할 때 중요한 원칙이다. 클린 아키텍처에서는 다음과 같은 계층이 존재한다

1. 엔티티(Entities) : 비즈니스 규칙을 포함한 가장 중심적인 계층이다.
2. 유스케이스(Use Cases) : 특정 애플리케이션의 비즈니스 로직을 정의한다.
3. 인터페이스 어댑터(Interface Adapters) : 외부 인터페이스를 애플리케이션의 유스케이스 및 엔티티에 맞게 변환한다.
4. 프레임워크 및 드라이버(Frameworks & Drivers) : 외부 시스템과의 통신을 담당하는 계층이다.

클린 아키텍처에서 각 계층은 상위 계층이 하위 계층에 의존하지 않도록 설계되어 있다. DIP를 통해 고수준 모듈(엔티티, 유스케이스)이 저수준 모듈(프레임워크, 데이터베이스)에 의존하지 않고, 추상화 계층을 통해 간접적으로 의존한다. 이는 모듈 간 결합도를 낮추고, 시스템을 유연하게 유지하는 데 기여한다.

결론

의존성 역전 원칙은 시스템의 모듈 간 상호작용을 효과적으로 관리하여, 유연성과 확장성을 높이고, 변경의 영향을 최소화하며, 테스트 가능성과 재사용성을 높이는 데 중요한 역할을 한다. 이를 통해 모듈 간 결합도를 낮추고, 시스템의 구조를 더 견고하고 유지보수하기 쉽게 만들어 준다.