Github 소스코드

🔎 이런거 해볼 거에요.

• HTTP 요청 header 파싱
• HTTP 요청 body 파싱
  • 요청 파라미터로 데이터가 전달되는 경우 (GET, POST)
  • 요청 파라미터로 데이터가 전달되는 경우 객체로 받는 경우 (GET, POST)
  • HTTP body에 String(text)이 전달되는 경우
  • HTTP body에 Json형태 값이 전달되는 경우
  • 요청받은 데이터를 객체로 받는 경우

---

HTTP 요청 Header 파싱

• @Slf4j (Lombok) : Logger를 사용하기 위함
• @RestController : 리턴되는 값을 HTTP응답의 body로 사용하기 위함
• 테스트를 위해 Postman 사용

@Slf4j
@RestController
public class RequestHeaderController {

    @GetMapping(value = "/headers")
    public String headers(
            HttpServletRequest request,
            HttpServletResponse response,
            HttpMethod httpMethod,
            Locale locale, 
            @RequestHeader MultiValueMap<String, String> headerMap,                
            @RequestHeader("host") String host, 
            @CookieValue(value="myCookie", required = false) String cookie
            ) {
        log.info("request={}", request);
        log.info("response={}", response);
        log.info("httpMethod={}", httpMethod);
        log.info("locale={}", locale);
        log.info("headerMap={}", headerMap);
        log.info("header host={}", host);
        log.info("myCookie={}", cookie);

        return "ok";
    }
}

• Postman을 이용한 API 호출
  

• 호출 후 Console의 Log
  

• HttpMethod

  • 요청의 HTTP Method 확인 (GET, POST, DELETE, FETCH ... )

• Locale

  • 언어정보 확인

• @RequestHeader MultiValueMap<String, String>

  • 요청된 헤더의 모든 정보
  • (MultiValueMap: 같은 Key값에 대해 중복된 Value를 갖을 수 있는 Map)

• @RequestHeader("host") String host

  • 확인하고자 하는 헤더의 속성 지정

• @CookieValue(value="myCookie", required = false) String cookie

  • Cookie 값 확인
  • Cookie값 확인 테스트를 위한 매핑 추가

    • @GetMapping("/add-cookie")
      public String addCookie(HttpServletRequest request, HttpServletResponse response) {
          Cookie cookie = new Cookie("myCookie", "myCookieValue");
          response.addCookie(cookie);
          return "ok";
      }

  • /add-cookie로 GET요청 후 /headers로 재요청 결과
    • 

---

요청 파라미터 GET, POST

GET 방식으로 쿼리 파라미터를 통해 전달되는 값을 얻어오는 것과
POST 방식으로 폼을 통해 전달되는 데이터를 얻어오는 방법입니다.

• 요청 파라미터의 경우 어떤 방식이든 얻어오는 방법은 같습니다. 이유는 GET 방식이든 POST 방식이든 전달되는 형식이 같기 때문입니다.
• GET 방식의 쿼리 파라미터의 경우 username에 kim을 age에 10을 전달하는 경우
  • localhost:8080/request?username=kim&age=10
• POST 방식의 쿼리 파라미터의 경우 username에 kim을 age에 10을 전달하는 경우
  • POST의 경우 username=kim&age=10이 부분을 그대로 body에 넣어 전달합니다.
• 결국 데이터가 담긴 위치? 가 다른 것 뿐이지 형태는 같습니다.

방법 1 (@RequestParam)

• @RequestParam("username") Sring username

  • username을 key값으로 하는 데이터를 String 타입으로 받습니다.

• @RequestParam("age") int age

  • age를 key값으로 하는 데이터를 int 타입으로 받습니다.

• Postman을 이용해 localhost:8080/request-param-v2?username=kim&age=10를 호출한 결과

  • 

  🚀 이후 모든 방식의 Log결과는 동일하기 때문에 결과 확인은 생략하겠습니다. ㅎ

    @ResponseBody 
    @RequestMapping("/request-param-v2")
    public String requestParamV2(@RequestParam("username") String username, @RequestParam("age") int age) {
        log.info("username = {}", username);
        log.info("age = {}", age);

        return "ok";
    }

방법 2 (@RequestParam key값 생략)

• @RequestParam의 key값을 생략하는 방식입니다.
• 파라미터명을 key값으로 이용하는 방식이므로 파라미터명과 요청 파라미터의 명을 일치시켜줘야 합니다.
• 이 방식이 조금 더 보기 좋네요.

    @ResponseBody
    @RequestMapping("/request-param-v3")
    public String requestParamV3(@RequestParam String username, @RequestParam int age) {
        log.info("username = {}", username);
        log.info("age = {}", age);

        return "ok";
    }

방법 3 (@RequestParam Required)

• Required 속성을 추가합니다. default는 true 입니다.
• false로 설정시 주의해야 할 사항이 있습니다.
  • primitive 타입 사용에 유의해야 합니다. primitive 타입은 int, boolean, double, long 등의 기본적으로 제공되는 타입을 의미합니다.
  • primitive 타입의 파라미터를 false로 설정시 null 값을 처리하지 못하고 5xx 서버측 에러코드를 리턴합니다.
  • primitive 타입에 Required false 설정시 클라이언트측 validation, 서버측 validation, Integer, Double 등 Wrapper 클래스 사용 혹은 @RequestParam의 defaultValue 를 사용합니다.

    @ResponseBody
    @RequestMapping("/request-param-required")
    public String requestParamRequired(
            @RequestParam(required = true) String username,
            @RequestParam(required = false) int age) {
        log.info("username = {}", username);
        log.info("age = {}", age);

        return "ok";
    }

---

요청 파라미터로 데이터가 전달되는 경우 객체로 받는 경우 (GET, POST)

GET방식의 Query-parameter , POST방식의 폼 데이터를 Object로 받는 방법입니다.

방법 1 ( @ModelAttribute + Object )

• 사용된 객체 UserDto 클래스 입니다.

@Data
public class UserDto {

    private String username;
    private int age;
}

• @ModelAttribute 는 전달된 요청 파라미터의 key값을 객체의 필드명과 매핑하여 해당 필드의 setter를 호출하여 값을 바인딩합니다.
• @ModelAttribute 는 값을 매핑하여 세팅해주는 것 뿐만 아니라 View단으로 값을 넘길 때 사용하는 Model에 값을 세팅해줍니다. 이후에 자세히 알아보겠습니다.

@RequestMapping("/model-attribute-v1")
public String modelAttributeV1(@ModelAttribute UserDto userDto) {
    log.info("username = {}", userDto.getUsername());
    log.info("age = {}", userDto.getAge());

    return "ok";
}

방법 2 ( @ModelAttribute 생략 )

• @ModelAttribute 는 생략 가능합니다. 단, Object인 경우에만 묵시적으로 @ModelAttribute가 붙습니다.
• primitive타입의 경우 @RequestParam이 붙게 됩니다.

@RequestMapping("/model-attribute-v2")
public String modelAttributeV2(UserDto userDto) {
     log.info("username = {}", userDto.getUsername());
     log.info("age = {}", userDto.getAge());

     return "ok";
}

---

HTTP body에 String(text)이 전달되는 경우

POST 방식으로 Http Body에 row데이터로 text가 전달되는 경우의 데이터 파싱 방법입니다.

방법 1 ( HttpEntity )

• HttpEntity 를 통해 Http 메시지에 직접 접근하여 body 메시지를 파싱합니다.
• HttpEntity는 body 정보 뿐만 아니라 header정보까지 파싱 가능합니다. Http messgae에 직접 접근하기 때문이지요 😁

   @PostMapping("/request-body-string-v3")
    public HttpEntity<String> requestBodyStringV3(HttpEntity<String> httpEntity) throws IOException {
        String str = httpEntity.getBody();
        log.info("body string = {}", str);

        return new HttpEntity<>("ok");
    }

방법 2 ( RequestEntity )

• HttpEntity 를 상속하는 RequestEntity를 사용하는 방법입니다.
• HttpEntity와 거의 기능이 같지만 RequestEntity 는 부가적인 기능을 제공합니다. (url 정보 등 ...)
• ResponseEntity 또한 HttpEntity를 상속하는 클래스로 거의 같은 기능이고 부가적인 기능을 제공합니다.

    @PostMapping("/request-body-string-v4")
    public ResponseEntity<String> requestBodyStringV4(RequestEntity<String> requestEntity) throws IOException {
        String str = requestEntity.getBody();

        log.info("body string = {}", str);
        log.info("request url = {}", requestEntity.getUrl());

        return new ResponseEntity<String>("ok", HttpStatus.OK);
    }

방법 3 ( RequestBody )

• 가장 간단한 방법입니다. ( 권 장 👍)
• @RequestBody 를 이용하여 Http message의 body부분을 바로 받아올 수 있습니다.

    @ResponseBody
    @PostMapping("/request-body-string-v5")
    public String requestBodyStringV5(@RequestBody String str) {

        log.info("body string = {}", str);

        return "ok";
    }

---

HTTP body에 Json형태 값이 전달되는 경우

• POST 방식으로 body에 Json 타입으로 데이터가 전송되는 경우 파싱 방법입니다.
• {"username":"kim", "age":10} 이런식으로 전달되는 형태입니다.

방법 1 ( @RequestBody + String + ObjectMapper)

• String타입 데이터를 Object로 변환하기 위해 ObjectMapper객체를 생성합니다.
• @RequestBody를 이용해 String으로 Json타입 body데이터를 받게 되면 {"username":"kim", "age":10} 이런 Json모양의 데이터가 그대로 String으로 들어오게 됩니다.
  • log.info("ObjectMapper 이전 bodyString = {}", bodyString); 그대로 로그를 찍은 결과입니다.
  • 
• 이런 Json형태의 String 데이터를 ObjectMapper의 readValue메서드를 이용해 객체로 변환합니다.
• ❗️ @RequestBody 사용시 주의
  • @RequestBody는 생략 불가합니다.
  • 생략시 객체의 경우 @ModelAttribute가 primitive타입의 경우 @RequestParam이 기본으로 들어가게 됩니다.

private ObjectMapper objectMapper = new ObjectMapper();

@ResponseBody
@PostMapping("/request-body-json-v3")
public String requestBodyJsonV3(@RequestBody String bodyString) throws JsonProcessingException {

    UserDto userDto = objectMapper.readValue(bodyString, UserDto.class);

    log.info("username = {}", userDto.getUsername());
    log.info("age = {}", userDto.getAge());

    return "ok";
}

방법 2 ( @RequestBody + Object )

• 이전에는 @RequestBody로 String타입을 받았지만 이번엔 Object로 받았습니다.
• 이렇게 하면 따로 객체로 변환하는 과정이 필요 없습니다. 따라서 ObjectMapper를 사용하지 않아도 되지요.
• 굉장히 간단하므로 권장되는 방법입니다. 👍

@ResponseBody
@PostMapping("/request-body-json-v4")
public String requestBodyJsonV4(@RequestBody UserDto userDto) {
    log.info("username = {}", userDto.getUsername());
    log.info("age = {}", userDto.getAge());

    return "ok";
}

방법 3 ( RequestEntity )

• RequestEntity를 이용해 Http 요청 자체를 받아들이는 방법입니다.
• 이 방법의 경우 body 데이터 뿐만 아니라 Http요청의 헤더, url 등의 정보를 추가적으로 얻을 수 있습니다.
• RequestEntity를 사용했으므로 리턴도 ResponseEntity를 사용했습니다. String을 리턴해도 상관 없습니다.

@ResponseBody
@PostMapping("/request-body-json-v5")
public ResponseEntity<String> requestBodyJsonV5(RequestEntity<UserDto> requestEntity) {
    log.info("username = {}", requestEntity.getBody().getUsername());
    log.info("age = {}", requestEntity.getBody().getAge());
        
    return new ResponseEntity<>("ok", HttpStatus.OK);
    }