java dip 위반이 무슨 말일까

DIP

DIP(Dependency Inversion Principle)는 SOLID 원칙 중 하나로, 의존 관계를 역전시키는 원칙

이 원칙은 고수준 모듈은 저수준 모듈에 의존해서는 안 되며, 둘 모두 추상화에 의존해야 한다는 것을 나타냅니다.

추상화는 구체적인 구현에 의존해서는 안 됩니다. 이를 통해 시스템이 유연하고 확장 가능한 구조를 갖출 수 있습니다.

 

예제

```java
public class LightBulb {
    public void turnOn() {
        // 전구를 켜는 동작
    }
}

public class Switch {
    private LightBulb bulb;

    public Switch() {
        this.bulb = new LightBulb();
    }

    public void operate() {
        bulb.turnOn();
    }
}
```

위의 코드에서 `Switch` 클래스는 `LightBulb` 클래스에 직접 의존하고 있습니다. 

이는 DIP를 위반한 것입니다. 대신에 추상화를 통해 의존성을 역전시킬 수 있습니다.

```java
public interface Switchable {
    void turnOn();
}

public class LightBulb implements Switchable {
    @Override
    public void turnOn() {
        // 전구를 켜는 동작
    }
}

public class Switch {
    private Switchable device;

    public Switch(Switchable device) {
        this.device = device;
    }

    public void operate() {
        device.turnOn();
    }
}
```

이제 `Switch` 클래스는 `Switchable` 인터페이스에 의존하고 있습니다. 이렇게 하면 `Switch` 클래스는 구체적인 구현이 아닌 추상화에 의존하므로, 시스템이 더 유연하고 확장 가능해집니다.

=> 새로운 디바이스를 추가하거나 기존 디바이스를 변경해도 `Switch` 클래스는 수정할 필요가 없어집니다.

DIP를 지키면서 의존성을 주입하는 것이 IoC (Inversion of Control) 원리와도 관련이 있습니다. 스프링 프레임워크에서의 `@Autowired`나 생성자 주입은 이러한 원칙을 따르며, 의존성 주입을 통해 객체 간의 결합도를 낮추고 유연성을 높입니다.

 

 

 

---

 

의존성을 역전시키기 위해 코드를 작성할 때는 다음과 같은 가이드라인을 따를 수 있습니다. 

아래 예시는 Java와 Spring 프레임워크를 기준으로 설명됩니다.

### 1. 인터페이스를 활용:
구체적인 클래스 대신 인터페이스를 사용하여 추상화를 도입합니다.

```java
public interface Switchable {
    void turnOn();
}

public class LightBulb implements Switchable {
    @Override
    public void turnOn() {
        // 전구를 켜는 동작
    }
}

public class Fan implements Switchable {
    @Override
    public void turnOn() {
        // 선풍기를 켜는 동작
    }
}
```

### 2. 추상화를 사용:
구체적인 클래스 대신 추상화된 클래스나 인터페이스에 의존합니다.

```java
public class Switch {
    private Switchable device;

    public Switch(Switchable device) {
        this.device = device;
    }

    public void operate() {
        device.turnOn();
    }
}
```

### 3. 의존성 주입(Dependency Injection) 활용:
의존하는 객체를 외부에서 주입받도록 설계합니다. Spring에서는 주로 생성자 주입을 사용합니다.

```java
@Configuration
public class AppConfig {
    
    @Bean
    public Switchable lightBulb() {
        return new LightBulb();
    }

    @Bean
    public Switchable fan() {
        return new Fan();
    }

    @Bean
    public Switch switchForLightBulb(@Qualifier("lightBulb") Switchable device) {
        return new Switch(device);
    }

    @Bean
    public Switch switchForFan(@Qualifier("fan") Switchable device) {
        return new Switch(device);
    }
}
```

위의 예제에서 `Switch` 클래스는 `Switchable` 인터페이스에만 의존하고 있습니다. 그리고 `Switchable`을 구현한 구체적인 클래스는 외부에서 주입받습니다. 이렇게 하면 코드의 유연성과 재사용성이 높아지며, DIP를 지키게 됩니다.

Spring의 `@Autowired` 어노테이션을 통해 의존성을 주입할 때에도 인터페이스나 추상 클래스를 사용하는 것이 일반적입니다. 클래스가 아닌 인터페이스에 의존하면 구현을 교체하거나 추가하기가 더 쉬워집니다.