[스프링 핵심 원리 - 기본편] week03

스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술

https://www.inflearn.com/course/스프링-입문-스프링부트/dashboard

 

섹션 3. 회원 관리 예제 - 백엔드 개발

1. 비즈니스 요구사항 정리
2. 회원 도메인과 리포지토리 만들기
3. 회원 리포지토리 테스트 케이스 작성
4. 회원 서비스 개발
5. 회원 서비스 테스트

 

 

3.1 비즈니스 요구사항 정리

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

 

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

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

 

클래스 의존관계

• 아직 데이터 저장소가 선정되지 않아서(가상의 시나리오), 우선 인터페이스로 구현 클래스를 변경할 수 있도록 설계
• 데이터 저장소는 RDB, NoSQL 등등 다양한 저장소를 고민중인 상황으로 가정
• 개발을 진행하기 위해서 초기 개발 단계에서는 구현체로 가벼운 메모리 기반의 데이터 저장소 사용

 

• MemberService: 회원 서비스.
• MemberRepository: 회원 저장소. 데이터 저장소가 선정되지 않았기 때문에, 인터페이스로 설계
• MemoryMemberRepository: 메모리 구현체(단순한 구현체). 향후에 구체적인 기술 결정 후 바꾸기 위함(인터페이스 사용 이유)

 

 

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

 

hello.hellospring -> New -> Package : domain (패키지 만들기)

domain -> New -> Java Class : Member (Member 클래스 만들기)

// Member.java

package hello.hellospring.domain;

public class Member {

    // 요구사항: id(식별자), name
    private Long id;    // 임의의 값. 고객이 정하는 id X. 시스템이 정함
    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;
    }
}

 

hello.hellospring -> New -> Package : repository (패키지 만들기)

repository -> New -> Java Class : MemberRepository (Interface)

// MemberRepository.java

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: findById(Name)에 없는 경우 Null을 Optional로 감싸서 반환. Java8 기능
    Optional<Member> findByName(String name);
    List<Member> findAll();

}

repository -> New -> Java Class : MemoryMemberRepository (Class)

// 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<>();
    private static long sequence = 0L;

    @Override
    public Member save(Member member) {
        member.setId(++sequence);
        store.put(member.getId(), member);
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) { // store에서 꺼내기
        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))    // 파라미터로 넘어온 name과 같은지 확인: 같은 경우만 필터링
                .findAny(); // 찾으면 반환
            // 돌리다 발견하면 바로 반환. 끝까지 돌렸는데 없으면 Optional로 NULL을 감싸서 반환
    }

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

• 제대로 동작하는지 확인: Test Case 작성

 

 

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

• 개발한 기능을 실행해서 테스트 할 때 자바의 main 메서드를 통해서 실행하거나, 웹 애플리케이션의 컨트롤러를 통해서 해당 기능을 실행한다. 이러한 방법은 준비하고 실행하는데 오래 걸리고, 반복 실행하기 어렵고 여러 테스트를 한번에 실행하기 어렵다는 단점이 있다. 자바는 JUnit이라는 프레임워크로 테스트를 실행해서 이러한 문제를 해결한다.

 

회원 리포지토리 메모리 구현체 테스트

test/java/hello.hellospring -> New -> Package : repository

• src/test/java 하위 폴더에 생성한다
• 주로 같은 패키지명(repository) 사용

테스트 할 class : MemoryMemberRepository test/java/hello.hellospring/repository -> New -> Java Class : MemoryMemberRepositoryTest 생성

MemoryMemberRepositoryTest.java

// MemoryMemberRepositoryTest.java

package hello.hellospring.repository;

import org.junit.jupiter.api.Test;

public class MemoryMemberRepositoryTest {

    MemberRepository repository = new MemoryMemberRepository();

    @Test
    public void save() {

    }
}

기존 실행되던 것 모두 종료 후 save() 실행

실행 확인

 

save() 확인

1. 직접 출력 System.out.println 이용

2. Assertions.assertEquals 이용

3. Assertions.assertThat 이용

* cmd + enter -> import

    @Test
    public void save() {
        // 저장이 잘 되는지 테스트
        Member member = new Member();
        member.setName("Spring");

        repository.save(member);    // 저장할 때 id 세팅됨

        Member result = repository.findById(member.getId()).get();  // optional에서 값을 꺼낼 때 get 이용

        // 가져온 값(result)과 member가 같은지 확인
        // 1. 직접 출력(True/False)해서 확인하는 방법
        System.out.println("result = " + (result == member));

        // 2. Assertions.assertEquals 이용
        Assertions.assertEquals(member, result);
        // 2-1. 다른 값을 넣으면 오류 확인
        // Assertions.assertEquals(member, null);

        // 3. Assertions.assertThat 이용
        assertThat(member).isEqualTo(result);
        // 3-1. 다른 값(Null)을 넣으면 오류 확인
        // assertThat(member).isEqualTo(null);
    }

• 실무에서는 test 단계를 통과하지 못하면 다음 단계로 넘어가지 못하게 막음

 

findByName() 확인

findByName() 테스트 spring2와 비교 - 오류 확인

    @Test
    public void findByName() {
        // 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);


        // spring2와 비교 -> 에러 확인
        //Member result = repository.findByName("spring2").get();
        //assertThat(result).isEqualTo(member1);
    }

 

• class에서 실행하면 class에 있는 테스트를 한번에 확인할 수 있음

 

findAll() 확인

 

    @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);

        // 오류
        // assertThat(result.size()).isEqualTo(3);
    }

 

class 전체 확인

class 실행: 오류

• 실행 순서는 보장되지 않음. 위에서 findAll()이 먼저 실행됨
• findAll()에서 spring1과 spring2이 먼저 만들어짐 -> findByName()에서 오류
• clear: test마다 clear 필요 -> @AfterEach
• @AfterEach: callBack 매서드. 어떤 매서드(save(), findByName() 등)가 끝날 때마다 실행하는 매서드

MemoryMemberRepository.java에 추가

// MemoryMemberRepository.java

    public void clearStore() {
        store.clear();
    }

MemoryMemberRepositoryTest.java에 추가. 실행 (성공)

    // MemoryMemberRepositoryTest.java
    
    //MemberRepository repository = new MemoryMemberRepository();
    MemoryMemberRepository repository = new MemoryMemberRepository();	// 변경

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

• @AfterEach: 한번에 여러 테스트를 실행하면 메모리 DB에 직전 테스트의 결과가 남을 수 있다. 이렇게 되면 다음 이전 테스트 때면 이전 테스트 때문에 다음 테스트가 실패할 가능성이 있다. @AfterEach를 사용하면 각 테스트가 종료될 때 마다 이 기능을 실행한다. 여기서는 메모리 DB에 저장된 데이터를 삭제한다.
• 테스트는 각각 독립적으로 실행되어야 한다. 테스트 순서에 의존관계가 있는 것은 좋은 테스트가 아니다.

 

• 테스트 주도 개발(Test-driven development TDD): test를 먼저 만든 후, test에 맞게 구현 클래스를 만들는 것
• 위의 실습에서는 구현 클래스를 만들고 작동을 확인하기 위해 test를 작성 (TDD 아님)

 

test/java/hello.hellospring -> Run 'Tests in 'hello.hellospring''

• test/java/hello.hellospring -> Run 'Tests in 'hello.hellospring''
  • 테스트가 수백개인 경우
  • 테스트를 자동으로 돌려줌
• 여러 명이서 개발하는 경우, 테스트 코드는 필수

 

 

3.4 회원 서비스 개발

main/java/hello.hellospring -> New -> Package : service service -> New -> Java Class : MemberService

MemberService.java

// MemberService.java

package 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
        /* -> 아래 validateDuplicataeMember로 작성
            Optional<Member> result = memberRepository.findByName(member.getName());
            result.ifPresent(m -> { // .ifPresent: 값이 null이 아니면(어떤 값이 있으면) 동작. Optional로 감싼 경우 사용 가능
                throw new IllegalStateException("이미 존재하는 회원입니다.");
            });
        */
        validateDuplicateMember(member);    // 중복 회원 검증

        memberRepository.save(member);
        return member.getId();
    }


    private void validateDuplicateMember(Member member) {
        // 한번에 작성 가능 (result 사용X. findByName의 결과: Oprional<Member> -> 따로 한번 더 감싸줄 필요X)
        memberRepository.findByName(member.getName())
            .ifPresent(m -> { // .ifPresent: 값이 null이 아니면(어떤 값이 있으면) 동작. Optional로 감싼 경우 사용 가능
                throw new IllegalStateException("이미 존재하는 회원입니다.");
            });
    }

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

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

• service는 주로 비즈니스에 의존적이게 설계 (join, findMembers 등 용어 사용)
• repository 같은 경우 개발에 가깝게 네이밍 (save, findById, findByName 등 용어 사용)

 

단축키

byName -> return 변수 명

• cmd + option + v : Optional<>

• ctrl + t : Refactor와 관련된 정보 확인
• cmd + option + m : 매서드 뽑아내기

 

 

3.5 회원 서비스 테스트

 

단축키

• cmd + shift+ t : test 자동 생성
• test/java에 같은 패키지명으로 자동 생성됨

 

회원 서비스 테스트(MemberServiceTest.java)

• test는 한글로도 많이 적음 (build시 실제 코드에 포함X)
• given, when, then 이용: test는 (given) 어느 것이 주어진 상황에서, (when) 실행되었을 때, (then) 특정한 결과가 나와야 함
  • given: 기반 데이터
  • when: 검증 상황
  • then: 검증부

 

회원가입

    @Test
    void 회원가입() {
        //given
        Member member = new Member();
        member.setName("hello");

        //when
        Long saveId = memberService.join(member);
        
        //then
        Member findMember = memberService.findOne(saveId).get();
        org.assertj.core.api.Assertions.assertThat(member.getName()).isEqualTo(findMember.getName());
    }

 

중복_회원_예외

• 중복 가입 시, 예외처리가 되는 것도 확인해야 함

1. try-catch 사용

2. assertThat 사용

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

        Member member2 = new Member();
        member2.setName("spring");  //member1과 동일한 이름으로 join

        //when
        memberService.join(member1);

        // memberService.join(member2); // 중복이므로 예외처리가 되어야 함

/*            // 01.try-catch 사용
            try {
                memberService.join(member2);
                fail();
            } catch (IllegalStateException e) {
                assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
            }*/

            // 02.asserThrows 사용 - 반환 가능 (cmd + option + v)
            IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));
            assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

        //then
    }

• (단축키) cmd + option + / : 전체 주석 처리

 

@AfterEach

• MemberServiceTest 역시 clear 필요

    MemoryMemberRepository memberRepository = new MemoryMemberRepository();

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

• 회원가입과 중복_회원_예외의 name을 모두 "spring"으로 test해도 오류 발생하지 않음

@AfterEach 작성 전 (오류) 작성 후

• (단축키) ctrl + r : 이전 실행 부분 재실행
• (단축키) cmd + b : 해당 클래스 파일로 이동
• (단축키) cmd + [ ( or ] ) : 이전(다음) 커서로 이동

 

주의(memberRepository)

• 현재 MemberService에서의 memberRepository와 test case에서 만든 memberRepository가 서로 다른 인스턴스
• 같은 memberRepository를 사용할 수 있게 수정

MemberService.java

• (단축키) cmd + n : Generate
• Gernerate -> Constructor: 외부에서 넣어주도록 바꿔줌 (직접 new로 넣는 것X)

MemberService.java 수정 후

MemberServiceTest.java 수정 후

• @BeforEach
  • 테스트 실행할 때마다 각각 생성
  • memberRepository = new MemoryMemberRepository();
    • MemoryMemberRepository를 만들어 memberRepository에 넣음
  • memberService = new MemberService(memberRepository);
    • 위의 memberRepository를 MemberService.java에서 public MemberService의 memberRepository(input)로 넣어 생성 -> memberService에 넣음
  • 각 테스트 실행 전에 호출된다. 테스트가 서로 영향이 없도록 항상 새로운 객체를 생성하고, 의존관계도 새로 맺어준다.

 

FIN.