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

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

인프런 김영한님 강의 필기
개발 환경 - Java 11, IntelliJ

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

비즈니스 요구사항 정리

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

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

회원 서비스 개발

회원 서비스 테스트

비즈니스 요구사항 정리

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

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

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

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

도메인

비즈니스 객체를 정의하는 곳 (회원ID, 제품명, 주문번호, 쿠폰번호 등등)
src/main/java/hello.hellospring.domain 패키지 생성
domain/Member.java 멤버 생성
멤버 - id, name 정의
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;
    }
}

리포지토리

리포지토리는 도메인 객체를 DB에 저장/관리하는 곳
src/main/java/hello.hellospring.repository 패키지 생성
repository/MemberRepository.java 인터페이스 생성
repository/MemoryMemberRepository.java 메모리 구현체 생성
인터페이스 - save, findById, findByName, findAll 정의
메모리 구현체 - save, findById, findByName, findAll 구현
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);   // 이름으로 회원 찾는 기능
    List<Member> findAll();                     // 모든 회원 찾는 기능
}

MemoryMemberRepository.java (메모리 구현체)

package hello.hellospring.repository;

import hello.hellospring.domain.Member;

import java.util.*;

public class MemoryMemberRepository implements MemberRepository {  // MemberRepository 인터페이스 구현

    private static Map<Long, Member> store = new HashMap<>();      // save 할 저장소 해쉬맵 정의
    private static long sequence = 0L;                             // ID로 들어갈 시퀀스 정의

    @Override
    public Member save(Member member) {
        member.setId(++sequence);             // setId 할때마다 sequence 값 1 추가해서 입력
        store.put(member.getId(), member);    // store 에다가 멤버 ID 저장
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        return Optional.ofNullable(store.get(id));  // store 에서 id로 꺼내올 때 null 처리해서 반환
    }

    @Override
    public Optional<Member> findByName(String name) {
        return store.values().stream()                            // 루프를 돌리면서
                .filter(member -> member.getName().equals(name))  // param 으로 넘어온 name 과 같은지 확인하는 필터링
                .findAny();                                       // 찾으면 반환
    }

    @Override
    public List<Member> findAll() {
        return new ArrayList<>(store.values());          // store 에 있는 모든 멤버들 반환
    }
}

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

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

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

src/test/java/hello.hellospring.repository 패키지 생성
repository/MemoryMemberRepositoryTest.java 테스트 생성
테스트 - save, findByName, findAll 정의/구현
MemoryMemberRepositoryTest.java (테스트)

package hello.hellospring.repository;

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

import java.util.List;

import static org.assertj.core.api.Assertions.*;   
// junit 도 있는데 assertj 사용으로 assertThat 문장 자연스럽게 만듬

class MemoryMemberRepositoryTest {

    MemoryMemberRepository repository = new MemoryMemberRepository();

    @AfterEach
    public void afterEach() {
        repository.clearStore();    // Test 들에서 member 저장에 연관성이 생기지 않게 store 을 비워줌
    }

    @Test
    public void save() {
        Member member = new Member();     // member 생성
        member.setName("spring");
        repository.save(member);          // save 로 저장

        Member result = repository.findById(member.getId()).get();  // findById 로 result 에 가져옴
        assertThat(result).isEqualTo(member);        // result 가 member 와 같다고 주장하다 
                                                     //-> 같으면 테스트 성공 아니면 실패
    }

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

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

        Member result = repository.findByName("spring1").get();  // findByName 으로 result 에 가져옴
        assertThat(result).isEqualTo(member1);      // result 가 member1 과 같다
    }

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

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

        List<Member> result = repository.findAll();    // findAll 로 result 에 가져옴

        assertThat(result.size()).isEqualTo(2);     // result 길이가 2이다
    }
}

// MemoryMemberRepository.java 에 메서드 추가
public void clearStore() {
        store.clear();
    }

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

회원 서비스 개발

서비스는 핵심 비즈니스 로직이 들어있는 곳
서비스는 기획자st 네이밍, 리포지토리는 개발자st 네이밍
src/main/java/hello.hellospring.service 패키지 생성
service/MemberService.java 서비스 생성
서비스 - join, findMembers, findOne 정의/구현
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);
    }
}

회원 서비스 테스트

src/test/java/hello.hellospring.service 패키지 생성
service/MemberServiceTest.java 테스트 생성
테스트 - join, findMembers, findOne 정의/구현
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.BeforeEach;
import org.junit.jupiter.api.Test;

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

class MemberServiceTest {

    MemberService memberService;
    MemoryMemberRepository memberRepository;    // Dependency Injection

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

    @AfterEach
    public void afterEach() {
        memberRepository.clearStore();   // Test 끼리 영향 없게 메모리 clear
    }

    @Test
    void 회원가입() {
        // 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("이미 존재하는 회원입니다.");
        }
*/

    }

    @Test
    void findMembers() {
    }

    @Test
    void findOne() {
    }
}

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

public class MemberService {

    private final MemberRepository memberRepository = new MemoryMemberRepository();

}

회원 리포지토리의 코드가 회원 서비스 코드를 DI 가능하게 변경한다.

public class MemberService {

	private final MemberRepository memberRepository;

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

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

Author And Source

이 문제에 관하여(스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술 (3)), 우리는 이곳에서 더 많은 자료를 발견하고 링크를 클릭하여 보았다 https://velog.io/@sunshine0070/스프링-입문-코드로-배우는-스프링-부트-웹-MVC-DB-접근-기술-3

우수한 개발자 콘텐츠 발견에 전념 (Collection and Share based on the CC Protocol.)