[Spring Boot 스터디] 한준교 #2 주차 - 섹션3

🏃 비즈니스 요구사항 정리

강의 목표가 실제 비즈니스가 아니라 스프링의 전반적인 흐름을 이해하는 것이기 때문에!

 

→ 회원ID 와 이름 만 데이터로 사용한다!

 

→ 기능은 회원 등록과 조회!!

 

→ 가상의 시나리오로 아직 데이터 저장소(DB) 가 선정되지 않음!! (기능을 파악하고 DB를 선정해보자..)

 

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

→ 컨트롤러 : 웹 MVC의 컨트롤러 역할

 

→ 서비스 : 핵심 비즈니스 로직 구현

ex. 중복 가입이 안되는 로직 등등 비즈니스 도메인 객체를 가지고 핵심 비즈니스 로직을 구현하는 계층이다.

 

→ 리포지토리 : 데이터베이스에 접근, 도메인 객체를 DB에 저장하고 관리

 

→ 도메인 : 비즈니스 도메인 객체

ex. 회원, 주문, 쿠폰 등등 주로 데이터베이스에 저장하고 관리됨

 

클래스 의존관계는

 

아직 데이터 저장소가 선정되지 않았다는 시나리오이기 때문에 우선은 Memory 구현체를 사용한다.

 

(일단 개발은 해야 하므로 단순하게 Memory 에 넣었다 뺐다 하는 그런 기본적인 구현체를 사용 → 나중에 RDB, NoSQL 등등 다양한 저장소로 바꿀 필요성이 있으므로 interface 로 구현 클래스를 변경할 수 있도록 설계함!)

 

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

우선 회원 도메인을 만들어주기 위해 domain package 를 만들어주고 그 안에 Member.java 를 만들어준다!

package hello.hellospring.domain;

public class Member {
    private Long id; // 고객이 정하는 id 가 아니라 구분을 위해 시스템이 정하는 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;
    }
}

alt + insert 로 getter setter 를 만들어주시고~~

 

이렇게 만들었으면!!! 리포지토리 사용을 위해 repository package 를 만들어준 후에

 

MemberRepository 라는 interface 를 생성! (interface 임!!!)

 

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 은 find~ 를 사용해서 가져왔을 때 NULL 인 경우 NULL 을 그대로 반환하는 것이 아닌 Optional 로 감싸서 반환하는 역할임!
    Optional<Member> findByName(String name);

    List<Member> findAll();
}

이어서 MemoryMemberRepository.java 파일을 생성해준다!

package hello.hellospring.repository;

import hello.hellospring.domain.Member;

import java.util.*;

public class MemoryMemberRepository implements MemberRepository {

    private static Map<Long, Member> store = new HashMap<>(); // key 가 회원의 id 이므로 Long 으로 해줌!
    private static long sequence = 0L; // sequence 는 0, 1, 2 처럼 키값을 생성해주는 애임

    @Override
    public Member save(Member member) {
        member.setId(++sequence); //store 에 put 하기전에 sequence 를 하나 올려줌
        store.put(member.getId(), member);
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        return Optional.ofNullable(store.get(id)); // NULL 을 Optional 로 감싸서 반환해줌
    }

    @Override
    public Optional<Member> findByName(String name) {
        return store.values().stream()
                .filter(member -> member.getName().equals(name))
                .findAny(); // 결과가 Optional 로 반환됨

        // loop 를 다 돌면서 Map 에서 하나라도 찾아지면 바로 반환 -> 만약 없다면 Optional 에 NULL이 포함이 되서 반환됨
    }

    @Override
    public List<Member> findAll() {
        return new ArrayList<>(store.values());
    }
}

alt + enter 로 implementes methods 를 해준다.

 

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

그럼 이제 작성한 코드가 제대로 작동하는지 검사해보겠습니다~

 

test 폴더 아래에 repository package 를 만들어 준 다음에 MemoryMemberRepositoryTest.java 파일을 만들어줍니다!!

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.*;

class MemoryMemberRepositoryTest { //다른데서 가져다가 쓸게 아니므로 public 으로 할 필요는 없음!
    MemoryMemberRepository repository = new MemoryMemberRepository();

    @Test // Test 할 로직!!
    public void save() {
        Member member = new Member();
        member.setName("spring");

        repository.save(member);

        Member result = repository.findById(member.getId()).get();
        System.out.println("result = " + (result == member));
        assertThat(member).isEqualTo(result);

        // System.out 을 사용해서 직접 출력 내용을 확인할 수 있지만
        // assert 를 사용하면 출력하지 않고도 오류를 확인할 수 있음!!
    }

    @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();
        member1.setName("spring2");
        repository.save(member2);

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

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

}

이제 Test 를 실행해보면 ~~ 완전 오류가 발생하는 걸 확인할 수 있다.

 

왜냐면 Test 는 작성한 순서대로가 아니라 임의로 선택되어서 진행되기 때문에

 

서로의 순서(의존관계 )에 상관없이 설계되어야 함!

→ 하나의 테스트가 끝날 때 마다 공용 데이터(저장소) 를 지워줘야 문제가 없음!!

 

그러기 위해서 ~

 

MemoryMemberRepository 에 다음의 내용을 추가해주고!!

...

public void clearStore() {
        store.clear(); // store 을 싹 비워줌!!

MemoryMemberRepositoryTest.java 파일에 다음 내용을 추가해준다!!

    @AfterEach // Test 의 메서드가 끝낼 때마다 어떤 동작을 하는 콜백 메서드이다!!
    public void afterEach() {
        repository.clearStore(); // Test 가 수행되고 끝낼 때 마다 repository 를 싹 지움
    }

대성공..!!

 

💡 TDD (테스트 주도 개발) : 테스트를 먼저 만들어서 틀을 잡는 개발 방식!

 

🏃 회원 서비스 개발

회원가입 서비스를 개발해볼건데!

같은 이름의 회원은 등록할 수 없는 로직으로 작성해보자!!!

 

main 폴더 안에 service 라는 package를 만들어주고!

MemberService.java 파일을 생성한다!

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) {
        // 같은 이름이 있는 중복 회원 X

        validateDuplicateMember(member); //중복 회원 검증
        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicateMember(Member member) {
        memberRepository.findByName(member.getName()) // Optional<Member> 로 반환됨
            .ifPresent(m -> { //Optional 로 반환되므로  ifPresent 를 사용할 수 있다. <-> 기존이었으면 if == null 을 사용
                throw  new IllegalStateException("이미 존재하는 회원입니다.");
            });
    }

    // 전체 회원 조회
    public List<Member> findMembers() {
        return memberRepository.findAll();
    }

    // id로 회원 조회
    public Optional<Member> findOne(Long memberId) {
        return memberRepository.findById(memberId);
    }
}

중복 회원 검증 로직은

ctrl + alt + m 을 사용하여 메서드로 만들어준다!!

 

전체 회원 조회와 id 회원 조회는 이미 만들어 놓은 메서드를 사용!!

 

그럼 끝.

🏃 회원 서비스 테스트

그럼 이제 잘 동작하는지 테스트를 해봐야겠죠~?

 

ctrl + shift + t 단축키를 사용해서 빠르게 Test 를 위한 준비작업을 하고!!

 

 

이렇게 기본 틀이 만들어집니다!!

 

테스트를 처음 접할 때에는

 

given(상황이 주어지고),

when(이런 조건에서),

then(이러한 결과가 나와야 함)

 

주석을 기반으로 하면 굉장히 도움이 됨!

 

💡 test 는 실제 코드에 포함되지 않으므로 과감하게 한글을 사용하여 직관적으로 실행하여도 좋음!!

 

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.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.*;

class MemberServiceTest {

    MemberService memberService;
    MemoryMemberRepository memberRepository;

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

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

    @Test
    void 회원가입() {
        //given (상황이 주어지면)
        Member member = new Member();
        member.setName("spring");

        //when (이럴 때에)
        Long saveId = memberService.join(member);

        //then (이게 나와야 함)
        Member findeMember = memberService.findOne(saveId).get();
        Assertions.assertThat(member.getName()).isEqualTo(findeMember.getName());
    }

    @Test
    public void 중복_회원_예외() {
        // member 2 명의 이름이 똑같다면 예외가 발생해야함!! -> 이걸 확인!

        //given
        Member member1 = new Member();
        member1.setName("spring");

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

        //when
        memberService.join(member1);
        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));
        // assertThrow 메서드를 사용하여 특정 메서드 호출 시 발생할 것으로 예상되는 예외를 검증
        Assertions.assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

        /*
        memberService.join(member1);
        try {
            memberService.join(member2);
            fail(); // 예외가 발생하지 않으면 fail 임!!
        } catch (IllegalStateException e) {
            Assertions.assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
        }
        */

        //then
    }
}

최종 test 코드는 이렇게 나오게 된다!

 

주석 처리된 try catch 문으로 예외가 발생하는지를 확인할 수도 있지만

assertThat 을 사용하면 훨씬 간편하다!

 

또 코드를 살펴보면 @BeforeEach 는 뭐지..? 라고 할 수 있는데

 

MemberService 와 MemberServiceTest 의 MemoryMemberRepository 가 서로 다르므로

같은 인스턴스를 쓰게 설정해주는게 좋음!

 

따라서 @AfterEach 와 반대로 Test 가 진행되기 전에 Repository 를 설정해주는 부분이라고 생각하면 됨!

 

기존의 MemberService.java 에서 new 를 이용하여 memberRepository 를 사용하던 부분도 다음과 같이 바꿔준다!

...

private final MemberRepository memberRepository;
    
    // 외부에서 Repository를 넣어줌
    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

...

→ 이제 Test와 기존 파일이 서로 같은 MemoryRepository 를 사용할 수 있게 됨!