Spring MVC - 요청 & 응답

import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; @Controller @RequestMapping("/board") public class BoardController { // 이 메서드는 "/board"와 연결된 경로의 하위 경로에 따라 매핑됩니다. @RequestMapping("/list") public String list() { // 게시판 목록을 보여주는 로직을 수행 return "board/list"; } }

import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; @Controller public class BoardController { @RequestMapping("/board/list") public String list() { // 게시판 목록을 보여주는 로직을 수행 return "board/list"; } }

@RequestMapping("/경로/{변수}") public String test(@PathVariable("변수명") String 파라미터명) { return "/site/test"; }

import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; @Controller @RequestMapping("/board") public class BoardController { // "/board/read/{id}" 경로와 연결 @RequestMapping("/read/{id}") public String read(@PathVariable("id") int id) { // id 변수를 사용하여 게시물을 조회하는 로직을 수행 // 예를 들어, id에 해당하는 게시물을 데이터베이스에서 가져와서 화면에 표시 return "/board/read"; } }

/* RequestMethod 열거타입 - RequestMethod.GET - RequestMethod.POST - RequestMethod.PUT - RequestMethod.DELETE */ @RequestMapping(value = "/경로", method = RequestMethod.메소드방식) public String insert(Board board) { return "/board/insert"; }

import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; @Controller @RequestMapping("/board") public class BoardController { @RequestMapping(value = "/insert", method = RequestMethod.GET) public String insert() { return "/board/insert"; } @RequestMapping(value = "/insert", method = RequestMethod.POST) public String insertPro(Board board, Model model) { return "redirect:/board/list"; } }

@RequestMapping(value = "/경로", method = RequestMethod.메소드방식, params="파라미터명") public String read() { return "/board/read"; }

import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; @Controller @RequestMapping("/board") public class BoardController { @RequestMapping(value = "/read", method = RequestMethod.GET, params="boardNo") public String read(Model model, @RequestParam("boardNo") int boardNo) { return "board/read"; } }

@RequestMapping(value = "/경로", headers="헤더명=헤더값") public String updatePro() { return "redirect:/board/list"; }

X-HTTP-Method-Override=PUT X-HTTP-Method-Override=DELETE

<filter> <filter-name>httpMethodFilter</filter-name> <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class> </filter> <filter-mapping> <filter-name>httpMethodFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>

<h3>PUT 요청</h3> <form action="<%= request.getContextPath() %>/request/board" method="post"> <!-- form 태그에서는 PUT 방식 요청을 지원하지 않는다. --> <!-- Spring 의 HiddenMethodFilter 를 등록하면, 우회적으로 PUT 요청을 할 수 있다. --> <!-- _method 를 X-HTTP-Method-Override 헤더로 지정한다. --> <!-- X-HTTP-Method-Override 헤더 - 값 : PUT --> <input type="hidden" name="_method" value="PUT" /> <input type="text" name="no" placeholder="번호 입력" /> <input type="submit" value="수정" /> </form>

import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestHeader; @Controller @RequestMapping("/board") public class BoardController { @RequestMapping(value = "/update", method = RequestMethod.POST, headers = "X-HTTP-Method-Override=PUT") public String updatePro() { return "redirect:/board/list"; // board/list.jsp 로 리다이렉트 } }

@RequestMapping(value = "/경로", consumes="컨텐츠타입") public String insertPro() { return "redirect:/board/list"; }

@RequestMapping(value = "/경로", produces="응답컨텐츠타입") public ResponseEntity<List<Board>> listJSON() { List<Board> boardList = boardService.list(); return new ResponseEntity<List<Board>>(boardList, HttpStatus.OK);; }

<!-- JSON 데이터 바인딩을 위한 라이브러리 --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.15.2</version> </dependency>

<!-- XML 데이터 바인딩을 위한 라이브러리 --> <dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson-dataformat-xml</artifactId> <version>2.15.2</version> </dependency>

@RequestMapping(value = "/board/list", produces="application/json") public ResponseEntity<List<Board>> listJSON() { List<Board> boardList = boardService.list(); return new ResponseEntity<List<Board>>(boardList, HttpStatus.OK); }

@RequestMapping(value = "/board/list", produces="application/xml") public ResponseEntity<List<Board>> listXML() { List<Board> boardList = boardService.list(); return new ResponseEntity<List<Board>>(boardList, HttpStatus.OK); }

model.addAttribute("속성명", 값); //

${속성명}

${속성명.변수}

model.addAttribute(객체명);

${객체명}

/** * 요청 경로 : /model/person * @param model * @param person * @return * * 컨트롤러 메소드에서 매개변수에 객체를 지정하면, * * 자동 객체 생성 : 해당 객체를 스프링에서 자동으로 생성해서 주입해준다. * * 자동 바인딩 : 요청 파라미터 값을 객체의 변수에 자동으로 매핑해준다. * ex) /model/person?name=ALOHA&age=20 * Person.name <---- "ALOHA" * Person.age <---- 20 */ @RequestMapping("/model/person") // method: GET(기본값) public String person(Model model, Person person) { // Model 인터페이스의 addAttribute() 메소드로 데이터를 등록하여, 뷰에 전달한다. // Model // : 컨트롤러에서 등록한 데이터를 뷰에 전달하는 인터페이스 // Person person = new Person(); // person.setName("김조은"); // person.setAge(20); // addAttribute("변수명", 객체) 메소드로 모델에 객체를 등록한다. // model.addAttribute("person", person); model.addAttribute(person); // 변수명을 생략하면 객체명과 일치하는 이름으로 접근할 수 있다. // view 에서 ${} (표현언어) 로 사용할 수 있다. // ${person.name}, ${person.age} // getter 메소드가 정의되어 있어야 위와같이 뷰에서 접근할 수 있다. return "model/person"; // view : model/person.jsp }

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>/model/person</title> </head> <body> <h1>이름 : ${person.name}</h1> <h1>나이 : ${person.age}</h1> <hr> <form action="${ pageContext.request.contextPath }/model/person" method="POST"> <input type="text" name="name" value="${person.name}" /> <br> <input type="text" name="age" value="${person.age}" /> <br> <input type="submit" value="등록" /> </form> </body> </html>

/** * 요청 경로 : /model/person2?name=김조은&age=20 * * 요청 파라미터의 변수명들을 객체의 필드(멤버변수)로 자동으로 매핑해준다. * @param person * @return */ @RequestMapping("/model/person2") public String person2(@ModelAttribute Person person) { // @ModelAttribute : 매개변수를 모델에 자동으로 등록해주는 어노테이션 // model.addAttribute("person", person); return "model/person"; // view : model/person.jsp }

/** * 요청 경로 : /model/person * method : POST * * @param person * @return */ @RequestMapping(value = "/model/person", method = RequestMethod.POST) public String personPost( Model model , @RequestParam("name") String personName , @RequestParam("age") int personAge ) { // @RequestParam("요청파라미터명") 데이터타입 메소드매개변수명 // : 요청 매개변수(parameter)를 메소드의 매개변수로 바인딩하는 어노테이션 // * 요청파라미터명 = 메소드매개변수명 일치하면, 생략가능 Person person = new Person(); person.setName(personName); person.setAge(personAge); // forward 방식으로 페이지 이동 시, 모델에 데이터 사용가능 model.addAttribute(person); return "model/person"; // view : model/person.jsp }

/** * 요청 경로 : /model/person * method : POST * * @param person * @return */ @RequestMapping(value = "/person", method = RequestMethod.POST) public String personPost(Model model, Person person, RedirectAttributes rttr) { // RedirectAttributes 인터페이스 // : 리다이렉트 방식으로 페이지 이동 시, 일회성으로 데이터를 전달하는 인터페이스 // forward 방식으로 페이지 이동 시, 모델에 데이터 사용가능 model.addAttribute(person); // redirect 방식으로 페이지 이동 시, // RedirectAttributes 인터페이스를 통해서 일회성으로 데이터 전달 가능 rttr.addFlashAttribute("person", person); // 리다이렉트 : redirect:요청경로 // * 최초 요청 객체는 사라진다. return "redirect:/model/person"; // view : model/person.jsp }

@Controller //@RequestMapping("/response") public class ResponseController { private static final Logger logger = LoggerFactory.getLogger(ResponseController.class); @Autowired private BoardService boardService; // (나머지 코드는 아래 코드블럭 하나씨 }

/** * 요청 경로 : /response/index * 응답 : /response/index.jsp */ @RequestMapping("/response/index") public void response() { logger.info("void 타입 - /response/index"); logger.info("/response/index.jsp 뷰를 응답"); }

/** * 요청 경로 : /response/view * 응답 : /response/index.jsp * @return */ @RequestMapping("/response/view") public String responseView() { logger.info("String 타입 - /response/index"); logger.info("/response/index.jsp 뷰를 응답"); logger.info("view 이름을 반환값으로 지정"); return "response/index"; }

/** * 요청 경로 : /response/model/view * 응답 : /response/index.jsp * @return */ @RequestMapping("/response/model/view") public ModelAndView responseModeAndView() { // ModelAndView // 뷰와 모델 데이터를 지정하여 함께 반환 처리할 수 있는 스프링프레임워크 클래스 logger.info("ModelAndView 타입 - /response/model/view"); logger.info("/response/index.jsp 뷰를 응답"); logger.info("모델과 뷰를 ModelAndView 객체에 지정하여 응답"); ModelAndView mv = new ModelAndView(); // 뷰이름 지정 mv.setViewName("/response/index"); // view : /response/index.jsp // 모델 등록 Board board = new Board("제목","작성자","내용"); mv.addObject("board", board); mv.addObject("message", "ModelAndView 컨트롤러 응답..."); // model : board, message return mv; }

/** * 요청 경로 : /response/data/board * 응답 : board (JSON/XML) * @ResponseBody : 응답하는 데이터를 응답 메시지의 body(본문) 에 지정하는 어노테이션 * @return */ @ResponseBody @RequestMapping("/response/data/board") public Board responseBoard() { Board board = new Board("제목","작성자","내용"); return board; }

text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7

/** * 브라우저에서 Accept 헤더의 값이 우선순위 * - text/html * - application/xhtml+xml * - application/xml * - ... * @return * @throws Exception */ @ResponseBody // @RequestMapping("/response/data/board/list") @RequestMapping(value = "/response/data/board/list", produces = "application/json") public List<Board> responseBoardList() throws Exception { // produces = "application/json" // - Accept:application/xml 으로 요청이 와도, json 으로 응답할 수 있다. List<Board> boardList = boardService.list(); return boardList; }

@ResponseBody // @RequestMapping(value = "/resopnse/data/map") @RequestMapping(value = "/response/data/map", produces = "application/json") public Map<String, Board> responseMap() throws Exception { Map<String, Board> map = new HashMap<String, Board>(); map.put("board1", new Board("b1", "제목1","작성자1","내용1")); map.put("board2", new Board("b2", "제목2","작성자2","내용2")); map.put("board3", new Board("b3", "제목3","작성자3","내용3")); return map; }

@ResponseBody @RequestMapping("/response/data/entity/void") public ResponseEntity<Void> responseEntityVoid() { // ResponseEntity // : 스프링 프레임워크에서 응답 헤더,본문,상태코드 등을 캡슐화하는 객체 // ResponseEntity<Void> // : 헤더정보, 상태코드를 지정하여 사용할 수 있다. // HttpStatus 열거타입 // : 상태코드를 가지고 있는 스프링프레임웤의 열거타입 // - OK : 200 // - NOT_FOUND : 404 // - INTERNAL_SERVER_ERROR : 500 return new ResponseEntity<Void>(HttpStatus.OK); }

@ResponseBody @RequestMapping("/response/data/entity/string") public ResponseEntity<String> responseEntityString() { // new ResponseEntity<반환타입>(응답메시지, 상태코드); return new ResponseEntity<String>("SUCCESS", HttpStatus.OK); }

@ResponseBody @RequestMapping("/response/data/entity/board") public ResponseEntity<Board> responseEntityBoard() { Board board = new Board("b01","제목","작성자","내용"); return new ResponseEntity<Board>(board, HttpStatus.OK); }

@ResponseBody @RequestMapping("/response/data/entity/board/list") public ResponseEntity<List<Board>> responseEntityBoardList() throws Exception { List<Board> boardList = boardService.list(); // return new ResponseEntity<>(boardList, HttpStatus.OK); // <> 생략가능 return new ResponseEntity<List<Board>>(boardList, HttpStatus.OK); }

@ResponseBody @RequestMapping("/response/data/entity/map") public ResponseEntity<Map<String, Board>> responseEntityBoardMap() throws Exception { List<Board> boardList = boardService.list(); Map<String, Board> map = new HashMap<String, Board>(); int i = 1; for (Board board : boardList) { map.put("board" + i++, board); } return new ResponseEntity<>(map, HttpStatus.OK); }

/** * 파일 다운로드 * * @return * @throws Exception */ @ResponseBody @RequestMapping("/response/data/file") public ResponseEntity<byte[]> responseFile(HttpServletRequest request) throws Exception { String path = request.getSession().getServletContext().getRealPath("/WEB-INF/upload/test.png"); logger.info("path : " + path); // 파일 경로 // String filePath = "E:\\TJE\\UPLOAD\\test.jpg"; String filePath = request.getSession().getServletContext().getRealPath("/WEB-INF/upload/test.png"); String fileName = "test.png"; // 헤더정보 HttpHeaders headers = new HttpHeaders(); headers.setContentType( MediaType.IMAGE_JPEG ); // 이미지로 응답 // headers.setContentType( MediaType.APPLICATION_OCTET_STREAM); // 일반 프로그램 응답 // headers.add("헤더명", "값") // Content-Disposition // - inline : 웹페이지에서 출력(기본값) // - attachment : 첨부파일 (다운로드) headers.add("Content-Disposition", "attachment; filename=" + fileName); // 다운로드 여부, 파일명 지정 byte[] fileData = null; try { FileInputStream fis = new FileInputStream(filePath); // commons-io 라이브러리 // toByteArray() : 파일을 바이트코드로 변환 fileData = IOUtils.toByteArray(fis); } catch (Exception e) { // TODO: handle exception } // new ResponseEntity<반환타입>(응답메시지, 헤더,상태코드); return new ResponseEntity<byte[]>(fileData, headers, HttpStatus.OK); }

/** * 요청 헤더 가져오기 * @return * * @RequestHeader("헤더명") 타입 변수명 */ @ResponseBody @RequestMapping(value = "/header", method = RequestMethod.GET) public String header(@RequestHeader("Accept") String accept ,@RequestHeader("User-Agent") String userAgent ,HttpServletRequest request) { // @RequestHeader 를 통한 헤더 정보 가져오기 logger.info("[GET] - /request/header"); logger.info("@RequestHeader 를 통한 헤더 정보 가져오기"); logger.info("Accept - " + accept); logger.info("User-Agent - " + userAgent); // request 객체로부터 헤더 가져오기 String requestAccept = request.getHeader("Accept"); String requestUserAgent = request.getHeader("User-Agent"); logger.info("request 객체로부터 헤더 가져오기"); logger.info("Accept - " + requestAccept); logger.info("User-Agent - " + requestUserAgent); return "SUCCESS"; }

@Controller // Controller 지정하고 빈 등록 @RequestMapping("/request") // [클래스 레벨 요청경로 매핑] "/request" 요청 경로로 매핑 public class RequestController { // log 객체 private static final Logger logger = LoggerFactory.getLogger(RequestController.class); }

/** * 요청 헤더 가져오기 * @return * * @RequestHeader("헤더명") 타입 변수명 */ @ResponseBody @RequestMapping(value = "/header", method = RequestMethod.GET) public String header(@RequestHeader("Accept") String accept ,@RequestHeader("User-Agent") String userAgent ,HttpServletRequest request) { // @RequestHeader 를 통한 헤더 정보 가져오기 logger.info("[GET] - /request/header"); logger.info("@RequestHeader 를 통한 헤더 정보 가져오기"); logger.info("Accept - " + accept); logger.info("User-Agent - " + userAgent); // request 객체로부터 헤더 가져오기 String requestAccept = request.getHeader("Accept"); String requestUserAgent = request.getHeader("User-Agent"); logger.info("request 객체로부터 헤더 가져오기"); logger.info("Accept - " + requestAccept); logger.info("User-Agent - " + requestUserAgent); return "SUCCESS"; }

/** * 요청 본문 가져오기 * @param board * @return * * @RequestBody * : HTTP 요청 메시지의 본문(body) 내용을 객체로 변환하는 어노테이션 * 주로, 클라이언트에서 json 형식으로 보낸 데이터를 객체로 변환하기 위해 사용한다. * * 생략가능 (주로 생략하고 쓴다.) * * 415 에러 - 지원되지 않는 미디어 타입 * (Unsupported Media Type) * : 클라이언트가 보낸 컨텐츠 타입의 요청을 서버가 처리할 수 없을 때 발생하는 에러 * [클라이언트] ( application/x-www-form-urlencoded ) * ↓ * [ 서 버 ] ( application/json ) * * @RequestBody 를 쓰면, 본문의 컨텐츠 타입을 application/json 을 기본으로 지정 * * * 비동기 또는 thunder client 로 테스트 가능 * Content-Type : application/json * body { "title" : "제목", "writer" : "작성자", "content" : "내용" } */ @ResponseBody @RequestMapping(value = "/body", method = RequestMethod.POST) public String requestBody(@RequestBody Board board) { logger.info("[POST] - /request/body"); logger.info(board.toString()); return "SUCCESS"; }

<!-- commons-io --> <!-- 파일 업로드/다운로드를 위한 라이브러리 --> <dependency> <groupId>commons-io</groupId> <artifactId>commons-io</artifactId> <version>2.11.0</version> </dependency> <!-- annotation --> <!-- @Resource 어노테이션 등 --> <dependency> <groupId>javax.annotation</groupId> <artifactId>javax.annotation-api</artifactId> <version>1.3.2</version> </dependency>

<!-- Processes application requests --> <servlet> <servlet-name>appServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!-- ✅ 파일업로드 기능 활성화 --> <multipart-config /> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>appServlet</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>

<!-- ✅ MultipartResolver 빈 등록 --> <beans:bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver"> </beans:bean> <!-- ✅ 업로드 경로 빈 등록 --> <beans:bean id="uploadPath" class="java.lang.String"> <beans:constructor-arg value="C:\\upload"> </beans:constructor-arg> </beans:bean>

<h3>/file.jsp/h3> <form action="${ pageContext.request.contextPath }/file" method="POST" enctype="multipart/form-data"> <input type="file" name="file" /> <br> <input type="submit" value="등록" /> </form>

@Resource(name = "uploadPath") private String uploadPath; // 파일 업로드 @ResponseBody @RequestMapping("/file") public String fileUpload(MultipartFile file) throws IOException { logger.info("/file"); logger.info("uploadPath : " + uploadPath); if( file == null ) return "FAIL"; logger.info("originalFileName : " + file.getOriginalFilename()); logger.info("size : " + file.getSize()); logger.info("contentType : " + file.getContentType()); byte[] fileData = file.getBytes(); // 파일 업로드 String filePath = uploadPath; String fileName = file.getOriginalFilename(); File uploadFile = new File(filePath, fileName); FileCopyUtils.copy(fileData, uploadFile); // 파일 업로드 return "SUCCESS"; }

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>Insert title here</title> </head> <body> <h1>AJAX 파일 업로드</h1> <form action="${ pageContext.request.contextPath }/request/ajax" method="POST" enctype="multipart/form-data"> <table class="board"> <tr> <td class="label">제목</td> <td class="data"> <input type="text" name="title" id="title" class="input-text"> </td> </tr> <tr> <td class="label">작성자</td> <td class="data"> <input type="text" name="writer" id="writer" class="input-text"> </td> </tr> <tr> <td class="label">내용</td> <td class="data"> <textarea name="content" id="content" cols="30" rows="10" class="input-textarea"></textarea> </td> </tr> <tr> <td class="label">파일</td> <td class="data"> <input type="file" name="file" id="file" multiple> </td> </tr> </table> <div class="btn-box"> <div class="item"> <a href="javascript:;" class="btn" id="btn-insert">등록</a> </div> </div> </form> <!-- script --> <script src="https://code.jquery.com/jquery-3.7.0.min.js"></script> <script> // 등록 버튼 - 클릭 이벤트 $('#btn-insert').on('click', function() { // 등록 요청 let formData = new FormData() // 폼 데이터 객체 let title = $('#title').val() let writer = $('#writer').val() let content = $('#content').val() formData.append('title', title) formData.append('writer', writer) formData.append('content', content) // 파일 입력 가져오기 let file = $('#file')[0] let files = file.files // 파일 데이터 추가 for (let i = 0; i < files.length; i++) { formData.append('file', files[i]) } let url = 'http://localhost:8080/spring/request/ajax' $.ajax({ url : url, type : 'POST', data : formData, contentType : false, processData : false, // 데이터 컨텐츠 타입 자동 변환 여부 // 기본값(true) // true -> contentType : application/x-www-form-urlencoded // false -> contentType : 데이터를 자동으로 처리하지 않고 직접 지정 success : function(response) { if( response == 'SUCCESS' ){ alert('등록이 완료되었습니다.') } }, error : function(request, status, error){ alert("code:"+request.status+"\n"+"message:"+request.responseText+"\n"+"error:"+error); } }) }) </script> </body> </html>

@ResponseBody @RequestMapping(value = "/ajax", method = RequestMethod.POST) public String ajaxUploadPost(Board board) throws IOException { logger.info("/request/ajax"); logger.info("uploadPath : " + uploadPath); logger.info(board.toString()); List<MultipartFile> fileList = board.getFile(); if( fileList == null ) return "FAIL"; if( !fileList.isEmpty() ) for (MultipartFile file : fileList) { logger.info("originalFileName : " + file.getOriginalFilename()); logger.info("size : " + file.getSize()); logger.info("contentType : " + file.getContentType()); byte[] fileData = file.getBytes(); String filePath = uploadPath; String fileName = file.getOriginalFilename(); File uploadFile = new File(filePath, fileName); FileCopyUtils.copy(fileData, uploadFile); // 파일 업로드 } return "SUCCESS"; }