스프링 부트와 AWS로 혼자 구현하는 웹 서비스

Section 3

1) 비즈니스 요구사항 정리

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

컨트롤러 -> 서비스 -> 리포지토리 -> DB

-> 도메인

 

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

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

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

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

<클래스 의존 관계>

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

MemberService -> MemberRepository(Interface) <- Memory MemberRepository

 

 

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

package hello.hellospring.domain;

public class Member {
	private Lond id;
    private String name;
    
    public Long getId() {
    	return id;
    }
    
    public 	void setId(Long id) {
    	this.id = id;
    }
    
    public String getName() {
    	return name;
    }
}

package hello.hellospring.repository;

import hello.hellospring.domain.Member;

import java.util.Optional;

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

package hello.hellospring.repository;

public class MemoryMemberRepository implements MemberRepository {

	private static Map<Long, Member> store = new HashMap();
    private state long sequence = 0L;
    
	@Override
    Member save(Member member) {
    	member.setId(++sequence);
        store.put(member.getId(), member);
        return member;
    }
    
    @Override
    public Optional<Member> findById(Long id) {
    	return Optional.ofNullable(store.get(id));
    }
    
    @Override
    public Optional<Member> findByName(String name) {
    	return store.values().stream()
        	.filter(member -> member.getName().equals(name))
            .findAny();
    }
    
    @Override
    List<Member> findAll() {
    	return new ArrayList<>(store.values());
    }
    
    public void clearStore() {
    	store.clear();
    }
}

 

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

개발한 기능을 실행에서 테스트할 때 자바의 main 메서드를 통해서 실행하거나, 웹 애플리케이션의 컨트롤러를 통해서 해당 기능을 실행한다.

이러한 방법은 준비하고 실행하는데 오래 걸리고, 반복 실행하기 어렵고, 여러 테스트를 한번에 실행하기 어렵다는 단점이 있다. 자바는 JUnit 이라는 프레임워크로 테스트를 실행해서 이러한 문제를 해결한다.

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

package hello.hellospring.repository;

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

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

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

class MemoryMemberRepositoryTest {
	MemoryMemberRepository repository = new MemoryMemberRepository();
    
    @After Each
    public void afterEach() {
    	repository.clearStore();
    }
    
    @Test
    public void save() {
    	//given
        Member member = new Member();
        member.setName("spring");
        
        repository.save(member);
        
        Member result = repository.findById(member.getId()).get();
        //System.out.printIn("result = " + (result == member));
		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("spirng2").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);
    } 
}

4) 회원 서비스 개발

package hello.hellospring.service;

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

public class MemberService {
	private final MemberRepository memberRepository = new MemoryMemberRepository();
    
    /**
    	회원가입
   	*/
    public Long join(Member member) {
    	//같은 이름이 있는 중복 회원 X
        validateDuplicateMembber(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(member);
    }    
}

5) 회원 서비스 테스트

class MemberServiceTest {
	
    MemberService memberService = new MemberService();
    MemoryMemeberRepository memberRepository = new MemoryMemberRepository();
    
    @AfterEach
    public void afterEach() {
    	repository.clearStore();
    }
    
    @Test
    void join() {
    	//given
        Member member = new Member();
        member.setName("spring");
        
        //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("이미 존재하는 회원입니다.");
        }
        
        */
        
        //then
        
    }
    
    @Test
    void findMembers() {
    
    }
    
    @Test
    void findOne() {
    
    }