[Spring Intro] Section 03. 회원 관리 예제_백엔드 개발, 비즈니스 요구사항 정리, 회원 도메인과 리포지토리 만들기, 회원 리포지토리 테스트, 회원 서비스 개발, 회원 서비스 테스트

비즈니스 요구사항 정리

데이터 : 회원 ID, 이름
기능 : 회원 등록, 조회
아직 데이터 저장소가 선정되지 않았다고 가정

이 강의의 목표는 복잡한 비즈니스를 하는 것이 아니라 단순한 예제를 가지고

스프링 생태계 전반적으로 어떤 식으로 개발이 이루어지고 동작하는지 알아보는 것이다.

따라서 단순한 비즈니스로 설정하여 진행해보기로 한다.

---

 

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

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

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

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

도메인 : 비즈니스 도메인 객체, 예) 회원, 주문, 쿠폰 등등 주로 데이터 베이스에 저장하고 관리됨

 

 

# 클래스 의존관계

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

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

아직 데이터 저장소가 선정되지 않았기에, 인터페이스를 사용하여 이후 DB를 결정하면 구현 클래스를 변경할 수 있도록 설계한다.

 

---

최종 계층 구조 미리보기

 

---

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

 

# 회원 객체

java/hello/hellospring/domain/Member.java

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;
    }
}

 

# 회원 리포지토리 인터페이스

java/hello/hellospring/repository/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); // ID로 회원 찾기

    Optional<Member> findByName(String name); // Name으로 회원 찾기

    List<Member> findAll(); // 지금까지 저장된 모든 회원 리스트 반환
}

 

# 회원 리포지토리 메모리 구현체

java/hello/hellospring/repository/MemoryMemberRepositoryTest.java

package hello.hellospring.repository;

import hello.hellospring.domain.Member;

import java.util.*;

/**
* 동시성 문제가 고려되어 있지 않음, 실무에서는 ConcurrentHashMap, AtomicLong 사용 고려
*/


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); // member save 할 때 sequence 값 하나씩 올려서 저장
        store.put(member.getId(), member); // member Id와 member를 한 쌍으로 Map에 저장
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        return Optional.ofNullable(store.get(id)); // ofNullable을 통해 반환값이 null이어도 클라이언트에서 처리 가능
    }

    @Override
    public Optional<Member> findByName(String name) {
        // 검색 결과는 Optional로 반환되며, 없는 이름이라면 Optional에 null이 포함되어 반환
        return store.values().stream()
                .filter(member -> member.getName().equals(name)) // member의 이름이 parameter의 name과 일치하는지 확인
                .findAny(); // String에서 가장 먼저 탐색되는 요소 리턴
    }

    @Override
    public List<Member> findAll() {
        return new ArrayList<>(store.values()); // store의 member들을 전부 반환
    }
    
    public void clearStore() {
        store.clear();
    }
}

 

---

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

 

보통 우리가 개발한 기능을 실행해서 테스트 할 때,

1. 자바의 Main 메서드를 통해 실행하거나

2. 웹 어플리케이션의 컨트롤러를 통해서 해당 기능을 실행한다.

 

하지만 이러한 방법은 준비와 실행이 오래 걸리고, 반복 실행과 여러 테스트의 동시 실행이 어렵다는 단점이 있다.

Java는 JUnit이라는 프레임워크로 테스트 코드를 만들고 그 코드 자체를 실행해서 위와 같은 문제를 해결한다.

 

 

# 회원 리포지토리 메모리 구현체 테스트
java/hello/hellospring/repository/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.assertThat;

class MemoryMemberRepositoryTest {
    MemoryMemberRepository repository = new MemoryMemberRepository();

    // 메서드가 끝날 때마다 동작하는 콜백 메서드
    @AfterEach
    public void afterEach() {
    	// clear repository
        repository.clearStore();
    }

    @Test
    public void save() {
        Member member = new Member(); // 새로운 member 생성
        member.setName("spring"); // member 이름 spring으로 설정
        repository.save(member); // repository에 저장

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

        // shift + F6으로 변수 편리하게 변경 가능
        Member member2 = new Member();
        member2.setName("spring2");
        repository.save(member2);

        // result에 repository에서 spring1이라는 이름을 가진 객체를 찾아 저장 (hello.hellospring.domain.Member@77f1baf5이 저장됨)
        Member result = repository.findByName("spring1").get();
        // result와 member1이 같은지 확인
        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);
    }
}

 

# save() 테스트 결과

> 정상적으로 실행된다.

 

 

# findByName() 테스트 결과

 

1) member가 result와 같은 경우

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

> 정상적으로 실행된다.

 

2) member가 result가 다른 경우

Member result = repository.findByName("spring2").get();
assertThat(result).isEqualTo(member1);

> result에는 spring2 이름을 통해 찾은 member2가 저장되어 있는데 member1과 같은지 비교하기 때문에 오류가 발생한다.

 

 

# findAll() 테스트 결과

 

1) isEqualTo가 2인 경우

> 정상적으로 실행된다.

 

2) isEqualTo가 3인 경우

> isEqualTo를 2에서 3으로 바꾸면 위와 같은 오류가 발생한다.

 

 

# Test 시 주의사항

class 단위에서의 테스트 진행 시 findByName()에서 이전과 다른 오류가 발생하는 것을 확인할 수 있다.

이는 findAll()에서 객체를 생성한 뒤 repository에 저장하는 코드가 findByName()에서 한 번 더 등장해서

이전에 저장했던 spring1에 대한 정보가 불러와졌기에 오류가 발생하는 것이다.

 

// 메서드가 끝날 때마다 동작하는 콜백 메서드
@AfterEach
public void afterEach() {
    repository.clearStore();
}

@AfterEach : 한번에 여러 테스트를 실행하면 메모리 DB에 직전 테스트의 결과가 남을 수 있다. 이렇게 되면 다음 이전 테스트 때문에 다음 테스트가 실패할 가능성이 있다. @AfterEach를 사용하면 각 테스트가 종료될 때 마다 이 기능을 실행한다. 여기서는 메모리 DB에 저장된 데이터를 삭제한다.

또한, 테스트는 각각 독립적으로 실행되어야 한다. 테스트 순서에 의존관계가 있는 것은 좋은 테스트가 아니다.

 

> AfterEach 사용 : class 단위에서 테스트 케이스 실행 시 정상적으로 동작하는 것을 확인할 수 있다.

 

 

# 개발과 테스트 순서

 

현재는 MemoryMemberRepository 개발 완료 후 테스트 클래스를 작성했다.

하지만 테스트 클래스를 먼저 작성하고 MemoryRepository를 작성하는 방법이 있는데

이를 테스트 주도 개발(TDD)이라고 한다.

 

---

회원 서비스 개발

 

# 회원 서비스 개발

java/hello/hellospring/service/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){

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

 

---

회원 서비스 테스트

MemberService 클래스에서 Command + Shift + T를 누르면 간편하게 테스트 케이스 생성이 가능하다.

 

# DI(Dependency Injection, 의존관계 주입)

 

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

기존에는 회원 서비스가 메모리 회원 리포지토리를 직접 생성하게 했다.

MemberService와 MemberServiceTest에서 new MemoryMemberRepository()를 각각 선언해주면

서로 다른 Repository(다른 객체)를 사용하게 된다. 이 문제를 해결하기 위해서는 의존관계를 주입해줘야 한다.

 

public class MemberService {

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

-> 회원 리포지토리의 코드가 회원 서비스 코드를 DI 가능하게 변경한다. (Constructor 추가)

 

 

# given, when, then 문법

given - 무언가가 주어졌는데

when - 이걸 실행했을 때

then - 이런 결과가 나와야 함

 

 

# 회원 서비스 테스트

test/java/hello/hellospring/service/MemberServiceTest.java

package hello.hellospring.service;

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

import java.util.Optional;

import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
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("hello");

        //when
        Long saveId = memberService.join(member);

        //then
        Member findMember = memberService.findOne(saveId).get();
        assertThat(member.getName()).isEqualTo(findMember.getName());
    }

    @Test
    public void 중복_회원_예외() {
        //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));
        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
/*
        try {
            memberService.join(member2);
            fail();
        } catch (IllegalStateException e) {
            assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
        }
*/
    }


    @Test
    void findMembers() {
    }

    @Test
    void findOne() {
    }
}

@BeforeEach : 각 테스트 실행 전에 호출된다. 테스트가 서로 영향이 없도록 항상 새로운 객체를 생성하고, 의존관계도 새로 맺어준다.

 

 

 

내용 및 이미지 출처 : 김영한의 스프링 입문