[스프링] 웹 MVC 및 DB 연동 - 3

백엔드 개발

시작

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

일반적으로 웹 애플리케이션은 다음과 같은 계층으로 구성됩니다.

  1. 컨트롤러: 웹 MVC의 컨트롤러 역할
  • 웹 애플리케이션의 진입점
  • HTTP 요청을 받아서 파라미터를 검증하고 비즈니스 로직을 실행
  • 적절한 응답을 클라이언트에게 반환
  1. 서비스: 핵심 비즈니스 로직 구현
  • 비즈니스 도메인 객체를 이용해 핵심 비즈니스 로직을 구현
  • 트랜잭션과 도메인 간의 순서를 보장
  • 여러 리포지토리를 호출하여 필요한 데이터를 처리
  1. 리포지토리: 데이터베이스에 접근
  • 데이터베이스에 접근하는 모든 코드가 모이는 계층
  • 도메인 객체를 DB에 저장하고 관리
  • JPA, JDBC 등을 통해 실제 데이터베이스와 통신
  1. 도메인: 비즈니스 도메인 객체
  • 회원, 주문, 쿠폰 등 데이터베이스에 저장하고 관리되는 비즈니스 도메인 객체
  • 비즈니스 로직의 주체가 되는 데이터 객체들

이러한 계층 구조를 통해 각 계층은 독립적으로 개발될 수 있으며, 유지보수가 용이해집니다. 또한 테스트 코드 작성이 쉬워지고 각 계층의 책임이 명확해지는 장점이 있습니다.

백엔드 프로젝트 예시

아래 사항을 시나리오로 백엔드 개발 클래스를 작성해봅시다.

아직 데이터 저장소가 선정되지 않았으면 우선 인터페이스로 구현 클래스를 변경할 수 있도록 설계합니다.

저장소는 RDB, NoSQL 등 다양한 저장소를 사용할 수 있도록 인터페이스로 구현합니다.

개발을 진행하기 위해 초기 개발 단계에서는 구현체로 가벼운 메모리 기반의 저장소를 사용합니다.

회원 도메인과 리포지토리 생성

도메인 입니다.

java
package hello.hello_spring.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;
    }
}

리포지토리 인터페이스 입니다.

java
package hello.hello_spring.repository;

import hello.hello_spring.domain.Member;

import java.util.List;
import java.util.Optional;

public interface MemberRepository {
    Member save(Member member);
    // Optional 의 경우 값이 없다면 nukll
    Optional<Member> findById(Long id);
    Optional<Member> findByName(String email);

    List<Member> findAll();
}

구현체 입니다.

java
package hello.hello_spring.repository;

import hello.hello_spring.domain.Member;

import java.util.*;

/**
 * 메모리 기반의 회원 저장소 구현체
 */
public class MemoryMemberRepository implements MemberRepository {

    // 메모리 상에 회원 정보를 저장하기 위한 Map
    private static Map<Long, Member> store = new HashMap<>();
    // 회원 ID를 생성하기 위한 시퀀스
    private static long sequence = 0L;

    /**
     * 회원을 저장소에 저장
     * @param member 저장할 회원 객체
     * @return 저장된 회원 객체
     */
    @Override
    public Member save(Member member) {
        // ID 생성 및 설정
        member.setId(++sequence);
        // 회원을 저장소에 저장
        store.put(member.getId(), member);
        return member;
    }

    /**
     * ID로 회원을 찾음
     * @param id 찾을 회원의 ID
     * @return Optional로 감싼 회원 객체
     */
    @Override
    public Optional<Member> findById(Long id) {
        // ID에 해당하는 회원을 Optional로 감싸서 반환
        return Optional.ofNullable(store.get(id));
    }

    /**
     * 이름으로 회원을 찾음
     * @param name 찾을 회원의 이름
     * @return Optional로 감싼 회원 객체
     */
    @Override
    public Optional<Member> findByName(String name) {
        // 저장소에서 이름이 일치하는 회원을 찾아 반환
        return store.values().stream()
                .filter(member -> member.getName().equals(name))
                .findAny();
    }

    /**
     * 모든 회원 목록을 반환
     * @return 저장된 모든 회원 목록
     */
    @Override
    public List<Member> findAll() {
        // 저장소의 모든 회원을 리스트로 반환 추론을 통해 Member 타입만 가짐
        return new ArrayList<>(store.values());
    }
}

테스트 케이스 작성

개발한 기능을 실행해 테스트 할 때 main 메서드를 통해 실행하거나 웹 어플리케이션 컨트롤러를 통해 해당 기능을 실행한다. 이 과정은 실행이 오래 걸리고 반복 수행하기 어려워 여러 테스트를 한번에 실행하기 어렵다.

Junit 을 이용해 테스트를 실행하는것이 좋다.

java
package hello.hello_spring.repository;

// 필요한 클래스들을 임포트
import hello.hello_spring.domain.Member;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

// AssertJ의 assertThat을 static import하여 직접 사용 가능하게 함
import static org.assertj.core.api.Assertions.*;

/**
 * MemoryMemberRepository 테스트 클래스
 */
class MemoryMemberRepositoryTest {

    // 테스트할 리포지토리 객체 생성
    MemberRepository repository = new MemoryMemberRepository();

    /**
     * 회원 저장 기능 테스트
     */
    @Test()
    public void save() {
        // 테스트용 Member 객체 생성
        Member member = new Member();
        member.setName("spring");

        // 리포지토리에 회원 저장
        repository.save(member);

        // 저장된 회원을 ID로 조회
        Member result = repository.findById(member.getId()).get();
        // 저장한 회원과 조회한 회원이 동일한지 검증
        assertThat(member).isEqualTo(null);
    }
}

위 테스트를 실행하는 경우 아래와 같이 에러를 발생시킵니다.

bash
org.opentest4j.AssertionFailedError: 
expected: null
 but was: hello.hello_spring.domain.Member@34f5090e

	at hello.hello_spring.repository.MemoryMemberRepositoryTest.save(MemoryMemberRepositoryTest.java:21)
	at java.base/java.lang.reflect.Method.invoke(Method.java:568)
	at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)
	at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)


Process finished with exit code 255

테스트 실행 결과 아래와 같은 에러가 발생했습니다:

  • 테스트 실패 (AssertionFailedError)
  • 기대값: null
  • 실제값: Member 객체 (hello.hello_spring.domain.Member@34f5090e)

이는 테스트 코드에서 assertThat(member).isEqualTo(null)로 검증하고 있기 때문입니다. 저장한 member 객체와 null을 비교하고 있어서 당연히 실패하게 됩니다. 이렇게 테스트에 대한 내용이 출력됩니다.

보통 빌드시에 테스트 케이스를 수행 시켜 그 이후 단계로 넘어가는 것을 방지할 때 테스트 케이스를 사용하는것이 좋습니다.

단 주의할 것은 각 메서드의 실행 순서는 일관되지 않으므로 각 메서드 테스트 마다 store를 clear 해주어야 합니다.

java
package hello.hello_spring.repository;

import hello.hello_spring.domain.Member;

import java.util.*;

public class MemoryMemberRepository implements MemberRepository {

    // ...

    /**
     * 테스트 케이스 실행 시 메모리에 저장된 데이터를 모두 삭제
     * 각 테스트 메서드가 독립적으로 실행될 수 있도록 보장
     */
    public void clearStore() {
        store.clear();
    }
}

이후 테스트 케이스를 실행하는 클래스 내부에 아래 메서드를 추가합니다.

java
package hello.hello_spring.repository;

// ...

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

class MemoryMemberRepositoryTest {

    MemberRepository repository = new MemoryMemberRepository();

    /**
     * 각 테스트 메서드가 실행된 후에 호출되는 메서드
     * 테스트 메서드 간의 독립성을 보장하기 위해 저장소를 초기화
     */
    @AfterEach
    public void afterEach() {
        repository.clearStore();
    }

    @Test()
    public void save() {
      // ...
    }

    @Test
    public void findByName() {
      // ...
    }

    @Test
    public void findAll() {
      // ...
    }
}

지금의 경우 개발을 완료한 후 테스트 케이스를 작성했지만 반대로 테스트 케이스를 작성하고 개발을 하는 TDD 방법도 있습니다.

이어서 서비스 로직을 수행하는 Service 클래스를 작성합니다.

java
package hello.hello_spring.service;

import hello.hello_spring.domain.Member;
import hello.hello_spring.repository.MemberRepository;
import hello.hello_spring.repository.MemoryMemberRepository;

import java.util.List;
import java.util.Optional;

/**
 * 회원 서비스 클래스
 * 회원과 관련된 핵심 비즈니스 로직을 처리
 */
public class MemberService {

    /**
     * 회원 저장소 객체
     * MemoryMemberRepository 구현체를 사용
     */
    private final MemberRepository memberRepository = new MemoryMemberRepository();

    /**
     * 회원가입 메서드
     * @param member 가입할 회원 정보
     * @return 가입된 회원의 ID
     */
    public Long join(Member member) {
        // 중복 회원은 불가(같은 이름)
        validateDuplicateMember(member);

        memberRepository.save(member);
        return member.getId();
    }

    /**
     * 중복 회원 검증 메서드
     * 같은 이름의 회원이 이미 있는 경우 예외 발생
     * @param member 검증할 회원 정보
     * @throws IllegalStateException 이미 존재하는 회원인 경우
     */
    private void validateDuplicateMember(Member member) {
        memberRepository.findByName(member.getName())
                .ifPresent(m -> {
                    throw new IllegalStateException("이미 존재하는 회원입니다.");
                });
    }

    /**
     * 전체 회원 목록 조회 메서드
     * @return 저장된 모든 회원 목록
     */
    public List<Member> findMembers() {
        return memberRepository.findAll();
    }

    /**
     * 특정 회원 조회 메서드
     * @param memberId 조회할 회원 ID
     * @return 해당 ID를 가진 회원 정보 (Optional로 랩핑됨)
     */
    public Optional<Member> findOne(Long memberId) {
        return memberRepository.findById(memberId);
    }

}

이후 테스트 케이스를 작성합니다.

우선 같은 repository 를 사용해야하므로 Service 클래스를 수정합니다.

java
package hello.hello_spring.service;

/**
 * 회원 서비스를 제공하는 클래스
 */
public class MemberService {

    /**
     * 회원 저장소 인터페이스
     * final로 선언하여 한번 주입된 후 변경 불가
     */
    private final MemberRepository memberRepository;

    /**
     * 생성자를 통한 의존성 주입(DI)
     * 외부에서 memberRepository를 주입받아 사용
     * @param memberRepository 회원 저장소 구현체
     */
    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }
    // ...
}

테스트 케이스를 수정합니다. 같은 메모리 repository 를 사용하도록 합니다.

java
package hello.hello_spring.service;

import hello.hello_spring.domain.Member;
import hello.hello_spring.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 memberService = new MemberService();

    /**
     * 테스트에서 사용할 MemoryMemberRepository 인스턴스
     */
    MemoryMemberRepository memoryMemberRepository;

    /**
     * 각 테스트 실행 전에 호출되는 메서드
     * 새로운 MemoryMemberRepository를 생성하고 MemberService에 주입
     * 각 테스트가 독립적인 환경에서 실행되도록 보장
     */
    @BeforeEach
    public void beforeEach() {
        memoryMemberRepository = new MemoryMemberRepository();
        memberService = new MemberService(memoryMemberRepository);
    }

    /**
     * 각 테스트 실행 후에 호출되는 메서드
     * 메모리 저장소의 데이터를 모두 삭제하여 다음 테스트에 영향을 주지 않도록 함
     */
    @AfterEach
    public void afterEach() {
        memoryMemberRepository.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);
        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() {
    }
}