[Spring] 회원 관리 예제 (백엔드 개발)

인프런의 스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술를 정리한 글이다.

🏃🏻‍♀️ 비즈니스 요구사항 정리

- 데이터 : 회원 ID, 이름

- 기능 : 회원 등록, 조회

- 아직 데이터 저장소가 선정되지 않음 (가상의 시나리오)

 

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

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

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

- 서비스 : 핵심 비즈니스 로직 구현 (회원은 중복 가입이 안된다거나..)

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

 

클래스 의존관계

- 아직 데이터 저장소가 선정되지 않아서, 우선 인터페이스로 구현 클래스를 변경할 수 있도록 설계

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

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

 

🏃🏻‍♀️ 회원 도메인과 레포지토리 만들기

1. 도메인 생성 (회원 객체)

hellospring 아래에 domain 패키지를 생성하고, 해당 패키지에 Member 파일 (회원 객체)를 생성한다.

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

 

2. 레포지토리 생성 (인터페이스 + 구현체)

hellospring 아래에 repository 패키지를 생성하고, 먼저 MemberRepository 인터페이스를 생성한다.

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<Member> findByName(String name);
    List<Member> findAll();
}

이후 MemoryMemberRepository 파일(구현체)을 생성해 위에서 만든 인터페이스를 implement 한다.

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<>(); // 동시성을 위해, 실무에서는 ConcurrentHashMap을 사용한다.
    private static long sequence = 0L; // 0, 1, 2 인덱스 생성해주는 변수 / 동시성을 위해, 실무에서는 AtomicLong을 사용한다.

    @Override
    public Member save(Member member) {
        member.setId(++sequence); // sequence 값을 하나 올려준다. store에 넣기 전에 id 값 세팅
        store.put(member.getId(), member);

        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        return Optional.ofNullable(store.get(id)); // Optional을 사용하면 store.get(id)가 null이어도 감싸서 반환해준다.
    }

    @Override
    public Optional<Member> findByName(String name) {
        return store.values().stream()
                .filter(member -> member.getName().equals(name)) // member.getName()이 파라미터로 넘어온 name과 같은지 확인
                .findAny(); // 위에서 같은 경우에만 필터링이 되고, 찾은 경우 return한다. findAny()는 결과가 Optional로 반환된다!
    }

    @Override
    public List<Member> findAll() {
        return new ArrayList<>(store.values()); // store는 Map이고, 현재 return 값은 list이므로 이렇게 반환해줘야 한다.
    }
}

 

🏃🏻‍♀️ 회원 레포지토리 테스트 케이스 작성

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

 

test 아래에 위와 같이 폴더링을 한다.

repository 패키지를 생성하고, MemoryMemberRepositoryTest 파일을 생성한다.

아래와 같이 테스트 케이스를 작성하고,

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.junit.jupiter.api.*;

import java.util.List;

import static org.assertj.core.api.Assertions.*; // 여기서 static import를 하면 아래의 Assertions.assertThat~ 에서 Assertions를 생략할 수 있다.

/**
 * 테스트를 먼저 만들고, 그걸 기반으로 구현하는게 TDD이다!
 */
class MemoryMemberRepositoryTest { // public으로 안해도 된다. (딴 데서 쓸 게 아니기 때문에)

    MemoryMemberRepository repository = new MemoryMemberRepository();

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

        repository.save(member);

        Member result = repository.findById(member.getId()).get(); // 저장할 때 id가 세팅된다. 해당 아이디를 가지고 확인 / Optional에서 값을 꺼내올 때는 get()을 사용해서 꺼내온다.
        // 검증
        /**
         * 위에서 생성한 Member와 result가 같은지 확인
         */
//        System.out.println("result = " + (result == member)); // 같으면 true라고 뜬다.

        /**
         * 위처럼 하나하나 출력할 수 없으므로, Assertions이라는 걸 사용해서 확인한다.
         */
        /**
         * JUnit.Jupiter 사용
         * member가 expected(기대하는 값), result가 actual(실제 값)
         */
//        Assertions.assertEquals(member, result);
        /**
         * org.assertj 사용
         */
        assertThat(member).isEqualTo(result); // member가 result와 같은가?
    }
}

 

함수 옆에 run 버튼을 클릭해 테스트 케이스가 정상적으로 작동하는지 확인할 수 있다.

 

완성된 테스트 코드

 

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.junit.jupiter.api.*;

import java.util.List;

import static org.assertj.core.api.Assertions.*; // 여기서 static import를 하면 아래의 Assertions.assertThat~ 에서 Assertions를 생략할 수 있다.

/**
 * 테스트를 먼저 만들고, 그걸 기반으로 구현하는게 TDD이다!
 */
class MemoryMemberRepositoryTest { // public으로 안해도 된다. (딴 데서 쓸 게 아니기 때문에)

    MemoryMemberRepository repository = new MemoryMemberRepository();

    /**
     * 테스트는 서로 의존관계 없이 실행되어야 한다.
     * 그러므로 테스트가 한 번 끝날 때마다 사용된 데이터가 삭제되어야 한다.
     */
    @AfterEach // 메서드가 끝날 때마다 이 메서드가 실행된다!
    public void afterEach() {
        repository.clearStore(); // 테스트가 실행되고 끝날 때마다 저장소를 다 지운다.
    }

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

        // when
        repository.save(member);

        // then
        // 검증
        Member result = repository.findById(member.getId()).get(); // 저장할 때 id가 세팅된다. 해당 아이디를 가지고 확인 / Optional에서 값을 꺼내올 때는 get()을 사용해서 꺼내온다.
        /**
         * 위에서 생성한 Member와 result가 같은지 확인
         */
//        System.out.println("result = " + (result == member)); // 같으면 true라고 뜬다.

        /**
         * 위처럼 하나하나 출력할 수 없으므로, Assertions이라는 걸 사용해서 확인한다.
         */
        /**
         * JUnit.Jupiter 사용
         * member가 expected(기대하는 값), result가 actual(실제 값)
         */
//        Assertions.assertEquals(member, result);
        /**
         * org.assertj 사용
         */
        assertThat(member).isEqualTo(result); // member가 result와 같은가?
    }

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

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

        // when
        Member result = repository.findByName("spring1").get(); // Optional에서 get을 사용해 결과값을 꺼내온다.

        // then
        assertThat(result).isEqualTo(member1);
    }

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

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

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

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

 

테스트 코드를 한번에 실행한 결과이다.

코드의 순서대로 실행되는게 아니라, 무작위로 실행되므로 메모리 DB에 직전 테스트의 결과가 남을 수 있다.

이렇게 되면 이전 테스트 때문에 다음 테스트가 실패할 가능성이 있다.

-> @AfterEach를 사용해 각 테스트가 종료될 때마다 이 기능을 실행한다. 여기서는 메모리 DB에 저장된 데이터를 삭제한다.

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

 

🏃🏻‍♀️ 회원 서비스 개발 (서비스)

service 패키지를 생성하고, MemberService 파일을 생성한다.

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
        /**
         * 방법 1
         */
//        Optional<Member> result = memberRepository.findByName(member.getName()); // command + option + V하면 쉽게 코드 작성 가능
//        // Optional!
//        result.ifPresent(m -> { // ifPresent는 Optional이기 때문에 가능하다! 만약 객체가 존재하면~ 이라는 뜻의 함수
//            throw new IllegalStateException("이미 존재하는 회원입니다.");
//        });
        /**
         * 방법 2
         * 위의 코드를 아래와 같이 예쁘게 줄일 수 있다.
         */
//        memberRepository.findByName(member.getName())
//                .ifPresent(m -> {
//                    throw new IllegalStateException("이미 존재하는 회원입니다.");
//                });

        /**
         * 방법 3
         * 위의 코드를 메서드로 뽑아내는 경우
         * 위 코드를 모두 잡고, control + T를 사용해 Refactor 관련된 것들을 볼 수 있다. -> 9. Extract Method 사용
         */
        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() { // 서비스 클래스는 보통 비즈니스와 비슷한 이름을 사용한다. (Role에 맞도록 네이밍)
        return memberRepository.findAll();
    }

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

 

🏃🏻‍♀️ 회원 서비스 테스트

위의 서비스 파일 (MemberService)에서 command + shift + T 단축키를 사용해 쉽게 테스트 파일을 작성할 수 있다.

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 static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.*;

class MemberServiceTest {

    MemberService memberService;
    MemoryMemberRepository memberRepository;

    // Dependency Injection
    @BeforeEach
    public void beforeEach() {
        memberRepository = new MemoryMemberRepository(); // MemberService와 같은 memberRepository를 사용하기 위해
        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);
        /**
         * 방법 1
         * try - catch 사용
         */
        /*
        try {
            memberService.join(member2);
            fail("예외가 발생해야 합니다.");
        } catch (IllegalStateException e) {
            assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
        }
        */
        /**
         * 방법 2
         * assertThrows 사용
         */
        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));// member2를 join하면 IllegalStateException이 발생해야 한다는 뜻!

        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

        // then

    }

    @Test
    void findMembers() {
    }

    @Test
    void findOne() {
    }
}

MemberService 객체가 기존의 객체와 같은 것을 사용해야 하므로, Dependency Injection을 사용한다.

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

-> Dependency Injection은 다음 강의에서 자세히 다룬다.