DI란 무엇인가
DI는 Dependency Injection의 줄임말로, 다양한 우리 말 번역이 있지만, 이 글에서는 의존관계 주입이라는 뜻으로 사용하고자 한다.
자원을 직접 명시하지 말고 의존 객체 주입을 사용하라
의존한다는 것은 무엇일까?
객체 지향 프로그래밍을 하다보면, 다른 객체쪽에서 자원을 빌려쓰는 경우가 많다.
예를 들어 A라는 기능을 구현하는 클래스를 만들고 싶은데,
이를 위해서는 a, b, c 세개의 자원이 필요하다고 가정해보자.
해당 자원들을 가지고 있는 곳이 이미 있을텐데 굳이 A에서 또 자원을 넣어주는건 비효율적이다.
그냥 마치 이웃끼리 서로 상부상조 하는 것처럼 빌려쓰면 그만이지 않을까?
이런 방식으로 만약 A라는 클래스가 B라는 자원을 가져와서 쓰고 있다면, 우리는 이때 A가 B에 의존한다고 말하게 된다.
맞춤법 검사기의 잘못된 예시
예를 들어보자.
맞춤법 검사 기능을 하는 클래스를 만들고 싶다고 했을 때 어떤 자원이 필요할까?
기본적으로 그 맞춤법을 확인해볼 수 있는 사전(Dictionary)이 필요할 것이다.
그럼 어떤 방식으로 맞춤법 검사기가 사전이라는 자원을 가져와 쓰는지,
직접 코드로 확인해보자.
정적 유틸리티를 사용한 코드
public class SpellChecker {
private static final Lexicon dictionary = ...;
private SpellChecker() {}
public static boolean isValid(String word) {
// ...
}
public static List<String> suggestions(String type) {
// ...
}
}싱글턴을 사용한 코드
public class SpellChecker {
private static final Lexicon dictionary = ...;
public static SpellChecker INSTANCE = new SpellChecker(...);
public static boolean isValid(String word) {
// ...
}
public static List<String> suggenstions(String type) {
// ...
}
}왜 위와 같은 예시를 들었을까?
실제로 이렇게 정적 유틸리티 클래스나 싱글턴으로 구현하는 경우가 흔하다고 한다.
문제는 앞선 Item에서 배웠듯,
정적 유틸리티 클래스는 더이상 인스턴스가 생성되지 못하게 하고,
싱글턴은 인스턴스가 무조건 하나만 생성되게 한다.
즉, 둘 모두 사전을 단 하나만 사용한다고 가정하고 있다.
실제로는 언어별 사전이 따로 있는 것은 물론이고, 특수 어휘용 사전도 따로 있다.
이렇게 하면 여러 상황에서 유연하게 대처할 수가 없다.
그래서 사용하는 자원에 따라 동작이 달라지는 클래스에서는,
정적 유틸리티 클래스나 싱글턴 방식이 부적합하다.
여러 상황에서도 능동적으로 대처할 수 있는 방안이 필요하다.
많은 클래스가 하나 이상의 자원에 의존한다. 이때 사용하는 자원에 따라 동작이 달라지는 클래스(하나 이상의 자원에 의존)에는 정적 유틸리티 클래스나 싱글턴 방식이 적합하지 않다.
의존관계를 인터페이스로 추상화하기
public class SpellChecker {
private Lexicon dictionary;
public SpellChecker() {
dictionary = new WordLexicon();
// dictionary = new SpecialWordLexicon();
}
}
interface Lexicon {
getWords();
// ...
}
class WordLexicon implements Lexicon {
public Words getWords() {
return new Words();
}
// ...
}다양한 Lexicon을 의존 받을 수 있게 구현하려면 인터페이스로 추상화 해야 한다.
위 코드에서 볼 수 있듯이, 다양한 사전들에 의존할 수 있는 SpellChecker가 된다.
의존관계를 인터페이스로 추상화하게 되면, 더 다양한 의존 관계를 맺을 수가 있고, 실제 구현 클래스와의 관계가 느슨해지고, 결합도가 낮아진다.
의존 객체 주입 방법
의존 객체 주입 방식이 바로 위 문제의 해결법이 될 수 있다.
원리는 간단하다.
자원을 가져와서 고정시켜 놓고 사용하는 것이 아닌,
인스턴스를 생성할 때 상황에 맞는 필요한 자원을 생성자에 넘겨주는 방법이다.
인스턴스를 생성할 때 생성자에 필요한 자원을 넘겨주는 방식을 사용하면, 클래스가 여러 자원 인스턴스를 지원하고, 클라이언트가 원하는 자원을 사용할 수 있다. 이 방법은 의존 객체 주입의 한 형태로 유연성과 재사용성, 테스트 용이성을 높여준다.
테스트 용이성은 왜 높아질까?
간단하다. 테스트라는 것은 여러가지 테스트케이스를 만들어 예외가 없는지 넣어보는 과정이다.이 방법이 여러 상황에서도 대처가 가능한 만큼,
테스트 할 수 있는 적절한 환경을 만들어준다고 할 수 있다.
생성자 의존성 주입
public class SpellChecker {
private final Lexicon dictionary;
public SpellChecker(Lexicon dictionary) {
//null이면 NPE 아닌 경우 objects 반환
this.dictionary = Objects.requireNonNull(dictionary);
}
public boolean is Valid(String word) {}
}위와 같이 하면, 인스턴스를 생성할 때 그 시점에 알맞는 필요한 자원을 넘겨줄 수가 있다.
메서드 의존성 주입
public class SpellChecker {
private final Lexicon dictionary = new WordLexicon();
public void setLexicon(Lexicon dictionary) {
this.dictionary = Objects.requireNonNull(dictionary);
}
public boolean is Valid(String word) {}
}필드 의존성 주입
public class SpellChecker {
private final Lexicon dictionary = new WordLexicon();
public void setLexicon(Lexicon dictionary) {
this.dictionary = Objects.requireNonNull(dictionary);
}
public boolean is Valid(String word) {}
}일반 사전이든, 특수용어 사전이든 다 가능하다는 말이 된다.
위의 예시에서는 단순히 한개의 자원만 사용하지만, 자원이 몇 개든 의존관계가 어떻게 되든 잘 동작한다.
불변을 보장하여 여러 클라이언트가 의존 객체를 안심하고 사용할 수 있다. 의존 객체 주입은 생성자, 정적 팩터리, Builder 모두에 똑같이 적용 할 수 있다.
팩토리 메서드 패턴(Factory Method Pattern) 의존성 주입
팩토리 메서드 패턴은 객체 생성을 서브 클래스에 위임하여 객체 생성 방식을 변경할 수 있는 디자인 패턴이다. 이를 이용해서 의존성을 주입할 수 있다.
// 의존성 주입을 위한 인터페이스
public interface Lexicon {
// ...
}
// 실제 사용될 구현체
public class WordLexicon implements Lexicon {
// ...
}
public class SpellChecker {
private final Lexicon dictionary;
private SpellChecker(Lexicon dictionary) {
this.dictionary = dictionary;
}
// 팩토리 메서드
public static SpellChecker createSpellChecker() {
Lexicon dictionary = new WordLexicon();
return new SpellChecker(dictionary);
}
}위 코드에서 SpellChecker 클래스는 createSpellChecker 메서드를 통해 WordLexicon을 생성하여 의존성 주입을 수행하고 있다.
추상 팩토리 패턴(Abstract Factory Pattern) 의존성 주입
추상 팩토리 패턴은 관련된 객체들의 집합을 생성할 수 있는 인터페이스를 제공하는 디자인 패턴이다.
public interface LexiconFactory {
Lexicon createLexicon();
}
// 각각의 구체적인 팩토리 구현체
public class WordLexiconFactory implements LexiconFactory {
public Lexicon createLexicon() {
return new WordLexicon();
}
}
public class SpecialWordLexiconFactory implements LexiconFactory {
public Lexicon createLexicon() {
return new SpecialWordLexicon();
}
}
// 추상 팩토리를 사용하는 클래스
public class SpellChecker {
private final Lexicon dictionary;
private SpellChecker(Lexicon dictionary) {
this.dictionary = dictionary;
}
// 추상 팩토리를 이용한 의존성 주입
public static SpellChecker createSpellChecker(LexiconFactory factory) {
Lexicon dictionary = factory.createLexicon();
return new SpellChecker(dictionary);
}
}위의 코드에서 SpellChecker 클래스는 createSpellChecker 메서드를 통해 LexiconFactory를 받아와서 해당 팩토리를 통해 WordLexicon 또는 SpecialWordLexicon 등을 생성하여 의존성 주입을 수행하고 있다.
Factory란 호출할 때마다 특정 타입의 인스턴스를 반복해서 만들어 주는 객체를 말하는데, Factory Method Pattern은 의존 객체 주입 패턴을 응용해서 구현한 것이다.
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}Supplier<T> 인터페이스는 팩터리를 표현한 완벽한 예시이다. 이 방식을 사용해 클라이언트는 자신이 명시한 타입의 하위 타입이라면 무엇이든 생성할 수 있는 팩터리를 만들 수 있다.
Mosaic create(Supplier<? extends Title> titleFactory) {...}하지만 역시나 단점도 존재하기 마련인데,
의존성이 수천개나 되는 큰 프로젝트라면 오히려 코드를 어지럽게 만들기도 한다.
그런데 그렇게 큰 프로젝트라면,
스프링(Spring) 같은 의존 객체 프레임워크를 쓰는게 더 올바르다.
장점
- 유연성이 높다.
- 테스트가 용이하다.
단점
- 의존성이 수천개나 되는 프로젝트 에서는 코드가 오히려 어지럽다.
의존 객체 주입이 유연성과 테스트 용이성을 개선해주지만, 의존성이 너무 많은 프로젝트에서는 코드를 어지럽게 하며, 스프링 같은 의존 객체 주입 프레임워크를 사용해 코드의 어지러움을 해소할 수 있다.
Item5 정리
클래스가 내부적으로 하나 이상의 자원에 의존하고,
그 자원이 클래스 동작에 영향을 준다면,
싱글턴과 정적 유틸리티 클래스는 사용하지 않는 것이 좋다.이 자원을 직점 클래스에서 만드는건 더 안된다.
대신 필요한 자원을 생성자에 넘겨주자.
이 기법은 클래스의 유연성, 재사용성, 테스트 용이성을 개선해준다.
