[Spring] 인프런 스프링 입문(김영한 님) - 회원 관리 예제:비즈니스 요구사항, 회원 도메인/리포지토리/서비스 개발, 테스트케이스 작성

이 글은 인프런 김영한 님의 스프링 입문 강의 를 듣고 정리한 글입니다.

회원 관리 예제 - 백엔드 개발

• 비즈니스 요구사항 정리
• 회원 도메인과 저장소(리포지토리) 만들기
• 회원 리포지토리 테스트케이스 작성
• 회원 서비스 개발
• 회원 서비스 테스트

*회원 저장소(리포지토리) : 회원 도메인 객체를 저장 및 불러올 수 있는 객체.

비즈니스 요구사항 정리

예시이므로 가장 쉬운 것으로 만든다.

단순한 서비스로 스프링 생태계가 어떻게 개발, 동작되는지 이해하는 게 목표다.

• 데이터 : 회원 아이디, 이름
• 기능 : 회원 등록, 조회
• (가상의 시나리오) 아직 데이터 저장소가 선정되지 않음

일반적 웹 애플리케이션 계층 구조

일반적인 웹 애플리케이션은 컨트롤러, 서비스, 리포지토리, 도메인, DB 의 5 요소로 구성된다.

• 컨트롤러 : 웹 MVC의 컨트롤러 역할
• 서비스 : 핵심 비즈니스 로직 구현
  • 비즈니스 도메인 객체를 가지고 핵심 비즈니스 로직이 동작하도록 구현한 계층.
• 리포지토리 : 데이터베이스에 접근, 도메인 객체를 DB에 저장 및 관리
• 도메인 : 비즈니스 도메인 객체.
  • 예) 회원, 주문, 쿠폰 등등 주로 데이터베이스에 저장하고 관리됨

클래스 의존관계

• 회원 리포지토리 (MemberRepository) : 인터페이스로 설계할 것이다.

  • 왜? 아직 데이터 저장소가 선정되지 않았으므로.

    데이터 저장소는 RDB, NoSQL 등 다양한 저장소를 고민 중인 상황으로 가정

  • Memory MemberRepository : 회원 리포지토리의 구현체 (단순)

    초기 개발 단계에서는 구현체로 가벼운 메모리 기반 데이터저장소를 사용한다.

  • 구체적인 기술이 선정되고 나면 이를 바꿀 것이다. 때문에 인터페이스로 만들면 나중에 구현 클래스를 변경하기 좋다.

회원 도메인과 리포지토리 만들기

앞의 비즈니스 요구사항을 바탕으로 구현을 시작한다.

• 회원 : 아이디와 이름을 가진다.

  src/main/java/프로젝트명/domain 패키지를 만들고 Member.java 생성

  • 아이디는 회원이 짓는 ID가 아니라, 회원 구분을 위해 시스템이 정하는 ID임.

    private Long id

  • 이름은 회원이 적는 이름.

    private String name

  • getter, setter를 만든다.

package hello.hellospring.domain;

public class Member {

    private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

• 저장소(리포지토리) : 회원(Member)을 저장하고 꺼낸다.

  src/main/java/프로젝트명/repository 디렉토리를 만들고 MemberRepository라는 인터페이스를 생성한다.

  • 저장 : 회원을 저장하고 저장된 회원을 반환함.

    Member save(Member member)

  • 아이디로 회원조회

    Optional<Member> findByID(Long id)

  • 이름으로 회원조회

    Optional<Member> findByName(String name)

  • 모든 회원조회

    List<Member> findAll()

Optional : 자바8에 들어간 기능으로, 반환되는 객체가 null일 가능성이 있을 때 사용한다.

(찾으려는 id나 name이 없을 수 있으므로 이런 처리를 한다)

우리 코드에서는 Member 객체를 Optional로 한 번 더 감싸서 사용할 것이다.

*Optional 변수에서 값을 꺼낼 때는 get()을 사용한다. (Optional객체에서 Member)

orElseGet() : 값이 있으면 꺼내고, 없으면 ()내의 메서드를 실행한다.

package hello.hellospring.repository;

import hello.hellospring.domain.Member;

import java.util.List;
import java.util.Optional;

public interface MemberRepository {
    Member save(Member member);
    Optional<Member> findById(Long id);
    Optional<Member> findByName(String name);
    List<Member> findAll();
}

• 저장소의 구현체

  src/main/java/프로젝트명/repository에 MemoryMemberRepository.java 생성

  클래스명 옆에 implements MemberRepository를 입력하고 alt + enter로 메서드를 만든다.

  만들어진 메서드를 하나하나 구현한다.

  • save() : 회원을 저장하려면 저장할 객체가 필요.

    • private static Map<Long, Member> store = new HashMap<>(); : member와 아이디를 저장할 객체이다.
    • private static long sequence = 0L; : 시퀀스는 0, 1, 2.. 와 같이 키 값을 생성해 주는 역할이라고 보면 된다.
    • sequence에 1을 더한 값을 member의 아이디로 지정한다 - store에 아이디와 member를 넣는다 - member를 반환한다

  • findById() : store에서 아이디를 가지고 member를 꺼낸다.

    • return Optional.ofNullable(store.get(id));
    • 아이디에 해당하는 회원이 없어 null이 나올 수 있으므로, Optional.ofNullable()로 감싸 준다.

  • findByName() : store에서 이름을 가지고 찾는다.

    • 람다와 스트림을 활용해 루프를 돌린다.
    • .filter(member -> member.getName().equals(name)) : member의 이름이 파라미터로 넘어온 name과 같은지 비교한다. 같은 경우에만 필터링이 된다.
    • .findAny() : 찾은 것들을 모두 반환한다.

  • findAll() : 모든 회원을 반환한다.

    return new ArrayList<>(store.values())

    • 회원 저장은 Map에 하지만 반환은 List로 한다. 이유는 루프를 돌리기 더 편해서.

회원 리포지토리 테스트 케이스 작성

구현된 MemoryMemberRepository가 잘 동작하는지 확인하기 위해, 테스트케이스를 만들어 본다.

개발한 기능을 실행해서 테스트 할 때, main메서드를 통해서 실행하거나 컨트롤러를 통해 실행한다. 이런 방법은 준비 및 실행이 오래 걸리고, 반복 실행이 어렵고, 여러 테스트를 한 번에 실행하기 어렵다.

자바는 JUnit이라는 프레임워크로 테스트를 실행해 이런 문제를 해결한다.

• 테스트 클래스는 src/test/java/프로젝트명 경로에 동일한 패키지를 만들고 거기에 작성한다.

• 테스트 클래스의 이름은 관례상 테스트하려는 클래스 이름+Test 이다.

  MemoryMemberRepository의 테스트클래스 이름은 MemoryMemberRepositoryTest가 된다.

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

import java.util.List;
import java.util.Optional;

import static org.assertj.core.api.Assertions.*;

public class MemoryMemberRepositoryTest {
    MemoryMemberRepository repository = new MemoryMemberRepository();

    @AfterEach
    public void afterEach() {
        repository.clearStore();
    }

    @Test
    public void save(){
        Member member = new Member();
        member.setName("spring");
        repository.save(member);

        Member result = repository.findById(member.getId()).get();
        // 검증 : 메모리에 저장한 것과 저장소에서 꺼낸 것이 동일해야 참이다.
        assertThat(member).isEqualTo(result);
    }

    @Test
    public void findByName() {
        Member member1 = new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2 = new Member();
        member2.setName("spring2");
        repository.save(member2);

        Member result = repository.findByName("spring1").get();

        assertThat(result).isEqualTo(member1);
    }

    @Test
    public void findAll(){
        Member member1 = new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2 = new Member();
        member2.setName("spring2");
        repository.save(member2);

        List<Member> result = repository.findAll();

        assertThat(result.size()).isEqualTo(2);

    }
}

• 테스트 클래스는 public일 필요가 없다.
• 테스트 클래스에 테스트를 원하는 객체를 생성하고, 메서드 위에 @Test 어노테이션을 붙이면 해당 메서드를 테스트할 수 있게 된다.
  • import org.junit.jupiter.api.Test;가 필요하다.
• 테스트 메서드 안에서 main메서드에서 테스트하던 것과 같이 테스트코드를 짜면 된다.
• 테스트 메서드에서 검증을 할 때는 org.assertj.core.api.Assertions의 Assertions.assertThat(member).isEqualTo(result)와 같이 사용.
  • import static org.assertj.core.api.Assertions.*; 로 가져오면 Assertions 없이 사용 가능하다.
• 각 @Test의 순서는 보장되지 않는다.
  • 테스트는 서로 의존관계 없이 (순서에 관계없이) 결과가 보장되어야 함.
  • @AfterEach : 각 테스트메서드가 끝날 때 마다 실행하는 메서드를 정의함
• 테스트 메소드의 이름은 한글로 적을 수도 있다. void 회원가입() { ... } - 좀 더 직관적이기 때문

(참고) 테스트 주도 개발(TDD)

: 테스트 케이스를 먼저 만들고 기능을 만드는 것.

우리는 기능 개발을 먼저 하고 그 기능을 테스트하기 위해 테스트를 만들었지만,

테스트 주도 개발에서는 테스트를 먼저 만들고 그 테스트에 맞는 기능을 개발한다.

규모가 커질수록, 협업을 할수록 테스트의 중요성은 커진다.

테스트 작성 역시 꼭 깊이 있게 공부해야 하는 부분이다.

회원 서비스 개발

도메인을 활용해 실제 비즈니스 로직을 작성한다.

src/main/java/프로젝트명/service 패키지를 만들고 MemberService.java 생성.

MemberRepository의 메서드명은 클래스 이름대로 "저장소에 넣고 빼는 느낌"이 들어야 한다. 저장소는 개발자에게 더 가깝기 때문.

MemberService의 메서드명은 클래스 이름대로 "비즈니스에 더 가까운 느낌"이 들어야 한다. 서비스가 더 비즈니스 의존적이기 때문.

package hello.hellospring.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;

import java.util.List;
import java.util.Optional;

public class MemberService {
    private final MemberRepository memberRepository = new MemoryMemberRepository();

    // 회원가입
    public Long join(Member member) {
        validateDuplicateMember(member);// 중복 회원 검증
        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicateMember(Member member) {
        memberRepository.findByName(member.getName())
                .ifPresent(m -> { // 값이 있으면
                    throw new IllegalStateException("이미 존재하는 회원입니다.");
                });
    }

    public List<Member> findMembers() {
        return memberRepository.findAll();
    }

    public Optional<Member> findOne(Long memberId) {
        return memberRepository.findById(memberId);
    }
}

• 회원가입

  • 같은 이름이 있는 회원은 가입할 수 없다

  • // 같은 이름의 회원 가입 차단
    memberRepository.findByName(member.getName())
        .ifPresent(m -> { // 값이 있으면
            throw new IllegalStateException("이미 존재하는 회원입니다.");
        });

    ifPresent() : Optional의 메서드로, 어떤 값이 존재하면 소괄호 내의 로직을 수행한다.

회원 서비스 테스트 케이스 작성

테스트를 작성하려는 클래스 이름에 대고 Ctrl + Shift + T를 누르면 편하게 테스트케이스를 만들 수 있다.

테스트 : given - when - then 법

테스트 메소드 내에 //given, //when, //then을 사용하는 기법이다.

테스트 메소드가 길고 복잡할 때 가독성을 높여준다.

''테스트''라는 과정 자체를 생각해봤을 때,

• 무언가 주어지고 (given)
  • 테스트하는 데이터를 나타낸다.
• 어떤 로직을 실행했을 때 (when)
  • 검증하는 로직을 나타낸다.
• 결과가 이러해야 한다 (then)
  • 검증부를 나타낸다.

의 절차로 검증하는 과정이기 때문.

테스트는 정상flow보다 예외flow가 중요하다

'회원가입'이라는 로직을 생각해 봤을 때, 회원가입이 잘 되는 것도 중요하지만 중복 회원일 때 예외가 발생되는지 확인하는 게 중요하다.

• try - catch 로 예외가 발생하는지 잡아내는 방법.
  • 설정한 예외를 catch문에 작성해 예외가 잘 발생하는지 확인.
  • error.getMessage() : 에러 메시지의 내용을 가져오는 메서드
  • fail() : 테스트케이스가 실패했음을 나타내는 메서드
• assertThrows(error.class, 람다식 ) : 람다식 을 실행했을 때 지정된error 가 터져야 한다. 그렇지 않으면 테스트는 실패한다.

package hello.hellospring.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemoryMemberRepository;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;

class MemberServiceTest {

    MemberService memberService = new MemberService();
    MemoryMemberRepository memberRepository = new MemoryMemberRepository();

    @AfterEach
    public void afterEach() {
        memberRepository.clearStore();
    }

    @Test
    void 회원가입() {
        // given - 테스트할 데이터
        Member member = new Member();
        member.setName("spring");
        // when - 검증하려는 로직 : MemberService의 join().
        Long saveId = memberService.join(member);

        // then - 테스트 결과 (검증부)
        Member findMember = memberService.findOne(saveId).get();
        assertThat(member.getName()).isEqualTo(findMember.getName());
    }

    @Test
    void 중복회원예외() {
        // given
        Member member1 = new Member();
        member1.setName("spring");

        Member member2 = new Member();
        member2.setName("spring");

        // when
        memberService.join(member1);
        /*
        try {
            memberService.join(member2); // 여기서 중복회원을 가려내는 예외가 발생해야.
            fail(); // 여기까지 도달하면 테스트는 실패이다.
        } catch (IllegalStateException e) {
            assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
        }
         */

        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));
        // then
        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
    }

    @Test
    void findMembers() {
    }

    @Test
    void findOne() {
    }
}

DI : 테스트 케이스를 위해 클래스 인스턴스를 새로 만들지 않고..

테스트 케이스만을 위해 클래스 인스턴스를 새로 만들면 기존 클래스와 다른 인스턴스이므로 문제가 발생할 수 있다.

• 해당 클래스의 인스턴스변수가 모두 항상 static일 수는 없다.
• 원본과 동일한 대상을 가지고 테스트해야 하는데, 다른 인스턴스를 만들어 테스트하는 상황이 된다.

✔ 해결 : 클래스의 인스턴스변수 값을 new로 생성하지 않고, 생성자를 통해 값을 외부에서 넣도록 변경한다. 이를 DI (Dependency Injection, 의존성 주입) 라고 한다.

• Before

  MemberService.java

  public class MemberService {
      private final MemberRepository memberRepository = new MemberRepository(); 
  }

  MemberServiceTest.java

  class MemberServiceTest {
      MemberService memberService = new MemberService();
      MemoryMemberRepository memberRepository = new MemoryMemberRepository();
  }

• After

  MemberService.java

  public class MemberService {
      private final MemberRepository memberRepository;
  
      public MemberService(MemberRepository memberRepository) {
          this.memberRepository = memberRepository;
      }
  }

  MemberServiceTest.java

  class MemberServiceTest {
      MemberService memberService;
      MemoryMemberRepository memberRepository;
  
      @BeforeEach
      public void beforeEach() {
          memberRepository = new MemoryMemberRepository();
          memberService = new MemberService(memberRepository);
      }
  }