[Unity] 의존성 주입(Dependency Injection - DI)

1. 개념
2. 의존성 주입 방식들
3. 장점
4. 단점

 

1. 개념

클래스가 필요한 객체를 외부에서 주입받는 방식. 객체 생성을 클래스 내부에서 하는 것이 아니라, 외부에서 주입받는 것. 즉, 객체의 생성 책임을 외부로 분리하여 해당 객체 생성에 대해 문제가 발생했을 때, 책임을 지지 않을 수 있다. 이를 통해 클래스 간 결합도를 낮추고, 유연성이 증가될 수 있다.

// 객체를 클래스 내부에서 생성해서 객체 A, B의 의존성이 높은 구조
public class A
{
    public void DoSomething()
    {
        B b = new B();  // new로 B 객체를 생성
        b.SomeMethod();
    }
}

public class B
{
    public void SomeMethod()
    {
        Console.WriteLine("B's method");
    }
}


// -------------------------------------------------------------------------------------


// 객체를 외부에서 주입받아서, 객체 A, B의 의존성이 낮은 구조
public class A
{
    private readonly B _b;

    // 생성자에서 B 객체를 외부에서 주입받음
    public A(B b)
    {
        _b = b;
    }

    public void DoSomething()
    {
        _b.SomeMethod();  // B의 메서드 호출
    }
}

public class B
{
    public void SomeMethod()
    {
        Console.WriteLine("B's method");
    }
}

// B 수정 후 새로운 B 클래스를 주입
public class BModified : B
{
    public void SomeMethod()
    {
        Console.WriteLine("BModified's method");
    }
}

2. 의존성 주입 방식들

생성자 주입(Constructor Injection):

• 객체가 생성될 때, 필요한 의존성을 생성자의 파라미터로 전달받는 방식이다.
• 장점: 의존성들이 객체 생성 시 필수적으로 제공되므로, 필수 의존성 누락을 방지할 수 있다.
• 단점: 생성자가 복잡해질 수 있고, 너무 많은 의존성을 주입받는 경우 관리가 어려워질 수 있다.

public class A
{
    private readonly B _b;

    public A(B b)  // 생성자로 B를 주입받음
    {
        _b = b;
    }
}

 

 

 

세터 주입(Setter Injection):

• 객체가 생성된 후, 필요한 의존성을 세터 메서드를 통해 주입받는 방식이다.
• 장점: 생성자는 간단하게 유지하고, 의존성 주입을 나중에 할 수 있어서 유연성이 높다.
• 단점: 의존성 주입이 선택적이 될 수 있어서, 누락되거나 잘못된 의존성을 주입할 가능성이 있다.

public class A
{
    private B _b;

    public void SetB(B b)  // 세터로 B를 주입받음
    {
        _b = b;
    }
}

 

 

인터페이스 주입(Interface Injection):

• 의존성 객체가 자신의 의존성 주입 메서드를 제공하고, 다른 클래스가 이를 구현하여 의존성을 주입받는 방식이다.
• 장점: 의존성을 유연하게 변경할 수 있다.
• 단점: 인터페이스와 관련된 추가적인 코드가 필요해, 복잡도가 올라갈 수 있다.

public interface IInjectable
{
    void InjectDependency(B b);
}

public class A : IInjectable
{
    private B _b;

    public void InjectDependency(B b)
    {
        _b = b;
    }
}

 

3. 장점

 

1. 결합도 감소

• 객체 간 결합도가 낮아져 클래스들이 서로 독립적으로 동작할 수 있다. 
• A는 B 객체의 인터페이스만 알고 있으면 되기에, A는 B의 구체적인 구현에 대한 의존성을 가지지 않는다.

2. 유연성 증가

• 객체 생성과 관련된 책임이 외부로 이동하므로, 어떤 객체를 주입할지 외부에서 결정할 수 있다. 이로 인해 객체의 구현을 쉽게 교체할 수 있게 된다.
• 예를 들어, B 클래스가 여러 종류가 있을 때, A는 B의 종류에 대해 알 필요 없이, 외부에서 적절한 B 객체를 주입해주기만 하면 된다.

3. 유지보수 용이

• B가 변경되더라도 A는 수정할 필요가 없다. A는 B의 구현이 아니라 인터페이스나 추상화된 클래스에 의존하기 때문이다.

 

4. 단점

 

1. 복잡성 증가

• 설계가 복잡해진다. 해당 객체에 어느 객체를 주입해주어야 하는지 사전에 구조 설계를 해야 한다. 특히, 객체 생성 및 관리가 간접적으로 처리되어 객체들이 어떻게 주입되고 관리되는지 추적하기 어려울 수 있다.