[Spring 기본] 2. 스프링 핵심 원리 이해1 - 예제 만들기

안녕하세요!

이번 섹션부터 본격적으로 코드 위주로 작성해볼거 같아요!

그럼 고고!!

---

1. 프로젝트 생성

우선 본격적으로 스프링을 시작하기 전에 순수하게 자바로만 구현을 해보겠습니다.

이렇게 하면 코드가 변경이 되도 유연하게 대처가 가능할까요?

차근차근 진행해보겠습니다.

 

먼저 프로젝트 생성을 해보겠습니다.

Java17과 IDE: IntelliJ를 설치하고, 스프링 부트 스타터 사이트로 이동해서 스프링 프로젝트를 생성해보겠습니다.

 

https://start.spring.io

위의 링크가 스프링 부트 스타터 사이트 입니다.

 

들어가보면..

이런식으로 나옵니다.

여기에서 Project는 Gradle - Groovy, Language는 Java, Spring Boot는 3.4.4로 해볼게요.

SNAPSHOT과 M2는 아직 불안정하다고 해야하나? 그래서 안정된 버전 중 최신 버전인 3.4.4로 해보겠습니다.

밑에 보면 Project Metadata라고 있을 겁니다.

여기서 Group은 hello, Artifact는 core로 적어보겠습니다. (Group과 Artifact 아무거나 적어도 됩니다.)

Artifact를 core로 적으면 Name과 Package name이 자동으로 core 관련되게 생성됩니다.

Packaging은 Jar로 하면 되고, Java는 17버전으로 해볼게요. 더 최신 버전으로 해봐도 됩니다.

 

옆에 있는 Dependencies는 아무 것도 추가(선택) 안 하면 됩니다.

아무 것도 선택 안 하면 스프링 부트가 스프링 core쪽 라이브러리만 가지고 몇 개 간단히 구성해줍니다.

그래서 별도의 의존 관계는 설정하지 않고 밑에 GENERATE 버튼을 누르면 core.zip으로 다운로드 될 텐데 그거 압축 풀면 됩니다.

압축 푼 것을 공부하기 좋은? 폴더로 옮겨놓으면 됩니다.

 

프로젝트를 열어보겠습니다.

프로젝트 열기 누르고 아까 core 폴더 옮겨 놓은 경로로 들어가서 

core에서 build.gradle을 누르고 프로젝트를 열어볼게요.

 

그러고 스프링이 잘 되어 있는지 확인해보겠습니다.

왼쪽 core 폴더에서 src 폴더에서 main에서 java에서 hello에서 core로 들어가면 coreApplication이 나옵니다.

coreApplication에 들어가서 위에 초록색 삼각형을 누르면 실행이 됩니다.

성공적으로 실행이 되면 위의 사진처럼 나올 것입니다.

그럼 본격적으로 시작해볼게요!

---

2. 비즈니스 요구사항과 설계

개발을 시작하기 전에 요구사항과 설계 단계는 필수입니다.

한 번 요구사항 정리와 설계를 해볼까요?

• 회원
  • 회원을 가입하고 조회할 수 있습니다.
  • 회원은 일반과 VIP 두 가지 등급이 있습니다.
  • 회원 데이터는 자체 DB를 구축할 수 있고, 외부 시스템과 연동할 수 있습니다. (미확정)
• 주문과 할인 정책
  • 회원은 상품을 주문할 수 있습니다.
  • 회원 등급에 따라 할인 정책을 적용할 수 있습니다.
  • 할인 정책은 모든 VIP는 1,000원을 할인해주는 고정 금액 할인을 적용해야 합니다. (나중에 변경될 수도..?)
  • 할인 정책은 변경 가능성이 높습니다. 회사의 기본 할인 정책을 아직 정하지 못하였고, 오픈 직전까지 고민을 미루고 싶다. 최악의 경우 할인을 적용하지 않을 수도 있습니다. (미확정)

요구사항을 보면 회원 데이터, 할인 정책 같은 부분은 지금 결정하기 어려운 부분입니다.

그렇다고 이런 정책이 결정될 때까지 개발을 무기한 기다릴 수도 없습니다.

그렇지만 앞에서 객체 지향 설계 방법을 배웠으므로, 인터페이스를 만들고 구현체를 언제든지 갈아끼울 수 있도록 설계하면 됩니다!

 

주의! 프로젝트 환경설정을 편리하게 하려고 스프링 부트를 사용한 것이고, 지금은 스프링 없는 순수한 자바로만 개발을 진행합니다. 스프링 관련은 나중에 나올 예정입니다.

---

3. 회원 도메인

3-1. 회원 도메인 설계

• 회원
  • 회원을 가입하고 조회할 수 있습니다.
  • 회원은 일반과 VIP 두 가지 등급이 있습니다.
  • 회원 데이터는 자체 DB를 구축할 수 있고, 외부 시스템과 연동할 수 있습니다. (미확정)
• 회원 도메인 협력 관계

협력 관계는 기획자도 볼 수 있는 그림입니다.

클라이언트가 회원 서비스를 호출하고, 회원 서비스는 회원 가입과 회원 조회라는 2가지 기능을 제공합니다.

클라이언트, 회원 서비스, 회원 저장소=역할 / 메모리 회원 저장소, DB 회원 저장소, 외부 시스템 연동 회원 저장소=구현

 

• 회원 클래스 다이어그램

회원 클래스 다이어그램은 회원 도메인 협력 관계를 바탕으로 개발자들이 구체화해서 만들어냅니다.

회원 데이터에 접근하는 계층을 따로 회원 저장소(MemberRepository)라는 인터페이스로 만들었습니다.

우선, 메모리 회원 저장소부터 구현해서 회원 서비스(MemberService)를 인터페이스로 만들고 그것에 대한 구현체로 MemberServiceImpl을 만들었습니다.

 

구현해야 할 것은 회원 가입과 회원 조회 2가지 인데 왜 MemberServiceImpl 하나만 구현체일까요?

왜냐하면, 회원과 관련된 모든 기능들은 회원 서비스 클래스 안에 구현되어야 하기 때문입니다.

 

그리고, 회원 저장소인 MemberRepository를 인터페이스로 만들어서 MemberRepository에 대한 구현체로 MemoryMemberRepository와 DbMemberRepository를 만듭니다.

 

• 회원 객체 다이어그램

클래스 다이어그램과 객체 다이어그램의 차이점

- 클래스 다이어그램-
시스템의 정적인 구조를 설계하는데 사용합니다.
어떤 클래스가 있고, 클래스 간의 관계(상속, 연관, 의존, 집합 등)을 나타내는 다이어그램입니다.
실제 서버를 실행하지 않고 클래스만 분석해서 볼 수 있는 것입니다.

-객체 다이어그램-
실제 실행중인 객체들의 상태를 표현하는 다이어그램입니다.
클래스 다이어그램을 기반으로 특정 시점에서 생성된 객체들의 관계를 보여줍니다.

 

 

3-2. 회원 도메인 개발

본격적으로 개발을 해보겠습니다.

우선 member라는 패키지를 생성합니다.

 

그러고 member 패키지 안에 등급을 나타내는 Grade 클래스를 만듭니다.

주의할 점은 Grade 클래스는 밑에 사진처럼 열거형 즉, enum으로 만듭니다.

 

Grade 클래스를 만들고 나면,

package hello.core.member;

public enum Grade {
}

이런 식으로 Grade라는 enum 클래스가 만들어 집니다.

package hello.core.member;

public enum Grade {
    BASIC,
    VIP
}

이 클래스 안에 저희가 요구사항에 적었던 등급 종류인 BASIC과 VIP를 적었습니다.

 

package hello.core.member;

public class Member {
}

그리고, Member 엔티티를 만들어보겠습니다.

Member 엔티티는 java 클래스로 생성합니다.

package hello.core.member;

public class Member {
    private Long id;
    private String name;
    private Grade grade;
}

회원 엔티티는 속성이 id, 이름, 등급 총 3가지가 있습니다.

 

그러고 생성자를 만들어볼건데, Mac은 command + n을 동시에 누르면 되고, Window는 Alt + Insert를 동시에 누르면 됩니다.

public class Member {
    private Long id;
    private String name;
    private Grade grade;

    public Member(Long id, String name, Grade grade) {
        this.id = id;
        this.name = name;
        this.grade = grade;
    }
}

아까와 같은 단축키를 눌러서 이번엔 Getter와 Setter를 만들어보겠습니다.

public class Member {
   ...
    public Member(Long id, String name, Grade grade) {
        ...
    }
	//Getter
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public Grade getGrade() {
        return grade;
    }
	//Setter
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }
}

Getter와 Setter를 만들 때 항목 다 선택하시면 됩니다.

 

인터페이스를 만들어보겠습니다.

아까 있던 member 패키지에서 우클릭하여 Javaclass에서 이름은 MemberRepository로 하여 인터페이스를 만들어볼거에요.

만들어보면

package hello.core.member;

public interface MemberRepository {
}

이런 식으로 나올거에요.

public interface MemberRepository {
    void save(Member member);
    Member findById(Long memberId);
}

인터페이스는 함수의 형태만 정의하는 것이어서 중괄호 안의 로직 코드가 없습니다.

 

인터페이스인 MemberRepository를 구현한 클래스인 MemoryMemberRepository를 만들어보겠습니다.

아까와 같은 패키지에 Javaclass 형태로 만들고, 밑에와 같이 코드를 작성합니다.

package hello.core.member;

public class MemoryMemberRepository implements MemberRepository{
}

왜 implements를 사용했냐면 MemberRepository라는 인터페이스에서 만들기로 정해놓은 함수들을 구현할 클래스라는 것을 명시하기 위해서 입니다.

근데 이렇게 되어있으면 빨간줄이 뜰 것입니다.

public class MemoryMemberRepository implements MemberRepository{
    @Override
    public void save(Member member) {
        
    }

    @Override
    public Member findById(Long memberId) {
        return null;
    }
}

window 기준 Alt + Enter를 누르고 메서드 구현을 누르면 인터페이스에서 정의한 함수들을 오버라이드 하는 기능이 나옵니다.

import java.util.HashMap;
import java.util.Map;

public class MemoryMemberRepository implements MemberRepository{
    private static Map<Long, Member> store = new HashMap<>();
    @Override
    public void save(Member member) {
        store.put(member.getId(), member);
    }

    @Override
    public Member findById(Long memberId) {
        return store.get(memberId);
    }
}

• private static Map<Long, Member> store = new HashMap<>();

Map은 2개의 타입을 갖고 있는 배열이라고 생각하면 됩니다.

첫 번째 타입은 해당 값의 고유 키이고, 두 번째 타입은 해당 값의 value 입니다.

형태가 [ {1,시월}, {2,쏭}, {3,코딩}] 이런 느낌입니다.

여기에서 Map<Long, Member>는 고유키는 Long 타입, value는 이전에 정한 Member 클래스 타입입니다.

Member 클래스는 id와 name과 grade를 갖고 있는 집합입니다. (1, 시월, VIP) 요런 느낌?

store는 변수 이름으로 아무거나 지정해도 됩니다.

그리고, Map은 여러 가지 종류가 있는데 HashMap은 해시 테이블을 사용해서 빠른 검색 속도를 제공하는 Map 입니다.

 

HashMap에는 put() 기능과 get() 기능을 제공합니다.

put()은 값을 넣는 기능이고, 인자값으로 고유키과 value 2개를 넣어줘야 합니다.

get()은 값을 찾는 기능이고, 고유키만 인자값으로 넣어주면 value를 찾아줍니다.

 

여기에서는 고유키가 member.getId의 값입니다. value는 member 자체입니다.

 

그 다음으로 MemberService 인터페이스를 만들어보겠습니다.

package hello.core.member;

public interface MemberService {
    void join(Member member); //회원 가입

    Member findMember(Long memberId); //회원 조회
}

회원 가입과 회원 조회 기능을 넣고, 구현체인 MemberServiceImpl을 만들어보겠습니다.

package hello.core.member;

public class MemberServiceImpl implements MemberService{

    private final MemberRepository memberRepository = new MemoryMemberRepository();
    @Override
    public void join(Member member) {
        memberRepository.save(member);
    }

    @Override
    public Member findMember(Long memberId) {
        return memberRepository.findById(memberId);
    }
}

MemberService의 구현체여서 implements를 사용했고, 아까처럼 Alt + Enter 키를 눌러 메서드 구현을 합니다.

 

•  private final MemberRepository memberRepository = new MemoryMemberRepository();

여기서 final은 변경할 수 없는 변수를 의미합니다.

MemberRepository는 이미 구성이 완료되어있는 것이기 때문에 MemberService에서 MemberRepository가 변경이 되면 안 됩니다. 때문에 final을 사용했습니다.

그리고, MemberRepository의 기능을 사용해야 하는데 memberRepository라는 변수명을 사용하여 MemoryMemberRepository에서 구현한 기능들을 가져옵니다. (MemoryMemberRepository는 MemberRepository의 구현체이기 때문에)

 

 

3-3. 회원 도메인 실행과 테스트

위에서 회원 도메인 개발한 것을 실행과 테스트를 해볼 것입니다.

먼저, core 폴더 안에 MemberApp이라고 클래스를 만들어줍니다.

그러고 메인 함수를 만들고, Member를 회원가입하고 조회를 해볼 것입니다.

package hello.core;

import hello.core.member.Grade;
import hello.core.member.Member;
import hello.core.member.MemberService;
import hello.core.member.MemberServiceImpl;

public class MemberApp {
    public static void main(String[] args) {
        MemberService memberService = new MemberServiceImpl();
        Member member = new Member(1L, "시월", Grade.VIP);
        memberService.join(member);

        Member findMember = memberService.findMember(1L);
        System.out.println("new member = " + member.getName());
        System.out.println("findMember = " + findMember.getName());
    }
}

new MemberServiceImpl()을 통해 MemberServiceImpl에서 구현했던 join과 findMember를 직접 사용해볼 것입니다.

우선, 가입시킬 회원 정보를 생성합니다.

new Member(1L, "시월", Grade.VIP);를 통해 id는 1번이고, 이름은 시월이고, 등급은 VIP인 Member를 하나 생성하였습니다.

해당 멤버를 회원가입 시키기 위해 MemberService.join()을 호출하여 MemoryMemberRepository의 store에 저장되도록 했습니다.

 

방금 저장한 회원을 id를 통해 조회해보겠습니다.

MemberService.findMember()를 통해 방금 저장한 "시월"을 조회할건데, "시월"의 id 값은 1이기 때문에 인자값으로 1을 넣어줍니다. (Long 타입이어서 1L)

호출하면 리턴값으로 member가 나오기 때문에 여기서 이전에 만들었던 getter들을 사용하여 이름이나 등급 등을 불러올 수 있습니다. (findMember.getName())

 

이름을 호출했으므로 결과는 이렇게 나옵니다.

 

여기는 보면 아시다시피 순수하게 자바만 사용한 것이고, 스프링 관련 코드가 1도 없습니다.

근데, 이렇게 애플리케이션 로직으로 테스트 하는 것은 좋은 방법이 아닙니다.

JUnit 테스트 프레임워크를 사용해보겠습니다.

 

이번에는 main 패키지가 아닌 test 패키지 안에 만들 것입니다.

test 패키지 안의 java 안의 hello 안의 core 안에서 member 패키지를 만들어서 거기에 MemberServiceTest라는 클래스를 만듭니다.

package hello.core.member;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

public class MemberServiceTest {
    MemberService memberService = new MemberServiceImpl();
    @Test
    void join() {
        //given //이런 환경이 주어졌을 때
        Member member = new Member(1L, "시월", Grade.VIP);

        //when //이렇게 했을 때
        memberService.join(member);
        Member findMember = memberService.findMember(1L);

        //then //이렇게 된다
        Assertions.assertThat(member).isEqualTo(findMember);

    }
}

MemberService의 기능을 테스트할 것이기 때문에 메서드들을 사용하기 위하여 new MemberServiceImpl()을 했습니다.

 

@Test가 붙은 메서드는 테스트를 위한 메서드라고 선언하는 annotation입니다.

테스트는 크게 given, when, then 3단계로 진행합니다.

given은 테스트 환경을 갖추는 단계이고, when은 테스트 할 상황을 진행하는 단계이고, then은 예상한대로 잘 작동했는지 테스트하는 단계입니다.

 

• Member member = new Member(1L, "시월", Grade.VIP);
  • 테스트 전 "시월"이라는 멤버형 변수를 생성합니다.
  • 회원가입 전에 회원가입 창에 회원의 정보들을 적어놓기만 한 상태와 비슷합니다.
• memberService.join(member);
  • 테스트 할 상황인 "시월"이라는 멤버를 회원가입시키는 단계입니다.
  • 여기서 findMember는 회원가입한 사용자를 조회하는 기능입니다.
• Assertions.assertThat(member).isEqualTo(findMember);
  • Assertions는 JUnit에서 제공하는 테스트 메서드들의 집합 클래스입니다.
    그 중 저희는 assertThat()을 사용합니다.
  • assertThat()은 비교 대상을 지정할 수 있습니다.
    저희는 맨 처음 생성한 멤버형 변수를 비교 대상에 지정했습니다.
  • 해당 변수가 MemberService.findMember()를 통해 조회해서 가져온 멤버와 같아야 테스트가 성공합니다.

 

테스트 실행을 해보겠습니다.

애플리케이션으로 테스트를 할 때는 출력을 하여 눈으로 검정을 하는데 JUnit을 사용하면 테스트 성공하면 밑에 사진처럼 나옵니다.

실패하면 빨간색으로 뜨면서 X나오고 뭐 오류 뜹니다.

테스트를 메인 함수에 하지 않는 이유

메인 함수에서 테스트를 진행하면 값 확인을 위해 System.out.println()과 같은 출력 함수를 써서 출력 로그를 봐야 합니다.
이 과정은 매우 번거롭고 실수가 있을 수 있어서 확실하게 ✔️ 혹은 ❌가 나오는 JUnit 테스트를 진행하는 것이 좋습니다.

 

그런데 이 회원 도메인 설계에는 문제점이 있습니다.

이렇게 코드를 짜면 클라이언트가 추상화에도 구체화에도 의존하고 있습니다.

(ex. MemberService가 MemberRepository에도 의존하고, MemoryMemberRepository에도 의존합니다.)

DIP를 위반하는 것이죠.

---

4. 주문과 할인 도메인

4-1. 주문과 할인 도메인 설계

• 주문과 할인 정책
  • 회원은 상품을 주문할 수 있다.
  • 회원 등급에 따라 할인 정책을 적용할 수 있다.
  • 할인 정책은 "모든 VIP는 1,000원을 할인해주는 고정 금액 할인을 적용해달라."입니다. (나중에 변경될 수 있다)
  • 할인 정책은 변경 가능성이 높다. 회사의 기본 할인 정책을 아직 정하지 못했고, 오픈 직전까지 고민을 미루고 싶다. 최악의 경우 할인을 적용하지 않을 수도 있다. (미확정)
• 주문 도메인 협력, 역할, 책임

1. 주문 생성: 클라이언트는 주문 서비스에 주문 생성을 요청합니다.

2. 회원 조회: 할인을 위해서는 회원 등급이 필요합니다. 그래서 주문 서비스는 회원 저장소에서 회원을 조회합니다.

3. 할인 적용: 주문 서비스는 회원 등급에 따른 할인 여부를 할인 정책에 위임합니다.

4. 주문 결과 반환: 주문 서비스는 할인 결과를 포함한 주문 결과를 반환합니다.

참고: 실제로는 주문 데이터를 DB에 저장하겠지만, 예제가 너무 복잡해질 수 있어서 생략하고, 단순히 주문 결과를 반환합니다.

 

• 주문 도메인 전체

할인 정책 역할 인터페이스에서 어떤 방식으로 할인을 할 건지에 따라 구현체를 나눴습니다.

고정 금액을 할인하는 정액 할인 정책과 % 할인하는 정률 할인 정책을 할인 정책 역할의 구현체로 나타냈습니다.

 

클라이언트가 주문 생성을 요청할 주문 서비스 역할 인터페이스는 회원의 등급을 확인해야하기 때문에 회원 저장소 역할이 필요하고, 등급에 따라 가격을 할인해줘야하기 때문에 할인 정책 역할도 필요합니다.

 

역할과 구현을 분리해서 자유롭게 구현 객체를 조립할 수 있게 설계했습니다.

덕분에 회원 저장소는 몰론이고, 할인 정책도 유연하게 변경할 수 있습니다.

 

• 주문 도메인 클래스 다이어그램

- 인터페이스 OrderService = 주문 서비스 역할

- OrderServiceImpl = 주문 서비스 구현체

- 인터페이스 DiscountPolicy = 할인 정책 역할

- FixDiscountPolicy = 정액 할인 정책

- RateDiscountPolicy = 정률 할인 정책

 

• 주문 도메인 객체 다이어그램1

회원을 메모리에서 조회하고, 정액 할인 정책(고정 금액)을 지원해도 주문 서비스를 변경하지 않아도 됩니다.

역할들의 협력 관계를 그대로 재사용할 수 있습니다.

 

• 주문 도메인 객체 다이어그램2

회원을 메모리가 아닌 실제 DB에서 조회하고, 정률 할인 정책(주문 금액에 따라 % 할인)을 지원해도 주문 서비스를 변경하지 않아도 됩니다.

협력 관계를 그대로 재사용할 수 있습니다.

 

 

4-2. 주문과 할인 도메인 개발 - 정액 할인 정책(FixDiscountPolicy)

위의 설계를 바탕으로 개발을 한 번 해보겠습니다.

먼저, hello 폴더 안의 core 패키지 안에 discount라는 패키지를 만들어보겠습니다.

그러고 이 패키지 안에 DiscountPolicy 인터페이스를 생성하겠습니다.

package hello.core.discount;

import hello.core.member.Member;

public interface DiscountPolicy {

    //@return 할인 대상 금액
    int discount(Member member, int price);
}

DiscountPolicy의 구현체가 구현해야 할 메서드를 지정했습니다.

왜 인자값이 2개일까요?

할인을 하려면 이 사람의 Grade와 물건의 가격을 알아야 하기 때문입니다.

Grade가 VIP이면 구현체의 할인 정책에 따라 원 가격에서 할인된 가격으로 return을 해줍니다.

 

그러고 DiscountPolicy의 구현체 중에 정액 할인 정책 구현체를 만들어보겠습니다.

아까처럼 discount 패키지 안에 FixDiscountPolicy 클래스를 만들어줍니다.

만들어보면

package hello.core.discount;

import hello.core.member.Member;

public class FixDiscountPolicy implements DiscountPolicy {
    @Override
    public int discount(Member member, int price) {
        return 0;
    }
}

이렇게 나오는데 이것은 위에서 MemoryMemberRepository때 했던 것처럼 인터페이스를 구현할 클래스라고 명시하기 위해서 implements를 사용합니다.

빨간 줄이 뜨는데 이 역시 Alt + Enter 키를 눌러서 메서드 구현을 하면 됩니다.

메서드 구현 하면 오버라이드를 하게 되는데 아까 인터페이스에서 정의했던 discount 메서드를 재정의했습니다.

public class FixDiscountPolicy implements DiscountPolicy {
    private int discountFixAmount = 1000; //1000원 할인

    @Override
    public int discount(Member member, int price) {
        if(member.getGrade() == Grade.VIP) {
            return discountFixAmount;  //1,000원을 할인하려고
        }
        else {
            return 0; //할인할 금액이 없다는 뜻
        }
    }
}

마저 더 구현해보았습니다.

할인할 금액을 1,000원으로 정의했기 때문에 private int discountFixAmout = 1000;로 변수를 지정했습니다.

그런데 할인은 VIP만 가능하기 때문에 밑에 함수에 if문을 사용했습니다.

만약에 VIP 등급이면 discountFixAmount 변수를 리턴하게끔 했고, 아닐 경우 0으로 리턴되게 하였습니다.

 

그 다음 주문 서비스 인터페이스와 구현체를 구현하기 위해 core 패키지 안에 order라는 패키지를 만들어보겠습니다.

그러고 order 패키지 안에 order 엔티티 클래스를 만들어보겠습니다.

package hello.core.order;

public class Order {
    private Long memberId; //회원 id
    private String itemName; //물건 이름
    private int itemPrice; //물건 금액
    private int discountPrice; //할인 금액

    public Order(Long memberId, String itemName, int itemPrice, int discountPrice) {
        this.memberId = memberId;
        this.itemName = itemName;
        this.itemPrice = itemPrice;
        this.discountPrice = discountPrice;
    }

    //비즈니스 계산 로직
    public int calculatePrice() {
        return itemPrice - discountPrice;
    }

    public Long getMemberId() {
        return memberId;
    }

    public String getItemName() {
        return itemName;
    }

    public int getItemPrice() {
        return itemPrice;
    }

    public int getDiscountPrice() {
        return discountPrice;
    }

    public void setMemberId(Long memberId) {
        this.memberId = memberId;
    }

    public void setItemName(String itemName) {
        this.itemName = itemName;
    }

    public void setItemPrice(int itemPrice) {
        this.itemPrice = itemPrice;
    }

    public void setDiscountPrice(int discountPrice) {
        this.discountPrice = discountPrice;
    }

    //문자열 출력을 할 때 보기 쉽게 하려고
    @Override
    public String toString() {
        return "Order{" +
                "memberId=" + memberId +
                ", itemName='" + itemName + '\'' +
                ", itemPrice=" + itemPrice +
                ", discountPrice=" + discountPrice +
                '}';
    }
}

먼저, 주문 데이터를 만들기 위해서 주문한 사용자의 id가 필요하고 주문한 물품의 이름, 가격과 할인할 가격이 필요합니다.

그래서 저 4개의 필드(엔티티 내의 변수들)를 각각 만들어서 Alt + Insert 키를 눌러 생성자와 Getter, Setter를 생성했습니다.

그리고, 사용자가 구매할 최종 물건 가격을 계산하기 위한 비즈니스 계산 로직으로 calculatePrice라는 함수를 구현했습니다.

또한 주문 정보를 문자열로 편하게 출력하기 위해서 Alt + Insert 키를 눌러서 toString()을 생성했습니다.

 

마지막으로 주문 서비스 인터페이스와 주문 서비스 구현체를 만들어보겠습니다.

우선 주문 서비스 인터페이스부터 만들건데요.

order 패키지 안에 OrderService라는 인터페이스를 만들어보겠습니다.

package hello.core.order;

public interface OrderService {
    Order createOrder(Long memberId, String itemName, int itemPrice);
}

createOrder는 Order를 생성하는 메서드 입니다.

Order를 생성하기 위해 필요한 회원 id, 물건 이름, 물건 가격을 인자값으로 갖고 Order를 생성해서 리턴하는 기능을 합니다.

 

 

주문 서비스 구현체를 만들어보겠습니다.

아까와 같은 order 패키지 안에 OrderServiceImpl이라는 클래스를 만들어줍니다.

package hello.core.order;

import hello.core.discount.DiscountPolicy;
import hello.core.discount.FixDiscountPolicy;
import hello.core.member.Member;
import hello.core.member.MemberRepository;
import hello.core.member.MemoryMemberRepository;

public class OrderServiceImpl implements OrderService{

    private final MemberRepository memberRepository = new MemoryMemberRepository();
    private final DiscountPolicy discountPolicy = new FixDiscountPolicy();

    //지금 OrderService 입장에서는 "할인에 관한 것은 discountPolicy 알아서 하고, 결과만 던져줘."
    //그래서 단일책임원칙을 잘 지킨 사례
    //만약에 할인에 대한 변경이 필요하면 할인 쪽만 수정하면 됨 (주문쪽까지 수정할 필요 없음)
    @Override
    public Order createOrder(Long memberId, String itemName, int itemPrice) {
        Member member = memberRepository.findById(memberId);
        int discountPrice = discountPolicy.discount(member, itemPrice);

        return new Order(memberId, itemName, itemPrice, discountPrice);
    }
}

findById()를 사용하기 위해서 해당 기능을 구현했던 MemoryMemberRepository를 할당받았습니다.

또한, discountPrice를 계산하기 위해서 discount()를 구현했던 FixDiscountPolicy를 할당받았습니다.

 

createOrder는 Order를 생성해서 리턴하는 메서드 입니다.

현재 Order를 생성하기 위해서는 memberId와 itemName, itemPrice를 인자값으로 받아왔습니다.

하지만, discountPrice는 Order 안에는 있지만, 사용자가 주문을 요청할 때 전달하는 값은 아니기 때문에 OrderServiceImpl의 createOrder 함수 안에서 계산이 되어야 합니다.

(int discountPrice = discountPolicy.discount(member, itemPrice);)

 

 

4-3. 주문과 할인 도메인 실행과 테스트 - 정액 할인 정책(FixDiscountPolicy)

테스트를 하기 위해서 우선 core라는 패키지 안에 OrderApp이라는 클래스를 만들어보겠습니다.

package hello.core;

import hello.core.member.Grade;
import hello.core.member.Member;
import hello.core.member.MemberService;
import hello.core.member.MemberServiceImpl;
import hello.core.order.Order;
import hello.core.order.OrderService;
import hello.core.order.OrderServiceImpl;

public class OrderApp {
    public static void main(String[] args) {
        MemberService memberService = new MemberServiceImpl();
        OrderService orderService = new OrderServiceImpl();

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

        Order order = orderService.createOrder(memberId, "초콜릿", 10000);

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

회원 id와 이름과 등급이 있는 Member를 생성하여 MemberServiceImpl에서 제공하는 회원가입(join)기능을 사용했습니다.

그리고, 주문을 생성하기 위해 OrderServiceImpl에서 제공하는 createOrder를 사용했습니다.

또한, 인자값으로 방금 회원가입한 회원의 id와 물건 이름, 물건 가격을 넣어줬습니다.

 

"시월"이의 등급은 VIP이기 때문에 Order가 생성될 때 할인될 가격(discountPrice)은 1,000원이 되어야할 것입니다.

 

테스트를 진행해보겠습니다.

결과에서 보면 아시다시피 discountPrice가 1,000원으로 잘 설정되었습니다.

 

근데 이 검사 방법은 위에서도 얘기했다시피 좋지 않은 방법이기 때문에 JUnit을 사용해서 테스트 해보겠습니다.

밑에 Test라는 폴더 안의 hello 폴더 안의 core 패키지 안에서 order라는 패키지를 만들어 거기에 OrderServiceTest라는 클래스를 만들었습니다.

package hello.core.order;

import hello.core.member.Grade;
import hello.core.member.Member;
import hello.core.member.MemberService;
import hello.core.member.MemberServiceImpl;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

public class OrderServiceTest {

    MemberService memberService = new MemberServiceImpl();
    OrderService orderService = new OrderServiceImpl();

    @Test
    void createOrder() {
        Long memberId = 1L;
        Member member = new Member(memberId, "시월", Grade.VIP);
        memberService.join(member);

        Order order = orderService.createOrder(memberId, "초콜릿", 10000);
        Assertions.assertThat(order.getDiscountPrice()).isEqualTo(1000);
    }
}

 

위에서처럼 Assertions 라이브러리를 사용해서 테스트를 작성했습니다.

VIP 등급인 "시월"이가 10,000원 짜리인 초콜릿을 주문했기 때문에 해당 주문의 discountPrice는 1,000원이 되어야 합니다.

테스트 결과는 잘 나왔을까요?

잘 나왔습니다.

끝났습니다.

---

여기까지 끄읕~

처음 제대로 스프링 배워보는거라 쫌 어렵네요..ㅎ

다음에 또 오겠슴다

안뇽!