[목차]
8. Controller 처리
① Client요청을 Controller로 연결하기
② 공유 객체 사용
③ 패턴을 사용한 경로 매핑
④ @annotation을 이용한 Controller호출
⑤ Spring MVC Project를 사용
⑥ @RequestParam 사용(get)
* Controller 값 처리(기존) : getParameter()
* Controller 값 처리(어노테이션 사용)
* get 방식은 한글이 안깨지나 post 방식사용시 한글이 깨진다. Encording을 하여 한글 깨짐을 방지한다.
⑦ FormBean, @ModelAttribute 사용(post)
* Controller 값 처리(기존) : getParameter()
* Controller 값 처리(FormBean 사용)
* Controller 값 처리(@ModelAttribute 사용)
[내용]
1) Client요청을 Controller로 연결하기
: implements Controller와 @Controller 사용
=sprweb3
- start.html
<body>
<a href="hello.do">클릭 1-1(get)</a>
<form action="hello.do" method="post">
<input type="submit" value="클릭 1-2(post)"/>
</form>
<hr>
<a href="world.do">클릭 2-1</a>
<a href="good.do">클릭 2-2</a>
<a href="hi/nice.do">클릭 2-3</a>
<form action="korea.do" method="get">
<input type="submit" value="클릭 2-4(get)"/>
</form>
<form action="usa.do" method="post">
<input type="submit" value="클릭 2-4(post)"/>
</form>
</body>=> 클릭 1-1 (요청 : hello.do / get)
클릭 1-2 (요청 : hello.do / post)
클릭 2-1 (요청 : world.do / get)
클릭 2-2 (요청 : good.do / get)
클릭 2-3 (요청 : hi/nice.do / get)
클릭 2-4 (요청 : korea.do / get)
클릭 2-4 (요청 : usa.do / post)
- web.xml
<!-- DispatcherServlet는 test-servlet.xml의 설정을 불러온다. -->
<servlet>
<servlet-name>test</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- servlet-name이 아닌 다른 path로 연결할 경우 사용-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>
<!-- 공백 구분 -->
/WEB-INF/abc/hello-servlet.xml
/WEB-INF/def/world-servlet.xml
</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>test</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>=> test-servlet.xml이 아닌 다른 patch로 연결할 경우, <init-param> 태그를 사용한다.
hello-servlet, world-servlet으로 연결된다.
- hello-servlet.xml/ world-servlet.xml
* Controller implemets(상속)을 사용할 경우
<!-- 2. Handler Mapping -->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!-- 3. Controller -->
<bean name="/hello.do" class="pack.HelloController"></bean>
<!-- 5. ViewResover -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/views/"/>
<property name="suffix" value=".jsp"/>
</bean>=> hello.do 요청이 올 경우 HelloController가 실행된다.
* @Controller(어노테이션)을 사용할 경우
<!-- 어노테이션 사용시 삭제 -->
<!-- 2. Handler Mapping -->
<!--
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
-->
<!-- 3. Controller -->
<!--
<bean name="/hello.do" class="pack.HelloController"></bean>
-->
<!-- 어노테이션 사용시 추가 -->
<context:component-scan base-package="pack"/>
<!-- 5. ViewResover -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/views/"/>
<property name="suffix" value=".jsp"/>
</bean>=> 어노테이션 사용시 <context:component-scan>를 사용한다. pack package의 어노테이션이 동작하도록 한다.
- HelloController
* Controller implemets(상속)을 사용할 경우
public class HelloController implements Controller{
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
throws Exception {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("veiw1"); // veiw1.jsp에 연결
modelAndView.addObject("message", "hello"); // 모델에 다녀왔다 가정. // key-value 전달.
return modelAndView;
}
}=> hello-servlet.xml/ world-servlet.xml에서 연결한 hello.do 요청 발생 시 실행된다.
=> handlerRequest() 메소드를 오버라이딩하여 request를 처리한다.
=> setVieName("파일명")으로 view1에 연결된다. .hello-servlet.xml 파일의 ViewResover 처리로 /views/view1.jsp파일이
연결된다.
=> addObject(key, value)를 이용하여 값을 전달한다.
* @Controller(어노테이션)을 사용할 경우
@Controller
@RequestMapping("hello.do") // 모든 메소드가 수행된다.
public class HelloController{
@RequestMapping(method=RequestMethod.GET)
//@RequestMapping("hello.do") // 해당 메소드만 실행된다.
public ModelAndView aaa() {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("view1");
modelAndView.addObject("message", "hello aaa");
return modelAndView;
}
@RequestMapping(method=RequestMethod.POST)
//@RequestMapping("hello.do")
public ModelAndView bbb() {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("view1");
modelAndView.addObject("message", "hello bbb");
return modelAndView;
}
}=> hello-servlet.xml의 <context:component-scan>태그로 인해 @Controller가 동작한다.
@Controller : 클라이언트 요청에 따라 해당 클래스가 Controller동작을 하게된다.
@RequestMapping("요청명") : 요청명에 해당하는 요청이 들어올 경우 클래스가 실행된다.
@RequestMapping(method=RequestMethod.GET) : Get방식의 요청이 들어올때만 실행하게 한다.
@RequestMapping(method=RequestMethod.POST) : Post방식의 요청이 들어올때만 실행하게 한다.
=> ModelAndView객체를 리턴하도록 하여 값을 전달한다. 메소드명을 임의 지정 가능하다.
- WorldController
* Controller implemets(상속)을 사용할 경우
public class WorldController implements Controller{
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
throws Exception {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("view2"); // veiw1.jsp에 연결
modelAndView.addObject("message", "hi world"); // 모델에 다녀왔다 가정. // key-value 전달.
return modelAndView;
}
}=> HelloController와 동일
* @Controller(어노테이션)을 사용할 경우
@Controller
public class WorldController{
@RequestMapping({"/world.do","/good*.*","/hi/nice.do"}) // 여러개의 요청을 받을 수 있음.
//@RequestMapping("world.do")
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
throws Exception {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("view2"); // veiw1.jsp에 연결
modelAndView.addObject("message", "hi world"); // 모델에 다녀왔다 가정. key-value 전달.
return modelAndView;
}
@RequestMapping(value="/korea.do", method=RequestMethod.GET) // GET만 받을 수 있다.
//@RequestMapping({"/korea.do"})// Get과 Post를 모두 받을 수 있다.
public ModelAndView handleRequest2(HttpServletRequest request, HttpServletResponse response)
throws Exception {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("view2"); // veiw1.jsp에 연결
modelAndView.addObject("message", "hi world korea"); // 모델에 다녀왔다 가정. key-value 전달.
return modelAndView;
}
@RequestMapping(value="/usa.*", method=RequestMethod.POST) // POST만 받을 수 있다.
//@RequestMapping(value="/usa.*", method=RequestMethod.GET) // GET만 받을 수 있다.
//@RequestMapping({"/usa.*"})
public ModelAndView handleRequest3(HttpServletRequest request, HttpServletResponse response)
throws Exception {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("view2"); // veiw1.jsp에 연결
modelAndView.addObject("message", "hi world usa"); // 모델에 다녀왔다 가정. key-value 전달.
return modelAndView;
}
}=> @RequestMapping({요청명1, 요청명2,..}) : 배열을 사용하여 여러개의 요청명을 받을 수 있다.
@RequestMapping(value="요청명", method=RequestMethod.GET) : 요청과 method 방식을 설정할 수 있다.
요청명에 * 를 사용하여 복수의 요청을 받을 수 있다.
- view1.jsp / view2.jsp
<body>
hello 결과 : ${requestScope.message}
</body>=> Controller에서 addObject()메소드로 전달한 value를 key를 사용하여 받을 수 있다. (EL 사용 - ${key})
2) 공유 객체 사용
= spr4_share
- index.html
<body>
클래스 간 자원 공유<br>
<a href="hello.do">요청 1</a><br>
<a href="world.kor">요청2</a><br>
</body>
- web.xml
<!-- WebApplicationContext보다 먼저 수행 : 공유 자원 설정시 필요 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>=> applicationContext.xml에 공유자원을 설정한다.
<!-- WebApplicationContext에 의해 자동 수행 -->
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- <load-on-startup> init() 메소드 호출 순서 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>world</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>world</servlet-name>
<url-pattern>*.kor</url-pattern>
<!-- <url-pattern>/</url-pattern> 모든 요청사항 -->
</servlet-mapping>=> *.do 요청과 hello-servlet.xml 연결
=> *.kor요청과 world-servlet.xml 연결
- applicationContext.xml
<!-- 공유 자원 객체 생성 -->
<bean id="sharedData" class="pack.SharedData">
<property name = "shared" value="스프링 프로젝트 공유자원입니다."/>
</bean>=> setter injection을 이용하여 공유자원 객체 shard에 value를 설정한다.
- hello-servlet.xml, world-servlet.xml
<!-- 2. Handler Mapping -->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!-- 3. Controller -->
<bean name="/hello.do" class="pack.HelloController">
<property name="data" ref="sharedData"/>
</bean>
<!-- 5. ViewResover -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/views/"/>
<property name="suffix" value=".jsp"/>
</bean>=> hello.do과 HelloController 연결. HelloController에 공유객체를 setter injection한다.
- SharedData
public class SharedData {
private String shared;
public void setShared(String shared) {
this.shared = shared;
}
public String getShared() {
return shared;
}
}=> getter, setter를 이용하여 공유객체를 사용한다.
- HelloController
public class HelloController implements Controller{
private SharedData data; // 공유객체 선언.
// setter injection에 사용
public void setData(SharedData data) {
this.data = data;
}
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
throws Exception {
// 현재 클래스가 공유자원을 사용
ModelAndView modelAndView = new ModelAndView("helloworld"); // ViewFile명
modelAndView.addObject("msg", data.getShared() + "hello");
return modelAndView;
}
} => ModelAndView("ViewFile명") : ModelAndView 생성자에 매개변수로 ViewFile명을 전달하여 ViewFile에 연결. (setViewName("ViewFile명")과 동일)
=> addObject()메소드 사용하여 공유 객체의 내용 전달.
- helloworld.jsp
<body>
결과 : ${msg}
</body>
3) 패턴을 사용한 경로 매핑
=spr5_arrange
- index.html
<body>
@MVC 기본정리<p/>
<a href="hello.do">인사하기 1</a>
</body>=> hello.do 요청. (get)
- web.xml
<!-- WebApplicationContext에 의해 자동 수행 -->
<servlet>
<servlet-name>test</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- <load-on-startup> init() 메소드 호출 순서 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>test</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>=> test-servlet.xml과 *.do를 url mapping한다.
=> <servlet-mapping>이 여러개 일 경우 <load-on-startup>로 init() 메소드 호출 순서를 지정할 수 있다.
- test-servlet.xml
* mapping 방법1 : 요청 url과 동일한 이름을 bean과 매핑(basic)
<!-- 2. Handler Mapping -->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!-- 3. Controller -->
<bean name="/hello.do" class="pack.controller.HelloController">
<property name="helloModel" ref="helloModel"></property>
</bean>
<bean id="helloModel" class="pack.model.HelloModel"></bean>
<!-- 5. ViewResover -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/views/"/>
<property name="suffix" value=".jsp"/>
</bean>=> HelloController에 helloModel를 setter injection하여 객체 생성.
=> hello.do 요청과 HelloController을 mapping
* mapping 방법2 : 경로 매핑(패턴 : *, ?)
<!-- 2. Handler Mapping-->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="alwaysUseFullPath" value="true"/>
<property name="mappings">
<props>
<!-- <prop key="*.do">hi</prop> -->
<!-- <prop key="h*.do">hi</prop> -->
<!--<prop key="/**/*.do">hi</prop> -->
<prop key="/**/?????.do">hi</prop>
</props>
</property>
</bean>
<!-- 3. Controller -->
<bean name="hi" class="pack.controller.HelloController">
<property name="helloModel" ref="helloModel"></property>
</bean>
<bean id="helloModel" class="pack.model.HelloModel"></bean>
<!-- 5. ViewResover -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/views/"/>
<property name="suffix" value=".jsp"/>
</bean>=>SimSimpleUrlHandlerMapping사용하여 <prop>에 경로 매핑 가능하다.
=> ?는 글자 갯수. * 복수개의 문자를 나타냄.
=> HelloController mapping의 name을 <prop>의 값으로 받아 패턴을 연결한다.
- HelloController
public class HelloController implements Controller{
private HelloModel helloModel;
//setter injection
public void setHelloModel(HelloModel helloModel) {
this.helloModel = helloModel;
}
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
throws Exception {
// 모델 만들고 모델과 통신하기
String result = helloModel.getGreeting();
ModelAndView modelAndView = new ModelAndView();
//ModelAndView modelAndView = new ModelAndView("hello"); // ViewFile명
modelAndView.setViewName("hello");
modelAndView.addObject("result",result); // forword 방식(default)
//modelAndView.setViewName("redirect:/views/hello.jsp?result='d'"); // reditect 방식
return modelAndView;
}
} => Controller를 상속받고 handleRequest 오버라이딩하여 요청사항을 처리한다.
=> 기본 방식을 forward로 하여 /views/hello.jsp에 addObject(key, value)로 값을 전달한다.
=> setViewName("redirect:/views/hello.jsp")으로 redirect 가능하다.
- HelloModel
public class HelloModel {
public String getGreeting() {
int hour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY);
if(hour >= 6 & hour <= 10) {
return "좋은 아침입니다.";
}else if(hour >= 12 & hour <= 15) {
return "점심은 맛있게 드셨나요";
}else if(hour >= 18 & hour <= 22) {
return "좋은 저녁되세요";
}else {
return "안녕하세요";
}
}
}=> 기능을 담당하는 model 클래스
- hello.jsp
<body>
인사말 : ${result}
</body>
4) @annotation을 이용한 Controller호출
= sprwrb6_annotation
- index.html
<body>
@MVC 기본정리<p/>
<a href="hello.do">인사하기 1 - annotation</a><br>
<a href="abc/world.do">인사하기 2 - annotation</a><br>
<a href="kbs.do">인사하기 3 - annotation</a><br>
<a href="hello">인사하기 4 - annotation</a><br>
<br>
<a href="kakao.do">인사하기 5 - annotation</a><br>
<a href="mbc">인사하기 6 - annotation</a><br>
<a href="sbs">인사하기 7 - annotation</a><br>
</body>=> 요청 url 설정.
- web.xml
<servlet>
<servlet-name>test</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>test</servlet-name>
<!-- <url-pattern>*.do</url-pattern> 확장자가 do인 요청 -->
<!-- <url-pattern>/aa.jsp</url-pattern> 단일 파일일 경우 /를 붙인다.-->
<url-pattern>/</url-pattern><!-- 모든요청 -->
</servlet-mapping> => <url-pattern>/</url-pattern> 모든요청.
=> test-servlet 실행.
- test-servlet.xml
* web.xml의 <url-pattern>/</url-pattern>를 적용하려면 다음 코드를 test-servlet.xml에 추가한다.
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="alwaysMustRevalidate" value="true"/>
</bean>
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping">
<property name="alwaysUseFullPath" value="true"/>
</bean>
<mvc:annotation-driven/>
<mvc:default-servlet-handler/>=> 모든 요청 경로가 연결된다.
=> <mvc:annotation-driven/> : @annotation기반의 Controller호출
=> <mvc:default-servlet-handler/> : 처리하지 못한 요청을 DefaultSerlvet에게 넘겨준다.
<!-- annotation인 경우 -->
<context:component-scan base-package="pack.controller"/>
<context:component-scan base-package="pack.model"/>
<!-- 5. ViewResover -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/views/"/>
<property name="suffix" value=".jsp"/>
</bean>=> <context:component-scan> : 어노테이션 사용시 사용.
- HelloController
@Controller // controller implements
@RequestMapping({ "hello.do", "abc/world.do", "k*", "mbc", "sbs", "h*" }) // url mapping
public class HelloController {
@Autowired // setter injection
private HelloModel helloModel;
@RequestMapping(method=RequestMethod.GET) // GET방식과 mapping
public ModelAndView abc() { // 모델 만들고 모델과 통신하기
String result = helloModel.getGreeting();
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("hello");
modelAndView.addObject("result",result); // forword 방식(default)
//modelAndView.setViewName("redirect:/views/hello.jsp?result='d'"); // reditect 방식
return modelAndView;
}
}
=> @Controller : 어노테이션을 사용하여 Controller를 호출한다.
=> ModelAndView객체를 리턴값으로 값을 전달한다. result key에 result value를 전달한다.
@Controller // controller implements
@RequestMapping({ "hello.do", "abc/world.do", "k*", "mbc", "sbs", "h*" }) // url mapping
public class HelloController {
@Autowired // setter injection
private HelloModel helloModel;
// Map을 이용할 경우 출력할 View의 ViewName을 명시하지않는다.
// 요청명을 그대로 ViewName으로 가져간다.
// 요청명 hello, view명 hello.jsp
@RequestMapping(method = RequestMethod.GET) // GET방식과 mapping
public Map<String, Object> abc() {
String result = helloModel.getGreeting();
HashMap<String, Object> map = new HashMap<String, Object>();
map.put("result", result); // 요청명이 view 파일명이 된다.
return map;
}
} => Map을 이용할 경우 출력할 View의 ViewName을 명시하지않는다.
요청명을 그대로 ViewName으로 가져간다. (spec에 약속된 사항)
요청명 hello, view명 hello
=> HashMap를 이용하여 key, value를 전달.
@Controller // controller implements
@RequestMapping({ "hello.do", "abc/world.do", "k*", "mbc", "sbs", "h*" }) // url mapping
public class HelloController {
@Autowired // setter injection
private HelloModel helloModel;
@RequestMapping(method = RequestMethod.GET) // GET방식과 mapping
public Model abc(Model model) {
String result = helloModel.getGreeting();
model.addAttribute("result",result); // 요청명이 view 파일명이 된다.
return model;
}
}=> Model 객체를 이용하여 addAttribute()메소드를 이용하여 값을 전달한다.
요청명을 그대로 ViewName으로 가져간다. (spec에 약속된 사항)
@Controller // controller implements
@RequestMapping({ "hello.do", "abc/world.do", "k*", "mbc", "sbs", "h*" }) // url mapping
public class HelloController {
@Autowired // setter injection
private HelloModel helloModel;
@RequestMapping(method = RequestMethod.GET) // GET방식과 mapping
public String abc() {
String result = helloModel.getGreeting();
return "hello";
}
}=> String 리턴값을 가져간다.
요청명을 그대로 ViewName으로 가져간다. (spec에 약속된 사항)
- HelloModel
@Component
public class HelloModel {
public String getGreeting() {
int hour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY);
if(hour >= 6 & hour <= 10) {
return "좋은 아침입니다.";
}else if(hour >= 12 & hour <= 15) {
return "점심은 맛있게 드셨나요";
}else if(hour >= 18 & hour <= 22) {
return "좋은 저녁되세요";
}else {
return "안녕하세요";
}
}
}
- hello.jsp
<body>
- annotation<br>
인사말 : ${result}
</body>
5) Spring MVC Project를 사용
[New] - [Spring Legacy Project] - project명 입력 - [Spring MVC Project] 선택 - [Next] - aa.bb.cc입력 - [finish]
- pom.xml
<properties>
<java-version>1.8</java-version>
<org.springframework-version>5.0.0.RELEASE</org.springframework-version>
<org.aspectj-version>1.6.10</org.aspectj-version>
<org.slf4j-version>1.6.6</org.slf4j-version>
</properties>=> 변경
6) @RequestParam 사용(get)
= sprweb8_parameter
- login.jsp
<form action="login" method="get">
id : <input type="text" name="id"/><br>
password : <input type="text" name="pwd"/><br>
<input type="submit" value="전송(get)">
</form>=> login url로 name이 id, pwd인 값 전달.(get)
- LoginController
* Controller 값 처리(기존) : getParameter()
@Controller
public class LoginController {
//@RequestMapping("login")
@RequestMapping(value="login", method=RequestMethod.GET)
public ModelAndView submit(HttpServletRequest request) {
String id = request.getParameter("id");
String pwd = request.getParameter("pwd");
System.out.println("id:"+id);
System.out.println("pwd:"+pwd);
String data = "";
if(id.equals("aa") && pwd.equals("11")) {
data = "로그인 성공";
}else {
data = "로그인 실패";
}
ModelAndView view = new ModelAndView();
view.setViewName("result");
view.addObject("data", data);
return view;
}
}=> getParameter() 메소드를 사용하여 값을 가져온다.
=> 로직 동작 후 seyViewName()로 result.jsp에 addObject()메소드로 data값을 전달한다.
* Controller 값 처리(어노테이션 사용)
@Controller
@RequestMapping("login") // type level mapping
public class LoginController {
@RequestMapping(method=RequestMethod.GET) // method level mapping
public ModelAndView submit(
@RequestParam("id") String id,
@RequestParam("pwd") String pwd) {
String data = "";
if(id.equals("aa") && pwd.equals("11")) {
data = "로그인 성공";
}else {
data = "로그인 실패";
}
ModelAndView view = new ModelAndView();
view.setViewName("result");
view.addObject("data", data);
return view;
}
}=> @RequestParam("name")을 사용하여 getParameter()의 기능을 수행한다.
- result.jsp
<body>
결과 : ${data}
</body>
* get 방식은 한글이 안깨지나 post 방식사용시 한글이 깨진다. Encording을 하여 한글 깨짐을 방지한다.
- web.xml
<!-- 한글 깨짐 방지(post) -->
<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>=> web.xml에 위의 코드를 copy&paste한다.
7) FormBean, @ModelAttribute 사용(post)
- input.jsp
<h2>* 자료입력</h2>
<form action="sangpum" method="post">
품명 : <input type="text" name="sang"><br>
수량 : <input type="text" name="su"><br>
단가 : <input type="text" name="dan"><br>
<input type="submit" valus="전송(post)"/>
</form>
- SangpumController
* Controller 값 처리(기존) : getParameter()
@Controller
public class SangpumController {
@RequestMapping(value="sangpum", method=RequestMethod.POST)
public ModelAndView submit(HttpServletRequest request) {
String sang = request.getParameter("sang");
String su = request.getParameter("su");
String dan = request.getParameter("dan");
System.out.println(sang+" "+" "+su+" "+dan);
ModelAndView view = new ModelAndView();
view.setViewName("result");
view.addObject("data","good");
return view;
}
}* Controller 값 처리(FormBean 사용)
@Controller
public class SangpumController {
@RequestMapping(value="sangpum", method=RequestMethod.POST)
public ModelAndView submit(SangpumBean bean) { // 지역 변수
//클라이언트로 부터 들어오는 데이터 양이 많을 경우 사용(form bean)
System.out.println(bean.getSang()+" "+" "+bean.getSu()+" "+bean.getDan());
ModelAndView view = new ModelAndView();
view.setViewName("result");
view.addObject("data","good");
return view;
}
}=> 매개변수로 FormBean을 사용하여 값을 전달한다. bean의 범위는 {}안으로 지역변수로 사용된다.
* Controller 값 처리(@ModelAttribute 사용)
@Controller
public class SangpumController {
@Autowired // setter injection
private SangpumModel sanpumModel;
@RequestMapping(value="sangpum", method=RequestMethod.POST)
//public ModelAndView submit(SangpumBean bean) { // 지역 변수
public ModelAndView submit(@ModelAttribute("bean") SangpumBean bean) { // 전역변수
//클라이언트로 부터 들어오는 데이터 양이 많을 경우 사용(form bean)
System.out.println(bean.getSang()+" "+" "+bean.getSu()+" "+bean.getDan());
ModelAndView view = new ModelAndView();
view.setViewName("result");
view.addObject("data",sanpumModel.computeSangpum(bean));
return view;
}
}=> 매개변수로 @ModelAttribute을 사용시 bean의 범위는 전역변수로 사용되어 addObject() 메소드를 사용하지않아도
다른 파일에서 접근이 가능하다.
- SangpumBean
@Component
public class SangpumBean { // form bean
private String sang; // 클라이언트로 부터 전달되어 오는 요청 Parameter값과 변수명을 동일하게 가져간다.
private int su, dan;
public String getSang() {
return sang;
}
public void setSang(String sang) {
this.sang = sang;
}
public int getSu() {
return su;
}
public void setSu(int su) {
this.su = su;
}
public int getDan() {
return dan;
}
public void setDan(int dan) {
this.dan = dan;
}
}=> Form Bean 정의. Form Bean의 멤버변수는 <form>태그 하위 태그 name의 값과 동일하게 가져간다.
- SangpumModel
@Component // 객체생성
public class SangpumModel { // 비지니스 로직 처리를 하는 모델 영역의 클래스
public String computeSangpum(SangpumBean bean) {
int price = bean.getSu() * bean.getDan();
String data = "품명" + bean.getSang() + " , 금액은 "+price;
return data;
}
}
- result.jsp
<body>
post 결과 : ${data}
<br>
${bean.sang}
</body>
'BACK END > Spring' 카테고리의 다른 글
| [Spring] 스프링 정리8 - CRUD (0) | 2021.01.19 |
|---|---|
| [Spring] 스프링 정리7 - Controller 처리, DB연동 (0) | 2021.01.14 |
| [Spring] 스프링 정리5 - MVC Pattern (0) | 2021.01.13 |
| [Spring] 스프링 정리4 - DB연동 (0) | 2021.01.12 |
| [Spring] 스프링 정리3 - AOP (Aspect Oriented Program) (0) | 2021.01.12 |