[Spring] 3.회원관리 예제 - 백엔드 개발

[Spring] 3.회원관리 예제 - 백엔드 개발

 

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

- 데이터 : 회원ID, 이름

- 기능 : 회원 등록, 조회

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

 

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

- 서비스 : 비즈니스 도메인을 가지고 핵심 비즈니스 로직 구현 (회원 중복가입 안되는 로직 등) 

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

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

 

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

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

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

 

클래스 의존관계

1) MemberService : 회원 비즈니스 로직에 회원 서비스

2) MemberRepository : 회원 저장하는 것은 인터페이스로 설계

3) MemoryMemberRespository : 구현체를 메모리 구현체로 만듦 (메모리로 단순히 저장)

 

구체적 기술(DB)이 선정이 되면 인터페이스가 필요

 

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

- java - hello.hellosp - domain package 만듦 - Member 클래스 생성

package hello.hellosp.domain;

public class Member {
    private Long id;   // system 등록할 때 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.hellosp - repository package 만듦 - MemberRepository 인터페이스 생성

package hello.hellosp.repository;

import first.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);   // find by null 반환할때 optional로 감싸서 반환하는 것이 optional의 기능

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

- Optional : 없으면 null로 반환되는데 반환될 때 optional로 감싸서 반환되는 것

 

 - java - hello.hellosp - repository package - M  emoryMemberRepository 클래스 생성

public class MemoryMemberRepository implements MemberRepository{

    // 저장할 곳
    private static Map<Long, Member> store = new HashMap<>(); // 실무에서는 동시성 문제로 concurrent hash 써야함
    private static long sequence = 0L; // 시퀀스는 key 값 생성해주는 것, 실무에서는 long보다는 atomic long

    @Override
    public Member save(Member member) {
        member.setId(++sequence);            // store 넣기 전에 member 아이디 값 세팅
        store.put(member.getId(), member);
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        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))  //같은지 확인
                .findAny(); // 하나라도 찾으면 반환, 끝까지 없으면 optional null
    }

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

 

 

 

3. 회원 리포지터리 테스트 케이스 작성

- 테스트 할 때 자바의 main 메서드를 통해서 실행하거나, 웹 어플리케이션의 컨트롤러를 통해 해당 기능을 실행

    -> 이런 방법은 번거롭다는 단점이 있다

- 자바의 JUnit 프레임워크로 테스트 실행

 

`src/test/java` 하위폴더에 테스트할 패키지와 클래스 생성 - hello.hellosp - repository package - MemoryMemberRepositorytest class

package hello.hellosp.repository;

import hello.hellosp.domain.Member;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

import java.util.List;

class MemoryMemberRepositoryTest {
  MemoryMemberRepository repository = new MemoryMemberRepository();

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

  @Test
  public void save() {   // test로 메서드 실행됨
    Member member = new Member();  // 메인 메서드 세팅해주는거랑 비슷
    member.setName("JoonieKim");

    repository.save(member);  // 저장할때 아이디 세팅됨

    Member result = repository.findById(member.getId()).get();  // 옵셔널에서 값 꺼냄, get으로 꺼내는게 좋은건 아님
    // Assertions.assertEquals(member, result); // 저장한 멤버와 결과값이 같은지 비교 -> 녹색불이 뜸(성공)
    // 요즘엔 아래껄 더 많이 씀 (assert J)
    Assertions.assertThat(member).isEqualTo(result); // 멤버가 result랑 똑같은지 비교해주는 것
    // Assertions을 static import로 해서 (옵션 + 엔터) assertThat 사용가능
  }

  @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("spring1").get();
    Assertions.assertThat(result).isEqualTo(member2); 
  }

  @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();
    Assertions.assertThat(result.size()).isEqualTo(2);
  }
}

 

- 따로 돌리거나 테스트 전체 돌리는 것 모두 가능

 

[한번에 돌렸을 때 오류]

WHY?

- 무작위로 실행되기 때문에 이전에 저장된 객체 (findall 테스트 때 저장된 객체)가 findbyname에 불려옴

- 그렇다면 하나의 @Test 하나가 끝나면 테이터 클리어 해줘야함

 

MemoryMemberRepository 마지막 부분에 추가

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

 

테스트 주도 개발 (TDD) : 테스트 먼저 설계하고 구현하는 방법

 

코드가 길어질수록 테스트 코드 없이 개발 불가능! 

테스트 공부 깊이있게 하는 것이 중요!

 

4. 회원 서비스 개발

- java - first package - service package 생성 - MemberService 클래스 생성

package first.hellospring.service;

import first.hellospring.domain.Member;
import first.hellospring.repository.MemberRepository;
import first.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) {
        //같은 이름이 있는 중복 회원 안됨
        validateDuplicateMemeber(member); // 중복회원검증
        /* 로직이 나오는 경우는 메서드로 뽑는 것이 좋음 */
        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicateMemeber(Member member) {
        memberRepository.findByName(member.getName())
                .ifPresent(member1 -> { // 멤버 값이 있으면 로직 동작 (Optional이 있기 때문에 가능) 과거 : if null
                    // get 권장하진 않음, orElseGet도 있음 (있으면 꺼내)
                    throw new IllegalStateException("이미 존재하는 회원입니다.");
                 });

        /* 좀더 쉬운 코드
        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);
    }
}

 

 

 

 

5. 회원 서비스 테스트 (JUnit)

- 쉽게 생성하는 법

-> MemberService 클래스에 ctrl + shift + t = test 생성

- test는 내부에서 보는 것이기 때문에 한글로도 가능 (빌드할 때 포함되지 않음)

[given - when - then 문법]

package first.hellospring.service;

import first.hellospring.domain.Member;
import first.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.junit.jupiter.api.Assertions.*;

class MemberServiceTest {

    MemberService memberService;
    MemoryMemberRepository memberRepository;


    // 테스트 실행하기 전에 테스트 마다 메모리멤버 repo 만들고 그거를 멤버 repo에 넣고
    // 멤버 repo를 memberservice에 넣어주면 같은 메모리 멤버 repo 사용
    // = DI (dependency injection) 의존성 주입
    @BeforeEach
    public void beforeEach() {
        memberRepository = new MemoryMemberRepository();
        memberService = new MemberService(memberRepository);
    }

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

    @Test
    void signUp() {
        // given - when - then 문법
        // given
        Member member = new Member();
        member.setName("hello");

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

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


    /** 중복 회원 예외 검증이 더 중요 **/
    @Test
    public void duplicatedCheck() {
        //given
        Member member1 = new Member();
        member1.setName("spring");

        Member member2 = new Member();
        member2.setName("spring");
        //when
//        try {
//            memberService.join(member2);
//            // 이게 멀쩡히 넘어가면 fail 인것임
//            fail();
//        } catch (IllegalStateException e) {
//            // exception 터져서 정상적으로 실행한 것
//            Assertions.assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
//        }
        // 좀 더 좋은 문법
        memberService.join(member1);
        assertThrows(IllegalStateException.class, () -> memberService.join(member2));
        // 뒤에 있는 member~ 로직 실행할건데 앞에 예외가 터져야한다.

        // 메세지 검증 -> cmd option v -> e값에 저장하고 확인
//        memberService.join(member1);
//        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));
//        Assertions.assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
    }

    @Test
    void findMembers() {
    }

    @Test
    void findOne() {
    }
}

 

의존성 주입

MemberService 클래스

//    private final MemberRepository memberRepository= new MemoryMemberRepository();
    // 멤버 서비스의 new MemoryMemberRepository와 Testcase의 그것이 다른 인스턴스임. (static이기 때문에 문제가 안되지만 아니라면 문제가 생길 수 있음)
    // 그리고 같은 repository로 테스트하려고 하는건데 지금 다른 레파지토리로 테스트 되고 있는 것

    // 의존성 주입
    private final MemberRepository memberRepository;
    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

 

MemberServiceTest 클래스

    // 테스트 실행하기 전에 테스트 마다 메모리멤버 repo 만들고 그거를 멤버 repo에 넣고
    // 멤버 repo를 memberservice에 넣어주면 같은 메모리 멤버 repo 사용
    // = DI (dependency injection) 의존성 주입
    @BeforeEach
    public void beforeEach() {
        memberRepository = new MemoryMemberRepository();
        memberService = new MemberService(memberRepository);
    }

 

* option + enter = 자동 import

* cmd + shift + enter = 바로 내려가기

* shift + fn f6 = rename refactoring 

* cmd + option + V

memberRepository.findByName(member.getName()); // 이거 하고 cmd + option + v하면 return 값 저장
Optional<Member> result = memberRepository.findByName(member.getName());

* ctrl + T : refactoring 관련 단축키 -> method extract

* ctrl + shift + T : 클래스에 대고 하면 해당 클래스에 대한 test 생성

* ctrl + R : 이전 Run 다시 실행