[스프링 입문] 3. 회원 관리 예제 - 백엔드 개발

📌 비지니스 요구사항 정리

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

 

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

 

 

 

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

 

2. 클래스 의존관계

 

🔷 회원 비지니스 로직 : MemberService
🔷 회원 리포지토리 : MebmerRepository (아직 저장소가 설계되지 않았기 때문에 interface로 설계)
🔷 구현체 : MemoryMemberRepository (메모리 모드로)

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

 

반응형

 

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

 

1. 회원 객체

🔶 main/java/helo/hellospring/domain/Member

 

✔ 요구사항에 있었던 ID와 name 데이터를 private로 생성

• ID는 고객이 정하는 ID가 아니라 시스템이 데이터를 구분하기 위해서 정하는 임의의 값이다
• name은 고객이 정한 값이다

✔ getter, setter 생성

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

 

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

🔶 main/java/helo/hellospring/domain/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();
}

 

✔ repository의 기능

• save : 회원을 저장소에 저장
• findById : ID로 회원을 찾음
• findByName : 이름으로 회원을 찾음
• findAll : 모든 회원 리스트 반환

Optional
: null을 그냥 반환하지 않고, optional로 감싸서 반환하는 것을 선호

 

 

 

📌 회원 리포지토리 메모리 구현체 생성

🔶 main/.../repository/MemoryMemberRepository

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);
        store.put(member.getId(), member);
        return member;
   }
    @Override
    public Optional<Member> findById(Long id) {
        return Optional.ofNullable(store.get(id));
    }
    @Override
    public List<Member> findAll() {
        return new ArrayList<>(store.values());
    }
    @Override
    public Optional<Member> findByName(String name) {
        return store.values().stream()
                .filter(member -> member.getName().equals(name))
                .findAny();
    }
    public void clearStore() { //다음 내용에 나옴
        store.clear();
    } 
}

 

• Map을 사용해서 key는 id이므로 Long, value값은 Member로 해준다.

private static Map<Long, Member> store = new HashMap<>();

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

 

 

함수

✔ save 함수

@Override
public Member save(Member member) {
    member.setId(++sequence);
    store.put(member.getId(), member);
    return member;
}

 

• member에 id 값을 세팅(sequence)
• store.put(member.getId(), member) => store에 저장(=Map에 저장)
• member 반환

 

 

✔ findById 함수

@Override
public Optional<Member> findById(Long id) {
      return Optional.ofNullable(store.get(id));
}

• store.get(id) => store에서 id를 넣어서 get으로 반환
• 결과가 없을 수도 있기에 Null이 반환될 가능성이 있으면 Optional.ofNullable로 감쌈
  •   client에서 할 수 있는 것들이 있음 (나중에 설명)

 

 

✔ findByName 함수

@Override
public Optional<Member> findByName(String name) {
    return store.values().stream()
    .filter(member -> member.getName().equals(name))
    .findAny();
}

•  lambda 사용
•  stream으로 Map에서 루프를 돌림
  • member.getName()이 parameter에서 넘어온 name과 같은지 판단
  • 같은 경우 fitering됨
•  findAny()로 있을 경우 Optional로 반환

 

 

✔ findAll 함수

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

 

• Map을 List로 변환하기 위해 new ArrayList<> 사용
•  store.values() 반환

 

 

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

 

• 앞에서 생성한 회원 리포지토리가 정상적으로 작동할 지에 대해 검증하는 것
• 개발 기능을 실행해서 테스트 할 때 자바의 main 메서드를 통해서 실행하거나, 웹 애플리케이션의 컨트롤러를 통해서 해당 기능을 실행
• JUnit이라는 프레임워크로 테스트를 실행

 

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

🔶 src/test/java/hello.hellospring/repository/MemoryMemberRepositoryTest

 

✔ save 함수 , findById 함수

@Test
public void save(){
    Member member = new Member();
    member.setName("spring");

    repository.save(member);

    Member result = repository.findById(member.getId()).get();

    Assertions.assertThat(member).isEqualTo(result);
}

 

1. 이름 세팅
2. repository에 member를 저장(save)
3. repository.findById()를 통해 아이디로 멤버를 찾고, 저장이 잘 되었는지 확인
   ➡ findById()는 반환타입이 Optional이므로 .get()으로 바로 가져와도 됨 (좋은 방법은 아님)
4. 검증 (Assertions) : Assertions.assertThat(member).isEqualTo(result)
   ➡ member가 result와 같은지 확인
   ➡  Assertions는 'org.assertj.core.api.Assertions' 사용

 

 

✔ findByName 함수

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

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

    Optional<Member> result = repository.findByName("spring1").get();

    Assertions.assertThat(result).isEqualTo(member1);

    //result(spring1)과 member1은 일치
    //"spring2"를 검색했다면 오류 -> member2이기 때문
}

 

 

✔ findAll 함수

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

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

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

    Assertions.assertThat(result.size()).isEqualTo(2); //3으로 바꾸면 error
}

 

 

💡 전체 코드를 실행하면 에러가 발생하는 이유

 

• 테스트 케이스는 순서와 상관 없이 메서드 별로 따로 동작하게 설계되어야 함
• 순서가 뒤죽박죽으로 실행되므로 개별적으로 실행했을 때는 잘 작동되다가 전체 코드를 실행했을 때 오류가 발생한다.
• 테스트는 각각 독립적으로 실행되어야 함.(의존관계가 있다면 좋지 않음)

❗ 하나의 테스트가 끝날 때마다 repository와 공용 데이터를 clear 해줘야 함

 

 

🔶 test/.../repository/MemoryMemberRepositoryTest

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

 

✔ @AfterEach

• 한 번에 여러 테스트를 실행하면 메모리 DB에 직전 테스트의 결과가 남을 수 있음
• 다음 테스트가 실패할 가능성이 있음

➡ @AfterEach는 각 테스트가 종료될 때마다 메모리 DB에 저장된 데이터를 삭제함

 

 

🔶 main/.../respository/MemoryMemberRepository

public void clearStroe(){
    stroe.clear;
}

 

 

최종 MemoryMemberRepositoryTest

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 java.util.Optional;
import static org.assertj.core.api.Assertions.*;
class MemoryMemberRepositoryTest {
    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();
        assertThat(result).isEqualTo(member);
    }

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

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

 

테스트 주도 개발(TDD)

테스트 케이스를 먼저 만들고 구현 클래스를 만들어서 돌려보는 것
➡ 위에서 한 것은 TDD가 아님 (구현클래스를 생성한 후 테스트 케이스를 생성함)

 

 

📌 회원 서비스 개발

✔ 회원 서비스 : 회원 리포지토리와 도메인을 활용해서 실제 비지니스 로직을 작성하는 것

🔶 main/.../hello.hellospring/service/MemberService

회원가입

public Long join(Member member){
    //같은 이름이 있는 중복회원 X
    Optional<member> result = memberRepository.findByName(member.getName());
    //값이 있으면
    result.ifPresent(m->{
        throw new IllegalStateException("이미 존재하는 회원입니다.");
    }); 

    //회원가입
    memberRepository.save(member);
    return member.getId();
}

 

• ifPresent : 이미 값이 존재하면 로직에 의해 동작함 (Optional이라서 가능한 것)

#1
Optional<Member> result = memberRepository.findByName(member.getName());
result.ifPresent(m->{
    throw new IllegalStateException("이미 존재하는 회원입니다.");
});

#2
memberRepository.findByName(member.getName())
    .ifPresent(m->{
        throw new IllegalStateException("이미 존재하는 회원입니다.");    
});

 

➡ 두 코드는 같은 의미이다

 

 

전체 회원 조회

public List <Member> findMembers(){
    return memberRepository.findAll();
}

 

ID로 바로 찾기

public Optional<Member> findOne(Long memberId){
    return memberRepository.findById(memberId);
}

 

최종 MemberService

package hello.hellospring.service;
import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemberRepository;
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);
    } 
}

 

 

📌 회원 서비스 테스트

🔶 test/.../hello.hellospring/service/MemberServiceTest

회원가입

@Test
void 회원가입(){
    //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());

}

 

 

⭐ 테스트는 예외처리가 중요함

public void 중복_회원_예외(){
    //given
    Member member1 = new Member();
    member1.setName("spring");

    Member member2 = new Member();
    member2.setName("spring");

    //when
    memberService.join(member1);
    memberService.join(member2);
    //둘 다 join이라 오류 

      //예외 처리 코드 밑에서 예시 들겠음!!

    //then
}

#1

try{
    memberService.join(member2);
    fail();
}catch(IllegalStateException e){
    //예외가 터져서 정상적으로 성공
    Assertions.assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다."); //"이미 존재하는 회원입니다.1213"이라 적으면 실패 
}

#2

memberService.join(member1);
Assertions.assertThrows(IllegalStateException.class, () -> memberService.join(member2));

 

#1보다 #2가 더 좋은 방법이다.
➡ 만약 IllegalStateException 대신 다른 Exception(ex. NullPointerException)으로 변경할 경우 오류문이 맞지 않아 오류 발생

#2-1
memberService.join(member1);
IllegalStateException e = Assertions.assertThrows(IllegalStateException.class, () -> memberService.join(member2));
Assertions.assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

 

repository clear

MemoryMemberRepository memberRepository = new MemoryMemberRepository();

 

 

✔ MemoryMemberRepository 객체 생성

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

 

리포지토리 초기화

MemberService에 있는 리포지토리와 Test에 있는 리포지토리가 다른 객체임 (각각 new로 생성)
➡ 두개를 쓸 이유가 없음

 

❗ MemberService

private final MemberRepository memberRepository;
//private final MemberRepository memberRepository = new MemoryMemberRepository(); =부터 지운다.



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

 

 

❗ MemberServiceTest

MemberService memberService;
MemoryMemberRepository memberRepository;

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

 

✔ @BeforeEach를 사용해 테스트 코드 실행 전에 리포지토리 초기화

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

 

✔ Dependent Injection(DI)를 사용하여 코드 변경
: 리포지토리를 외부에서 넣어줌

 

 

 

 

 

이 글은 <김영한_스프링 입문>을 수강하고 참고하여 작성한 글입니다

 

 

---

PREV

[스프링 입문] 2. 스프링 웹개발 기초

 

NEXT

[스프링 입문] 4. 스프링 빈과 의존관계