[Spring] Mapping

 

 

하... 스프링을 하면서 힘든 게 한 두개가 아니다.

일단 프론트엔드 공부해 보면서, 수퍼베이스 연동하여 DB에서 CRUD를 경험한 바 있다. 

그렇기 때문에 프론트도 다 할 수 있는데 백엔드와의 차이가 명확하게 안보여서 힘들었다.

 

프엔 개발하면서 안 보였던 점은, 슈퍼베이스가 백엔드 역할을 대신 맡아준 셈.

=> DB 트랜잭션, 권한 정책, 로깅, 감사 등의 진짜 실행 주체는 서버 쪽이 필요함

 

안일했던 것 같다. 뭔가 기억 저편 너머에 있는 것 같기도 하고.

같은 기능(예: “유저 삭제”)을 React(프론트) vs Spring(백엔드)로 나눠서 보면 차이가 확 선다.

// React 예시
function UserItem({ id }) {
  const handleDelete = async () => {
    await fetch(`/api/users/${id}`, { method: 'DELETE' });
    // 화면에서 제거(리스트 다시 불러오거나, 로컬 상태에서 빼기)
  };

  return <button onClick={handleDelete}>삭제</button>;
}

 

버튼 클릭 시 HTTP 요청 전송하는 코드

불가능한 점: DB에서 진짜로 지우기, 권한 체크, 트랜잭션 처리, 로그 기록 등 

(브라우저 개발자도구로 누구나 직접 요청 보낼 수 있기 때문에, “진짜 삭제”는 서버가 판단/실행해야 함)

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService service;

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

    @DeleteMapping("/{id}")        // ← 매핑: DELETE /api/users/3
    public void delete(@PathVariable Long id,
                       @AuthenticationPrincipal UserPrincipal me) {

        // 1) 인증/권한 체크
        if (!me.isAdmin()) throw new ForbiddenException();

        // 2) 비즈니스 룰(관련 데이터 정리 등)
        service.deleteUser(id);

        // 3) 트랜잭션으로 DB 변경
        // 4) 감사 로그 기록
    }
}

 

• 어떤 URL + HTTP 메서드(DELETE) → 어떤 메서드가 받을지 매핑
• 요청값을 검증/권한체크
• DB 조작, 트랜잭션 관리
• 정확한 응답 코드/바디 반환
• 로그, 모니터링, 예외 처리 등 운영 책임

 

---

매핑

 

 

매핑이란?
- HTTP 요청(주소+메서드+기타 정보)을 어떤 메서드로 보낼지 연결해 두는 규칙.
- 쉽게 말해 라우팅, 길찾기 표지판 역할

 

다음과 같은 매핑이 있다.

• @RequestMapping
• @GetMapping
• @PostMapping
• @PutMapping
• @DeleteMapping
• @PatchMapping

예시 코드를 보며 이해를 하기로 했다.

//내부적으로 @Controller + @ResponseBody가 합쳐진 애너테이션.
//이 클래스는 웹 요청을 처리하는 컨트롤러 + 메서드가 리턴한 걸 그대로 HTTP 응답 바디에 넣음
@RestController 

//이 클래스 안의 모든 메서드 URL 앞에 /users를 붙여라는 공통 경로(prefix)지정.
@RequestMapping("/users")


// 클래스에 @RequestMapping("/users")
// 메서드에 @GetMapping("/{id}")  
// ⇒ 실제 URL: GET http://localhost:8080/users/10


// 컨트롤러는 결국 클래스로 만들어야 함.(메서드를 담을 그릇이 필요)
public class UserController{ 

	//1) 조회: GET
	@GetMapping("{/id}") //GET/user/10
	public UserDto getUser(@PathVariable Long id){
	// @PathVariable 로 URL의 {id} 값을 매핑
		return service.findById(id);	
	}

	//2) 생성: POST
	@PostMapping( // POST /users
    		// 요청 바디 타입 제한(선택)
		consumes = "application/json",
      	 	 // 응답 타입 제한(선택)
		produces = "application/json" 
	)

	//3) PUT: 전체 수정(치환)
	@PutMapping("/{id}") //PUT/users/10
	public UserDto replace(@PathVariable Long id, @RequestBody UpdateUserReq req
	){
		return service.replace(id, req);
	}

	//4) PATCH: 부분수정
	@PathMapping("/{id}") //PATCH/users/10
	public UserDto patch(@PathVariable Long id, @RequestBody Map<String, Object> fields){
		return service.prtialUpdate(id, fields);
	}

	//5) DELETE: 삭제
	@DeleteMapping("/{id}") //DELETE/users/10
	public void delete(@PathVariable Long id){
		service.delete(id);
	}

}

 

실제 주소는 아래와 같다

실제 URL = 서버주소(http://localhost:8080) + 클래스 prefix(/users) + 메서드 경로("/{id}" 같은 것)

 

 

문법만 놓고 보면

@RestController
@RequestMapping("/users")  // 공통 prefix
public class UserController {

    // 1) 조회(Read, 단건)
    @GetMapping("/{id}")                     // GET /users/{id}
    public UserDto getUser(@PathVariable Long id) { ... }

    // 2) 생성(Create)
    @PostMapping(                            // POST /users
        consumes = "application/json",
        produces = "application/json"
    )
    public UserDto create(@RequestBody CreateUserReq req) { ... }

    // 3) 전체 수정(Replace)
    @PutMapping("/{id}")                     // PUT /users/{id}
    public UserDto replace(@PathVariable Long id,
                           @RequestBody UpdateUserReq req) { ... }

    // 4) 부분 수정(Patch)
    @PatchMapping("/{id}")                   // PATCH /users/{id}
    public UserDto patch(@PathVariable Long id,
                         @RequestBody Map<String, Object> fields) { ... }

    // 5) 삭제(Delete)
    @DeleteMapping("/{id}")                  // DELETE /users/{id}
    public void delete(@PathVariable Long id) { ... }
}

 

 

*컨트롤러 = 클래스(그릇).
솔직히 *컨트롤러만 있어도 돌아가긴 한다. 그러나 실무에서는 보통

Controller → Service → Repository(DB)로 나누고 DTO 로 요청/응답 형식을 분리한다.

 

굳이 나누는 이유는

 

• Controller: HTTP처리(매핑, 파라미터 바인딩, 상태코드 등)만 
• Service: 비즈니스 로직(계산, 정책, 트랜잭션)
• Repository: DB접근
• DTO: HTTP용 데이터 포맷(필드명, 검증)과 내부 도메인을 분리

=> 안 나누면 컨트롤러 안에 로직/DB코드 다 때려넣어서 금방 지옥 됨

 

나머지 예시코드도 같이 다뤄보겠다

Service

// src/main/java/com/example/demo/user/UserService.java
package com.example.demo.user;

import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.atomic.AtomicLong;

@Service
public class UserService {
 // 메모리를 간이 DB처럼 사용하기 위한 Map (key: id, value: UserDto)
    private final Map<Long, UserDto> store = new HashMap<>();
    // ID를 1씩 증가시키며 발급하기 위한 쓰레드 안전한 카운터
    private final AtomicLong seq = new AtomicLong(1);

  	// 단건 조회: id로 store에서 찾아 반환
    public UserDto findById(Long id) {
        return store.get(id);
    }

	// 전체 조회: store의 값들만 뽑아서 List로 반환
    public List<UserDto> findAll() {
        return new ArrayList<>(store.values());
    }

    // 생성: 새 ID 발급 → DTO 만들고 → store에 저장 → 저장된 DTO 반환
    public UserDto create(CreateUserReq req) {
        Long id = seq.getAndIncrement();// 현재 값 반환 후 +1
         // 요청 바디를 기반으로 DTO 생성
        UserDto dto = new UserDto(id, req.name(), req.email());
        store.put(id, dto);// 메모리 저장
        return dto;
    }

    // 전체 수정(치환): 들어온 값으로 통째로 덮어쓰기
    public UserDto replace(Long id, UpdateUserReq req) {
        UserDto dto = new UserDto(id, req.name(), req.email());
        store.put(id, dto);// 해당 id에 덮어씀(없으면 새로 들어감)
        return dto;
    }

    // 부분 수정: 전달된 fields(Map)에 있는 값만 기존 값에서 바꿔치기
    public UserDto partialUpdate(Long id, Map<String, Object> fields) {
        UserDto old = store.get(id);// 기존 데이터 조회
        if (old == null) return null;// 없으면 null (실무에선 예외 던짐)

        // 새 값 있으면 새 값, 없으면 기존 값
        String name  = (String) fields.getOrDefault("name",  old.name());
        String email = (String) fields.getOrDefault("email", old.email());

        UserDto updated = new UserDto(id, name, email);// 수정된 DTO 생성
        store.put(id, updated); // 저장소에 갱신
        return updated;
    }

    // 삭제: id로 store에서 제거
    public void delete(Long id) {
        store.remove(id);
    }
}

 

dto

 

// src/main/java/com/example/demo/user/dto들.java
package com.example.demo.user;

// Java 17 record 예시 (간단 DTO)
public record UserDto(Long id, String name, String email) {}

public record CreateUserReq(String name, String email) {}

public record UpdateUserReq(String name, String email) {}

 

 

포스트맨으로 확인 시

 

GET http://localhost:8080/users

POST http://localhost:8080/users (JSON 바디)

GET http://localhost:8080/users/1

PUT http://localhost:8080/users/1

PATCH http://localhost:8080/users/1

DELETE http://localhost:8080/users/1

HTTP 한 방에 처리 흐름

[브라우저/React] ──HTTP요청──>[Controller]─>[Service]─>[Repository/DB]
                                   │          │                │
                          (요청/응답 처리) (비즈니스 로직)(데이터 저장/조회)
                                   │
                               [DTO 변환]
                                   │
                             HTTP 응답(JSON 등)

 

 

 

 

 

 

다 필요 없고 일단 아래 코드만 기억해야겠다

@RestController
@RequestMapping("/리소스")
public class FooController {

    private final FooService service;
    public FooController(FooService service){ this.service = service; }

    @GetMapping("/{id}")
    public FooDto get(@PathVariable Long id){ return service.get(id); }

    @PostMapping // 새로만들기라 id가 없음
    public FooDto create(@RequestBody CreateFooReq req){ return service.create(req); }

    @PutMapping("/{id}")
    public FooDto replace(@PathVariable Long id, @RequestBody UpdateFooReq req){ return service.replace(id, req); }

    @PatchMapping("/{id}")
    public FooDto patch(@PathVariable Long id, @RequestBody Map<String,Object> fields){ return service.patch(id, fields); }

    @DeleteMapping("/{id}")
    public void delete(@PathVariable Long id){ service.delete(id); }
}