좋은 객체지향 설계의 5가지 원칙의 적용

여기서 3가지. SRP, DIP, OCP 적용

SRP 단일 책임 원칙

한 클래스는 하나의 책임만 가져야 한다.

• 클라이언트 객체는 직접 구현 객체를 생성하고, 연결하고, 실행하는 다양한 책임을 가지고 있음.
• SRP 단일 책임 원칙을 따르면서 관심사를 분리함.
• 구현 객체를 생성하고 연결하는 책임은 AppConfig가 담당
• 클라이언트 객체는 실행하는 책임만 담당.

DIP 의존관계 역전 원칙

프로그래머는 추상화에 의존해야지, 구체화에 의존하면 안된다. 의존성 주입은 이 원칙을 따르는 방법 중 하나.

• 새로운 할인 정책을 개발하고 적용하려고 하니, 클라이언트 코드도 함께 변경해야 했다.
  • 기존 클라이언트 코드(OrderServiceImp은 DIP를 지키며 DiscountPolicy추상화 인터페이스에 의존하는 것 같았지만, FixDiscountPolicy 구체화 구현 클래스에도 함께 의존했다.
• 클라이언트 코드가 DiscountPolicy 추상화 인터페이스에만 의존하도록 코드를 변경했다.
• 하지만 클라이언트 코드는 인터페이스만으로는 아무것도 실행할 수 없다.
• AppConfig가 FixDiscountPolicy객체 인스턴스를 클라이언트 코드 대신 생성해서 클라이언트 코드에 의존관게를 주입했다.
  • 이를 통해 DIP원칙을 따르면서도 문제도 해결

OCP 개방 폐쇄 원칙

소프트웨어 요소는 확장에는 열려 있으나 변경에는 닫혀 있어야 한다.

• 다형성을 사용하면서 클라이언트가 DIP를 지킴
• 애플리케이션을 사용 영역과 구성 영역으로 나눔.
• AppConfig가 의존 관계를 FixDiscountPolicy에서 RateDiscountPolicy로 변경해서 클라이언트 코드에 주입하므로 클라이언트 코드는 변경하지 않아도 됨.
• 소프트웨어 요소를 새롭게 확장해도 사용 영역의 변경은 닫혀있다.

IoC, DI, 그리고 컨테이너

제어의 역전 IoC (Inversion of Control)

• 기존 프로그램은 클라이언트 구현 객체가 스스로 필요한 서버 구현 객체를 생성하고, 연결하고, 실행했다.
  • 한마디로 구현 객체가 프로그램의 제어 흐름을 스스로 조종했다.
  • 개발자의 입장에서는 자연스러운 흐름이다.
• 반면에 AppConfig가 등장한 이후에 구현 객체는 자신의 로직을 실행하는 역할만 담당한다.
  • 프로그램의 제어 흐름은 이제 AppConfig가 가져간다.
  • 예를 들어서, OrderServiceImpl은 필요한 인터페이스들을 호출하지만 어떤 구현 객체들이 실행될지 모른다.
• 프로그램에 대한 제어흐름에 대한 권한은 모두 AppConfig가 가지고 있다.
  • 심지어 OrderServiceImpl도 AppConfig가 생성한다.
  • 그리고 AppConfig는 OrderServiceImp이 아닌 OrderServie 인터페이스의 다른 구현 객체를 생성하고 실행할 수도 있다.
  • 그런 사실도 모른채 OrderServiceImpl은 묵묵히 자신의 로직을 실행할 뿐이다.
  • 이렇듯 프로그램의 제어 흐름을 직접 제어하는 것이 아니라 외부에서 관리하는 것을 제어의 역전(IoC)이라 한다.
    • 김영한 그는 신인가?

프레임워크 vs 라이브러리

• 프레임워크가 내가 작성한 코드를 제어하고, 대신 실행하면 그것은 프레임워크가 맞다. (JUnit)
• 반면에 내가 작성한 코드가 직접 제어의 흐름을 담당한다면 그것은 프레임워크가 아니라 라이브러리다.

의존관계 주입 DI (Dependency Injection)

• OrderServiceImpl은 DiscountPolicy인터페이스에 의존한다.
  • 실제 어떤 구현 객체가 사용될지는 알 수 없다.
• 의존관계는 정적인 클래스 의존 관계와, 실행 시점에 결정되는 동적인 객체(인스턴스) 의존관계 둘을 분리해서 생가해야 한다.

정적인 클래스 의존관계

• 클래스가 사용하는 import 코드만 보고 의존 관계를 쉽게 판단할 수 있다.
  • 정적인 의존관계는 애플리케이션을 실행하지 않아도 분석할 수 있다.

• OrderServiceImpl은 MemberRepository, DiscountPolicy에 의존한다는 것을 알 수 있다.
  • 그런데 이러한 클래스 의존 관계 만으로는 실제 어떤 객체가 OrderServiceImpl에 주입될지 알 수 없다.

동적인 객체 인스턴스 의존 관계

애플리케이션 실행 시점에 실제 생성된 객체 인스턴스의 참조가 연결된 의존 관계다.

• 애플리케이션 실행 시점(런타임)에 외부에서 실제 구현 객체를 생성하고 클라이언트에 전달해서 클라이언트와 서버의 실제 의존 관계가 연결되는 것을 의존관계 주입이라 한다.
• 객체 인스턴스를 생성하고, 그 참조값을 전달해서 연결된다.
• 의존관계 주입을 사용하면 클라이언트 코드를 변경하지 않고, 클라이언트가 호출하는 대상의 타입 인스턴스를 변경할 수 있다.
• 의존관계 주입을 사용하면 정적인 클래스 의존관계를 변경하지 않고, 동적인 객체 인스턴스 의존관계를 쉽게 변경할 수 있다.

IoC 컨테이너, DI 컨테이너

• AppConfig처럼 객체를 생성하고 관리하면서 의존관계를 연결해주는 것을 IoC 컨테이너 또는 DI 컨테이너라 한다.
• 의존관계 주입에 초점을 맞추어 최근에는 주로 DI 컨테이너라 한다.
  • 스프링이 DI 컨테이너 역할을 하게 됨.
• 또는 어셈블러, 오브젝트 팩토리 등으로 불리기도 한다.

스프링으로 전환하기

지금까지 순수한 자바 코드만으로 DI를 적용했다. 이제 스프링을 사용해보자!

AppConfig 스프링 기반으로 변경

@Configuration
public class AppConfig {

    @Bean
    public MemberService memberService() {
        return new MemberServiceImpl(memberRepository());
    }

    @Bean
    public OrderService orderService() {
        return new OrderServiceImpl(memberRepository(), discountPolicy());
    }

    @Bean
    public DiscountPolicy discountPolicy() {
        return new RateDiscountPolicy();
    }

    @Bean
    public MemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }
}

• @Configuration으로 Config파일로 설정
• @Bean 어노테이션으로 스프링 컨테이너에 등록

MemberApp

 public class MemberApp {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        MemberService memberService = applicationContext.getBean("memberService", MemberService.class);

        ...
    }
}

OrderApp

public class OrderApp {
    public static void main(String[] args) {

        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

        MemberService memberService = applicationContext.getBean("memberService", MemberService.class);
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);

        Long memberId = 1L;
        Member member = new Member(memberId, "memberA", Grade.VIP);
        memberService.join(member);

        Order order = orderService.createOrder(memberId, "itemA", 10000);

        System.out.println("order = " + order);
    }
}

스프링 컨테이너

• ApplicationContext를 스프링 컨테이너라 한다.
• 기존에는 개발자가 AppConfig를 사용해 직접 객체를 생성하고 DI를 했지만, 이제부터는 스프링 컨테이너를 통해 사용한다.
• 스프링 컨테이너는 @Configuration이 붙은 AppConfig를 설정(구성)정보로 사용한다. 여기서 @Bean이라 적힌 메서드를 모두 호출해서 반환된 객체를 스프링 컨테이너에 등록한다.
  • 이렇게 스프링 컨테이너에 등록된 객체를 스프링 빈이라 한다.
• 스프링 빈은 @Bean이 붙은 메서드의 명을 스프링 빈의 이름으로 사용한다. (memberService, orderService)
  • 물론 이름을 명시적으로 바꿀 수 있다.
  • @Bean(name = "{이름}")
• 이전에는 개발자가 필요한 객체를 AppConfig를 통해서 직접 조회했지만, 이제부터는 스프링 컨테치언를 통해서 필요한 스프링 빈(객체)를 찾아야 한다.
  • 스프링 빈은 applicationContext.getBean()메서드를 사용해서 찾을 수 있다.
• 기존에는 개발자가 직접 자바 코드로 모든 것을 했다면, 이제부터는 스프링 컨테이너에 객체를 스프링 빈으로 등록하고, 스프링 컨테이너에서 스프링 빈을 찾아서 사용하도록 변경되었다.
• 코드가 약간 더 복잡해진 것 같은데… 스프링 컨테이너를 사용하면 어떤 장점이 있을까?

  대충 어마어마한 장점이 있다고 하는데…