Spring [회원 관리 / 백엔드]

이번에 배운 건 좀 어렵다...그래도 열심히 들어야겠다๑･̑◡･̑๑

아직 기초공부하고 있는데도 자바 공부의 부족함이 확실히 느껴진다ㅠㅠ 내일부터 다시 자바 공부를 해야겠다

 

그동안 잘 작동되던 intelliJ가 갑자기 side-by-side에러가 났다...visual c++ 다시 깔고 그래도 안돼서 인텔리제이 지우고 다시 깔았더니 아주 잘 작동 됐다...다신 이런 일 만들지 말아라 (ꐦ°꒫°)

 

---

이번에 배운 건 회원 관리 예제이다!

 

회원가입을 하고, 중복된 이름은 사용하지 못하도록 관리해야한다!

 

< 일반적인 웹 계층 구조 >

 

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

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

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

도메인 : 비즈니스 도메인 객체

 

 

1. 회원 도메인 생성

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

 

get, set으로 id와 이름을 지정해준다! 자바를 배울땐 몰랐었는데 저렇게 실제로 지정해주니까 뭔가를 만들고 있다는 느낌이 확 든다.

 

여기서 id는 회원이 친 아이디가 아닌 시스템이 지정한 아이디이다.

 

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

member repository를 인터페이스로 설계한다. repository는 저장소 개념이다.

domain 패키지를 만들었던 위치에 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();
}

 

여기서 id나 name이 없을때 null이 반환되는데 요즘은 null을 그대로 반환하지 않고 optional로 감싸서 반환하는 것을 선호한다고 한다. 

 

3. 회원 리포지토리 메모리 구현체

 

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import java.util.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

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 Optional<Member> findByName(String name) {
        return store.values().stream()
                .filter(member -> member.getName().equals(name))
                .findAny();
    }

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

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

MemberRepository를 상속받은 MemoryMemberRepository 클래스를 만든다.

 

 

이렇게 만들면 테스트를 해봐야된다!! 테스트 케이스를 만들어서 잘 작동이 되는지 실행해본다.

 

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

 

src - test - java - hello.hellospring 에 repository 패키지를 만들고 MemoryMemberRepositoryTest 클래스를 만든다.

package hello.hellospring.repository;

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

import java.util.List;

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

public class MemoryMemberRepositoryTest {

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

        repository.save(member);
        Member result = repository.findById(member.getId()).get();
        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("spring1").get();

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

 

위의 코드를 실행시키면 

모두 초록색체크가 뜨면서 통과되는 모습을 볼 수 있다. 

하지만 비교를 null로 하게 된다면 

이렇게 오류가 뜬다!

name의 경우도 마찬가지이다. 

 

전체 몇명의 회원인지 찾는 코드를 추가해보자

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

하지만 이 코드를 추가하고 전체 실행을 하게 됐을 경우에 개별로는 잘 작동하던 코드가 오류가 난다.

분명 잘 돌아가던 코드가 한번에 돌리니까 오류가 생긴다!

findAll의 메서드를 가장 나중에 작성했음에도 불구하고 실행하는 것은 순서가 보장되지 않는다. 메서드별로 따로 동작하게 설계된다. 

위를 보면 findAll이 먼저 실행이 되었기 때문에  spring 이름이 저장되어버려서 그 다음 findByName이 실행될 때 오류가 생긴다!

또한 테스트는 의존관계없이 통과되어야하게 때문에 하나의 메서드 테스트가 끝나고나면 데이터를 클리어해줘야한다. 

저장소나 공용데이터를 지우는 코드를 써주었다!

 

    MemoryMemberRepository repository = new MemoryMemberRepository();
    //MemoryMemberRepository만 실행하는 거니까 앞에 있던 MemberRepository에서 MemoryMemberRepository로 바꿈

    @AfterEach // 메서드 끝날때마다 동작하는 거
    public void afterEach(){
        repository.clearStore();
    }

위에 저장되어있던 MemoryMemberRepository를 실행해야하기 때문에 MemberRepository에서 MemoryMemberRepository로 변경하였다.

 

잘 작동된다 !_!

 

5. 회원서비스 

domain을 만들었던 곳에 새로운 패키지를 만들어준다.

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();
    //바꾸기 전에 쓴 코드
    private  final MemberRepository memberRepository;

    public MemberService(MemberRepository memberRepository){
        this.memberRepository = memberRepository;
    }//멤버서비스 입장에서 보면 멤버리포지토리를 외부에서 넣어줌 = DI (Dependency Injection)

    /**
     * 회원가입
     */
    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);
    }
}

 

여기서도 테스트를 해준다!

위에 클래스 이름을 클릭한 다음에 shift + ctrl + T를 같이 눌러주면 class test가 저절로 생성된다!!!!

 

 

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.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.Optional;

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

class MemberServiceTest {

    //MemberService memberService = new MemberService();
    //MemoryMemberRepository memberRepository = new MemoryMemberRepository();

    MemberService memberService;
    MemoryMemberRepository memberRepository;

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

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

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

        //then
    }

    @Test
    void findMembers() {
    }

    @Test
    void findOne() {
    }
}

전에 만들었던 코드(주석처리한 코드)는 이름은 같지만 다른 멤버리포지토리를 사용하고 있었다.

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

 

---

으아...점점 어려워지는 것 같다..나 정말 갈 길이 멀구나!!!!

그래도 회원 서비스를 이런식으로 만든다는게 신기하다 웹사이트 얼른 만들어보고 싶다( *ฅ́˘ฅ̀*)