🌼 SpringMVC (Annotation)

• Annotation 사용 : Sprinv MVC 역시 XML 설정을 최소화할 수 있도록 Annotation 기반 설정을 지원하는데 기본 설정은 IoC 설정과 동일함

1. context 관련 Namespace 선언
2. <context:component-scan> 이라는 태그를 사용하여 Controller Annotation 컴포넌트 스캔
3. 스캔할 클래스들의 패키지를 base-package 속성을 이용해서 등록

---

📌 web.xml (appServlet)

• 스프링 어노테이션을 검색하는 component-scan 엘리먼트를 사용한 Spring Bean Configuration File은 하나만 제공 가능

  • <param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>

• url-pattern 엘리먼트의 내용을 [/]로 설정한 경우 클라이언트의 모든 웹프로그램 요청에 대한 처리가 가능하도록 설정

  • <url-pattern>/</url-pattern>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

	<!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
	<!-- context-param : 모든 웹프로그램 실행에 필요한 값을 제공하기 위한 엘리먼트 -->
	<!-- => contextConfigLocation 이름으로 스프링 컨테이너(WebApplocationContext 객체)에게
	Spring Bean Configuration File의 경로를 제공 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<!-- 모든 웹프로그램에서 사용할 수 있는 Spring Bean를 등록하기 위한 Spring Bean Configuration File -->
		<!-- => 모든 Front Controller 역활을 하는 웹프로그램에게 필요한 객체를 제공하기 위해 Spring Bean으로 등록  -->
		<param-value>/WEB-INF/spring/root-context.xml</param-value>
	</context-param>
	
	<!-- Creates the Spring Container shared by all Servlets and Filters -->
	<!-- listener : WAS 프로그램이 시작될 때 Listener 클래스를 제공받아 객체로 생성하기 위한 엘리먼트 -->
	<!-- Listener 클래스 : ServletContextListener 인터페이스를 상속받은 자식클래스 -->
	<!-- => contextInitialized 메소드 : Listener 객체 생성 후 자동 호출되는 메소드 - 초기화 작업 -->
	<!-- => contextDestroyed 메소드 : Listener 객체 소멸 전 자동 호출되는 메소드 - 마무리 작업 -->
	<listener>
		<!-- listener-class : ServletContextListener 인터페이스를 상속받은 자식클래스를 설정하기 위한 엘리먼트 -->
		<!-- => WAS 프로그램이 시작될 때 ContextLoaderListener 클래스를 객체로 생성하고
		contextInitialized 메소드를 호출하여 초기화 작업 -->
		<!-- ContextLoaderListener 클래스의 contextInitialized 메소드에서 스프링 컨테이너(Spring Container)를
		생성하고 Spring Bean Configuration File을 제공받아 Spring Bean으로 등록된 클래스를 객체로 생성 -->
		<!-- Listener 객체의 메소드에 의해 생성된 스프링 컨테이너(WebApplicationContext 객체)는
		모든 웹자원(서블릿 및 필터)에게 공유되어 사용 가능 - Spring Bean 제공  -->
		<!-- => WebApplicationContext 객체는 기본적으로 src/main/webapp 폴더의 Spring Bean 
		Configuration File 파일만 제공받아 처리 가능 -->
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- servlet : 서블릿 클래스를 서블릿(웹프로그램)으로 등록하기 위한 엘리먼트 -->
	<servlet>
		<!-- servlet-name : 서블릿을 구분하기 위한 식별자를 설정하기 위한 엘리먼트 -->
		<servlet-name>mvc</servlet-name>
		<!-- servlet-class : 클라이언트 요청에 의해 객체로 생성되어 실행될 서블릿 클래스을
		설정하기 위한 엘리먼트 -->
		<!-- DispatcherServlet 클래스 : 컨트롤러(Controller) 역활을 제공하는 클래스 - Front Controller -->
		<servlet-class>xyz.itwill09.mvc.DispatcherServlet</servlet-class>
	</servlet>
	
	<!-- servlet-mapping : 서블릿을 실행하기 위한 URL 주소의 패턴을 등록하기 위한 엘리먼트 -->
	<servlet-mapping>
		<!-- servlet-name : 클라이언트 요청에 의해 실행될 서블릿의 식별자를 설정하기 위한 엘리먼트 -->
		<servlet-name>mvc</servlet-name>
		<!-- url-pattern : 서블릿을 실행하기 위한 URL 주소의 패턴을 설정하기 위한 엘리먼트 -->
		<!-- => Front Controller 역활을 제공하는 서블릿은 클라이언트의 모든 요청을 받아 처리되도록 설정 -->
		<url-pattern>*.itwill</url-pattern>
	</servlet-mapping>

	<servlet>
		<servlet-name>springMvc</servlet-name>
		<!-- Spring Framework의 라이브러리에 의해 제공되는 DispatcherServlet 클래스 사용 - Front Controller -->
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- init-param : 서블릿 클래스에게 실행에 필요한 값을 제공하기 위한 엘리먼트 -->
		<!-- => contextConfigLocation 이름으로 스프링 컨테이너(WebApplicationContext 객체)에게
		Spring Bean Configuration File의 경로를 제공 -->
		<!-- => 현재 설정된 Front Controller 역활의 객체에게만 제공한 Spring Bean을 등록하기 
		위한 Spring Bean Configuration File -->
		<!-- => Spring Bean Configuration File은 엔터(Enter) 또는 [,] 및 [;]으로 구분하여 여러개 제공 가능 -->
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>
				/WEB-INF/spring/springMvc/mvc-context1.xml
				/WEB-INF/spring/springMvc/mvc-context2.xml
			</param-value>
		</init-param>
		<!-- load-on-startup : WAS 프로그램이 시작될 때 서블릿 클래스를 미리 객체로 생성하기 위한 엘리먼트 -->
		<!-- => 클라이언트가 서블릿(Front Controller)를 요청하지 않아도 서블릿 객체를 미리 생성 -->
		<!-- => 엘리먼트 내용으로 설정된 정수값을 작을수록 먼저 서블릿 객체로 생성 -->
		<load-on-startup>0</load-on-startup>
	</servlet>
	
	<servlet-mapping>
		<servlet-name>springMvc</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>

	<!-- Processes application requests -->
	<servlet>
		<servlet-name>appServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<!-- 스프링 어노테이션을 검색하는 component-scan 엘리먼트를 사용한 Spring Bean 
			Configuration File은 하나만 제공 가능 -->
			<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>/</url-pattern>
	</servlet-mapping>

</web-app>

---

📕 servlet-context.xml

• servlet-context.xml : appServlet 이름의 Front Controller에서 사용될 클래스의 Spring Bean을 등록하기 위한 Spring Bean Configuration File

• annotation-driven : @Controller 어노테이션을 사용하여 요청 처리 클래스를 Spring Bean으로 등록하고 @RequestMapping 어노테이션을 사용하여 작성된 메소드를 요청 처리 메소드로 등록하여 클라이언트 요청에 의해 요청 처리 클래스의 메소드가 호출되어 처리되도록 설정하는 엘리먼트
  • HandlerMapping 객체를 사용하지 않아도 요청 처리 클래스의 요청 처리 메소드가 클라이언트의 요청에 의해 호출되도록 자동으로 매핑 처리

• InternalResourceViewResolver 클래스를 Spring Bean으로 등록
  • InternalResourceViewResolver 객체 : 클라이언트 요청에 의해 호출되는 요청 처리 메소드의 반환값(ViewName)을 제공받아 응답 가능한 JSP 문서로 변환하여 반환하는 객체

• component-scan : 스프링 컨테이너가 스프링 어노테이션을 검색하여 처리하기 위한 엘리먼트
  • base-package 속성 : 스프링 어노테이션을 검색하기 위해 어노테이션을 사용한 클래스의 패키지를 속성값으로 설정
  • xyz.itwill10.controller 패키지에 요청 처리 클래스(Model)를 작성하고 스프링 어노테이션을 이용하여 Spring Bean으로 등록
  • <context:component-scan base-package="xyz.itwill10.controller" />

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
	<!-- servlet-context.xml : appServlet 이름의 Front Controller에서 사용될 클래스의 Spring
	Bean을 등록하기 위한 Spring Bean Configuration File -->
	
	<!-- Enables the Spring MVC @Controller programming model -->
	<!-- annotation-driven : @Controller 어노테이션을 사용하여 요청 처리 클래스를 Spring Bean으로
	등록하고 @RequestMapping 어노테이션을 사용하여 작성된 메소드를 요청 처리 메소드로 등록하여
	클라이언트 요청에 의해 요청 처리 클래스의 메소드가 호출되어 처리되도록 설정하는 엘리먼트 -->
	<!-- => HandlerMapping 객체를 사용하지 않아도 요청 처리 클래스의 요청 처리 메소드가 
	클라이언트의 요청에 의해 호출되도록 자동으로 매핑 처리 -->
	<annotation-driven />

	<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
	<resources mapping="/resources/**" location="/resources/" />

	<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
	<!-- InternalResourceViewResolver 클래스를 Spring Bean으로 등록 -->
	<!-- InternalResourceViewResolver 객체 : 클라이언트 요청에 의해 호출되는 요청 처리 메소드의
	반환값(ViewName)을 제공받아 응답 가능한 JSP 문서로 변환하여 반환하는 객체 -->
	<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<beans:property name="prefix" value="/WEB-INF/views/" />
		<beans:property name="suffix" value=".jsp" />
	</beans:bean>

	<!-- component-scan : 스프링 컨테이너가 스프링 어노테이션을 검색하여 처리하기 위한 엘리먼트 -->
	<!-- base-package 속성 : 스프링 어노테이션을 검색하기 위해 어노테이션을 사용한 클래스의 패키지를 속성값으로 설정 -->	
	<!-- <context:component-scan base-package="xyz.itwill.controller" /> -->
	<!-- xyz.itwill10.controller 패키지에 요청 처리 클래스(Model)를 작성하고 스프링 어노테이션을
	이용하여 Spring Bean으로 등록 -->
	<context:component-scan base-package="xyz.itwill10.controller" />
</beans:beans>

---

📙 Model (포워드 이동)

• @Controller : 요청 처리 클래스를 Spring Bean으로 등록하기 위한 어노테이션
  • 클래스의 이름을 Spring Bean의 식별자(beanName)으로 자동 설정 (첫문자는 소문자로 변환)
  • value 속성을 사용하여 Spring Bean의 식별자(beanName) 변경 가능
  • Controller 인터페이스를 상속받지 않아도 요청 처리 클래스로 처리
  • @RequestMapping 어노테이션으로 다수의 요청 처리 메소드를 작성하여 클라이언트의 요청에 대한 처리 가능

• 요청 처리 메소드는 Front Controller에게 반드시 뷰이름(ViewName) 제공

  • Front Controller는 제공받은 뷰이름을 이용하여 응답 관련 정보로 변환(ViewResolver)하여 응답 처리

• Front Controller에 의해 JSP 문서로 포워드 이동하여 응답되도록 뷰이름을 제공하는 방법
  • JSP 문서로 응답 처리하지 않을 경우 요청 처리 메소드의 반환형을 Model 또는 Map으로 설정 가능

1. 요청 처리 메소드의 반환형을 void로 설정한 경우 Front Controller에게 메소드의 이름을 뷰이름으로 제공

2. 요청 처리 메소드의 반환형을 String로 설정한 경우 Front Controller에게 반환값을 뷰이름으로 제공

3. 요청 처리 메소드의 반환형을 ModelAndView로 설정한 경우 Front Controller에게 ModelAndView 객체에 뷰이름을 저장하여 제공

   • ModelAndView 객체 : 요청에 대한 처리 결과를 속성값으로 저장하고 뷰이름을 저장하기 위한 객체
   • modelAndView.setViewName("hello"); : Setter 메소드를 이용하여 뷰이름 변경
   • ModelAndView modelAndView=new ModelAndView("hello"); : 생성자를 이용하여 뷰이름 변경
     

• @RequestMapping : 클라이언트 요청을 처리하기 위한 메소드를 선언하기 위한 어노테이션
  • 기본적으로 클라이언트의 모든 요청방식(Method - GET, POST, PUT, PATCH, DELETE 등)에 의해 호출되는 요청 처리 메소드를 작성할 경우 사용하는 어노테이션
  • 클라이언트의 요청방식을 구분하여 요청 처리 메소드가 호출되도록 처리하고자 할 경우 @GetMaaping, @PostMapping, @PutMapping, @PatchMapping, @DeleteMapping 등의 어노테이션 사용 가능
  • value 속성 : 클라이언트의 요청 URL 주소를 속성값으로 설정
  • Front Controller에 의해 등록된 클라이언트 요청 URL 주소(식별자)로 요청 처리 메소드가 자동 호출되어 클라이언트의 요청 처리
  • 다른 속성이 없는 경우 속성값만 설정 가능
  • 다른 요청 처리 메소드의 value 속성값과 요청 URL 주소가 중복될 경우 WAS 시작시 에러 발생

package xyz.itwill10.controller;

//@Controller : 요청 처리 클래스를 Spring Bean으로 등록하기 위한 어노테이션
// => 클래스의 이름을 Spring Bean의 식별자(beanName)으로 자동 설정 - 첫문자는 소문자로 변환
// => value 속성을 사용하여 Spring Bean의 식별자(beanName) 변경 가능
// => Controller 인터페이스를 상속받지 않아도 요청 처리 클래스로 처리
// => @RequestMapping 어노테이션으로 다수의 요청 처리 메소드를 작성하여 클라이언트의 요청에 대한 처리 가능
@Controller
public class HelloController {//모델(Model) 역활을 제공하는 클래스 - 요청 처리 클래스
	private static final Logger logger=LoggerFactory.getLogger(HelloController.class);

	//요청 처리 메소드는 Front Controller에게 반드시 뷰이름(ViewName) 제공
	// => Front Controller는 제공받은 뷰이름을 이용하여 응답 관련 정보로 변환(ViewResolver)하여 응답 처리
	//Front Controller에 의해 JSP 문서로 포워드 이동하여 응답되도록 뷰이름을 제공하는 방법 
	// => JSP 문서로 응답 처리하지 않을 경우 요청 처리 메소드의 반환형을 Model 또는 Map으로 설정 가능
	//1.요청 처리 메소드의 반환형을 void로 설정한 경우 Front Controller에게 메소드의 이름을 뷰이름으로 제공 
	//2.요청 처리 메소드의 반환형을 String로 설정한 경우 Front Controller에게 반환값을 뷰이름으로 제공 
	//3.요청 처리 메소드의 반환형을 ModelAndView로 설정한 경우 Front Controller에게 ModelAndView 객체에 뷰이름을 저장하여 제공
	
	//@RequestMapping : 클라이언트 요청을 처리하기 위한 메소드를 선언하기 위한 어노테이션
	// => 기본적으로 클라이언트의 모든 요청방식(Method - GET, POST, PUT, PATCH, DELETE 등)에
	//의해 호출되는 요청 처리 메소드를 작성할 경우 사용하는 어노테이션
	// => 클라이언트의 요청방식을 구분하여 요청 처리 메소드가 호출되도록 처리하고자 할 경우 @GetMaaping
	//, @PostMapping, @PutMapping, @PatchMapping, @DeleteMapping 등의 어노테이션 사용 가능
	//value 속성 : 클라이언트의 요청 URL 주소를 속성값으로 설정
	// => Front Controller에 의해 등록된 클라이언트 요청 URL 주소(식별자)로 요청 처리 메소드가
	//자동 호출되어 클라이언트의 요청 처리
	// => 다른 속성이 없는 경우 속성값만 설정 가능
	// => 다른 요청 처리 메소드의 value 속성값과 요청 URL 주소가 중복될 경우 WAS 시작시 에러 발생
	@RequestMapping(value = "/hello")
	public void hello() {//요청 처리 메소드
		//요청 처리 명령 작성 - Service 객체의 메소드 호출
		logger.info("[/hello] 페이지 요청 : HelloController 클래스의 hello() 메소드 호출");
	}
	
	@RequestMapping(value = "/helloViewName")
	public String helloViewName() {
		logger.info("[/helloViewName] 페이지 요청 : HelloController 클래스의 helloViewName() 메소드 호출");
		return "hello";
	}
	
	@RequestMapping(value = "/helloModelAndView")
	public ModelAndView helloModelAndView() {
		logger.info("[/helloModelAndView] 페이지 요청 : HelloController 클래스의 helloModelAndView() 메소드 호출");
		
		//ModelAndView 객체 : 요청에 대한 처리 결과를 속성값으로 저장하고 뷰이름을 저장하기 위한 객체
		//ModelAndView modelAndView=new ModelAndView();
		//modelAndView.setViewName("hello");//Setter 메소드를 이용하여 뷰이름 변경
		
		ModelAndView modelAndView=new ModelAndView("hello");//생성자를 이용하여 뷰이름 변경
		
		return modelAndView;
	}
}

---

🐣 응답 (뷰이름)

• hello(), helloViewName(), helloModelAndView() 메소드 모두 동일한 뷰 제공
  • 요청 처리 메소드로 구분

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>Hello, Spring!!!</h1>
	<hr>
</body>
</html>

---

📙 Model (처리 결과 return)

• 요청 처리 메소드에 의해 처리된 결과를 뷰(JSP 문서)에 제공하는 방법
  

• 요청 처리 메소드는 Front Controller에 의해 자동 호출되는 메소드

  • 요청 처리 메소드에 매개변수를 작성하면 Front Controller는 스프링 컨테이너로부터 매개변수에 저장 가능한 웹 관련 객체를 제공받아 전달하여 저장

1. ModelAndView 객체에 처리결과를 속성값으로 저장하여 제공
   • ModelAndView.addObject(String attributeName, Object attributeValue) : ModelAndView 객체에 속성명과 속성값을 저장하기 위한 메소드 (Request Scope)
   • modelAndView.addObject("mavName","홍길동");
   • 뷰(JSP 문서)에서는 EL 표현식으로 속성명을 사용하여 속성값을 제공받아 출력

2. HttpServletRequest 객체에 처리결과를 속성값으로 저장하여 제공
   • HttpServletRequest.setAttribute(String attributeName, Object attributeValue) : HttpServletRequest 객체에 속성명과 속성값을 저장하기 위한 메소드 (Request Scope)
   • request.setAttribute("requestName", "임꺽정");

3. Model 객체에 처리결과를 속성값으로 저장하여 제공
   • Model 객체 : 처리결과를 속성값으로 저장하여 뷰(View)에게 제공하기 위한 객체
   • Model.addAttribute(String attributeName, Object attributeValue) : Model 객체에 속성명과 속성값을 저장하기 위한 메소드 (Request Scope)

package xyz.itwill10.controller;

@Controller
public class ResultController {
	/*
	@RequestMapping("/resultMAV")
	public ModelAndView modelAndViewResult() {
		ModelAndView modelAndView=new ModelAndView("result_display");
		//ModelAndView.addObject(String attributeName, Object attributeValue)
		// => ModelAndView 객체에 속성명과 속성값을 저장하기 위한 메소드 - Request Scope
		// => 뷰(JSP 문서)에서는 EL 표현식으로 속성명을 사용하여 속성값을 제공받아 출력
		modelAndView.addObject("mavName","홍길동");
		return modelAndView;
	}
	*/
	
	//요청 처리 메소드는 Front Controller에 의해 자동 호출되는 메소드
	// => 요청 처리 메소드에 매개변수를 작성하면 Front Controller는 스프링 컨테이너로부터
	//매개변수에 저장 가능한 웹 관련 객체를 제공받아 전달하여 저장
	@RequestMapping("/resultMAV")
	public ModelAndView modelAndViewResult(ModelAndView modelAndView) {
		modelAndView.setViewName("result_display");
		modelAndView.addObject("mavName","홍길동");
		return modelAndView;
	}
	
	@RequestMapping("/resultRequest")
	public String requestResult(HttpServletRequest request) {
		//HttpServletRequest.setAttribute(String attributeName, Object attributeValue)
		// => HttpServletRequest 객체에 속성명과 속성값을 저장하기 위한 메소드 - Request Scope
		request.setAttribute("requestName", "임꺽정");
		return "result_display";
	}
	
	@RequestMapping("/resultModel")
	public String modelResult(Model model) {
		//Model 객체 : 처리결과를 속성값으로 저장하여 뷰(View)에게 제공하기 위한 객체
		//Model.addAttribute(String attributeName, Object attributeValue)
		// => Model 객체에 속성명과 속성값을 저장하기 위한 메소드 - Request Scope
		model.addAttribute("modelName", "전우치");
		return "result_display";
	}
}

---

🐣 응답 (속성명-속성값)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>처리결과 출력페이지</h1>
	<hr>
	<h2>ModelAndView = ${mavName }</h2>
	<h2>HttpServletRequest = ${requestName }</h2>
	<h2>Model = ${modelName }</h2>
</body>	
</html>

---

📙 @ModelAttribute (method)

• 요청 처리 클래스의 메소드에 @ModelAttribute 어노테이션 사용

  • @ModelAttribute : 메소드에 의해 반환되는 객체(값)을 속성값으로 저장하여 현재 클래스에 작성된 모든 요청 처리 메소드의 뷰(JSP 문서)에게 제공하기 위한 어노테이션
  • 요청 처리 메소드에 의해 응답될 모든 뷰에서 공통적으로 사용되는 객체(값)을 제공할 목적으로 사용
  • value 속성 : 뷰에서 속성값을 사용하기 위한 이름(속성명)을 속성값으로 설정
  • 다른 속성이 없는 없는 경우 속성값만 설정 가능

package xyz.itwill10.controller;

@Controller
public class ModelController {
	@RequestMapping("/display1")
	public String displayOne(Model model) {
		model.addAttribute("name", "홍길동");
		//model.addAttribute("now", new SimpleDateFormat("yyyy년 MM월 dd일 HH시 mm분 ss초").format(new Date()));
		return "model_display";
	}
	
	@RequestMapping("/display2")
	public String displayTwo(Model model) {
		model.addAttribute("name", "임꺽정");
		//model.addAttribute("now", new SimpleDateFormat("yyyy년 MM월 dd일 HH시 mm분 ss초").format(new Date()));
		return "model_display";
	}
	
	@RequestMapping("/display3")
	public String displayThree(Model model) {
		model.addAttribute("name", "전우치");
		//model.addAttribute("now", new SimpleDateFormat("yyyy년 MM월 dd일 HH시 mm분 ss초").format(new Date()));
		return "model_display";
	}
	
	//시스템의 현재 날짜와 시간을 문자열로 반환하는 메소드
	// => 요청 처리 클래스의 메소드에 @ModelAttribute 어노테이션 사용
	//@ModelAttribute : 메소드에 의해 반환되는 객체(값)을 속성값으로 저장하여 현재 클래스에
	//작성된 모든 요청 처리 메소드의 뷰(JSP 문서)에게 제공하기 위한 어노테이션
	// => 요청 처리 메소드에 의해 응답될 모든 뷰에서 공통적으로 사용되는 객체(값)을 제공할 목적으로 사용
	//value 속성 : 뷰에서 속성값을 사용하기 위한 이름(속성명)을 속성값으로 설정
	// => 다른 속성이 없는 없는 경우 속성값만 설정 가능
	@ModelAttribute("now")
	public String getNow() {
		return new SimpleDateFormat("yyyy년 MM월 dd일 HH시 mm분 ss초").format(new Date());
	}
}

---

🐣 응답 (now)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>처리결과 출력페이지</h1>
	<hr>
	<h2>이름 = ${name }</h2>
	<h2>현재 날짜와 시간 = ${now }</h2>
</body>
</html>

---

📙 Model (요청방식)

• method 속성 : RequestMethod 자료형(Enum)의 상수(Constant) 중 하나를 속성값으로 설정

  • RequestMethod 자료형(Enum)은 클라이언트의 요청방식을 상수로 제공
  • method 속성으로 클라이언트가 페이지를 요청하기 위한 요청방식을 지정 가능
  • method 속성값으로 설정된 요청방식외의 방법으로 페이지를 요청한 경우 405 에러코드 발생

• 클라이언트가 페이지를 [GET] 방식으로 요청한 경우에만 요청 처리 메소드 호출

  • @RequestMapping(value = "/method", method = RequestMethod.GET)
  • [GET] 방식으로 요청 처리 메소드를 호출하기 위해 @RequestMapping 어노테이션 대신 @GetMapping 어노테이션 사용 가능

• 클라이언트가 페이지를 [POST] 방식으로 요청한 경우에만 요청 처리 메소드 호출

  • @RequestMapping(value = "/method", method = RequestMethod.POST)
  • 요청 처리 메소드를 호출하는 요청 URL 주소가 같아도 요청방식을 다르게 지정하면 다른 요청 처리 메소드로 매핑 처리
  • [POST] 방식으로 요청 처리 메소드를 호출하기 위해 @RequestMapping 어노테이션 대신 @PostMapping 어노테이션 사용 가능

package xyz.itwill10.controller;

@Controller
public class MethodController {
	//사용자에게 값을 입력받기 위한 JSP 문서의 ViewName를 반환하는 요청 처리 메소드
	// => 클라이언트의 요청방식에 상관없이 무조건 요청 처리 메소드 호출
	@RequestMapping("/method_input")
	public String inputOne() {
		return "method_input1";
	}
	
	//입력값을 반환받아 Request Scope 속성값으로 저장하고 속성값을 출력하기 위한 JSP 문서의
	//ViewName를 반환하는 요청 처리 메소드  
	// => 클라이언트의 요청방식에 상관없이 무조건 요청 처리 메소드 호출
	@RequestMapping("/method_output")
	public String outputOne(HttpServletRequest request, HttpServletResponse response) throws IOException {
		//클라이언트가 해당 페이지를 GET 방식으로 요청한 경우 - 비정상적인 요청
		if(request.getMethod().equals("GET")) {
			//response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);//클라이언트에게 405 에러코드 전달
			response.sendRedirect("method_input");//클라이언트에게 URL 주소 전달 -  URL 주소로 재요청
			return null;
		}
		
		request.setCharacterEncoding("utf-8");
		String name=request.getParameter("name");
		request.setAttribute("name", name);
		return "method_output";
	}
	
	//사용자에게 값을 입력받기 위한 JSP 문서의 ViewName를 반환하는 요청 처리 메소드
	// => 클라이언트가 페이지를 [GET] 방식으로 요청한 경우에만 요청 처리 메소드 호출
	//method 속성 : RequestMethod 자료형(Enum)의 상수(Constant) 중 하나를 속성값으로 설정
	// => RequestMethod 자료형(Enum)은 클라이언트의 요청방식을 상수로 제공
	// => method 속성으로 클라이언트가 페이지를 요청하기 위한 요청방식을 지정 가능
	// => method 속성값으로 설정된 요청방식외의 방법으로 페이지를 요청한 경우 405 에러코드 발생
	//[GET] 방식으로 요청 처리 메소드를 호출하기 위해 @RequestMapping 어노테이션 대신 
	//@GetMapping 어노테이션 사용 가능
	@RequestMapping(value = "/method", method = RequestMethod.GET)
	public String inputTwo() {
		return "method_input2";
	}

	//입력값을 반환받아 Request Scope 속성값으로 저장하고 속성값을 출력하기 위한 JSP 문서의
	//ViewName를 반환하는 요청 처리 메소드  
	// => 클라이언트가 페이지를 [POST] 방식으로 요청한 경우에만 요청 처리 메소드 호출
	//요청 처리 메소드를 호출하는 요청 URL 주소가 같아도 요청방식을 다르게 지정하면 다른 
	//요청 처리 메소드로 매핑 처리
	//[POST] 방식으로 요청 처리 메소드를 호출하기 위해 @RequestMapping 어노테이션 대신 
	//@PostMapping 어노테이션 사용 가능	
	@RequestMapping(value = "/method", method = RequestMethod.POST)
	public String outputTwo(HttpServletRequest request) throws UnsupportedEncodingException {
		request.setCharacterEncoding("utf-8");
		String name=request.getParameter("name");
		request.setAttribute("name", name);
		return "method_output";
	}
}

---

🐣 응답 (input1)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>입력페이지</h1>
	<hr>
	<form action="method_output" method="post">
		이름 : <input type="text" name="name">
		<button type="submit">전송</button>
	</form>
</body>
</html>

---

🐣 응답 (input2)

• 요청 처리 메소드를 호출하는 요청 URL 주소가 같아도 요청방식(GET or POST)에 따라 다른 요청 처리 메소드 실행

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>입력페이지</h1>
	<hr>
	<form action="method" method="post">
		이름 : <input type="text" name="name">
		<button type="submit">전송</button>
	</form>
</body>
</html>

---

🐣 응답 (output)

• 클라이언트가 해당 페이지를 GET 방식으로 요청한 경우 (비정상적인 요청) 클라이언트에게 405 에러코드 전달 or URL 주소 전달 가능

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>출력페이지</h1>
	<hr>
	<h2>${name }님, 환영합니다.</h2>
</body>
</html>

---

📙 Model (param)

• 요청 처리 메소드에 HttpServletRequest 인터페이스로 매개변수를 선언하면 Front Controller에게 클라이언트의 요청정보가 저장된 HttpServletRequest 객체를 제공받아 사용 가능
  • HttpServletRequest 객체의 메소드를 호출하여 페이지 요청시 전달된 값을 반환받아 처리
  • public String result(HttpServletRequest request){}

• 요청 처리 메소드에서 페이지 요청시 전달되는 값의 이름으로 원시형 또는 String 클래스의 매개변수를 선언하면 Front Controller에 의해 전달값이 매개변수에 자동으로 저장되어 제공
  • 전달값의 이름과 매개변수의 이름이 같지 않을 경우 String 매개변수에는 [null] 저장
  • 원시형의 매개변수에 전달된 값이 없거나 자료형이 맞지 않을 경우 400 에러코드 발생
  • public String result(String food, Model model) {}

• 클라이언트 요청에 의해 웹프로그램이 실행되기 전과 후에 원하는 명령을 실행할 수 있는 필터를 [web.xml] 파일에 등록하여 사용 가능
  • 클라이언트의 모든 요청에 대해 요청정보가 저장된 리퀘스트 메세지의 몸체부의 문자형식을 변경하는 필터가 사용되도록 [web.xml] 파일을 이용하여 설정 (인코딩 필터 적용)
  • 필터는 Front Controller 전에 위치되어 요청과 응답 관련 정보 변경 가능 (WAS에 의해 제어)

• 전달값을 저장하기 위한 매개변수에 @RequestParam 어노테이션 사용 (권장)
  • @RequestParam : 전달값을 매개변수에 저장하기 위한 어노테이션
  • 매개변수의 이름과 같은 이름의 전달값이 없는 경우 400 에러 발생
  • 매개변수에 반드시 전달값이 저장되도록 설정하기 위한 어노테이션
  • public String result(@RequestParam String food, Model model){}

• value 속성 : 전달값의 이름을 속성값으로 설정

  • @RequestParam 속성을 사용하여 전달값의 이름으로 값을 제공받아 매개변수에 저장 가능
  • 전달값의 이름과 매개변수의 이름이 다른 경우 사용
  • 다른 속성이 없는 경우 속성값만 설정 가능
  • public String result(@RequestParam(value = "foodname") String food, Model model) {}

• required 속성 : false(미필수) 또는 true(필수 - 기본) 중 하나를 속성값으로 설정

  • 전달값이 매개변수에 전달되어 저장되는 필수 여부를 구분하기 위한 속성

• defaultValue 속성 : 전달값과 매개변수이 다른 경우 사용될 기본값을 속성값으로 설정

  • 전달값이 없는 경우에도 매개변수에 null 대신 저장될 기본값으로 사용
  • public String result(@RequestParam(defaultValue = "된장찌개") String food, Model model) {}

package xyz.itwill10.controller;

@Controller
public class ParamController {
	@RequestMapping(value = "/param", method = RequestMethod.GET)
	public String form() {
		return "param_form";
	}
	
	/*
	//요청 처리 메소드에 HttpServletRequest 인터페이스로 매개변수를 선언하면 Front Controller에게
	//클라이언트의 요청정보가 저장된 HttpServletRequest 객체를 제공받아 사용 가능
	// => HttpServletRequest 객체의 메소드를 호출하여 페이지 요청시 전달된 값을 반환받아 처리
	@RequestMapping(value = "/param", method = RequestMethod.POST)
	public String result(HttpServletRequest request) throws UnsupportedEncodingException {
		String food=request.getParameter("food");
		request.setAttribute("food", food);
		return "param_display";
	}
	*/
	
	/*
	//요청 처리 메소드에서 페이지 요청시 전달되는 값의 이름과 같은 이름으로 String 자료형의
	//매개변수를 선언하면 Front Controller에 의해 전달값이 매개변수에 자동으로 저장되어 제공
	// => 전달값의 이름과 매개변수의 이름이 같지 않을 경우 매개변수에는 [null] 저장
	//클라이언트 요청에 의해 웹프로그램이 실행되기 전과 후에 원하는 명령을 실행할 수 있는
	//필터를 [web.xml] 파일에 등록하여 사용 가능
	// => 클라이언트의 모든 요청에 대해 요청정보가 저장된 리퀘스트 메세지의 몸체부의 문자형식을
	//변경하는 필터가 사용되도록 [web.xml] 파일을 이용하여 설정 - 인코딩 필터 적용
	// => 필터는 Front Controller 전에 위치되어 요청과 응답 관련 정보 변경 가능 - WAS에 의해 제어 
	@RequestMapping(value = "/param", method = RequestMethod.POST)
	public String result(String food, Model model) {
		model.addAttribute("food", food);
		return "param_display";
	}
	*/
	
	/*
	//전달값을 저장하기 위한 매개변수에 @RequestParam 어노테이션 사용
	//@RequestParam : 전달값을 매개변수에 저장하기 위한 어노테이션
	// => 매개변수의 이름과 같은 이름의 전달값이 없는 경우 400 에러 발생
	// => 매개변수에 반드시 전달값이 저장되도록 설정하기 위한 어노테이션
	@RequestMapping(value = "/param", method = RequestMethod.POST)
	public String result(@RequestParam String food, Model model) {
		model.addAttribute("food", food);
		return "param_display";
	}
	*/
	
	/*
	//value 속성 : 전달값의 이름을 속성값으로 설정
	// => @RequestParam 속성을 사용하여 전달값의 이름으로 값을 제공받아 매개변수에 저장 가능
	// => 전달값의 이름과 매개변수의 이름이 다른 경우 사용
	// => 다른 속성이 없는 경우 속성값만 설정 가능
	//required 속성 : false(미필수) 또는 true(필수 - 기본) 중 하나를 속성값으로 설정
	// => 전달값이 매개변수에 전달되어 저장회는 필수 여부를 구분하기 위한 속성 
	@RequestMapping(value = "/param", method = RequestMethod.POST)
	public String result(@RequestParam(value = "foodname", required = true) String food, Model model) {
		model.addAttribute("food", food);
		return "param_display";
	}
	*/
	
	//defaultValue 속성 : 전달값과 매개변수이 다른 경우 사용될 기본값을 속성값으로 설정
	// => 전달값이 없는 경우에도 매개변수에 null 대신 저장될 기본값으로 사용
	@RequestMapping(value = "/param", method = RequestMethod.POST)
	public String result(@RequestParam(value = "foodname", defaultValue = "된장찌개") String food, Model model) {
		model.addAttribute("food", food);
		return "param_display";
	}
}

---

📌 web.xml (filter)

• filter : 필터 클래스를 필터(Filter)로 등록하기 위한 엘리먼트

  • 필터(Filter) : 웹프로그램 실행 전과 후에 실행될 명령을 제공
  • filter-name : 필터를 구분하기 위한 식별자를 설정하기 위한 엘리먼트
  • filter-class : 클라이언트 요청에 의해 객체로 생성되어 실행될 필터 클래스를 설정하기 위한 엘리먼트
  • CharacterEncodingFilter : 리퀘스트 메세지 몸체부의 저장된 값에 대한 문자형태를 변경하기 위한 필터 클래스
  • init-param 엘리먼트를 사용하여 CharacterEncodingFilter 클래스에 의해 변경하고자 하는 문자형태(캐릭터셋)을 제공

• filter-mapping : 필터가 실행되기 위한 웹프로그램의 요청 URL 주소의 패턴을 등록하기 위한 엘리먼트

  • filter-name : 클라이언트 요청에 의해 실행될 필터의 식별자를 설정하기 위한 엘리먼트
  • url-pattern : 필터가 실행되기 위한 웹프로그램의 요청 URL 주소의 패턴을 설정하기 위한 엘리먼트

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

	<!-- filter : 필터 클래스를 필터(Filter)로 등록하기 위한 엘리먼트 -->
	<!-- => 필터(Filter) : 웹프로그램 실행 전과 후에 실행될 명령을 제공 -->
	<filter>
		<!-- filter-name : 필터를 구분하기 위한 식별자를 설정하기 위한 엘리먼트 -->
		<filter-name>encodingFilter</filter-name>
		<!-- filter-class : 클라이언트 요청에 의해 객체로 생성되어 실행될 필터 클래스을 설정하기 위한 엘리먼트 -->
		<!-- CharacterEncodingFilter : 리퀘스트 메세지 몸체부의 저장된 값에 대한 문자형태를 변경하기 위한 필터 클래스 -->
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<!-- init-param 엘리먼트를 사용하여 CharacterEncodingFilter 클래스에 의해 변경하고자
		하는 문자형태(캐릭터셋)을 제공  -->
		<init-param>
			<param-name>encoding</param-name>
			<param-value>utf-8</param-value>
		</init-param>
	</filter>
	
	<!-- filter-mapping : 필터가 실행되기 위한 웹프로그램의 요청 URL 주소의 패턴을 등록하기 위한 엘리먼트 -->
	<filter-mapping>
		<!-- filter-name : 클라이언트 요청에 의해 실행될 필터의 식별자를 설정하기 위한 엘리먼트 -->
		<filter-name>encodingFilter</filter-name>
		<!-- url-pattern : 필터가 실행되기 위한 웹프로그램의 요청 URL 주소의 패턴을 설정하기 위한 엘리먼트 -->
		<url-pattern>/*</url-pattern>
	</filter-mapping>

</web-app>

---

🐣 응답 (input)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>입력페이지</h1>
	<hr>
	<form action="param" method="post">
		<!-- 내가 좋아하는 음식 : <input type="text" name="food"> -->
		내가 좋아하는 음식 : <input type="text" name="foodname">
		<button type="submit">입력완료</button>
	</form>
</body>
</html>

---

🐣 응답 (output)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>출력페이지</h1>
	<hr>
	<h2>오늘의 점심은 [${food }]로 결정 하겠습니다.</h2>
</body>
</html>

---

📙 @ModelAttribute (param)

• @RequestParam 어노테이션을 사용하여 전달값과 같은 이름의 매개변수에 전달값을 제공받아 요청 처리 메소드에서 사용
  • @RequestParam 어노테이션을 사용하여 매개변수와 같은 이름으로 전달되는 값이 없는 경우 400 에러코드 발생
  • public String join(@RequestParam String id, @RequestParam String passwd){}

• @ModelAttribute 어노테이션을 사용하여 전달값과 같은 이름의 매개변수에 전달값을 제공받아 요청 처리 메소드에서 사용
  • @ModelAttribute 어노테이션을 사용하여 매개변수에 저장된 값을 속성값으로 저장하여 뷰(View) 제공
  • @ModelAttribute : 객체(값)을 뷰에게 제공하기 위한 어노테이션
  • 메소드에 @ModelAttribute 어노테이션을 사용하면 메소드의 반환값을 속성값으로 저장하여 요청 처리 클래스의 모든 요청 처리 메소드의 뷰에게 제공
  • 매개변수에 @ModelAttribute 어노테이션을 사용하면 매개변수에 저장된 값을 속성값으로 저장하여 요청 처리 메소드의 뷰에게 제공
  • value 속성 : 뷰(JSP)에서 속성값을 사용하기 위한 속성명을 속성값으로 설정
  • 다른 속성이 없는 경우 속성값만 설정 가능
  • public String join(@ModelAttribute(value = "id") String id, @ModelAttribute("passwd") String passwd){}

• DTO 클래스로 객체를 생성하여 전달값을 매개변수로 제공받아 객체의 필드값으로 저장
  • Member member=new Member(); member.setId(id); model.addAttribute("member", member);
• Model.addAttribute(Object attributeValue) : Model 객체에 속성명과 속성값(객체)을 저장하기 위한 메소드 (Request Scope)
  • 속성값의 자료형(클래스이름)을 속성명으로 자동 설정 (첫문자는 소문자로 변환)
  • 속성값으로 원시값(Wrapper 객체) 또는 String 객체 저장 불가
  • model.addAttribute(member);

• 요청 페이지의 전달값이 있는 경우 요청 처리 메소드의 매개변수 자료형을 VO 클래스(DTO 클래스)로 작성하면 Front Controller는 VO 클래스로 객체를 생성하여 매개변수에 전달하여 저장
  • VO 클래스의 객체는 전달값의 이름과 같은 필드에 전달값을 제공받아 저장

• ★ Command 객체 : 전달값을 제공받아 필드에 저장된 객체로 속성값으로 저장하여 요청 처리 메소드의 뷰에서 사용될 수 있도록 제공
  • @ModelAttribute 어노테이션을 사용하여 객체를 속성값으로 저장해 뷰에게 제공 (첫문자는 소문자로 변환)
  • @ModelAttribute 어노테이션 생략 가능
  • value 속성을 생략하면 Command 객체의 자료형(클래스)이 속성명으로 자동 설정
  • public String join(@ModelAttribute Member member) {}
  • @ModelAttribute 어노테이션의 value 속성을 사용하여 뷰에게 제공될 속성값의 속성명을 변경 가능

• 요청 페이지의 전달값이 있는 경우 요청 처리 메소드의 매개변수 자료형을 Map 인터페이스로 작성하면 Front Controller는 Map 객체를 생성하여 매개변수에 전달하여 저장
  • Map 객체의 엔트리에는 전달값의 이름을 맵키(MapKey)로 제공받고 전달값을 맵값(MapValue)로 제공받아 저장
  • Map 인터페이스로 작성된 매개변수에는 반드시 @RequestParam 어노테이션을 사용해야만 Map 객체의 맵값으로 전달값을 제공받아 사용 가능
  • public String join(@RequestParam Map<String, Object> map, Model model) {}

package xyz.itwill10.controller;

@Controller
public class JoinController {
	@RequestMapping(value = "join", method=RequestMethod.GET)
	public String join() {
		return "join_form";
	}
	
	/*
	//전달값을 제공받아 Request Scope 속성값으로 저장하고 속성값을 출력하기 위한 JSP 문서의 
	//뷰이름을 반환하는 요청 처리 메소드
	// => 전달값과 같은 이름의 매개변수에 전달값을 제공받아 요청 처리 메소드에서 사용
	// => @RequestParam 어노테이션을 사용하여 매개변수와 같은 이름으로 전달되는 값이 없는 경우 400 에러코드 발생
	@RequestMapping(value = "join", method=RequestMethod.POST)
	public String join(@RequestParam String id, @RequestParam String passwd
			,@RequestParam String name,@RequestParam String email, Model model) {
		model.addAttribute("id", id);
		model.addAttribute("passwd", passwd);
		model.addAttribute("name", name);
		model.addAttribute("email", email);
		return "join_display";
	}
	*/
	
	/*
	//전달값을 제공받아 Request Scope 속성값으로 저장하고 속성값을 출력하기 위한 JSP 문서의 
	//뷰이름을 반환하는 요청 처리 메소드
	// => 전달값과 같은 이름의 매개변수에 전달값을 제공받아 요청 처리 메소드에서 사용
	// => @ModelAttribute 어노테이션을 사용하여 매개변수에 저장된 값을 속성값으로 저장하여 뷰(View) 제공
	//@ModelAttribute : 객체(값)을 뷰에게 제공하기 위한 어노테이션
	// => 메소드에 @ModelAttribute 어노테이션을 사용하면 메소드의 반환값을 속성값으로 저장하여
	//요청 처리 클래스의 모든 요청 처리 메소드의 뷰에게 제공
	// => 매개변수에 @ModelAttribute 어노테이션을 사용하면 매개변수에 저장된 값을 속성값으로 
	//저장하여 요청 처리 메소드의 뷰에게 제공
	//value 속성 : 뷰(JSP)에서 속성값을 사용하기 위한 속성명을 속성값으로 설정
	// => 다른 속성이 없는 경우 속성값만 설정 가능
	//@ModelAttribute 어노테이션을 사용하면 매개변수와 같은 이름의 전달값이 없어도 400 에러코드 미발생
	@RequestMapping(value = "join", method=RequestMethod.POST)
	public String join(@ModelAttribute("id") String id, @ModelAttribute("passwd") String passwd
			,@ModelAttribute("name") String name,@ModelAttribute("email") String email) {
		return "join_display";
	}
	*/
	
	/*
	//전달값을 매개변수로 제공받아 객체의 필드값으로 저장하고 객체를 Request Scope 속성값으로
	//저장하고 속성값을 출력하기 위한 JSP 문서의 뷰이름을 반환하는 요청 처리 메소드
	@RequestMapping(value = "join", method=RequestMethod.POST)
	public String join(@RequestParam String id, @RequestParam String passwd
			,@RequestParam String name,@RequestParam String email, Model model) {
		Member member=new Member();
		member.setId(id);
		member.setPasswd(passwd);
		member.setName(name);
		member.setEmail(email);
		
		//model.addAttribute("member", member);
		//Model.addAttribute(Object attributeValue) : Model 객체에 속성명과 속성값(객체)을  
		//저장하기 위한 메소드 - Request Scope
		// => 속성값의 자료형(클래스)을 속성명으로 자동 설정 - 첫문자는 소문자로 변환
		// => 속성값으로 원시값(Wrapper 객체) 또는 String 객체 저장 불가
		model.addAttribute(member);
		
		return "join_display";
	}
	*/

	/*
	//요청 페이지의 전달값이 있는 경우 요청 처리 메소드의 매개변수 자료형을 VO 클래스(DTO 클래스)로
	//작성하면 Front Controller는 VO 클래스로 객체를 생성하여 매개변수에 전달하여 저장
	// => VO 클래스의 객체는 전달값의 이름과 같은 필드에 전달값을 제공받아 저장
	//Command 객체 : 전달값을 제공받아 필드에 저장된 객체로 속성값으로 저장하여 요청 처리 
	//메소드의 뷰에서 사용될 수 있도록 제공
	// => @ModelAttribute 어노테이션을 사용하여 객체를 속성값으로 저장해 뷰에게 제공 - 첫문자는 소문자로 변환
	// => @ModelAttribute 어노테이션 생략 가능
	// => value 속성을 생략하면 Command 객체의 자료형(클래스)이 속성명으로 자동 설정
	@RequestMapping(value = "join", method=RequestMethod.POST)
	public String join(@ModelAttribute Member member) {
		return "join_display";
	}
	*/
	
	/*
	//@ModelAttribute 어노테이션의 value 속성을 사용하여 뷰에게 제공될 속성값의 속성명을 변경 가능
	@RequestMapping(value = "join", method=RequestMethod.POST)
	public String join(@ModelAttribute(value = "mem") Member member, Model model) {
		if(member.getId().equals("abc123")) {//아이디가 중복된 경우
			model.addAttribute("message", "이미 사용중인 아이디를 입력 하였습니다.");
			return "join_form";//입력페이지 이동
		}
		return "join_display";
	}
	*/

	//요청 페이지의 전달값이 있는 경우 요청 처리 메소드의 매개변수 자료형을 Map 인터페이스로
	//작성하면 Front Controller는 Map 객체를 생성하여 매개변수에 전달하여 저장
	// => Map 객체는 전달값의 이름을 맵키(MapKey - String)로 설정하여 전달값을 맵값
	//(MapValue - String)로 제공받아 엔트리로 추가
	// => Map 인터페이스로 작성된 매개변수에는 반드시 @RequestParam 어노테이션을 사용해야만
	//Map 객체의 맵값으로 전달값을 제공받아 사용 가능
	@RequestMapping(value = "join", method=RequestMethod.POST)
	public String join(@RequestParam Map<String, String> map, Model model) {
		model.addAttribute("mem", map);
		return "join_display";
	}
}

---

🌸 VO class (Member)

• 회원정보를 저장하기 위한 클래스 (VO 클래스) : 값을 저장할 목적의 객체를 생성하기 위한 클래스
  • DAO 클래스의 메소드에서 사용될 경우 DTO 클래스의 기능 제공
  • 전달값을 제공받아 저장하기 위해서는 반드시 전달값의 이름과 필드의 이름이 같도록 작성

package xyz.itwill10.dto;

import lombok.Data;

@Data
public class Member {
	private String id;
	private String passwd;
	private String name;
	private String email;
}

---

🐣 응답 (input)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>회원가입</h1>
	<hr>
	<form action="join" method="post">
	<table>
		<tr>
			<td>아이디</td>
			<td><input type="text" name="id" value="${mem.id }"></td>
		</tr>
		<tr>
			<td>비밀번호</td>
			<td><input type="password" name="passwd" value="${mem.passwd }"></td>
		</tr>
		<tr>
			<td>이름</td>
			<td><input type="text" name="name" value="${mem.name }"></td>
		</tr>
		<tr>
			<td>이메일</td>
			<td><input type="text" name="email" value="${mem.email }"></td>
		</tr>
		<tr>
			<td colspan="2"><button type="submit">회원가입</button></td>
		</tr>
	</table>
	</form>
	<p style="color: red;">${message }</p>
</body>
</html>

---

🐣 응답 (output)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>회원가입확인</h1>
	<hr>
	<%-- 
	<ul>
		<li>아이디 = ${id }</li>
		<li>비밀번호 = ${passwd }</li>
		<li>이름 = ${name }</li>
		<li>이메일 = ${email }</li>
	</ul>
	--%>
	
	<%-- 
	<ul>
		<li>아이디 = ${member.id }</li>
		<li>비밀번호 = ${member.passwd }</li>
		<li>이름 = ${member.name }</li>
		<li>이메일 = ${member.email }</li>
	</ul>
	--%>
	
	<ul>
		<li>아이디 = ${mem.id }</li>
		<li>비밀번호 = ${mem.passwd }</li>
		<li>이름 = ${mem.name }</li>
		<li>이메일 = ${mem.email }</li>
	</ul>
</body>
</html>

---

📙 Model (session)

• 전달값을 제공받아 인증 처리 후 권한 관련 정보를 Session Scope 속성값으로 저장하고 로그인 성공 메세지를 출력하는 JSP 문서의 뷰이름을 반환하는 요청 처리 메소드

  • 전달값을 String 매개변수에 하나씩 제공받아 사용 가능
  • Session Scope 속성값을 저장하기 위해 매개변수를 이용하여 HttpSession 객체를 제공받아 사용
  • public String login(@RequestParam String id, HttpSession session, Model model) {}
  • 에러 관련 정보를 Request Scope 속성값 저장 (입력페이지(JSP)에서 출력 가능)
  • Request Scope : 현재 실행중인 요청 처리 메소드와 포워드 이동되는 뷰에서만 속성값 제공받아 사용
  • model.addAttribute("message", "아이디 또는 비밀번호을 잘못 입력 하였습니다.");
  • 인증 성공 (권한 관련 정보를 Session Scope 속성값 저장)
  • Session Scope : 동일한 세션을 사용하는 모든 요청 처리 메소드와 뷰에서 속성값을 제공받아 사용 가능 (같은 클라이언트 요청)
  • session.setAttribute("loginId", id);

• 전달값을 Command 객체로 제공받아 사용

  • public String login(@ModelAttribute Member member, HttpSession session, Model model) {}

package xyz.itwill10.controller;

@Controller
public class LoginController {
	@RequestMapping(value = "/login", method = RequestMethod.GET)
	public String login() {
		return "login_form";
	}
	
	/*
	//전달값을 제공받아 인증 처리 후 권한 관련 정보를 Session Scope 속성값으로 저장하고
	//로그인 성공 메세지를 출력하는 JSP 문서의 뷰이름을 반환하는 요청 처리 메소드
	// => 전달값을 String 매개변수에 하나씩 제공받아 사용 가능 
	// => Session Scope 속성값을 저장하기 위해 매개변수를 이용하여 HttpSession 객체를 제공받아 사용
	@RequestMapping(value = "/login", method = RequestMethod.POST)
	public String login(@RequestParam String id, @RequestParam String passwd
			, HttpSession session, Model model) {
		if(!id.equals("abc123") || !passwd.equals("123456")) {//인증 실패
			//에러 관련 정보를 Request Scope 속성값 저장 - 입력페이지(JSP)에서 출력 가능
			//Request Scope : 현재 실행중인 요청 처리 메소드와 포워드 이동되는 뷰에서만 속성값만 제공받아 사용
			model.addAttribute("message", "아이디 또는 비밀번호을 잘못 입력 하였습니다.");
			model.addAttribute("id",id);
			return "login_form";//입력페이지 이동
		}
		
		//인증 성공 - 권한 관련 정보를 Session Scope 속성값 저장
		//Session Scope : 동일한 세션을 사용하는 모든 요청 처리 메소드와 뷰에서 속성값을 제공받아 사용 가능
		session.setAttribute("loginId", id);
		
		return "login_display";
	}
	*/
	
	//전달값을 Command 객체로 제공받아 사용
	@RequestMapping(value = "/login", method = RequestMethod.POST)
	public String login(@ModelAttribute Member member, HttpSession session, Model model) {
		if(!member.getId().equals("abc123") || !member.getPasswd().equals("123456")) {//인증 실패
			model.addAttribute("message", "아이디 또는 비밀번호을 잘못 입력 하였습니다.");
			return "login_form";//입력페이지 이동
		}
		session.setAttribute("loginId", member.getId());
		return "login_display";
	}
}

---

🐣 응답 (input)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>로그인</h1>
	<hr>
	<form action="login" method="post">
	<table>
		<tr>
			<td>아이디</td>
			<%-- <td><input type="text" name="id" value="${id }"></td> --%>
			<td><input type="text" name="id" value="${member.id }"></td>
		</tr>
		<tr>
			<td>비밀번호</td>
			<td><input type="password" name="passwd"></td>
		</tr>
		<tr>
			<td colspan="2"><button type="submit">로그인</button></td>
		</tr>
	</table>
	</form>
	<p style="color: red;">${message }</p>
</body>
</html>

---

🐣 응답 (output)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>로그인 성공</h1>
	<hr>
	<h2>${loginId }님, 환영합니다.</h2>
</body>
</html>

---

🎀 @SessionAttributes

• @SessionAttributes : Model 객체를 사용하여 저장되는 속성값을 현재 요청 처리 클래스(Controller클래스)의 모든 요청 처리 메소드와 뷰에게 제공하는 어노테이션

  • Model 객체를 사용하여 저장되는 속성값을 Request Scope 속성값이 아닌 제한적인 Session Scope 속성값으로 변환하여 제공하는 어노테이션
  • 변경 처리시 호출되는 요청 처리 메소드에서 변경할 객체를 검색하지 않고 뷰에서는 값을 전달하지 않도록 제한적인 Session Scope 속성값 사용
  • value 속성 : 제한적인 Session Scope 속성값으로 변환하기 위한 속성명을 속성값으로 설정
  • 다른 속성이 없는 경우 속성값만 설정 가능

• 아이디를 전달받아 회원정보를 뷰에게 제공하기 위한 요청 처리 메소드 (요청 처리 메소드에 의해 제공된 회원정보를 입력태그의 초기값으로 사용되도록 뷰 작성)
  • Model 객체를 사용하여 검색된 회원정보를 속성값으로 저장하여 뷰에게 제공
  • 요청 처리 메소드의 뷰에게만 속성값을 제공하여 출력 처리 (Request Scope)
  • 속성값으로 저장된 객체의 자료형(클래스의 이름 - 첫문자는 소문자로 변환)이 자동으로 속성명으로 설정
  • @SessionAttributes 어노테이션에 의해 Model 객체로 저장된 속성값은 제한적인 Session Scope 속성값으로 변환되어 현재 요청 처리 클래스의 모든 요청 처리 메소드와 뷰에게 속성값 제공
  • model.addAttribute(hewon);//속성명 생략 가능

• 회원정보를 전달받아 변경된 회원정보를 뷰에게 제공하는 요청 처리 메소드
  • 요청 처리 메소드의 매개변수에는 Command 객체로 @SessionAttributes 어노테이션에 의해 제공된 회원정보를 전달받아 저장하고 변경값으로 필드값만 변경해 사용
  • 요청 처리 메소드에 SessionStatus 인터페이스로 매개변수를 선언하면 SessionStatus 객체를 제공받아 사용 가능
  • SessionStatus 객체 : @SessionAttributes 어노테이션에 의해 제공된 제한적인 Session Scope 속성값의 상태정보를 저장하기 위한 객체

package xyz.itwill10.controller;

@Controller
//@SessionAttributes : Model 객체를 사용하여 저장되는 속성값을 현재 요청 처리 클래스(Controller
//클래스)의 모든 요청 처리 메소드와 뷰에게 제공하는 어노테이션
// => Model 객체를 사용하여 저장되는 속성값을 Request Scope 속성값이 아닌 제한적인 Session Scope
//속성값으로 변환하여 제공하는 어노테이션
// => 변경 처리시 호출되는 요청 처리 메소드에서 변경할 객체를 검색하지 않고 뷰에서는 값을 
//전달하지 않도록 제한적인 Session Scope 속성값 사용
//value 속성 : 제한적인 Session Scope 속성값으로 변환하기 위한 속성명을 속성값으로 설정
// => 다른 속성이 없는 경우 속성값만 설정 가능
@SessionAttributes("hewon")
public class SessionController {
	//아이디를 전달받아 회원정보를 검색하여 반환하는 메소드 - Service 클래스의 메소드
	private Hewon getHewon(String id) {
		Hewon hewon=new Hewon();
		hewon.setId(id);
		hewon.setName("홍길동");
		hewon.setEmail("abc@itwill.xyz");
		return hewon;
	}
	
	//아이디를 전달받아 회원정보를 뷰에게 제공하기 위한 요청 처리 메소드
	// => 요청 처리 메소드에 의해 제공된 회원정보가 출력되도록 뷰 작성
	@RequestMapping("/hewon_view")
	public String view(@RequestParam(defaultValue = "abc123") String id, Model model) {
		//Service 클래스의 메소드를 호출하여 아이디를 전달해 해당 아이디의 회원정보를 
		//검색하여 반환받아 저장
		Hewon hewon=getHewon(id);
		
		//Model 객체를 사용하여 검색된 회원정보를 속성값으로 저장하여 뷰에게 제공 
		// => 요청 처리 메소드의 뷰에게만 속성값을 제공하여 출력 처리 - Request Scope
		//model.addAttribute("hewon", hewon);
		//속성값으로 저장된 객체의 자료형(클래스의 이름 - 첫문자는 소문자로 변환)이 자동으로 속성명으로 설정
		//@SessionAttributes 어노테이션에 의해 Model 객체로 저장된 속성값은 제한적인 Session Scope 
		//속성값으로 변환되어 현재 요청 처리 클래스의 모든 요청 처리 메소드와 뷰에게 속성값 제공
		model.addAttribute(hewon);//속성명 생략 가능  
		
		return "hewon_view";
	}
	
	/*
	//아이디를 전달받아 회원정보를 뷰에게 제공하기 위한 요청 처리 메소드
	// => 요청 처리 메소드에 의해 제공된 회원정보를 입력태그의 초기값으로 사용되도록 뷰 작성
	@RequestMapping(value="/hewon_update", method = RequestMethod.GET)
	public String update(@RequestParam(defaultValue = "abc123") String id, Model model) {
		Hewon hewon=getHewon(id);
		model.addAttribute(hewon);
		return "hewon_update";
	}
	*/
	
	//@SessionAttributes 어노테이션에 의해 제공된 회원정보를 요청 처리 메소드와 뷰에서 사용 가능
	// => 아이디를 전달받아 회원정보를 검색하는 명령과 뷰에게 제공하기 위한 속성값 저장 불필요
	@RequestMapping(value="/hewon_update", method = RequestMethod.GET)
	public String update() {
		return "hewon_update";
	}

	//회원정보를 전달받아 변경된 회원정보를 뷰에게 제공하는 요청 처리 메소드
	// => 요청 처리 메소드의 매개변수에는 Command 객체로 @SessionAttributes 어노테이션에 의해
	//제공된 회원정보를 전달받아 저장하고 변경값으로 필드값만 변경해 사용 
	//요청 처리 메소드에 SessionStatus 인터페이스로 매개변수를 선언하면 SessionStatus 객체를
	//제공받아 사용 가능
	// => SessionStatus 객체 : @SessionAttributes 어노테이션에 의해 제공된 제한적인 Session
	//Scope 속성값의 상태정보를 저장하기 위한 객체
	@RequestMapping(value="/hewon_update", method = RequestMethod.POST)
	public String update(@ModelAttribute Hewon hewon, SessionStatus status) {
		//SessionStatus.setComplete() : @SessionAttributes 어노테이션에 의해 제공된 제한적인
		//Session Scope 속성값을 제거하는 메소드
		status.setComplete();
		return "hewon_result";
	}
}

---

🐣 hewon_view.jsp

• 회원정보 변경페이지를 요청할 수 있는 링크 제공 (아이디 전달)

• @SessionAttributes 어노테이션을 사용한 경우 아이디를 전달하지 않아도 회원정보 변경 페이지의 요청 처리 메소드에서 회원정보를 제공받아 사용 가능

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>회원정보</h1>
	<hr>
	<ul>
		<li>아이디 = ${hewon.id }</li>
		<li>이름 = ${hewon.name }</li>
		<li>이메일 = ${hewon.email }</li>
	</ul>
	
	<%-- <button type="button" onclick="location.href='hewon_update?id=${hewon.id}';">회원정보변경</button> --%>
	<%-- @SessionAttributes 어노테이션을 사용한 경우 아이디를 전달하지 않아도 회원정보 변경
	페이지의 요청 처리 메소드에서 회원정보를 제공받아 사용 가능 --%>
	<button type="button" onclick="location.href='hewon_update';">회원정보변경</button>
</body>
</html>

---

🐣 hewon_update.jsp

• 회원정보를 변경하기 위해 hidden 타입의 입력태그로 아이디 전달

  • 아이디를 입력태그의 초기값으로 설정하여 read-only 속성을 사용해 전달 가능

• @SessionAttributes 어노테이션을 사용한 경우 아이디를 전달하지 않아도 회원정보 변경페이지의 요청 처리 메소드에서 회원정보를 제공받아 사용 가능

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>회원정보변경</h1>
	<hr>
	<form action="hewon_update" method="post">
	<!-- 회원정보를 변경하기 위해 hidden 타입의 입력태그로 아이디 전달 -->
	<!-- => 아이디를 입력태그의 초기값으로 설정하여 read-only 속성을 사용해 전달 가능 -->
	<%-- @SessionAttributes 어노테이션을 사용한 경우 아이디를 전달하지 않아도 회원정보 변경
	페이지의 요청 처리 메소드에서 회원정보를 제공받아 사용 가능 --%>
	<%-- <input type="hidden" name="id" value="${hewon.id }"> --%>
	<table>
		<tr>
			<td>아이디</td>
			<td>${hewon.id }</td>
		</tr>
		<tr>
			<td>이름</td>
			<td><input type="text" name="name" value="${hewon.name }"></td>
		</tr>
		<tr>
			<td>이메일</td>
			<td><input type="text" name="email" value="${hewon.email }"></td>
		</tr>
		<tr>
			<td colspan="2"><button type="submit">회원변경</button></td>
		</tr>
	</table>	
	</form>
</body>
</html>

---

📙 Model (redirect)

• Front Controller는 제공받은 뷰이름을 InternalResourceViewResolver 객체를 사용하여 JSP 문서로 변환하고 JSP 문서로 포워드 이동하여 응답 처리

  • 포워드 이동 : 서버 내부에서 현재 웹프로그램의 스레드를 다른 웹프로그램으로 이동하여 명령 실행
  • 클라이언트의 요청 URL 주소는 변경되지 않으며 Request Scope 속성값을 객체로 제공받아 사용 가능

• 뷰이름에 redirect 접두사를 사용하여 URL 주소를 반환하면 Front Controller는 반환받은 뷰이름의 URL 주소를 클라이언트에게 전달 (리다이렉트 이동)

  • 클라이언트에게 URL 주소를 전달하여 응답 처리하면 클라이언트는 해당 URL 주소로 브라우저의 주소를 변경하고 서버에 URL 주소의 페이지 요청 처리
  • 리다이렉트 이동 : 클라이언트에게 URL 주소를 전달하여 페이지를 재요청하여 웹프로그램의 명령 실행
  • 클라이언트의 요청 URL 주소 변경되지만 Request Scope 속성값 사용 불가능
  • return "redirect:/redirect_move";
  • Model 객체에 저장된 속성값은 리다이렉트 이동된 페이지의 요청 처리 메소드와 뷰에서 사용 불가능

• RedirectAttributes 객체 : 리다이렉트 이동되는 페이지의 요청 처리 메소드와 뷰에서 사용 가능한 Request Scope 속성값을 제공하는 객체

  • RedirectAttributes.addFlashAttribute(String attributeName, Object attributeValue) : 속성명과 속성값을 저장하여 리다이렉트 이동되는 페이지의 요청 처리 메소드와 뷰에게 속성값을 제공하기 위한 메소드 (Request Scope)
  • public String redirect(RedirectAttributes attributes) {attributes.addFlashAttribute("name", "임꺽정");}

package xyz.itwill10.controller;

@Controller
public class RedirectController {
	@RequestMapping("/forward_move")
	public String forward(Model model) {
		//Model 객체를 이용하여 뷰(View)에게 제공할 객체를 속성값으로 저장 - Request Scope
		model.addAttribute("name", "홍길동");
		//뷰를 생성하기 위한 뷰이름(ViewName) 반환
		// => Front Controller는 제공받은 뷰이름을 InternalResourceViewResolver 객체를 사용하여 
		//JSP 문서로 변환하고 JSP 문서로 포워드 이동하여 응답 처리
		//포워드 이동 : 서버 내부에서 현재 웹프로그램의 스레드를 다른 웹프로그램으로 이동하여 명령 실행
		// => 클라이언트의 요청 URL 주소는 변경되지 않으며 Request Scope 속성값을 객체로 제공받아 사용 가능
		return "display_forward";
	}
	
	/*
	@RequestMapping("/redirect_move")
	public String redirect(Model model) {
		model.addAttribute("name", "임꺽정");
		return "display_redirect";
	}
	
	@RequestMapping("/redirect")
	public String redirect() {
		//뷰이름에 redirect 접두사를 사용하여 URL 주소를 반환하면 Front Controller는
		//반환받은 뷰이름의 URL 주소를 클라이언트에게 전달 - 리다이렉트 이동
		// => 클라이언트에게 URL 주소를 전달하여 응답 처리하면 클라이언트는 해당 URL 주소로
		//브라우저의 주소를 변경하고 서버에 URL 주소의 페이지 요청 처리
		//리다이렉트 이동 : 클라이언트에게 URL 주소를 전달하여 페이지를 재요청하여 웹프로그램의 명령 실행
		// => 클라이언트의 요청 URL 주소 변경되지만 Request Scope 속성값 사용 불가능
		return "redirect:/redirect_move";
	}
	*/
	
	@RequestMapping("/redirect_move")
	public String redirect() {
		return "display_redirect";
	}
	
	/*
	@RequestMapping("/redirect")
	public String redirect(Model model) {
		//Model 객체에 저장된 속성값은 리다이렉트 이동된 페이지의 요청 처리 메소드와 뷰에서 사용 불가능
		model.addAttribute("name", "임꺽정");//Request Scope
		return "redirect:/redirect_move";
	}
	*/

	//RedirectAttributes 객체 : 리다이렉트 이동되는 페이지의 요청 처리 메소드와 뷰에서 사용
	//가능한 Request Scope 속성값을 제공하는 객체  
	@RequestMapping("/redirect")
	public String redirect(RedirectAttributes attributes) {
		//RedirectAttributes.addFlashAttribute(String attributeName, Object attributeValue)
		// => 속성명과 속성값을 저장하여 리다이렉트 이동되는 페이지의 요청 처리 메소드와
		//뷰에게 속성값을 제공하기 위한 메소드 - Request Scope
		attributes.addFlashAttribute("name", "임꺽정");
		return "redirect:/redirect_move";
	}
}

---

🐣 응답 (forword)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>포워드 이동</h1>
	<hr>
	<h2>${name }님, 환영합니다.</h2>
</body>
</html>

---

🐣 응답 (redirect)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
</head>
<body>
	<h1>리다이렉트 이동</h1>
	<hr>
	<h2>${name }님, 환영합니다.</h2>
</body>
</html>

---

📕 servlet-context.xml (resource)

• resources : 클라이언트 요청을 Front Controller가 직접 응답 처리되도록 설정하는 엘리먼트
  • 클라이언트의 리소스 파일 요청에 대한 응답 처리를 위해 사용하는 엘리먼트
  • mapping 속성 : 클라이언트에 의해 요청되는 리소스 파일의 요청 URL 주소 패턴을 속성값으로 설정
  • [**] 패턴문자를 속성값으로 사용한 경우 현재 폴더 및 하위 폴더의 리소스 파일 요청 가능
  • location 속성 : 클라이언트 요청에 의해 리소스 파일을 검색하기 위한 폴더를 속성값으로 설정
  • <resources mapping="/images/**" location="/resources/images/" />

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">


	<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
	<!-- resources : 클라이언트 요청을 Front Controller가 직접 응답 처리되도록 설정하는 엘리먼트 -->
	<!-- => 클라이언트의 리소스 파일 요청에 대한 응답 처리를 위해 사용하는 엘리먼트 -->
	<!-- mapping 속성 : 클라이언트에 의해 요청되는 리소스 파일의 요청 URL 주소 패턴을 속성값으로 설정 -->
	<!-- => [**] 패턴문자를 속성값으로 사용한 경우 현재 폴더 및 하위 폴더의 리소스 파일 요청 가능 -->
	<!-- location 속성 : 클라이언트 요청에 의해 리소스 파일을 검색하기 위한 폴더를 속성값으로 설정 -->
	<!-- <resources mapping="/resources/**" location="/resources/" /> -->
	<resources mapping="/images/**" location="/resources/images/" />
	<resources mapping="/css/**" location="/resources/css/" />


</beans:beans>

---

📙 Model (resource)

package xyz.itwill10.controller;

@Controller
public class ResourceController {
	@RequestMapping("/resource")
	public String resource() {
		return "resource_display";
	}
}

---

🐣 응답 (img)

• 리소스 파일(Resource File) : 클라이언트가 웹문서(HTML 문서)를 해석하여 실행하기 위해 필요한 정보를 제공하는 서버에 저장된 파일
  • CSS 파일, JavaScript Source 파일, 멀티미디어 파일 등
  • 리소스 파일을 WEB-INF 폴더에 저장할 경우 클라이언트는 리소스 파일 요청 불가능
  • WEB-INF 폴더 : 웹서버에서 실행되는 프로그램(서블릿)에서만 접근 가능한 폴더 (클라이언트에게는 은닉화 처리)

• SpringMvc 프로그램에서는 클라이언트의 모든 요청을 Front Controller를 이용하여 처리되도록 설정

  • 문제점 : 클라이언트가 서버의 리소스 파일을 요청할 경우 Front Controller가 요청을 받아 리소스 파일의 요청 URL 주소와 매핑된 요청 처리 메소드를 검색하지만 없으므로 404 에러코드 발생
  • Front Controller을 특정 확장자로 페이지를 요청하는 경우 제외 (*.do)
  • 해결법) 클라이언트가 리소스 파일을 요청한 경우 Front Controller가 요청 처리 메소드를 호출하지 않고 직접 응답되도록 Spring Bean Configuration File 설정 → servlet-context.xml
    

• 리소스 파일을 상대경로로 표현하여 처리한 경우 페이지의 요청 URL 주소 경로와 리소스 파일의 경로가 다른 경우 404 에러코드 발생 (리소스 파일은 절대경로로 표현하는 것을 권장)

  • <img src="images/Koala.jpg" width="200">

• 컨텍스트 이름이 변경될 경우 컨텍스트 경로가 변경되어 404 에러 코드 발생

  • 컨텍스트 경로는 직접 지정하지 않고 객체로 제공받아 사용
  • <img src="/spring/images/Koala.jpg" width="200">

• 컨텍스트 경로를 EL의 pageContext 내장객체로 제공받아 사용

  • <img src="${pageContext.request.contextPath }/images/Koala.jpg">

• 컨텍스트 경로를 Core 태그 라이브러리의 URL 태그로 제공받아 사용

  • <img src="<c:url value="/images/Koala.jpg"/>" width="200">

• 컨텍스트 경로를 Spring 태그 라이브러리의 URL 태그로 제공받아 사용

  • <img src="<spring:url value="/images/Koala.jpg"/>" width="200">

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>    
<%@taglib prefix="spring" uri="http://www.springframework.org/tags"%>    
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>SPRING</title>
<link href="<c:url value="/css/style.css"/>" type="text/css" rel="stylesheet">
</head>
<body>
	<h1 class="text">리소스 파일</h1>
	<hr>
	<%-- 리소스 파일(Resource File) : 클라이언트가 웹문서(HTML 문서)를 해석하여 실행하기 
	위해 필요한	정보를 제공하는 서버에 저장된 파일 --%>
	<%-- => CSS 파일, JavaScript Source 파일, 멀티미디어 파일 등 --%>
	<%-- => 리소스 파일을 WEB-INF 폴더에 저장할 경우 클라이언트는 리소스 파일 요청 불가능  --%>
	<%-- WEB-INF 폴더 : 웹서버에서 실행되는 프로그램(서블릿)에서만 접근 가능한 폴더 - 클라이언트에게는 은닉화 처리 --%>
	
	<%-- SpringMvc 프로그램에서는 클라이언트의 모든 요청을 Front Controller를 이용하여 처리되도록 설정 --%>
	<%-- 문제점)클라이언트가 서버의 리소스 파일을 요청할 경우 Front Controller가 요청을 받아 리소스 
	파일의 요청 URL 주소와 매핑된 요청 처리 메소드를 검색하지만 없으므로 404 에러코드 발생 --%>
	<%-- => Front Controller을 특정 확장자로 페이지를 요청하는 경우 제외 --%>
	<%-- 해결법)클라이언트가 리소스 파일을 요청한 경우 Front Controller가 요청 처리 메소드를 
	호출하지 않고 직접 응답되도록 Spring Bean Configuration File 설정 - servlet-context.xml --%>
	
	<%-- 리소스 파일을 상대경로로 표현하여 처리한 경우 페이지의 요청 URL 주소 경로와 리소스 
	파일의 경로가 다른 경우 404 에러코드 발생 - 리소스 파일은 절대경로로 표현하는 것을 권장 --%>
	<%-- <img src="resources/Koala.jpg" width="200"> --%>
	<img src="images/Koala.jpg" width="200">
	
	<%-- 컨텍스트 이름이 변경될 경우 컨텍스트 경로가 변경되어 404 에러 코드 발생 --%>
	<%-- => 컨텍스트 경로는 직접 지정하지 않고 객체로 제공받아 사용 --%>
	<img src="/spring/images/Koala.jpg" width="200">
	
	<%-- 컨텍스트 경로를 EL의 pageContext 내장객체로 제공받아 사용 --%>
	<img src="${pageContext.request.contextPath }/images/Koala.jpg" width="200">

	<%-- 컨텍스트 경로를 Core 태그 라이브러리의 URL 태그로 제공받아 사용 --%>
	<img src="<c:url value="/images/Koala.jpg"/>" width="200">

	<%-- 컨텍스트 경로를 Spring	태그 라이브러리의 URL 태그로 제공받아 사용 --%>
	<img src="<spring:url value="/images/Koala.jpg"/>" width="200">
</body>
</html>

---