Spring 11 MVC(Spring) 총정리

Kang.__.Mingu·2024년 9월 10일

Controller MVC filter spring mvc 어노테이션

Spring

목록 보기

10/21

Spring MVC 처리 흐름

클라이언트 요청 (1):
- 클라이언트가 브라우저를 통해 서버에 요청을 보냅니다. 이 요청은 특정 URL을 통해 들어오며, Spring MVC의 DispatcherServlet이 가장 먼저 이를 받아들이게 됩니다.
DispatcherServlet (2):
- Spring MVC의 Front Controller 역할을 하는 DispatcherServlet은 모든 요청을 중앙에서 처리합니다.
- 요청을 수신한 후, 적절한 HandlerMapping을 사용해 요청을 처리할 수 있는 적절한 컨트롤러(Controller)를 찾습니다.
HandlerMapping (3):
- HandlerMapping은 요청 URL과 매핑된 컨트롤러를 찾는 역할을 합니다. 요청 URL과 일치하는 컨트롤러를 반환하여 DispatcherServlet에 전달합니다.
Controller (4):
- DispatcherServlet은 HandlerMapping에 의해 찾아진 컨트롤러를 호출하여 요청을 처리합니다.
- 컨트롤러는 비즈니스 로직을 수행하고, 처리 결과를 ModelAndView 객체에 담아 반환합니다. ModelAndView는 뷰 이름과 모델 데이터를 포함하고 있습니다.
ViewResolver (5):
- DispatcherServlet은 ModelAndView 객체에서 뷰 이름을 추출하고, ViewResolver를 사용해 해당 뷰의 실제 경로를 찾습니다.
- ViewResolver는 논리적인 뷰 이름을 실제 JSP, Thymeleaf 등과 같은 템플릿 파일의 물리적인 경로로 변환해줍니다.
View (6):
- ViewResolver에 의해 찾아진 뷰가 최종적으로 렌더링됩니다. 이 과정에서 모델에 담겨 있는 데이터를 사용해 동적 HTML을 생성하게 됩니다.

렌더링된 결과는 DispatcherServlet을 통해 클라이언트에게 응답으로 반환됩니다.

##핵심 역할 요약

DispatcherServlet: Spring MVC의 중심 역할을 하며, 모든 요청을 관리하고 적절한 구성 요소들(컨트롤러, 뷰 리졸버 등)과 상호작용하여 요청을 처리합니다.
HandlerMapping: 요청 URL에 매핑된 적절한 컨트롤러를 찾아 반환합니다.
Controller: 실제 비즈니스 로직을 수행하고, 처리 결과를 ModelAndView에 담아 반환합니다.
ViewResolver: 논리적인 뷰 이름을 실제 뷰 경로로 변환합니다.
View: 최종적으로 클라이언트에게 보여질 응답 화면을 렌더링합니다.

@Controller

요청 처리 클래스(Controller 클래스)를 Spring Bean으로 등록하기 위한 어노테이션
클래스의 이름을 Spring Bean을 구분하는 식별자(beanName)으로 사용
@Controller 어노테이션을 사용하여 Controller 인터페이스를 상속받지 않아도 요청 처리 클래스로 사용할 수 있음
메소드에 @RequestMapping 어노테이션을 사용해 요청 처리 메소드로 사용되도록 작성
=> @RequestMapping 어노테이션을 사용한 요청 처리 메소드를 여러개 등록하여 사용 가능

servlet-context.xml

@Controller 어노테이션을 사용하려면 <context:component-scan /> 엘리먼트를 이용하여 Controller 패키지를 등록하여 패키지 내에 @Controller 어노테이션을 작성한 모든 클래스를 Spring Container가 관리하는 Spring Bean으로 등록해야한다.

@RequestMapping

Controller 클래스의 메소드를 요청 처리 메소드로 설정하기 위한 어노테이션
=> 클라이언트의 모든 요청방식(Method - GET, POST, PUT, PATCH, DELETE 등)에 의해 호출되는 요청 처리 메소드를 작성할 때 사용
value 속성: 클라이언트의 요청정보(Command - URL 주소)를 속성값으로 설정
ex) @RequestMapping(value = "/hello")

ModelAndView 객체를 사용하여 요청에 대한 처리 결과와 뷰이름을 저장하여 return하면 해당 뷰가 호출된다.

Setter 메소드로 뷰이름 저장

ModelAndView modelAndView=new ModelAndView();
modelAndView.setViewName("hello");//Setter 메소드로 뷰이름 저장
return modelAndView;
	```

생성자로 뷰이름 저장

ModelAndView modelAndView=new ModelAndView("hello");//생성자로 뷰이름 저장
return modelAndView;

요청 처리 메소드의 명령으로 생성된 결과값을 뷰(JSP)에게 제공하는 방법

ModelAndView 객체로 addObject() 메소드를 호출해 결과값을 속성값으로 저장하여 제공
HttpServletRequest 객체로 setAttribute() 메소드를 호출해 결과값을 속성값으로 저장하여 제공
Model 객체로 addAttribute() 메소드를 호출해 결과값을 속성값으로 저장하여 제공

객체에 요청 처리 메소드의 실행결과를 속성값으로 저장하기 위한 메소드를 Request Scope라고 한다.
뷰(JSP)에서는 EL을 사용해 속성명으로 속성값을 객체로 제공받아 응답처리할 수 있다 => ${myName}

ModelAndView 버전

요청 처리 메소드에 매개변수를 작성하면 Front Controller이 스프링 컨테이너(WebApplicationContext 객체)로부터 객체를 제공받아 매개변수에 저장해 사용되도록 제공

	@RequestMapping("/resultMav")
	public ModelAndView modelAndViewResult(ModelAndView modelAndView) {
		modelAndView.setViewName("result_display");
		modelAndView.addObject("mavName", "홍길동");
		return modelAndView;		
	}

HttpServletRequest 버전

HttpServletRequest.setAttribute(String attributeName, Object attributeValue)
=> HttpServletRequest 객체에 요청 처리 메소드의 실행결과를 속성값으로 저장하기 위한 메소드 -> Request Scope

	@RequestMapping("/resultRequest")
	public String requestResult(HttpServletRequest request) {
    	request.setAttribute("requestName", "임꺽정");
		return "result_display";
	}

Model 버전

Model 객체: 요청 처리 메소드의 처리 결과값을 뷰에게 제공하기 위한 객체
Model.addAttribute(String attributename, Object attributeValue)
=> Model 객체에 요청 처리 메소드의 실행결과를 속성값으로 저장하기 위한 메소드 -> Request Scope

	@RequestMapping("/resultModel")
	public String modelResult(Model model) {
    	model.addAttribute("modelName", "전우치");
		return "result_display";
	}

`Model` 객체란?

Model객체는 컨트롤러에서 데이터를 담아 뷰로 전달하는 역할을 한다. 뷰에서 사용될 데이터(속성)를 저장하고, 이를 Request Scope에 담아 뷰에서 쉽게 접근할 수 있도록 한다.

-> 쉽게 말해서 임시 데이터 저장소이다.

	@RequestMapping("/resultModel")
	public String modelResult(Model model) {
		model.addAttribute("modelName", "전우치");
		return "result_display";
	}

@ModelAttribute

값(객체)를 뷰(View)에게 제공하기 위한 어노테이션
=> 요청 처리 클래스의 메소드에 @ModelAttribute 어노테이션을 사용하면 메소드 반환값을 현재 Controller 클래스에 작성된 모든 요청 처리 메소드의 뷰에게 제공한다.
value 속성: 메소드의 반환값을 뷰에서 사용하기 위한 속성명을 속성값으로 설정
Controller 클래스에 작성된 모든 뷰에게 제공하는 메서드이기 때문에 EL로 value 속성에 있는 식별자로 호출 가능

@RequestMapping(value, method = GET, POST)

사용자로부터 값을 입력받기 위한 JSP 문서의 뷰이름을 반환하는 요청 처리
=> 클라이언트가 페이지를 GET 방식으로 요청한 경우에만 요청 처리 메소드를 호출할 수 있도록 설정 가능
method 속성: RequestMethod(Enum 자료형)의 상수필드 중 하나를 속성값으로 설정
- RequestMethod(Enum 자료형)에는 클라이언트의 요청방식을 상수필드로 제공
- method 속성값과 다른 요청방식으로 페이지를 요청한 경우 405 에러코드로 응답 처리
GET 방식은 @GetMapping 어노테이션도 사용 가능

	@RequestMapping(value = "/method", method = RequestMethod.GET)
	public String inputTwo() {
		return "method_input2";
	}

전달값을 반환받아 Request Scope 속성값으로 저장하고 속성값을 제공받아 출력할 수 있는 JSP 문서의 뷰이름을 반환하는 요청 처리 메소드
=> method 속성을 사용해 POST 방식으로 요청한 경우에만 요청 처리 메소드가 실행되도록 설정
@RequestMapping 어노테이션의 value 속성값이 중복되어도 method 속성값이 다르면 에러 미발생
POST방식은 @PostMapping 어노테이션 사용 가능

GET, POST 복습

GET 메서드

정의 및 용도
- GET 메서드는 클라이언트가 서버에서 데이터를 요청할 때 사용된다. 일반적으로 웹 페이지를 열거나, 서버에서 데이터를 조회할 때 사용된다.
- GET 요청은 데이터를 서버로 보내지 않고 URL에 쿼리 파라미터를 포함시켜 필요한 정보를 서버에 전달한다.
클라이언트 관점
- 브라우저 주소창: 사용자가 URL을 입력하거나, 북마크를 이용하거나, 하이퍼링크를 클릭할 때 GET 요청이 발생한다.
- 쿼리 파라미터: 데이터가 URL에 쿼리 문자열로 포함되므로, ?key=value&key2=value2 형식으로 보인다.
- 캐싱 가능: GET 요청은 서버에서 데이터를 조회하기 위한 목적이므로, 브라우저나 프록시 서버에 의해 캐싱될 수 있다.
- 데이터 전송 제한: GET 요청은 URL에 데이터를 포함하기 때문에 전송할 수 있는 데이터의 크기가 제한적이며, 보안이 취약할 수 있다.
예시

// GET 요청을 처리하는 컨트롤러 메서드
@RequestMapping(value = "/products", method = RequestMethod.GET)
public String getProducts(Model model) {
    // 서버에서 데이터 조회 후 클라이언트에 전달
    List<Product> products = productService.getAllProducts();
    model.addAttribute("products", products);
    return "productList"; // 뷰 이름 반환
}

클라이언트는 /products URL로 GET 요청을 보낸다.
서버는 데이터를 조회하고, 클라이언트에게 해당 데이터를 포함한 페이지를 반환한다.

post

정의 및 용도
- POST 메서드는 클라이언트가 서버로 데이터를 전송하거나, 새로운 리소스를 생성할 때 사용된다. 주로 폼 제출, 파일 업로드, 데이터 수정 등에 사용된다.
- POST 요청은 본문에 데이터를 담아 서버로 전송한다.
클라이언트 관점
- 폼 제출: 사용자가 웹 페이지에서 폼에 데이터를 입력하고 제출 버튼을 클릭하면 POST 요청이 발생한다.
- 보안성: 데이터가 URL에 노출되지 않고 요청 본문에 포함되기 때문에 상대적으로 안전하다.
- 전송 데이터 양 제한 없음: GET과 달리 전송할 수 있는 데이터의 양에 제한이 없으며, 텍스트, 파일, 이미지 등 다양한 데이터를 전송할 수 있다.
- 캐싱 불가: POST 요청은 데이터 변경을 목적으로 하므로, 일반적으로 캐싱되지 않는다.
예시

// POST 요청을 처리하는 컨트롤러 메서드
@RequestMapping(value = "/submitProduct", method = RequestMethod.POST)
public String submitProduct(@ModelAttribute Product product) {
    // 서버에서 데이터 처리 후 클라이언트에게 응답
    productService.saveProduct(product);
    return "redirect:/products"; // 처리 후 리다이렉트
}

클라이언트는 /submitProduct URL로 데이터를 포함한 POST 요청을 보낸다.
서버는 요청 본문에 있는 데이터를 사용하여 리소스를 생성하거나 수정하고, 처리 결과를 반환한다.

Filter(필터 클래스)

웹프로그램 실행 전 또는 후에 필요한 기능을 제공하기 위한 웹프로그램
Filter 인터페이스를 상속받은 자식클래스를 작성하고 [web.xml]파일에 Filter 클래스를 필터로 등록하고 필터가 실행될 수 있는 요청 URL 주소(패턴) 설정
주로 인코딩 필터를 사용 - Front Controller 실행 전에 전달값에 대한 문자형태를 변경하기 위해 사용
filter: 클래스를 필터로 등록하기 위한 엘리먼트
- filter-name: 필터를 구분하기 위한 식별자를 설정하기 위한 엘리먼트
- filter-class: 서블릿 요청시 객체로 생성될 필터 클래스를 설정하기 위한 엘리먼트
- init-param: 필터 클래스에 필요한 값 제공하는 엘리먼트
filter-mapping: 필터가 실행되기 위한 서블릿의 요청 URL 주소를 등록하기 위한 엘리먼트
- filter-name: 서블릿 요청에 의해 실행될 필터의 식별자를 설정하기 위한 엘리먼트
- url-pattern: 필터를 실행하기 위한 서블릿의 요청 URL 주소(패턴)를 설정하기 위한 엘리먼트

[web.xml]

<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>utf-8</param-value>
		</init-param>
</filter>
<filter-mapping>
		<filter-name>encodingFilter</filter-name>
        <!-- 클라이언트의 모든 요청에 대해 필터가 실행되도록 설정 -->
		<url-pattern>/*</url-pattern>
	</filter-mapping>

@RequestParam

전달값을 제공받아 매개변수에 저장하기 위한 어노테이션
매개변수의 이름과 같은 이름으로 전달된 값이 없는 경우 400 에러코드 발생
전달값의 이름과 매개변수의 이름이 같도록 작성해 전달값이 매개변수에 저장되도록 사용하는 어노테이션
전달값의 이름과 매개변수의 이름이 같은 경우 클라이언트로부터 전달된 값이 비어 있으면 변수에는 [null] 저장 - 400 에러코드 미발생

	@RequestMapping(value = "/param", method = RequestMethod.POST)
	public String action(@RequestParam String food, Model model) {
		model.addAttribute("food", food);
		return "param_display";
	}

required 속성: false 또는 true(기본값) 중 하나를 속성값으로 설정
- 속성값으로 [false]를 설정하면 매개변수의 이름과 같은 이름으로 전달되는 값이 없어도 400 에러코드가 미발생
- 속성값이 [true]로 설정하면 매개변수의 이름과 같은 이름으로 전달되는 값이 없으면 400 에러코드 발생

	@RequestMapping(value = "/param", method = RequestMethod.POST)
	public String action(@RequestParam(required = true, value = "food") String foodname, Model model) {
		model.addAttribute("food", foodname);
		return "param_display";
	}

defaultValue 속성: 매개변수에 저장될 기본값을 속성값으로 설정
=> 매개변수의 이름과 같은 이름으로 전달되는 값이 없거나 매개변수의 이름과 같은 이름으로 전달되는 값이 비어있는 경우 매개변수에 저장될 기본값 설정

전달값이 없다면 defaultValue 속성으로 설정된 "라면"이 전달

	@RequestMapping(value = "/param", method = RequestMethod.POST)
	public String action(@RequestParam(required = false, defaultValue = "라면") String food, Model model) {
		model.addAttribute("food", food);
		return "param_display";
	}

아무것도 입력하지 않고 제출 버튼을 누르면

defaultValue로 설정한 [라면]이 들어간다.

같은 이름으로 전달되는 값이 여러개인 경우 매개변수를 List 인터페이스로 작성해 전달값이 요소에 차례대로 저장된 List 객체를 제공받아 매개변수에 저장하여 사용

	@RequestMapping(value = "/paramValues", method = RequestMethod.POST)
	public String action(@RequestParam("hobby") List<String> hobbyList, Model model) {
		model.addAttribute("hobbyList", hobbyList);
		return "paramValues_display";
	}

전달되는 값이 여러개(독서, 낚시) 선택하고 제출하면

잘 출력된다.

	@RequestMapping(value = "/paramValues", method = RequestMethod.POST)
	public String action(@RequestParam("hobby") List<String> hobbyList, Model model) {
		model.addAttribute("hobbyList", hobbyList);
		return "paramValues_display";
	}

입력값을 전달받은 View 페이지에서 List 객체를 잘 처리해줘야한다.
Core taglib를 forEach로 잡으면 된다.

varStatus 속성: 반복문의 상태를 저장하기 위한 속성명을 속성값으로 설정
속성명.index: 반복 처리하는 요소의 첨자(0부터 시작)를 제공
속성명.count: 반복 처리하는 요소의 순서값(1부터 시작)를 제공

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>    

등등등
<h1>출력페이지</h1>
	<hr>
	<c:forEach var="hobby" items="${hobbyList }" varStatus="status">
		<%-- <h2>취미-${status.index + 1} : ${hobby }</h2> --%>
		<h2>취미-${status.count} : ${hobby }</h2>
	</c:forEach>

전달값을 객체로 전달받아 Request Scope 속성값으로 저장하고 속성값을 출력

Member.java(DTO)

회원정보를 저장하기 위한 클래스 - DTO클래스
데이터 처리를 목적으로 작성된 클래스의 메소드에게 정보를 전달할 목적으로 작성된 클래스지만 전달값을 매개변수에 저장하기 위해 사용 가능
중요: 전달값의 이름과 같은 이름으로 필드가 작성되어 있어야 한다.

JoinController(Controller)

GET 방식은 문제없지만 POST 방식이 중요!
위에서 배웠던 @RequestParam 어노테이션으로 입력값을 하나씩 가져올 수 있다. 하지만 입력값이 10개가 아니라 100개면 @RequestParam도 100번 써야하는 불편함이 있다.
또 하나의 문제점은 @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";
	}

@ModelAttribute 어노테이션을 사용하는 방법도 있다.
@ModelAttribute: 값(객체)를 뷰(View)에게 제공하기 위한 어노테이션
=> 전달값을 제공받아 저장하기 위한 매개변수에 @ModelAttribute 어노테이션을 사용하면 매개변수에 저장된 전달값을 요청 처리 메소드의 뷰이름으로 생성된 뷰에게 제공한다.
=> value 속성을 사용해 value 속성값으로 전달값을 얻어와 뷰에서 속성값을 사용할 수 있도록 반드시 속성명(전달값의 이름)을 설정해야한다.

	@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";
	}

위에랑 똑같이 노가다 뛰는 건 똑같은 코드이다. 그래서 요청 처리 메소드의 매개변수 자료형을 DTO 클래스로 작성하면 Front Controller는 DTO 클래스로 Command 객체를 생성하여 매개변수에 저장되도록 할 수 있다.
=> 전달값의 이름과 같은 이름의 객체 필드에 전달값을 자동으로 저장하여 제공하기 때문에 DTO 클래스의 필드 이름이랑 똑같이 작성해야하는 것!
Command 객체: 전달값이 필드에 저장된 객체로 매개변수에 저장되고 매개변수에 저장된 객체를 뷰에서 사용할 수 있도록 제공하는 객체이다 => @ModelAttribute 어노테이션 사용
=> @ModelAttribute 어노테이션을 사용하지 않아도 Command 객체는 뷰에게 제공
=> @ModelAttribute 어노테이션에 value속성을 생략하면 매개변수의 자료형(DTO 클래스)을 자동으로 속성명으로 사용되도록 설정
추천하는 방법

	@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("hewon") Member member) {
		return "join_display";
	}

요청 처리 메소드의 매개변수 자료형을 Map 인터페이스로 작성하면 Front Controller는 Map 객체를 생성하여 매개변수에 저장되도록 제공한다.
=> 전달값의 이름은 Map Key(String)로 사용하고 전달값은 Map Value(String)으로 사용한 엔트리가 저장된 Map 객체를 매개변수에 저장하여 사용된다.
=> 전달값이 저장된 Map 객체를 제공받기 위해서는 반드시 매개변수에 @RequestParm 어노테이션을 사용하여 작성

	@RequestMapping(value = "/join", method = RequestMethod.POST)
	public String join(@RequestParam Map<String, String> map, Model model) {
		model.addAttribute("hewon", map);
		return "join_display";
	}

=> 전달값을 Map 객체를 담아서 임시 객체인 Model 객체로 View 페이지로 전달하면 모델 객체의 hewon이라는 객체의 Map 객체의 Key를 꺼내서 사용하면 전달값을 출력할 수 있다.

	<ul>
		<li>아이디 = ${hewon.id }</li>
		<li>비밀번호 = ${hewon.passwd }</li>
		<li>이름 = ${hewon.name }</li>
		<li>이메일 = ${hewon.email }</li>
	</ul>

→ join_form.jsp
→ join_display.jsp

LoginController

전달값(인증정보)을 반환받아 인증 처리하고 인증 성공시 권한 관련 정보를 Session Scope 속성값으로 저장한 후 인증 성공 메세지를 출력하는 JSP 문서의 뷰이름을 반환하는 컨트롤러
요청 처리 메소드의 매개변수 자료형을 HttpSession 인터페이스로 작성하면 Front Controller는 세션 바인딩 처리된 HttpSession 객체를 매개변수에 저장하여 사용되도록 제공한다.

Session Scope

동일한 세션을 사용하는 모든 요청 처리 메소드와 뷰에서 속성값을 제공받아 사용 가능
session.setAttribute("key", "Value");
session.getAttribute("key")
Session Scope도 EL 사용 가능

	@RequestMapping(value = "/login", method = RequestMethod.POST)
	public String login(@ModelAttribute Member member, Model model, HttpSession session) {
		if(!member.getId().equals("abc123") || !member.getPasswd().equals("123456")) {
			model.addAttribute("message", "아이디 또는 비밀번호를 잘못 입력 하였습니다.");
			return "login_form";
		}
        // 인증 성공 - Session Scope 속성값으로 권한 관련 정보를 저장
		session.setAttribute("loginId", member.getId());
		return "login_display";
	}

=> 매개변수 자료형을 Member DTO 클래스로 작성해 전달값과 같은 이름의 필드에 전달값이 저장된 DTO객체(Command 객체)를 제공받아 매개변수에 저장하여 사용

=> 인증 성공하면 session에 로그인 정보 저장하여 다른 곳에서도 사용가능하게 할 수 있음

SessionController

@SessionAttributes

요청 처리 메소드에서 Model 객체를 사용해 저장된 속성값을 @SessionAttributes 어노테이션을 사용한 Controller 클래스의 모든 요청 처리 메소드와 뷰에게 제공하기 위한 어노테이션
Model 객체를 사용해 저장된 속성값을 Request Scope 속성값이 아닌 제한적인 Session Scope 속성값으로 사용하는 기능 제공
뷰(JSP)에서 페이지 요청시 식별자 전달이 불필요하며 식별자로 정보를 검색하지 않아도 요청 처리 메소드와 뷰에서 사용 가능 - 변경 처리시 사용하는 기능
value 속성: 제한적인 Session Scope 속성값으로 사용할 속성명을 속성값으로 설정
- value 속성외에 다른 속성이 없는 경우 속성값만 설정 가능
- 속성명이 여러개인 경우 {} 기호를 사용해 배열의 요소로 작성 가능

@SessionAttributes("hewon")
public class SessionController {
	//아이디를 전달받아 회원정보를 검색해 반환하는 메소드 - Service 클래스의 메소드
	public Hewon getHewon(String id) {
		return Hewon.builder().id(id).name("홍길동").email("abc@itwill.xyz").build();
	}
	
	//아이디를 전달받아 아이디의 회원정보를 검색해 Model 객체의 속성값으로 저장하여 뷰에게 
	//제공하기 위한 요청 처리 메소드
	// => Model 객체의 속성값으로 회원정보를 출력하는 JSP 문서로 포워딩 하는 뷰이름 반환 
	@RequestMapping("/hewon_view")
	public String view(@RequestParam(defaultValue = "kangmingu") String id, Model model) {
		//Service 클래스의 메소드를 호출하여 매개변수로 전달한 아이디의 회원정보를 반환받아 저장 
		Hewon hewon=getHewon(id);
        
        model.addtribute(hewon);
        
        return "hewon_view";
	}
    //@SessionAttributes 어노테이션에 의해 전달값(아이디)을 제공받아 회원정보를 검색하거나
	//속성값을 저장하는 명령 불필요
	@RequestMapping(value = "/hewon_update", method = RequestMethod.GET)
	public String update() {
		return "hewon_update";
	}
    
    // 요청 처리 메소드의 매개변수 자료형을 SessionStatus 인터페이스로 작성하면 Front Controller에게 SessionStatus 객체를 제공받아 사용
    @RequestMapping(value = "/hewon_update", method = RequestMethod.POST)
	public String update(@ModelAttribute Hewon hewon, SessionStatus sessionStatus) {
		//SessionStatus.setComplete() : @SessionAttributes 어노테이션에 의해 제공된 제한적인
		//Session Scope 속성값을 종료하는 메소드
		sessionStatus.setComplete();
		return "hewon_result";
	}
}

RedirectController

Forward 이동

Front Controller(DispatcherServlet 객체)는 요청 처리 메소드를 호출하여 호출 처리 후 반환받은 뷰이름을 InternalResourceViewResolver 객체에게 전달하여 JSP문서의 경로를 제공받아 JSP 문서로 포워드 이동하여 응답 처리
클라이언트 요청에 의해 실행된 웹프로그램(Front Controller)에서 응답 처리할 웹프로그램(View - JSP)으로 스레드를 이동하여 응답 처리
클라이언트의 요청 URL 주소는 변경되지 않고 Request Scope 속성값을 포워드 이동된 웹프로그램(JSP)에서 객체로 제공받아 사용 가능하다.

@RequestMapping("/forward_move")
public String forward(Model model) {
    //Model 객체를 사용해 뷰(View)에게 제공할 객체를 Request Scope 속성값으로 저장
    model.addAttribute("name", "홍길동");
    return "display_forward";
 }

Redirect 이동

요청 처리 메소드의 반환값(뷰이름)에 redirect 접두사를 사용해 반환하면 Front Controller (DispatcherServlet 객체)는 반환받은 URL 주소를 클라이언트에게 전달하여 응답 처리
URL 주소를 응답받은 클라이언트는 요청 URL 주소를 변경하여 해당 페이지를 요청해 새로운 응답결과를 제공받아 출력 처리 - 리다이렉트 이동
클라이언트에게 URL 주소를 전달하여 새로운 페이지를 요청해 실행결과를 응답받아 처리
=> 클라이언트의 요청 URL 주소는 변경되고 Request Scope 속성값을 요청 페이지의 요청 처리 메소드 및 뷰에서 사용 불가능

@RequestMapping("/redirect")
	public String redirect() {
    return "redirect:/redirect_move";
}
	
@RequestMapping("/redirect_move")
public String redirect(Model model) {
	model.addAttribute("name", "전우치");
	model.addAttribute("url", "redirect_move");
	return "display_redirect";
}

주의: Model 객체에 저장된 Request Scope 속성값은 리다이렉트 이동되는 페이지의 요청 처리 메소드와 뷰에서 사용 불가능하다.

RedirectAttributes 인터페이스

요청 처리 메소드에 RedirectAttributes 인터페이스로 매개변수를 작성하면 Front Controller로부터 RedirectAttributes 객체를 제공받아 사용 가능
리다이렉트 이동되는 페이지의 요청 처리 메소드와 뷰에게 Request Scope 속성값을 제공하기 위한 객체

RedirectAttributes.addFlashAttribute(String attributeName, Object attributeValue)

=> 요청 처리 메소드의 실행결과를 Request Scope 속성값으로 저장해 리다이렉트 이동되는 페이지의 요청 처리 메소드와 뷰에게 제공하기 위한 메소드

리소스 파일(Resource File)

ResourceController.java
resource_display.jsp
클라이언트에서 HTML 문서를 해석하여 실행하기 위해 필요한 정보를 URL 주소로 제공받기 위해 서버에 저장된 파일(웹자원)
CSS파일, JavaScript 파일, 멀티미디어 파일(그림 파일, 소리 파일, 동영상 파일) 등
클라이언트에서 HTML 문서를 해석해 실행할 때 URl 주소의 리소스 파일이 서버에 없는 경우 404 에러코드에 의해 비정상적인 출력 결과 발생

문제점

리소스 파일이 [WEB-INF] 폴더에 저장된 경우 클라이언트 요청에 의해 응답 불가능
=> [WEB-INF] 폴더는 서버에서 서블릿으로만 접근 가능하고 클라이언트 접근이 불가능한 은닉화 처리된 폴더이므로 클라이언트 요청에 의해 응답 불가능

해결법

[WEB-INF] 폴더가 아닌 웹 자원으로 제공될 [webapp] 폴더에 리소스 파일 저장

문제점

Front Controller가 클라이언트의 모든 요청을 전달받아 처리되도록 설정된 경우 리소스 파일을 클라이언트가 요청한 경우에도 Front Controller가 요청 처리 메소드 호출하여 처리
=> 리소스 파일의 URL 주소에 대한 요청 처리 메소드가 없으므로 404 에러코드 발생

해결법

클라이언트가 리소스 파일을 요청한 경우 Front Controller가 요청 처리 메소드를 호출해 뷰로 응답하지 않고 직접 응답 처리되도록 Spring Bean Configuration File(servlet-context.xml)에 resources 엘리먼트를 사용해 환경 설정

servlet-context.xml

<resources mapping="/images/**" location="/resources/images/" />
<resources mapping="/css/**" location="/resources/css/" />
<resources mapping="/js/**" location="/resources/js/" />

resources: 클라이언트 요청시 Front Controller가 요청 처리 메소드를 호출하여 뷰로 응답하지 않고 직접 응답 처리되도록 설정하는 엘리먼트
=> 클라이언트가 리소스 파일을 요청한 경우 응답 처리하기 위해 사용
mapping속성: 클라이언트 요청에 의해 직접 응답하기 위한 URL 패턴을 속성값으로 설정하기 위한 URL 패턴을 속성값으로 설정
=> [**] 패턴문자를 속성값으로 사용한 경우 현재 폴더 및 하위 폴더의 웹 자원 요청 가능
location 속성: 웹 자원의 파일을 검색하기 위한 폴더를 속성값으로 설정
웹 자원의 경로는 반드시 절대경로로 표현하여 요청
- 컨텍스트 폴더의 이름이 변경되면 URL 주소도 변경되어 404 에러코드 발생 가능
- 컨텍스트 폴더의 이름이 변경되면 URL 주소도 자동 변경되도록 컨텍스트 폴더의 경로를 제공받아 작성

<%-- 1. EL 표현식에 pageContext 내장객체를 사용해 컨텍스트 폴더의 경로를 제공받아 URL 주소 작성 --%>
<img alt="코알라" src="${pageContext.request.contextPath }/images/Koala.jpg" width="200">
	
<%-- 2. core 태그 라이브러리의 url 태그를 사용해 웹자원의 URL 주소를 제공받아 사용 --%>
<img alt="코알라" src="<c:url value="/images/Koala.jpg"/>" width="200">
	
<%-- 3. spring 태그 라이브러리의 url 태그를 사용해 웹자원의 URL 주소를 제공받아 사용 --%>
<img alt="코알라" src="<spring:url value="/images/Koala.jpg"/>" width="200">

TilesController.java

TilesView 클래스를 사용해 생성된 뷰(View)로 응답 처리하기 위한 방법
TilesView 클래스: 요청 처리 메소드의 반환값(ViewName)을 제공받아 다수의 JSP문서가 결합된 뷰(View)로 응답하기 위한 기능을 제공하는 ViewResolver 클래스

TilesView 관련 라이브러리(tiles-extras 라이브러리)를 프로젝트에 빌드 처리 - 메이븐 사용: pom.xml
요청 처리 메소드의 반환값(ViewName)을 제공받아 응답할 JSP 문서(템플릿 페이지) 설정
=> TilesView 클래스가 제공받아 사용하기 위한 환경설정파일 작성 - /WEB-INF/spring/appServlet/tiles.xml
Front Controller(DispatcherServlet 객체)가 요청 처리 메소드의 반환값(ViewName)을 제공받아 TilesView 클래스의 ViewResolver 객체로 응답 처리되도록 Spring Bean configuration File(servlet-context.xml)을 설정
=> InternalResourceViewResolver 객체보다 TilesView 객체가 먼저 실행되도록 우선순위 설정

tiles-extras 라이브러리

Apache Tiles는 JSP 기반의 템플릿 관리 프레임워크로, Spring MVC와 함께 사용되며 웹 애플리케이션의 UI를 모듈화하고 재사용성을 높이기 위해 사용된다.

Apache Tiles와 `tiles-extras` 라이브러리의 역할

Apache Tiles
- JSP 페이지를 블록(예: Header, Footer, Sidebar, Body)으로 나누어 재사용 가능한 템플릿을 구성하고 관리할 수 있는 프레임워크입니다.
- 페이지 레이아웃을 분리하여 각 부분을 독립적으로 개발하고 유지보수할 수 있게 해줍니다.
- Spring MVC와 잘 어울리며, ViewResolver로 설정되어 각 요청에 맞는 레이아웃을 조합하여 최종 페이지를 렌더링합니다.
tiles-extras 라이브러리:
- tiles-extras는 기본 Tiles 기능에 추가적인 기능을 제공하는 확장 라이브러리입니다.
- 주요 기능으로는 템플릿의 동적 설정, 다양한 새로운 정의 방식, URL 기반의 템플릿 로딩 등의 기능을 포함합니다.

tiles.xml

defintion: 요청 처리 메소드의 반환값(ViewName)으로 응답 처리될 기능의 JSP 문서를 제공하기 위한 엘리먼트
- name 속성: definition 엘리먼트ㅡㄹ 구분하기 위한 식별자를 속성값으로 설정
  - 요청 처리 메소드의 반환값과 같은 name 속성ㅇ값의 definition 엘리먼트로 응답 처리
- template 속성: definition 엘리먼트로 응답할 템플릿 기능의 JSP 문서의 경로를 속성값으로 설정
put-attribute: 템플릿 페이지를 구성하는 JSP 문서를 제공하기 위한 엘리먼트
- name 속성: put-attribute 엘리먼트를 구분하기 위한 식별자
- value 속성: put-attribute 엘리먼트로 템플릿 페이지에 제공될 JSP 문서의 경로를 속성값으로 설정

<definition name="main" template="/WEB-INF/views/layout/template.jsp">
  	<put-attribute name="header" value="/WEB-INF/views/layout/header_admin.jsp"/>
	<put-attribute name="content" value="/WEB-INF/views/layout/main.jsp"/>
	<put-attribute name="footer" value="/WEB-INF/views/layout/footer.jsp"/>
</definition>

<definition name="admin" extends="main">
	<put-attribute name="header" value="/WEB-INF/views/layout/header_admin.jsp"/>
	<put-attribute name="content" value="/WEB-INF/views/layout/main_admin.jsp"/>
	<put-attribute name="footer" value="/WEB-INF/views/layout/footer_admin.jsp"/>
</definition>
	
<definition name="admin/*" extends="admin">
	<put-attribute name="content" value="/WEB-INF/views/admin/{1}.jsp"/>
</definition>
	
<definition name="admin/*/*" extends="admin">
	<put-attribute name="content" value="/WEB-INF/views/admin/{1}/{2}.jsp"/>
</definition>

definition 엘리먼트의 name 속성값을 [*]로 설정한 경우 요청 처리 메소드에서 ["값"] 형식으로 반환되는 모든 뷰이름을 제공받아 응답 처리 가능
extends 속성: definition 엘리먼트의 식별자를 속성값으로 설정
- definition 엘리먼트의 정보를 상속받아 사용하기 위해 작성
- put-attribute 엘리먼트를 상속받아 사용 가능하지만 오버라이드 선언 가능

<definition name="*" extends="main">
 	<!-- definition 엘리먼트의 name 속성값을 [*]로 설정한 경우 put-attribute 엘리먼트의
	value 속성값에서는 반환되는 값을 {정수값} 형식으로 표현하여 값을 사용 가능 -->
	<!-- => 뷰이름 대신 사용되는 정수값은 1 부터 1씩 증가되는 정수값 사용 -->
	<!-- => 요청 처리 메소드의 반환값으로 폴더 및 파일명을 만들어 템플릿 페이지에게 제공 -->
	<put-attribute name="content" value="/WEB-INF/views/{1}.jsp"/>
	<!-- <put-attribute name="footer" value="/WEB-INF/views/layout/footer.jsp"/> -->
</definition>
<!-- definition 엘리먼트의 name 속성값을 [*/*]로 설정한 경우 요청 처리 메소드에서 ["값/값"] 
	형식으로 반환되는 모든 뷰이름을 제공받아 응답 처리 가능 -->	

<definition name="*/*" extends="main">
	<put-attribute name="content" value="/WEB-INF/views/{1}/{2}.jsp"/>
</definition>
	
<!-- definition 엘리먼트의 name 속성값을 [*/*/*]로 설정한 경우 요청 처리 메소드에서 ["값/값/값"]
형식으로 반환되는 모든 뷰이름을 제공받아 응답 처리 가능 -->
<definition name="*/*/*" extends="main">
	<put-attribute name="content" value="/WEB-INF/views/{1}/{2}/{3}.jsp"/>
</definition>

servlet-context.xml

TilesView를 사용하려면 UrlBasedViewResolver 클래스를 Spring Bean으로 등록해야된다.

UrlBasedViewResolver 객체: 요청 처리 메소드의 반환값을 Spring 프레임워크에서 제공하는 ViewResolver 객체를 사용하지 않고 ViewResolver 기능의 클래스를 사용해 응답 처리하는 기능을 제공하기 위한 ViewResolver 객체
=> 뷰 이름으로 응답 처리하기 위한 ViewResolver 객체를 커스텀마이징 할 때 사용하는 객체

<beans:bean class="org.springframework.web.servlet.view.UrlBasedViewResolver">
	<!-- viewClass 필드에 ViewResolver 기능을 제공하는 클래스가 저장되도록 값 주입 -->
	<beans:property name="viewClass" value="org.springframework.web.servlet.view.tiles3.TilesView"/>
	<!-- order 필드에 ViewResolver 기능을 제공하는 클래스의 우선순위를 설정하기 위해 값(정수값) 주입 -->
	<!-- => ViewResolver 기능을 제공하는 클래스가 여러개 등록될 경우 반드시 설정 -->
	<!-- => 필드에 저장된 정수값이 작을수록 우선순위가 높게 설정되어 먼저 실행 -->
	<beans:property name="order" value="2"/>
</beans:bean>

ViewResolver 객체를 등록하고 TilesConfigurer 클래스를 Spring Bean으로 등록해야된다.

TilesConfigurer 객체: 요청 처리 메소드의 반환값(ViewName)으로 응답 처리하기 위한 정보가 저장된 환경설정파일을 제공하기 위한 객체

<beans:bean class="org.springframework.web.servlet.view.tiles3.TilesConfigurer">
	<!-- definitions 필드에 List 객체를 생성하여 저장되도록 의존성 주입 -->
	<!-- => List 객체의 요소에는 환경설정파일의 경로가 저장되도록 값 주입 -->
	<beans:property name="definitions">
		<beans:list>
			<beans:value>/WEB-INF/spring/appServlet/tiles.xml</beans:value>
		</beans:list>
	</beans:property>
</beans:bean>

template.jsp

페이지의 뼈대를 제공하기 위한 JSP 문서 - 템플릿 페이지

<%@taglib prefix="tiles" uri="http://tiles.apache.org/tags-tiles"%>

<body>
	<div id="header">
		<%-- insertAttribute 태그 : TilesView 기능을 제공하는 환경설정파일에서 put-attribute
		엘리먼트로 제공된 JSP 문서의 실행결과를 제공받아 삽입하기 위한 태그 --%>
		<tiles:insertAttribute name="header"/>
	</div>
	
	<div id="content">
		<tiles:insertAttribute name="content"/>
	</div>
	
	<div id="footer">
		<tiles:insertAttribute name="footer"/>
	</div>
</body>

클라이언트 측에서 검증

클라이언트 측에서 검증하는 방법은 클라이언트 측 검증은 사용자가 폼을 제출하기 전에 JavaScript, HTML5 속성(required, pattern 등) 등을 사용해 사용자의 입력을 즉시 검증하는 방식입니다.
장점
- 빠른 피드백: 사용자가 입력을 제출하기 전에 오류를 바로 확인할 수 있어 사용자 경험(UX)이 좋아진다.
- 서버 부하 감소: 잘못된 데이터가 서버로 전송되기 전에 필터링되므로 서버의 불필요한 요청을 줄일 수 있다.
단점
- 보안 취약성: 클라이언트 측 검증만으로는 데이터를 완벽하게 보호할 수 없습니다. 사용자가 JavaScript를 비활성화하거나, 네트워크 요청을 직접 조작할 수 있기 때문에 서버 측 검증이 필수적이다.

<h1>사원등록</h1>
	<hr>
	<c:url value="/valid/html" var="url"/>
	<form action="${url }" method="post" id="registerForm">
	<table>
		<tr>
			<td>아이디</td>
			<td>
				<input type="text" name="id" id="id" value="${employee.id }">
				<span id="idMsg" class="error">${idMsg }</span>
			</td>	
		</tr>
		<tr>
			<td>비밀번호</td>
			<td>
				<input type="password" name="passwd" id="passwd" value="${employee.passwd }">
				<span id="passwdMsg" class="error"></span>
			</td>	
		</tr>
		<tr>
			<td>이름</td>
			<td>
				<input type="text" name="name" id="name" value="${employee.name }">
				<span id="nameMsg" class="error"></span>
			</td>	
		</tr>
		<tr>
			<td>이메일</td>
			<td>
				<input type="text" name="email" id="email" value="${employee.email }">
				<span id="emailMsg" class="error"></span>
			</td>	
		</tr>
		<tr>
			<td>성별</td>
			<td>
				남자<input type="radio" name="gender" class="gender" value="남자">&nbsp;&nbsp;
				여자<input type="radio" name="gender" class="gender" value="여자">
				<span id="genderMsg" class="error"></span>
			</td>	
		</tr>
		<tr>
			<td colspan="2">
				<button type="submit">등록</button>
			</td>	
		</tr>
	</table>
	</form>
	
	<script type="text/javascript">
	$("#registerForm").submit(function() {
		var validResult=true;
		
		$(".error").html("").hide();
		
		/*
		var idReg=/^[a-zA-Z]\w{5,19}$/g;
		if($("#id").val()=="") {
			$("#idMsg").html("아이디를 입력해 주세요.");
			validResult=false;
		} else if(!idReg.test($("#id").val())) {
			$("#idMsg").html("아이디를 형식에 맞게 입력해 주세요.");
			validResult=false;
		}
		*/

		var passwdReg=/^(?=.*[a-zA-Z])(?=.*[0-9])(?=.*[~!@#$%^&*_-]).{6,20}$/g;
		if($("#passwd").val()=="") {
			$("#passwdMsg").html("비밀번호를 입력해 주세요.");
			validResult=false;
		} else if(!passwdReg.test($("#passwd").val())) {
			$("#passwdMsg").html("비밀번호를 형식에 맞게 입력해 주세요.");
			validResult=false;
		} 
		
		if($("#name").val()=="") {
			$("#nameMsg").html("이름을 입력해 주세요.");
			validResult=false;
		}
		
		var emailReg=/^([a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+(\.[-a-zA-Z0-9]+)+)*$/g;
		if($("#email").val()=="") {
			$("#emailMsg").html("이메일을 입력해 주세요.");
			validResult=false;
		} else if(!emailReg.test($("#email").val())) {
			$("#emailMsg").html("이메일을 형식에 맞게 입력해 주세요.");
			validResult=false;
		}

		if($(".gender").filter(":checked").length == 0) {
			$("#genderMsg").html("성별을 선택해 주세요.");
			validResult=false;
		}
		
		$(".error").show();
		
		return validResult;
	});
	</script>

Spring Data Validation(서버측 검증)

Spring Data Validation 기능을 사용해 요청 처리 메소드의 매개변수에 저장된 Command 객체의 필드값(전달값)을 검증하는 방법 - 어노테이션을 사용해 Spring Data Validation 기능 구현

validation-api 라이브러리와 hibernate-validator 라이브러리를 프로젝트에 빌드 처리 - 메이븐 사용 : pom.xml
- https://mvnrepository.com/artifact/javax.validation/validation-api
- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator
HTML 태그 대신 Spring 태그를 사용해 JSP 문서 작성 - 에러메세지를 전달받아 출력 처리
요청 처리 메소드에서 Command 객체가 저장된 매개변수에 @Valid 어노테이션을 사용해 Command 객체의 필드에 저장된 전달값을 검증 처리되도록 설정
Command 객체를 저장한 DTO 클래스의 필드에 검증 관련 어노테이션을 사용해 전달값 검증

서버 측 점은은 클라이언트가 제출한 데이터를 서버에서 재확인하는 과정이다. 이 검증은 필수적인 보안 단계로, 클라이언트에서 조작된 데이터를 막기 위해 수행된다.
장점
- 보안 강화: 클라이언트 측 검증을 우회하거나 조작한 데이터를 방어할 수 있어 데이터의 무결성과 보안을 유지할 수 있다.
- 신뢰성: 서버에서 데이터를 확실하게 검증하므로, 잘못된 데이터가 데이터베이스에 저장되는 것을 방지할 수 있다.
단점
- 속도 지연: 서버로 요청을 보내고 응답을 기다려야 하기 때문에 사용자 피드백이 느릴 수 있다.

DTO 클래스에서 검증 어노테이션 사용(Employee.java)

@NotNull : 전달값이 [null]인 경우 에러를 발생하는 어노테이션
@NotBlank : 전달값이 [null]이거나 전달값에 공백이 있는 경우 에러를 발생하는 어노테이션
@NotEmpty : 전달값이 [null]이거나 비어있는(NullString) 경우 에러를 발생하는 어노테이션
message 속성 : 뷰에게 제공될 에러메세지를 속성값으로 설정
- message 속성을 생략한 경우 기본적으로 제공되는 에러메세지를 뷰에게 전달하여 출력
@Size : 전달값의 크기(문자갯수)를 비교하여 에러를 발생하는 어노테이션
- min 속성 : 전달값의 최소 크기를 속성값으로 설정
- max 속성 : 전달값의 최대 크기를 속성값으로 설정
- ex) @Size(min = 6, max = 20, message = "아이디는 최소 6자 이상 최대 20자 이하로만 입력해 주세요.")
@Pattern : 전달값의 문자패턴을 비교해 에러를 발생하는 어노테이션
- regexp 속성 : 전달값을 비교하기 위한 정규표현식을 속성값으로 설정
@Email : 이메일의 작성규칙을 비교하여 에러를 발생하는 어노테이션

Employee.java

@Data
public class Employee {
	@NotEmpty(message = "아이디를 입력해 주세요.")
    @Pattern(regexp = "^[a-zA-Z]\\w{5,19}$", message = "아이디를 형식에 맞게 입력해 주세요.")
	private String id;
    @Pattern(regexp = "^(?=.*[a-zA-Z])(?=.*[0-9])(?=.*[~!@#$%^&*_-]).{6,20}$"
			, message = "비밀번호를 형식에 맞게 입력해 주세요.")
    private String passwd;
	@NotEmpty(message = "이름을 입력해 주세요.")
	private String name;
	@NotEmpty(message = "이메일을 입력해 주세요.")
	@Email(message = "이메일을 형식에 맞게 입력해 주세요.")
	private String email;
	@NotEmpty(message = "성별을 입력해 주세요.")
	private String gender;

Spring form 태그(spring_form.jsp)

Spring form 태그: 페이지를 요청하여 입력값을 전달하는 태그

Spring form 태그를 사용하려면 taglib에 등록

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib prefix="form" uri="http://www.springframework.org/tags/form"%>

modelAttribute 속성(필수) 요청 처리 메소드의 매개변수에 저장된 Command 객체의 속성명을 속성값으로 설정
=> 전달값에 대한 검증 실패시 전달값이 저장된 Command 객체를 속성값으로 제공받아 입력태그의 입력값 및 에러메세지 출력시 사용

<form:form action="${url }" method="post" id="registerForm" modelAttribute="employee">

Spring input 태그: 문자열을 입력받아 전달하기 위한 태그
=> HTML input 태그의 type속성값을 [text]로 설정한 것과 동일한 태그
- path 속성: 입력값을 전달하기 위한 이름을 속성값으로 설정
  => HTML input 태그의 name 속성과 id 속성을 설정하는 것과 동일
  => 전달값에 대한 검증 실패시 value 속성으로 Command객체의 필드값을 제공받아 사용
Spring errors 태그: 요청 처리 메소드로부터 제공 받은 에러메세지를 출력하기 위한 태그
- path 속성: 에러메세지를 제공받아 출력하기 위한 식별자(전달값의 이름)를 속성값으로 설정
- cssClass 속성: CSS 스타일의 클래스 선택자를 속성값으로 설정 - HTML 태그의 class 속성과 동일
- element 속성: 에러메세지를 출력하기 위한 애그의 이름을 속성값으로 설정
- delimiter 속성: 다수의 에러메세지가 전달된 경우 에러메세지를 구분하기 위한 문자를 속성값으로 설정
Spring password 태그: 문자열을 입력받아 전달하기 우이한 태그
=> HTML input 태그의 type속성값을 [password]로 설정한 것과 동일한 태그
Spring radiobutton 태그: 나열될 목록 중 하나만 선택하여 값을 전달하기 위한 태그
=> HTML input 태그의 type 속성값을 [radio]로 설정한 것과 동일한 태그

남자<form:radiobutton path="gender" cssClass="gender" value="남자"/>
여자<form:radiobutton path="gender" cssClass="gender" value="여자"/>

Spring radiobuttons 태그: 나열될 목록 중 하나만 선택하여 값을 전달하기 위한 태그
=> 요청 처리 메소드로 제공받은 List 객체의 요소값을 목록으로 사용해 값을 입력받기 위한 태그
- item 속성: 목록이 요소값으로 저장된 List 객체를 속성값으로 설정

<form:radiobuttons path="gender" items="${genderList }"/>
<form:errors path="gender" cssClass="error" element="span" delimiter=" "/>
<span id="genderMsg" class="error"></span>

컨트롤러 클래스에서 @ModelAttribute("genderList")로 설정하면 메소드의 반환값을 Controller 클래스의 모든 요청 메소드의 뷰에게 제공가능하다.

@ModelAttribute("genderList")
public List<String> genderList() {
	return Arrays.asList("남자", "여자");
}

Spring button 태그: 제출 이벤트를 발생하기 위한 태그
=> HTML button 태그의 type 속성값을 [submit]으로 설정한 것과 동일

<form:button>등록</form:button>

ValidController(@Valid)

@Valid

@Valid 어노테이션은 Java Bean Validation 표준에 따라 객체의 유효성을 검사하는 역할을 한다. 주로 Spring MVC와 함께 사용되어, 클라이언트로부터 전달된 데이터가 서버에서 정의된 조건에 맞는지 검증할 때 사용된다.
어노테이션의 목적: @Valid는 DTO(Data Transfer Object)나 커맨드 객체에 설정된 검증 어노테이션(예: @NotNull, @Size, @Pattern 등)을 활성화하여, 데이터를 유효성 검증하는 역할을 한다.
작동 방식: Spring MVC에서는 컨트롤러 메서드의 파라미터에 붙여 객체의 유효성을 자동으로 검증할 수 있다.
검증 결과 처리: 검증 결과는 BindingResult 또는 Errors 객체에 저장되며, 이를 통해 검증 오류 메시지를 처리하고, 적절한 응답을 반환할 수 있다.

@ModelAttribute와 @Valid 어노테이션을 함께 사용하면, Spring MVC가 클라이언트로부터 받은 폼 데이터를 자동으로 바인딩하고, 그 데이터를 검증할 수 있다.

에러 발생시

요청 처리 메소드의 매개변수 자료형을 Errors 인터페이스로 작성하면 Front Controller에게 Errors 객체를 제공받아 사용
Error 객체: 전달값에 대한 검증 실패시 발생되는 모든 에러 관련 정보를 저장한 객체
Errors.hasError(): Errors 객체에 에러 관련 정보가 저장된 경우 [true]를 반환하는 메소드

@RequestMapping(value = "/spring", method = RequestMethod.GET)
public String spring(@ModelAttribute Employee employee, Model model) {
	//Arrays.asList(Object ... args) : 매개변수로 전달받은 값(객체)가 요소값으로 저장된
	//List 객체를 생성하여 반환하는 정적메소드
	//model.addAttribute("genderList", Arrays.asList("남자", "여자"));
	return "valid/spring_form";		
}

@RequestMapping(value = "/spring", method = RequestMethod.POST)
public String spring3(@ModelAttribute @Valid Employee employee, Errors errors, Model model) {
	//Errors.hasErrors() : Errors 객체에 에러 관련 정보가 저장된 경우 [true]를 반환하는 메소드
	if(errors.hasErrors()) {
	//model.addAttribute("genderList", Arrays.asList("남자", "여자"));
		return "valid/spring_form";		
	}	
		return "valid/result";		
}
	
//메소드의 반환값을 Controller 클래스의 모든 요청 메소드의 뷰에게 제공
@ModelAttribute("genderList")
public List<String> genderList() {
	return Arrays.asList("남자", "여자");
}

왜 두 검증을 모두 사용해야 할까?

보안 강화: 클라이언트 측 검증만으로는 충분히 데이터를 보호할 수 없다. 반드시 서버 검증이 필요하다.
사용자 경험 개선: 클라이언트 측 검증은 사용자에게 빠른 피드백을 제공하며, 사용자가 잘못된 데이터를 입력했을 때 즉시 수정할 수 있도록 도와준다.
데이터 무결성 유지: 서버 측에서 데이터를 한 번 더 검증함으로써 잘못된 데이터가 시스템에 들어오지 않도록 할 수 있다.

Spring Message - 메세지 관리

메세지가 저장된 Properties 파일을 생성하여 메세지 저장
- 스프링 컨테이너(WebApplicationContext 객체)가 참조할 수 있도록 [src/main/webapp] 폴더에 Properties 파일을 작성하는 것을 권장
- [src/main/java] 또는 [src/main/resources] 폴더에 properties 파일 작성 가능
Spring Bean Configuration File(servlet-context.xml)에 메세지 관리 기능을 제공하는 클래스를 Spring Bean으로 등록하고 메세지가 저장된 Properties 파일의 경로를 필드에 저장되도록 의존성 주입

servlet-context.xml

MessageSource 인터페이스를 상속받은 클래스를 Spring Bean으로 등록
ReloadableResourceBundleMessageSource 클래스로 메세지 관리 기능 제공
=> Spring Bean의 식별자(beanName)을 반드시 [messageSource]로 설정

<beans:bean class="org.springframework.context.support.ReloadableResourceBundleMessageSource" id="messageSource">
	<!-- basenames 필드에 List 객체를 생성하여 저장되도록 의존성 주입 -->
	<!-- => List 객체의 요소에는 메세지가 저장된 Properties 파일의 경로가 요소값으로 저장되도록 값 주입 -->
	<beans:property name="basenames">
		<beans:list>
			<!-- [src/main/java] 또는 [src/main/resources] 폴더에 Properties 파일을 작성한
			경우 classpath 접두사를 사용해 Properties 파일의 경로 제공 -->
			<!-- => Properties 파일이 변경되면 WAS 프로그램을 재실행해야 변경된 메세지 적용 -->
			<beans:value>classpath:message/label</beans:value>
          
			<!-- [src/main/webapp] 폴더에 Properties 파일을 작성한 경우	Properties 파일을
			웹자원의 경로로 제공 -->
			<!-- => Properties 파일이 변경되면 자동으로 변경된 메세지 적용 -->
			<beans:value>/WEB-INF/message/error</beans:value>
		</beans:list>
	</beans:property>
	<!-- cacheSeconds 필드에 Properties 파일을 읽어 메모리에 로딩하기 위한 시간(초)이 저장되도록 값 주입 -->
	<beans:property name="cacheSeconds" value="60"/>
	<!-- defaultEncoding 필드에 Properties 파일의 문자형태(CharacterSet)가 저장되도록 값 주입 -->
	<beans:property name="defaultEncoding" value="utf-8"/>
</beans:bean>

SessionLocaleResolver 클래스를 Spring Bean으로 등록
SessionLocaleResolver 객체: Session Scope 속성값으로 Locale 객체를 저장해 해당 지역의 언어로 작성된 메세지를 제공하기 위한 객체

<beans:bean class="org.springframework.web.servlet.i18n.SessionLocaleResolver" id="localeResolver">
	<!-- defaultLocale 필드에 Locale 객체에 저장될 지역이 저장되도록 값 주입 -->
	<beans:property name="defaultLocale" value="ko"/>
</beans:bean>

Product.java
MessageController.java
label.properties
servlet-context.xml
register.jsp
success.jsp
error_en.properties
error_ko.properties

Kang.__.Mingu

최선을 다해 꾸준히 노력하는 개발자 망고입니당 :D

이전 포스트

Spring 10 MVC(일반)

다음 포스트

Spring 11 MVC(Spring) 총정리

Spring

Spring MVC 처리 흐름

@Controller

servlet-context.xml

@RequestMapping

요청 처리 메소드의 명령으로 생성된 결과값을 뷰(JSP)에게 제공하는 방법

ModelAndView 버전

HttpServletRequest 버전

Model 버전

Model 객체란?

@ModelAttribute

@RequestMapping(value, method = GET, POST)

GET, POST 복습

GET 메서드

post

Filter(필터 클래스)

@RequestParam

전달값을 객체로 전달받아 Request Scope 속성값으로 저장하고 속성값을 출력

Member.java(DTO)

JoinController(Controller)

LoginController

Session Scope

SessionController

@SessionAttributes

RedirectController

Forward 이동

Redirect 이동

RedirectAttributes 인터페이스

리소스 파일(Resource File)

문제점

해결법

문제점

해결법

TilesController.java

tiles-extras 라이브러리

Apache Tiles와 tiles-extras 라이브러리의 역할

tiles.xml

servlet-context.xml

template.jsp

클라이언트 측에서 검증

Spring Data Validation(서버측 검증)

DTO 클래스에서 검증 어노테이션 사용(Employee.java)

Spring form 태그(spring_form.jsp)

ValidController(@Valid)

왜 두 검증을 모두 사용해야 할까?

Spring Message - 메세지 관리

Spring 10 MVC(일반)

Spring 12 MyBatis(설정)

0개의 댓글

`Model` 객체란?

Apache Tiles와 `tiles-extras` 라이브러리의 역할