전체 메뉴

테마

Chapter 05

CRUD API와 DTO

사용자 CRUD API를 만들며 POST, PUT, PATCH, DELETE의 차이와 DTO, Controller·Service·Repository 계층 분리를 익힙니다.

난이도
입문
예상 학습
95분
Spring Boot 기준
Spring Boot 4.1.1
JDK 기준
JDK 21
최종 검토

전체 24개 Chapter 중 Chapter 05입니다. 예제 코드는 공개 저장소 spring-boot-curriculum의 examples/ch05-crud-api 폴더에서 확인할 수 있습니다.

Learning goals

오늘 배울 내용

  • POST·GET·PUT·PATCH·DELETE 성공 상태와 404 구분하기
  • PUT과 PATCH 차이를 요청 DTO의 타입과 갱신 규칙으로 설명하기
  • 요청 DTO·도메인 객체·응답 DTO를 분리하는 이유 설명하기
  • Controller·Service·Repository 책임을 나누고 흐름 테스트하기
  1. CRUD 흐름 확인
  2. POST 생성
  3. PUT과 PATCH 비교
  4. DELETE 처리
  5. DTO와 계층 분리
  6. 테스트로 검증
이 Chapter의 진행 흐름

이 Chapter에서 완성할 것

Chapter 04 HTTP와 REST Controller에서 조회 API를 만들었습니다. 이 Chapter에서는 사용자 한 명의 생애, 즉 만들고(Create), 조회하고(Read), 바꾸고(Update), 지우는(Delete) 전체 흐름을 API로 완성합니다. 코드가 늘어나는 만큼 구조도 정리합니다. 요청과 응답의 모양을 DTO로 나누고, Controller, Service, Repository의 책임을 분리합니다.

Chapter를 마치면 아래 내용을 직접 만들고 확인한 상태가 됩니다.

만드는 것 설명
POST/GET/PUT/PATCH/DELETE /users 사용자 CRUD API 전체입니다.
요청 DTO 3종 CreateUserRequest, UpdateUserRequest, PatchUserRequest입니다.
UserResponse 응답 본문 전용 객체입니다.
UserController, UserService, UserRepository HTTP, 변경 규칙, 보관을 나눈 세 계층입니다.
테스트 12건 API 흐름과 Service 단독 동작을 자동으로 검증합니다.

사전 지식은 Chapter 04 HTTP와 REST Controller의 @RestController, ResponseEntity, @PathVariable과 Chapter 03 IoC, DI, Bean의 생성자 주입입니다. 코드는 공개 저장소의 examples/ch05-crud-api 폴더에 있습니다. JDK 21과 Spring Boot 4.1.1을 기준으로 하며, 모든 명령은 저장소 루트에서 Gradle Wrapper로 실행합니다. 실행 결과는 컨테이너에서 JAR로 직접 실행해 얻은 값이고, Windows 실행은 검증하지 못했습니다.

사용자의 생애를 호출 순서대로 따라가기

사용자 한 명을 만들고, 조회하고, 통째로 바꾸고, 일부만 바꾸고, 지우는 데까지를 API 호출 순서대로 따라가 봅니다. 마지막에 같은 삭제를 한 번 더 보내면 무슨 일이 생기는지도 봅니다.

코드를 보기 전에 결과부터 봅니다. 어떤 요청에 어떤 응답이 와야 하는지를 먼저 알면, 이어지는 절의 코드가 왜 그렇게 생겼는지 이해하기 쉽습니다.

호출 순서대로 본 응답

JAR를 실행해 한 사용자의 요청을 순서대로 보냈습니다.

POST /users  {"name":"kim","email":"kim@example.com","age":28}
201  Location: /users/1
{"id":1,"name":"kim","email":"kim@example.com","age":28}

GET /users/1
200 {"id":1,"name":"kim","email":"kim@example.com","age":28}

PUT /users/1  {"name":"lee","email":"lee@example.com","age":35}
200 {"id":1,"name":"lee","email":"lee@example.com","age":35}

PATCH /users/1  {"age":29}
200 {"id":1,"name":"lee","email":"lee@example.com","age":29}

DELETE /users/1
204

DELETE /users/1
404

GET /users/1
404

응답에서 읽을 것

  • 생성(POST)은 201과 Location 헤더입니다. Location은 새로 만들어진 자원의 주소를 알려 줍니다. 클라이언트는 응답 본문을 읽지 않고도 다음에 GET /users/1을 호출하면 된다는 것을 압니다.
  • PUT은 name, email, age를 모두 보냈고 모두 바뀌었습니다.
  • PATCH는 age만 보냈는데 name과 email은 PUT으로 바꾼 값(lee) 그대로 남았습니다.
  • 삭제(DELETE)는 204입니다. “성공했고 돌려줄 본문이 없다”는 뜻입니다.
  • 삭제를 한 번 더 보내면 이미 없으므로 404입니다. 이후 조회도 404입니다.

전체 대응표

동작 요청 성공 응답 자원이 없을 때
생성 POST /users 201 + Location -
목록 GET /users 200 -
조회 GET /users/{id} 200 404
전체 교체 PUT /users/{id} 200 404
부분 수정 PATCH /users/{id} 200 404
삭제 DELETE /users/{id} 204 404

이 표가 이 Chapter의 API 계약입니다. 컨트롤러 소스 위의 주석에도 같은 표가 있고, 테스트가 이 표를 하나씩 검증합니다.

실행해 보기

OS 실행 이 Chapter만 빌드
Linux / macOS ./gradlew :examples:ch05-crud-api:bootRun ./gradlew :examples:ch05-crud-api:build
Windows gradlew.bat :examples:ch05-crud-api:bootRun gradlew.bat :examples:ch05-crud-api:build
curl -i -X POST http://localhost:8080/users -H "Content-Type: application/json" \
  -d '{"name":"kim","email":"kim@example.com","age":28}'
curl -X PATCH http://localhost:8080/users/1 -H "Content-Type: application/json" -d '{"age":29}'
curl -i -X DELETE http://localhost:8080/users/1

curl로 POST를 보낼 때 Content-Type: application/json 헤더를 빼면 415가 나옵니다. 아래 “오류 2: Content-Type 없이 보내면 415” 절에서 이유를 봅니다.

따라 하기: 전체 흐름을 한 번에

  1. ./gradlew :examples:ch05-crud-api:bootRun으로 서버를 켭니다.
  2. 아래를 순서대로 실행하고, 각 명령의 상태 코드가 표와 같은지 확인합니다.
curl -i -X POST http://localhost:8080/users -H "Content-Type: application/json" \
  -d '{"name":"kim","email":"kim@example.com","age":28}'
curl -i http://localhost:8080/users/1
curl -i -X PUT http://localhost:8080/users/1 -H "Content-Type: application/json" \
  -d '{"name":"lee","email":"lee@example.com","age":35}'
curl -i -X PATCH http://localhost:8080/users/1 -H "Content-Type: application/json" -d '{"age":29}'
curl -i -X DELETE http://localhost:8080/users/1
curl -i -X DELETE http://localhost:8080/users/1
  1. 응답이 순서대로 201, 200, 200, 200, 204, 404이면 성공입니다. 마지막 두 줄이 “같은 삭제 요청을 반복하면 결과 코드가 달라진다”는 것을 보여 줍니다.

자주 하는 실수

실수 증상 해결
POST에 Content-Type 헤더를 빠뜨림 415 -H "Content-Type: application/json" 추가
서버를 재시작하고 이전 id로 조회 404 저장소가 메모리라 재시작하면 데이터가 사라짐, 다시 생성
-d 안의 JSON에 작은따옴표 사용 400 JSON 문자열은 큰따옴표, 셸 인자는 바깥을 작은따옴표로

확인 문제

  1. 생성 응답이 200이 아니라 201인 이유는 무엇인가요?
  2. Location 헤더는 클라이언트가 무엇을 하는 데 쓰나요?

답: 1) “새 자원이 만들어졌다”는 의미를 상태 코드로 정확히 알리기 위해서입니다. 2) 새로 만들어진 자원의 주소를 알아내어 바로 조회하는 데 씁니다.

직접 해 보기

  1. 서버를 켜고 위 순서대로 요청을 직접 보내 보세요. 각 응답의 상태 코드와 Location을 확인합니다.
  2. 사용자를 두 명 만들고 GET /users로 목록에 두 명이 모두 나오는지 보세요. id가 1, 2로 증가하는지도 확인합니다.
  3. 존재하지 않는 id 999에 PUT과 PATCH를 보내면 어떤 응답인지 예측하고 확인하세요.

POST와 요청 본문: @RequestBody와 201

조회 API는 값이 주소에 실려 왔습니다. 생성 요청은 보낼 데이터가 많아서 요청 본문(body)에 JSON으로 실립니다. 이 절에서는 본문을 Java 객체로 받는 @RequestBody와, 만들어진 자원의 주소를 알리는 201 응답을 코드로 봅니다.

요청 DTO

생성 요청의 본문은 이름, 이메일, 나이입니다. id는 서버가 정하므로 요청에 없습니다.

/** POST /users 요청 본문. id는 서버가 정하므로 받지 않는다. */
public record CreateUserRequest(String name, String email, int age) {
}

JSON {"name":"kim","email":"kim@example.com","age":28}이 이 record로 바뀌어 메서드에 전달됩니다. record의 컴포넌트 이름과 JSON 키가 같아야 값이 연결됩니다.

생성 메서드

@PostMapping
public ResponseEntity<UserResponse> create(@RequestBody CreateUserRequest request) {
    User created = service.create(request);
    return ResponseEntity
            .created(URI.create("/users/" + created.id()))
            .body(UserResponse.from(created));
}

컨트롤러는 변환과 응답 조립만 하고, 저장은 서비스와 저장소가 맡습니다. id는 저장소에서 정해집니다.

주요 코드 설명

  • @PostMapping: POST /users 요청을 이 메서드에 연결합니다. 클래스의 @RequestMapping("/users")와 합쳐집니다.
  • @RequestBody CreateUserRequest request: 요청 본문의 JSON을 CreateUserRequest로 바꿔 받습니다. 이 애노테이션이 없으면 본문을 읽지 않으며, 그 증상은 아래 “오류 1: @RequestBody를 빠뜨리면” 절에서 봅니다.
  • service.create(request): 실제 생성은 Service가 합니다. Controller는 HTTP 처리만 맡습니다. 이 분리는 아래 “세 계층의 책임” 절에서 설명합니다.
  • ResponseEntity.created(URI.create(...)): 201 상태와 Location 헤더를 한 번에 만듭니다. /users/1처럼 새로 만든 자원의 주소를 담습니다.
  • .body(UserResponse.from(created)): 응답 본문에는 만들어진 사용자를 응답 객체로 바꿔 담습니다.

Chapter 04에서는 ResponseEntity.ok와 notFound를 봤습니다. created도 같은 계열의 도구입니다.

왜 201과 Location인가

HTTP는 “자원을 만들었다”는 의미의 상태 코드(201 Created)를 따로 둡니다. 200으로 응답해도 동작은 하지만, 201을 쓰면 클라이언트가 “새 자원이 생겼고 Location에 주소가 있다”는 것을 코드만 보고 압니다. Location을 쓰면 클라이언트는 id를 응답 본문에서 꺼내 주소를 조립하지 않아도 됩니다. 테스트도 이 헤더에서 id를 꺼내 씁니다.

서버가 id를 정한다

저장소는 증가하는 번호를 id로 줍니다. 요청 본문에 id를 넣어 보내도 쓰지 않습니다(요청 DTO에 필드가 없기 때문입니다).

public User save(String name, String email, int age) {
    User user = new User(sequence.incrementAndGet(), name, email, age);
    users.put(user.id(), user);
    return user;
}

sequence는 아래 “저장소 코드” 절에서 볼 AtomicLong입니다. 여러 요청이 동시에 들어와도 id가 겹치지 않게 합니다.

따라 하기

curl -i -X POST http://localhost:8080/users -H "Content-Type: application/json" \
  -d '{"id":99,"name":"kim","email":"kim@example.com","age":28}'

본문에 id: 99를 넣어 보냈지만 응답의 id는 서버가 정한 값(첫 요청이면 1)입니다. 요청 DTO에 id 필드가 없어서 무시되기 때문입니다. 응답에서 Location 헤더가 /users/1처럼 서버가 정한 id를 가리키는지 확인하세요.

자주 하는 실수

실수 증상 해결
@RequestBody를 빠뜨림 JSON을 보냈는데 400 파라미터에 @RequestBody 추가(아래 “오류 1: @RequestBody를 빠뜨리면” 절)
필드 이름 오타(nmae) 이름이 null로 들어감 JSON 키를 record 컴포넌트 이름과 맞춤
생성 응답을 200으로 돌려줌 동작은 하지만 새 자원이 만들어졌다는 의미가 사라짐 ResponseEntity.created(...) 사용

JSON 키를 틀려도 오류 없이 null이 들어가는 문제는 입력 검증이 없기 때문입니다. 값의 형식을 검사하는 방법은 Chapter 06에서 다룹니다.

확인 문제

  1. 요청 DTO에 id를 두지 않은 이유는 무엇인가요?
  2. Location 헤더 값을 "/users/" + created.id()로 만드는 이유는 무엇인가요?

답: 1) id는 서버가 정하는 값이라 클라이언트가 임의로 정하지 못하게 하기 위해서입니다. 2) 새로 만들어진 자원의 주소를 알려 주기 위해서입니다.

직접 해 보기

  1. curl -i로 POST를 보내 응답의 Location 헤더를 확인하세요. 그 주소로 GET을 보내 같은 사용자가 나오는지 봅니다.
  2. 요청 본문에 "id":100을 넣어 보내 보세요. 응답의 id가 100이 아닌 것을 확인합니다.
  3. 요청에서 email을 빼고 보내면 응답의 email이 어떻게 되는지 관찰하세요. 이 Chapter에서는 검증하지 않으므로 null이 되어 저장됩니다. Chapter 06의 검증이 필요한 이유입니다.

PUT과 PATCH: 통째로 바꾸기와 일부만 바꾸기

수정 API는 두 가지가 있습니다. 자원을 요청 본문으로 통째로 교체하는 PUT, 바꾸고 싶은 필드만 보내는 PATCH입니다. 둘의 차이는 설명으로는 한 줄이지만, 코드에서는 요청 DTO의 타입 하나(int와 Integer)로 드러납니다.

PUT: 전체 교체

PUT은 자원을 요청 본문으로 교체합니다. 보내지 않은 필드는 “없는 값”이 되므로 모든 필드를 받습니다.

/** PUT /users/{id} 요청 본문. PUT은 리소스 전체를 교체하므로 모든 필드를 받는다. */
public record UpdateUserRequest(String name, String email, int age) {
}
@PutMapping("/{id}")
public ResponseEntity<UserResponse> update(@PathVariable long id, @RequestBody UpdateUserRequest request) {
    return service.update(id, request).map(UserResponse::from).map(ResponseEntity::ok)
            .orElseGet(() -> ResponseEntity.notFound().build());
}

경로 변수 id와 요청 본문을 함께 받습니다. 같은 PUT 요청을 몇 번 보내도 결과가 같으므로 멱등합니다(Chapter 04의 메서드 표). 없는 id에는 404를 돌려줍니다. 이 예제는 PUT을 “존재하는 자원의 교체”로 정의했고, 없는 id를 새로 만들지 않습니다.

PATCH: 보낸 필드만 수정

PATCH는 바꾸고 싶은 필드만 보냅니다. 보내지 않은 필드는 그대로 둡니다.

public record PatchUserRequest(String name, String email, Integer age) { }

age가 int가 아니라 Integer입니다. 이유는 “보내지 않았다”를 표현해야 하기 때문입니다.

  • 보내지 않은 필드는 null로 들어와야 “변경 없음”으로 해석할 수 있습니다.
  • int는 null을 담을 수 없습니다. 그러면 값이 0이 될 것 같지만, 이 프로젝트의 Boot 4(Jackson 3)에서 int 필드를 빼고 보내면 0이 아니라 Cannot map null into type int로 요청이 거부되어 400이 됩니다. 어느 쪽이든 PATCH에서는 쓸 수 없는 타입입니다.

PatchUserRequest와 UpdateUserRequest의 필드는 같지만 age의 타입이 다릅니다. PUT은 age가 필수라 int, PATCH는 선택이라 Integer입니다. 요청 DTO를 메서드별로 나눈 이유 중 하나입니다.

규칙은 Service에 있다

public Optional<User> patch(long id, PatchUserRequest request) {
    return repository.findById(id).flatMap(current -> repository.replace(new User(
            id,
            request.name() != null ? request.name() : current.name(),
            request.email() != null ? request.email() : current.email(),
            request.age() != null ? request.age() : current.age())));
}

주요 코드 설명

  • repository.findById(id): 현재 값을 찾습니다. 없으면 Optional.empty()가 되어 아래 전체가 비어 있고, Controller가 404로 바꿉니다.
  • flatMap(current -> ...): 현재 값이 있을 때만 새 User를 만들어 교체합니다. 결과가 Optional<User>이므로 map이 아니라 flatMap을 씁니다.
  • request.name() != null ? request.name() : current.name(): 요청에 값이 있으면 그 값을, 없으면 현재 값을 씁니다. 세 필드에 같은 규칙을 적용합니다.

이 규칙이 Controller가 아니라 Service에 있어서 Spring 없이도 테스트할 수 있습니다(아래 “Service 단독 테스트” 절).

PATCH의 한계

보내지 않은 필드와 null로 보낸 필드가 둘 다 null로 들어와 구분되지 않습니다. 그래서 이 방식으로는 값을 null로 지울 수 없습니다. 값 삭제가 필요한 API는 빈 값 표현이나 전용 엔드포인트 같은 규칙을 따로 정해야 합니다. 이 한계는 코드 구조에서 나온 설명이고 별도 테스트는 없습니다.

비교

PUT PATCH
의미 전체 교체 부분 수정
요청 본문 모든 필드 필수 바꿀 필드만
요청 DTO int age Integer age
같은 요청 반복 결과 같음(멱등) 구현에 따라 다름
값을 null로 지우기 가능(전체를 보내므로) 불가(이 구현에서는)

따라 하기: 차이를 직접 확인

  1. 서버를 켜고 사용자 한 명을 만듭니다(POST /users).
  2. PUT /users/1에 세 필드를 모두 보내 모두 바뀌는지 확인합니다.
  3. PATCH /users/1에 {"age":29}만 보내고 name, email이 그대로인지 확인합니다.
  4. PATCH에 {"name":null}을 보내 봅니다. 이름이 지워지지 않고 그대로인 것이 이 구현의 한계입니다.

자주 하는 실수

실수 증상 해결
PUT에 일부 필드만 보냄({"name":"x"}) 기본형 age가 없어 400이 되고 저장된 데이터는 바뀌지 않음(실제로 호출한 결과) PUT은 전체를 보내고, 부분 수정은 PATCH 사용
PATCH DTO에 int age를 사용 필드를 보내지 않으면 변경 없음으로 해석할 수 없음, Boot 4에서는 400까지 발생 Integer로 선언
없는 id를 수정 404 먼저 생성하고 올바른 id 사용

확인 문제

  1. PUT을 같은 본문으로 세 번 보내면 최종 결과는 한 번 보냈을 때와 같을까요?
  2. PATCH DTO를 Integer가 아닌 int로 두면 무엇이 달라지나요?

답: 1) 같습니다. PUT은 멱등합니다. 2) “보내지 않음”을 null로 구분할 수 없고, 이 프로젝트의 Boot 4에서는 int 필드에 null이 들어올 때의 처리가 달라져 요청이 400이 되는 경우가 있습니다.

직접 해 보기

  1. PUT에서 email을 빼고 보내 보세요. 응답의 email이 null이 되는 것을 확인합니다. 전체 교체이므로 보내지 않은 값은 없어집니다.
  2. PATCH에서 빈 객체 {}를 보내면 어떻게 되는지 예측하고 확인하세요(아무것도 바뀌지 않고 200).
  3. PATCH 요청 DTO의 age를 int로 바꾸고 {"name":"x"}만 보내 보세요. 400이 되는 것을 확인한 뒤 되돌립니다.

DELETE와 204, 메모리 저장소 읽기

삭제는 가장 단순해 보이지만 “삭제를 두 번 보내면?“이라는 질문에서 API의 성격이 드러납니다. 이 절에서는 DELETE의 응답 설계와, 이 Chapter의 저장소 코드를 읽습니다. 저장소가 동시 요청을 어떻게 견디는지도 함께 봅니다.

삭제 메서드

@DeleteMapping("/{id}")
public ResponseEntity<Void> delete(@PathVariable long id) {
    return service.delete(id) ? ResponseEntity.noContent().build() : ResponseEntity.notFound().build();
}

삭제할 자원이 있으면 204, 없으면 404입니다. 같은 요청을 두 번 보내면 첫 번째는 204, 두 번째는 404가 됩니다.

  • service.delete(id)는 삭제했으면 true, 없었으면 false를 돌려줍니다.
  • ResponseEntity.noContent()는 204입니다. “성공했고 돌려줄 본문이 없다”는 뜻입니다.
  • ResponseEntity<Void>는 본문이 없는 응답을 타입으로 표현합니다.

두 번째 삭제가 404인 점에 대해 의문이 생길 수 있습니다. DELETE는 멱등(여러 번 보내도 “그 자원이 없는 상태”는 같다)이지만, 응답 코드까지 같아야 하는 것은 아닙니다. 이 예제는 “없는 자원을 지우려 했다”는 사실을 404로 알립니다. 어느 쪽이 맞는지는 API마다 정하는 규칙이고, 이 예제의 규칙은 존재하지 않으면 404입니다. 규칙을 정해 문서(앞의 “전체 대응표”)와 테스트로 고정하는 것이 중요합니다.

저장소 코드

@Repository
public class UserRepository {

    private final Map<Long, User> users = new ConcurrentHashMap<>();
    private final AtomicLong sequence = new AtomicLong();

    public User save(String name, String email, int age) {
        User user = new User(sequence.incrementAndGet(), name, email, age);
        users.put(user.id(), user);
        return user;
    }

    public Optional<User> findById(long id) {
        return Optional.ofNullable(users.get(id));
    }

    public List<User> findAll() {
        List<User> result = new ArrayList<>(users.values());
        result.sort((a, b) -> Long.compare(a.id(), b.id()));
        return result;
    }

    /** 존재하는 id만 교체한다. 없는 id를 넣으면 새로 만들지 않고 빈 값을 돌려준다. */
    public Optional<User> replace(User user) {
        return Optional.ofNullable(users.computeIfPresent(user.id(), (id, old) -> user));
    }

    public boolean deleteById(long id) {
        return users.remove(id) != null;
    }
}

주요 코드 설명

  • @Repository: 데이터 보관 계층의 Bean이라는 표시입니다(Chapter 03의 Bean 등록).
  • ConcurrentHashMap: 요청은 여러 스레드가 동시에 처리합니다. 일반 HashMap을 쓰면 동시 접근에서 데이터가 깨질 수 있어, 동시 접근에 안전한 맵을 씁니다. singleton 공유 주의와 같은 이야기입니다. 저장소 Bean은 하나를 모든 요청이 공유하기 때문입니다.
  • AtomicLong.incrementAndGet(): 번호를 하나 올리고 돌려주는 연산이 쪼개지지 않아, 동시에 두 요청이 와도 id가 겹치지 않습니다.
  • findAll: 맵의 값을 리스트에 담아 id순으로 정렬합니다. 맵은 순서를 보장하지 않기 때문입니다.
  • replace: computeIfPresent로 이미 있는 id만 교체합니다. 없으면 null이 되어 Optional.empty()가 됩니다. PUT과 PATCH가 없는 자원을 새로 만들지 않는 근거입니다.
  • deleteById: remove는 지운 값을 돌려주고 없었으면 null입니다. != null로 삭제 여부를 알립니다.

이 저장소는 메모리에만 있어 서버를 재시작하면 데이터가 사라집니다. 데이터베이스는 Chapter 07 DataSource와 H2부터 붙입니다.

따라 하기

curl -i -X POST http://localhost:8080/users -H "Content-Type: application/json" \
  -d '{"name":"kim","email":"kim@example.com","age":28}'
curl -i -X DELETE http://localhost:8080/users/1   # 204
curl -i -X DELETE http://localhost:8080/users/1   # 404
curl -i http://localhost:8080/users/1             # 404

동시성 도구를 쓰는 이유

도구 일반 도구 문제 이 예제가 선택한 것
맵 HashMap 여러 스레드가 동시에 읽고 쓰면 데이터가 깨질 수 있음 ConcurrentHashMap
번호 long 필드를 ++ 증가와 읽기가 분리되어 같은 번호가 두 번 발급될 수 있음 AtomicLong.incrementAndGet()

웹 요청은 스레드 여러 개가 동시에 처리하므로, 상태를 가진 저장소는 이런 도구가 필요합니다. 데이터베이스를 쓰면 이 책임을 DB가 가져갑니다.

자주 하는 실수

실수 증상 해결
삭제 응답에 본문을 채우려 함 204는 본문이 없어야 함 본문이 필요하면 200 사용
존재하지 않는 id의 삭제를 204로 처리 클라이언트가 실제로 삭제되었는지 알 수 없음 없으면 404(이 Chapter의 선택)
서버 재시작 후 데이터가 남아 있다고 기대 메모리 저장소라 모두 사라짐 영속 저장은 Chapter 08 이후

확인 문제

  1. DELETE가 멱등인데 두 번째 응답이 404인 것은 모순일까요?
  2. findAll이 id순으로 정렬하는 이유는 무엇인가요?

답: 1) 모순이 아닙니다. 멱등은 응답 코드가 아니라 서버의 최종 상태(“그 id가 없음”)가 같다는 뜻입니다. 2) 맵은 순서를 보장하지 않아, 매번 같은 순서의 목록을 돌려주기 위해서입니다.

직접 해 보기

  1. 사용자를 만들고 삭제한 뒤 같은 id로 다시 조회하고 삭제를 한 번 더 해서 204, 404, 404를 확인하세요.
  2. 서버를 재시작하고 GET /users가 빈 배열인 것을 확인하세요. 메모리 저장소의 한계입니다.
  3. findAll의 정렬을 지우고 사용자를 여러 명 만든 뒤 순서가 보장되는지 관찰해 보세요. 맵의 순서가 우연히 맞아 보일 수 있으므로 여러 번 만들어 봅니다. 확인 후 되돌립니다.

DTO와 계층 분리

이 Chapter에는 사용자를 나타내는 객체가 여럿 있습니다. 요청용이 셋, 내부용 하나, 응답용 하나입니다. 필드가 거의 같은데 왜 나눴을까요? 그리고 Controller, Service, Repository는 각각 무엇을 책임질까요?

이 절에서는 이 두 질문의 답을 정리합니다. 규모가 작은 예제에서는 과해 보일 수 있지만, 이 구조는 이후 모든 Chapter의 기본이 됩니다.

객체 셋을 나눈 이유

DTO(Data Transfer Object)는 계층이나 시스템 사이에서 데이터를 주고받는 객체입니다. 이 예제에는 모양이 다른 객체가 있습니다.

요청에서 응답까지 객체는 요청 JSON, CreateUserRequest(id 없음), UserService, User(내부 객체, id 포함), UserResponse.from(user), 응답 JSON 순서로 바뀝니다. 각 단계에서는 “이 계층이 알아야 하는 모양”만 다룹니다. 요청에는 id가 없고, 내부 객체에는 id가 있고, 응답은 밖에 보여 줄 필드만 가집니다.

객체 용도 나눈 이유
CreateUserRequest, UpdateUserRequest, PatchUserRequest 요청 본문 id는 서버가 정하므로 생성 요청에는 없고, 수정 방식마다 필수 필드가 다름
User 저장소가 다루는 내부 객체 저장 방식이 바뀌어도 외부 계약에 영향이 없어야 함
UserResponse 응답 본문 내부 객체를 그대로 노출하지 않고 외부에 보여 줄 필드만 정함
public record UserResponse(long id, String name, String email, int age) {

    public static UserResponse from(User user) {
        return new UserResponse(user.id(), user.name(), user.email(), user.age());
    }
}

지금은 필드가 같아서 중복처럼 보입니다. 하지만 내부 객체에 비밀번호나 내부 상태 같은 필드가 생기는 순간 분리가 필요해집니다. 내부 객체를 그대로 반환하면 그 필드가 JSON으로 새어 나갑니다. 변환 코드(from)를 줄이는 방법은 Chapter 12 MapStruct와 OpenAPI 계약에서 봅니다.

세 계층의 책임

계층 맡는 일 이 예제의 코드
Controller HTTP를 다룸: 요청 본문 변환, 상태 코드, 헤더 ResponseEntity.created(...), noContent()
Service “무엇을 어떻게 바꿀지” 규칙 PATCH에서 값이 있는 필드만 덮어쓰기
Repository 데이터를 보관하고 꺼냄 ConcurrentHashMap 읽기·쓰기

의존 방향은 한쪽입니다. Controller는 Service를, Service는 Repository를 알지만 거꾸로는 모릅니다. 각 계층은 생성자로 다음 계층을 받습니다(Chapter 03의 생성자 주입).

public UserController(UserService service) { this.service = service; }

public UserService(UserRepository repository) { this.repository = repository; }

나누면 좋은 점

  1. 바꾸는 이유가 계층마다 다릅니다. 응답 코드를 바꾸려면 Controller만, PATCH 규칙을 바꾸려면 Service만, 저장 방식을 바꾸려면 Repository만 고칩니다.
  2. 테스트가 쉬워집니다. Service는 HTTP를 모르므로 Spring 없이 new UserService(new UserRepository())로 테스트합니다. 아래 “Service 단독 테스트” 절에서 확인합니다.
  3. 저장소 교체가 쉬워집니다. 메모리 저장소를 데이터베이스로 바꿔도 Service와 Controller는 그대로입니다. 이 구조를 더 엄격하게 만드는 방법(인터페이스와 포트)은 Chapter 15 계층과 Port-Adapter 설계에서 다룹니다.

나누지 않으면 생기는 문제

상황 하나의 객체를 요청·저장·응답에 모두 쓸 때 나누었을 때
요청 본문에 id를 넣어 보냄 클라이언트가 임의의 id를 지정할 수 있음 요청 DTO에 id가 없어 무시됨
내부 객체에 passwordHash 필드 추가 응답 JSON에 그대로 노출될 위험 UserResponse에 필드를 추가하지 않으면 노출되지 않음
저장 방식 변경(메모리 → DB) 요청·응답 모양까지 영향 저장소와 User 안에서만 변경
PUT은 전체, PATCH는 일부 수정 같은 객체로 두 의미를 표현하기 어려움 요청마다 DTO 분리

계층 책임을 어긴 예

잘못된 배치 문제 올바른 위치
Controller에서 PATCH의 “null이 아니면 반영” 규칙 구현 규칙을 테스트하려면 웹 계층이 필요 Service
Service에서 ResponseEntity를 만듦 서비스가 HTTP를 알게 됨 Controller
Repository에서 상태 코드 결정 저장소가 웹에 의존 Controller

직접 해보기: 필드 하나를 추가해 보기

  1. User에 String note 필드를 추가하고 UserService와 UserRepository를 컴파일되게 고쳐 봅니다.
  2. 이때 수정해야 하는 파일이 어디인지 세어 보세요. UserResponse를 고치지 않으면 응답 JSON에는 note가 나타나지 않습니다.
  3. 응답에 보여 주려면 UserResponse의 필드와 from을 고쳐야 합니다. “내부 변경이 자동으로 외부 계약을 바꾸지 않는다”는 점을 확인하는 실험입니다.

자주 하는 실수

실수 증상 해결
규모가 작다며 하나의 객체로 합침 필드가 늘수록 노출·수정 범위 통제가 어려움 요청·내부·응답을 분리
UserResponse.from을 만들고 쓰지 않음 내부 객체가 그대로 응답됨 컨트롤러에서 from을 거치기
서비스가 컨트롤러를 호출 의존 방향이 거꾸로 Controller → Service → Repository 한 방향

확인 문제

  1. Controller가 상태 코드를 정하고 Service가 규칙을 정하는 이유는 무엇인가요?
  2. 필드가 같은 User와 UserResponse를 굳이 따로 두는 이유는 무엇인가요?

답: 1) 바뀌는 이유가 다르기 때문입니다. HTTP 계약이 바뀌면 Controller만, 업무 규칙이 바뀌면 Service만 바꿉니다. 2) 내부 변경이 외부 응답을 의도치 않게 바꾸지 않도록 경계를 두기 위해서입니다.

직접 해 보기

  1. UserResponse에 displayName(이름을 대문자로) 필드를 추가해 보세요. 내부 객체 User와 요청 DTO는 바꾸지 않아도 되는지 확인합니다.
  2. Controller에서 PATCH 규칙을 직접 구현했다면 무엇이 불편해질지 적어 보세요. 테스트를 짜려면 무엇이 필요한가요?
  3. 이 Chapter의 파일을 계층별로 나눠 목록을 만들어 보세요(Controller 1개, Service 1개, Repository 1개, DTO 4개, 내부 객체 1개).

테스트: 흐름 테스트와 Service 단독 테스트

CRUD의 약속(상태 코드, 멱등, 404)은 테스트로 남겨야 오래 갑니다. 이 Chapter는 두 종류의 테스트를 둡니다. 흐름 전체를 MockMvc로 검증하는 API 테스트 8건과, Spring 없이 Service만 검증하는 단위 테스트 3건입니다. 컨텍스트 로딩 테스트 1건을 더해 모두 12건입니다.

흐름 테스트의 준비

@SpringBootTest
@AutoConfigureMockMvc
class UserApiTests {

    private static final String KIM = """
            {"name":"kim","email":"kim@example.com","age":28}""";

    /** 사용자를 만들고 Location 헤더에서 id를 꺼낸다. */
    private long createUser() throws Exception {
        String location = mockMvc.perform(post("/users").contentType(MediaType.APPLICATION_JSON).content(KIM))
                .andExpect(status().isCreated())
                .andReturn().getResponse().getHeader("Location");
        return Long.parseLong(location.substring(location.lastIndexOf('/') + 1));
    }
}

주요 코드 설명

  • """...""": Java의 텍스트 블록입니다. JSON을 문자열로 직접 써서 요청 본문이 실제로 어떻게 생겼는지 그대로 보여 줍니다.
  • contentType(MediaType.APPLICATION_JSON): 요청의 Content-Type 헤더를 JSON으로 지정합니다. 빠지면 415입니다.
  • .content(KIM): 요청 본문을 넣습니다.
  • createUser(): 사용자를 만들고 Location 헤더에서 id를 꺼내는 도우미입니다. 저장소가 테스트 사이에 공유되므로, 각 테스트는 자기가 만든 사용자의 id만 씁니다. 다른 테스트가 만든 데이터에 기대면 실행 순서에 따라 결과가 달라집니다.

대표 테스트 읽기

생성

@Test
void createReturns201WithLocationAndBody() throws Exception {
    mockMvc.perform(post("/users").contentType(MediaType.APPLICATION_JSON).content(KIM))
            .andExpect(status().isCreated())
            .andExpect(header().string("Location", startsWith("/users/")))
            .andExpect(jsonPath("$.name").value("kim"))
            .andExpect(jsonPath("$.id").isNumber());
}

PUT의 멱등

@Test
void putReplacesWholeResourceAndIsIdempotent() throws Exception {
    long id = createUser();
    String body = """
            {"name":"lee","email":"lee@example.com","age":35}""";

    for (int i = 0; i < 2; i++) {
        mockMvc.perform(put("/users/" + id).contentType(MediaType.APPLICATION_JSON).content(body))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("lee"))
                .andExpect(jsonPath("$.age").value(35));
    }
}

같은 PUT을 두 번 보내도 두 번 모두 같은 결과인지 확인합니다. 반복문 안에서 같은 검증이 두 번 통과하는 것이 멱등의 증명입니다.

삭제와 404

@Test
void deleteReturns204ThenNotFound() throws Exception {
    long id = createUser();

    mockMvc.perform(delete("/users/" + id)).andExpect(status().isNoContent());
    mockMvc.perform(get("/users/" + id)).andExpect(status().isNotFound());
    mockMvc.perform(delete("/users/" + id)).andExpect(status().isNotFound());
}

잘못된 요청 본문

@Test
void missingContentTypeReturns415() throws Exception {
    mockMvc.perform(post("/users").content(KIM))
            .andExpect(status().isUnsupportedMediaType());
}

@Test
void malformedJsonReturns400() throws Exception {
    mockMvc.perform(post("/users").contentType(MediaType.APPLICATION_JSON).content("{not json"))
            .andExpect(status().isBadRequest());
}

Content-Type이 없는 요청은 415, 깨진 JSON은 400입니다. 두 테스트는 상태 코드만 확인합니다. 응답 본문은 확인하지 않았습니다.

Service 단독 테스트

/** 서비스는 Spring 없이 저장소만 만들어 넣어 테스트할 수 있다. */
class UserServiceUnitTests {

    private final UserService service = new UserService(new UserRepository());

    @Test
    void patchChangesOnlyProvidedFields() {
        User created = service.create(new CreateUserRequest("kim", "kim@example.com", 28));

        User patched = service.patch(created.id(), new PatchUserRequest(null, null, 29)).orElseThrow();

        assertEquals("kim", patched.name());
        assertEquals("kim@example.com", patched.email());
        assertEquals(29, patched.age());
    }

    @Test
    void updateDoesNotCreateMissingUser() {
        assertTrue(service.update(999, new UpdateUserRequest("x", "x@example.com", 1)).isEmpty());
        assertTrue(service.list().isEmpty());
    }

    @Test
    void deleteTwiceSecondReturnsFalse() {
        User created = service.create(new CreateUserRequest("kim", "kim@example.com", 28));

        assertTrue(service.delete(created.id()));
        assertFalse(service.delete(created.id()));
    }
}

@SpringBootTest가 없습니다. Service가 생성자로 Repository를 받기 때문에 new로 직접 만들 수 있어(Chapter 03의 단위 테스트) 컨텍스트를 띄우지 않아 빠르고, HTTP 없이 규칙만 검증합니다. 각 테스트가 새 Service를 만들므로 서로 영향을 주지 않습니다.

테스트 구성과 결과

테스트 클래스 건수 내용
Ch05ApplicationTests 1 컨텍스트 로딩
UserApiTests 8 생성, 목록, PUT, PATCH, DELETE, 404, 415, 400
UserServiceUnitTests 3 PATCH 규칙, PUT이 새로 만들지 않음, 두 번 삭제
./gradlew :examples:ch05-crud-api:build

12건이 모두 통과했습니다. 더 다양한 테스트 방법은 Chapter 19 단위·슬라이스 테스트에서 다룹니다.

테스트 구조

흐름 테스트는 느리지만 HTTP 계약(상태 코드, 헤더)까지 검증하고, 단위 테스트는 빠르게 업무 규칙만 검증합니다. 둘을 함께 두면 실패했을 때 어느 계층 문제인지 좁히기 쉽습니다.

따라 하기

  1. ./gradlew :examples:ch05-crud-api:test를 실행하고 12건이 통과하는지 확인합니다.
  2. UserService.patch에서 request.age() != null ? ... : current.age()의 조건을 일부러 뒤집어 다시 실행합니다.
  3. 단위 테스트(UserServiceUnitTests)와 흐름 테스트 중 어느 쪽이 실패하는지 확인하고, 원래대로 되돌립니다.

자주 하는 실수

실수 증상 해결
테스트가 저장소 상태를 공유한다는 점을 잊음 순서에 따라 결과가 달라짐 테스트마다 사용자를 새로 만들고 id를 Location에서 꺼내 사용
contentType을 지정하지 않음 415 contentType(MediaType.APPLICATION_JSON)
상태 코드만 확인하고 본문을 확인하지 않음 본문이 틀려도 통과 jsonPath로 핵심 필드 검증

확인 문제

  1. 흐름 테스트에서 저장소 공유로 인한 간섭을 피하려고 이 절은 어떻게 했나요?
  2. PUT의 멱등성은 테스트에서 어떻게 확인하나요?

답: 1) 각 테스트가 자기가 만든 id만 사용합니다. 2) 같은 PUT 요청을 두 번 보내 결과가 같은지 검증합니다.

직접 해 보기

  1. patchChangesOnlyProvidedFields에 name만 바꾸는 케이스를 추가해 age가 그대로인지 검증해 보세요.
  2. createUser() 도우미를 쓰지 않고 다른 테스트가 만든 id 1에 기대는 테스트를 만들어 보세요. 테스트 실행 순서를 바꾸면 왜 불안정해지는지 관찰합니다.
  3. PATCH에 빈 객체 {}를 보내도 200이고 값이 그대로인 테스트를 추가해 보세요.

자주 만나는 오류와 해결 방법

CRUD API의 오류는 요청 본문을 읽는 단계에서 자주 나옵니다. 아래는 이 예제에서 일부러 만든 결과입니다. 한 군데씩 코드를 바꿔 테스트를 돌렸고, 바꾼 코드는 되돌렸습니다.

오류 1: @RequestBody를 빠뜨리면

create(@RequestBody CreateUserRequest request)에서 @RequestBody를 지웠습니다. 서버가 JSON 본문을 읽지 않는 것으로 보입니다. 테스트 12건 중 6건이 실패했습니다.

createReturns201WithLocationAndBody()
Status expected:<201> but was:<400>
missingContentTypeReturns415()
Status expected:<415> but was:<400>

JSON으로 보냈는데 400이 나오고, 심지어 Content-Type이 없는 요청이 원래 기대하던 415 대신 400이 됩니다. 이처럼 상태 코드가 줄줄이 바뀌면 한 곳의 애노테이션 누락을 의심합니다. POST, PUT, PATCH의 본문 객체에는 @RequestBody가 필요합니다. 400이 되는 내부 이유는 확인하지 않았고 테스트가 본 상태 코드만 적었습니다.

오류 2: Content-Type 없이 보내면 415

curl로 POST를 보낼 때 -H "Content-Type: application/json"을 빼면 415(Unsupported Media Type)가 나옵니다. 서버가 본문의 형식을 알 수 없다는 뜻입니다. 위 missingContentTypeReturns415 테스트가 이것을 고정합니다. 요청 헤더를 먼저 확인하세요.

오류 3: 깨진 JSON은 400

{not json 같은 JSON이 아닌 본문은 400입니다. 따옴표 누락, 쉼표 위치 같은 JSON 문법 오류도 같은 증상입니다. curl에서 작은따옴표와 큰따옴표를 바꿔 쓰는 실수가 흔합니다. 응답 본문은 이 Chapter에서 확인하지 않았습니다.

요청이 컨트롤러에 도달하는 과정에서 실패하는 지점

POST /users 요청은 Content-Type이 JSON인지 확인하는 단계(아니면 415)와, @RequestBody가 있고 JSON 문법이 맞는지 확인하는 단계(아니면 400)를 차례로 통과해야 컨트롤러에 도달합니다. 오류 1처럼 @RequestBody가 없으면 본문을 읽지 않아 두 번째 단계에서 걸리고, 그 영향으로 Content-Type이 없는 요청도 415가 아닌 400이 되었습니다.

따라 하기: 세 오류를 curl로 재현

## 415: Content-Type 없음
curl -i -X POST http://localhost:8080/users -d '{"name":"kim","email":"k@e.com","age":28}'
## 400: 깨진 JSON
curl -i -X POST http://localhost:8080/users -H "Content-Type: application/json" -d '{not json'
## 정상
curl -i -X POST http://localhost:8080/users -H "Content-Type: application/json" \
  -d '{"name":"kim","email":"k@e.com","age":28}'

첫 요청은 415, 둘째는 400, 셋째는 201이 나오면 이 절의 설명과 같습니다.

증상별 점검표

증상 가장 먼저 볼 것
JSON을 보냈는데 400, 객체 필드가 null 컨트롤러 파라미터의 @RequestBody
415 (Unsupported Media Type) 요청의 Content-Type: application/json
400 (본문이 JSON이 아님) JSON 문법, 따옴표
404 (Not Found) 경로 변수와 존재하는 id, 이미 삭제된 id인지
PATCH에서 400 요청 DTO 필드가 int 같은 기본형인지(앞의 “PATCH: 보낸 필드만 수정” 절)

직접 해 보기

  1. 복사한 저장소에서 @RequestBody를 지워 위 증상을 재현하세요. 몇 건이 실패하는지 세어 보세요. 확인 후 되돌립니다.
  2. curl에서 Content-Type 헤더를 빼고 POST를 보내 415를 확인하세요.
  3. 오류가 나면 먼저 상태 코드를 점검표에서 찾아 의심할 곳을 한 줄로 적는 습관을 들이세요.

용어와 참고 자료

아래 표는 이 Chapter에 나온 용어와 참고한 사이트를 모은 것입니다. 앞 Chapter에서 설명한 용어는 다시 쓰지 않으므로 Chapter 03 IoC, DI, Bean과 Chapter 04 HTTP와 REST Controller를 참고하세요.

참고한 자료

CRUD와 HTTP

용어 설명
CRUD 데이터를 다루는 네 가지 기본 동작인 생성(Create), 조회(Read), 수정(Update), 삭제(Delete)입니다.
201 Created 자원이 만들어졌다는 응답입니다.
Location 헤더 새로 만든 자원의 주소를 알리는 응답 헤더입니다.
204 No Content 성공했지만 돌려줄 본문이 없다는 응답입니다.
415 Unsupported Media Type 요청 본문의 형식(Content-Type)을 서버가 처리할 수 없을 때의 응답입니다.
멱등 같은 요청을 몇 번 보내도 결과가 한 번 보낸 것과 같은 성질입니다. PUT과 DELETE가 해당합니다.
PUT 자원 전체를 요청 본문으로 교체하는 메서드입니다.
PATCH 자원의 일부 필드만 수정하는 메서드입니다.

코드와 구조

용어 설명
@RequestBody 요청 본문의 JSON을 Java 객체로 바꿔 받습니다.
@PostMapping / @PutMapping / @PatchMapping / @DeleteMapping 각 메서드의 요청을 컨트롤러 메서드에 연결합니다.
DTO Data Transfer Object. 계층이나 시스템 사이에서 데이터를 주고받는 객체입니다.
요청 DTO / 응답 DTO 요청 본문을 받는 객체 / 응답 본문으로 내려가는 객체입니다.
Controller HTTP 요청과 응답을 다루는 계층입니다.
Service 업무 규칙을 담는 계층입니다.
Repository 데이터를 보관하고 꺼내는 계층입니다.
ResponseEntity<Void> 본문이 없는 응답을 표현하는 타입입니다.
flatMap Optional 안의 값을 또 다른 Optional을 돌려주는 함수에 넘길 때 씁니다.
텍스트 블록 """로 여러 줄 문자열을 쓰는 Java 문법입니다.
ConcurrentHashMap 여러 스레드가 동시에 접근해도 안전한 맵입니다.
AtomicLong 쪼개지지 않는 연산으로 숫자를 증가시키는 클래스입니다.

예제 코드 파일

본문에서 다룬 파일은 예제 저장소의 다음 위치에 있습니다.

대상 링크
컨트롤러 UserController.java
생성 요청 DTO CreateUserRequest.java
PUT 요청 DTO UpdateUserRequest.java
PATCH 요청 DTO PatchUserRequest.java
서비스 UserService.java
저장소 UserRepository.java
응답 객체 UserResponse.java
내부 객체 User.java
API 테스트 UserApiTests.java
Service 단위 테스트 UserServiceUnitTests.java

직접 해보기

  1. ./gradlew :examples:ch05-crud-api:bootRun으로 서버를 켜고 “사용자의 생애를 호출 순서대로 따라가기” 절의 순서대로 POST, GET, PUT, PATCH, DELETE를 보내 각 상태 코드(201, 200, 204, 404)와 Location 헤더를 확인해 보세요.
  2. PUT에서 email을 빼고 보낸 결과와 PATCH에 {}를 보낸 결과를 비교해 전체 교체와 부분 수정의 차이를 확인해 보세요.
  3. 요청 본문에 "id":100을 넣어 POST를 보내고, 응답의 id가 서버가 정한 값인 이유를 요청 DTO와 내부 객체 User의 구분으로 설명해 보세요.
  4. User에 note 필드를 추가해도 UserResponse를 고치기 전까지 응답 JSON이 바뀌지 않는 것을 확인하고, 응답에 보이려면 어느 파일을 고쳐야 하는지 적어 보세요.
  5. curl에서 Content-Type 헤더를 빼고 POST를 보내 415를 확인하고, @RequestBody를 지워 ./gradlew :examples:ch05-crud-api:test에서 몇 건이 실패하는지 센 뒤 되돌려 보세요.

이번 장의 정리

  • 생성은 201과 Location, 조회와 수정은 200, 삭제는 204이고, 자원이 없으면 404입니다. 같은 삭제를 두 번 보내면 두 번째는 404입니다.
  • @RequestBody가 요청 본문의 JSON을 DTO로 바꾸고, id는 요청이 아니라 서버가 정합니다.
  • PUT은 모든 필드를 받아 통째로 교체하고 멱등합니다. PATCH는 보낸 필드만 현재 값 위에 덮어쓰므로 요청 DTO의 필드가 Integer처럼 null을 담을 수 있어야 합니다.
  • 저장소 Bean은 모든 요청이 공유하므로 ConcurrentHashMap과 AtomicLong처럼 동시 접근에 안전한 도구를 씁니다.
  • 요청 DTO, 내부 객체, 응답 DTO를 나누고, Controller는 HTTP, Service는 규칙, Repository는 보관을 맡습니다. 의존은 Controller → Service → Repository 한 방향입니다.
  • MockMvc 흐름 테스트와 Spring 없는 Service 단위 테스트를 합쳐 12건으로 계약을 고정했고, @RequestBody 누락은 400, Content-Type 누락은 415로 나타납니다.

지금은 빈 이름이나 음수 나이도 그대로 저장됩니다. 다음 Chapter 06 검증과 예외 처리에서 잘못된 입력을 막고 오류 응답 형식을 통일합니다.

FAQ

자주 묻는 질문

PUT과 PATCH의 가장 큰 차이는 무엇인가요?

PUT은 자원 전체를 주어진 표현으로 교체하는 의미이고 PATCH는 보낸 필드만 부분 변경합니다. 그래서 PATCH DTO는 값이 없는 상태와 기본값을 구분할 수 있어야 합니다.

엔티티를 요청과 응답에 그대로 써도 되나요?

작은 실습에서는 가능하지만 저장 구조가 API 계약에 그대로 노출됩니다. DTO를 분리하면 입력 규칙과 공개 필드를 독립적으로 바꿀 수 있습니다.

생성 응답은 왜 201과 Location 헤더를 사용하나요?

새 자원이 만들어졌음을 201로 알리고 Location에는 생성된 자원을 다시 조회할 URI를 담습니다.

DELETE 성공 때 본문이 없어도 되나요?

삭제 결과로 돌려줄 표현이 없다면 204 No Content가 자연스럽습니다. 이때 응답 본문은 보내지 않습니다.

작성·편집 ToolPado

콘텐츠 유형 Spring Boot 학습 가이드

기술 기준 Spring Boot 4.1.1 · JDK 21

마지막 검토