2020. 12. 16. 11:28ㆍ교육과정/KOSMO
키워드 : Spring-MVC / SpringMVC RequestMapping 연습 / SpringMVC ArrayList를 사용한 MultiInsert 연습 / SpringMVC파라미터 연습 / SpringMVC 로그인 연습 / SpringMVC 리턴타입 연습 / SpringMVC 리다이렉트연습 / Spring Legacy Project만들기
****
0. 복습
※ 스프링MVC - 요청 따로 응답 따로 나가는 구조 (보안 때문)
(1) 시작 페이지 : 00_test_jsp
- "요청"이라는 단어에 링크 → "test.do"
(2) 컨트롤러 클래스 : TestController.java
- "test.do" 요청을 받는 test( ) 함수 선언
- test( ) 안에 출력문장 작성
- 컨트롤러의 빈 생성
- 리턴형이 void라면 뷰 페이지 자동으로 지정되므로
(3) 뷰 페이지 : 위치와 뷰 페이지 명 정하기
- Resolver 설정을 해두었으므로 /WEB-INF/view 안에 test.jsp
(4) 실행하여 정상적으로 출력되는지 확인
< 00_test.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> 00_test.jsp </title>
</head>
<body>
<a href="test.do">요청</a>
</body>
</html>< TestController.java 전체 소스 코드 >
package spring.mvc.test.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class TestController {
@RequestMapping("test.do")
public void test() {
System.out.println("test.do 요청 들어옴");
}
}
< test.jsp 전체 소스 코드 >
package spring.mvc.test.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class TestController {
@RequestMapping("test.do")
public void test() {
System.out.println("test.do 요청 들어옴");
}
}
< springMVC-servlet.xml 전체 소스 코드 >
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<!-- 빈설정 -->
<bean class="spring.mvc.test.controller.TestController"></bean>
<bean id='memberVO' class="spring.mvc.model.MemberVO">
<!-- 나중에는 DB에서 값을 가져오게 할 것 -->
<property name="id" value='0001' />
<property name="name" value='홍길동' />
<property name="age" value='33' />
</bean>
<!-- 자동 빈 설정 -->
<context:component-scan base-package="spring.mvc.controller"></context:component-scan>
</beans>
< common-servlet.xml 전체 소스 코드 >
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/" /> <!-- 위의 클래스 안에 있는 setPrefix()를 찾음 -->
<property name="suffix" value=".jsp" /> <!-- 위의 클래스에서 setsuffix()를 찾음 -->
</bean>
</beans>
1. RequestMapping 연습
(1) 기존의 02_rquest.jsp 활용
(2) "요청1"과 "요청2"라는 글씨에 각각 a.do와 b.do라는 요청이 가도록 링크 걸기
<h1> 요청 연습 </h1>
<a href="board/a.do">요청1</a><br/>
<a href="board/b.do">요청2</a><br/>
(3) 기존의 RequestController.java 활용
(4) test( ) 라는 함수가 a.do 요청과 b.do 요청을 모두 받도록 작성
@Controller
@RequestMapping("/board")
public class RequestController {
@RequestMapping(value={"/a.do", "/b.do"})
public void test() {
System.out.println("a.do요청과 b.do 요청 받음");
}
(5) String을 리턴할 경우 동일한 이름을 가진 뷰 페이지가 나타난다.
@RequestMapping("/board")
public class RequestController {
@RequestMapping(value={"/a.do", "/b.do"})
public String test() {
System.out.println("a.do요청과 b.do 요청 받음");
return "request";
}
(6) 02_request.jsp 에서 "요청3"과 "요청4"를 작성한다.
<h1> 요청 연습 </h1>
<a href="board/a.do">요청1</a><br/>
<a href="board/b.do">요청2</a><br/>
<a href="board/c.do?id=kim">요청3</a><br/>
<a href="board/c.do">요청4</a><br/>
(7) RequestController.java 에서 c.do 요청을 받는 ccc( ) 함수를 작성한다.
@Controller
@RequestMapping("/board")
public class RequestController {
@RequestMapping("/c.do")
public void ccc() {
System.out.println("c.do 요청");
}
}
(8) (7)의 리턴형이 없으므로 자동으로 뷰 페이지의 경로가 /WEB-INF/view + /board + /c + .jsp 가 된다.
view 폴더에 c.jsp 파일을 작성하면 정상적으로 수행된다.
(9) ccc( ) 함수의 RequestMapping을 다음과 같이 변경하면 요청4는 400에러가 발생한다.
@RequestMapping(value="/c.do", params="id=kim")
public void ccc() {
(10) 02_request.jsp 에서 <form> 태그 전체를 복사하여 전송방식을 get으로 변경한다.
<form action='board/request.do' method="get" >
<!-- name 부여시 VO의 멤버이름과 맞추는 것이 중요! -->
번호 : <input type="text" name='id' /><br/>
이름 : <input type="text" name='name' /><br/>
나이 : <input type="text" name='age' /><br/>
<input type="submit" value="전송" />
</form>
(11) RequestController.java 에서 request.do 요청에 대한 RequestMapping 스크립트를 다음과 같이 변경하면
post방식은 정상적으로 수행되나, get방식은 405에러가 발생한다.
(이와 같이 조건을 세분화하여 페이지를 구성할 수 있다.)
@RequestMapping(value="/request.do", method=RequestMethod.POST)
public void request(MemberVO vo) {
< 02_request.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> request.jsp </title>
</head>
<body>
<h1> 요청 연습 </h1>
<a href="board/a.do">요청1</a><br/>
<a href="board/b.do">요청2</a><br/>
<a href="board/c.do?id=kim">요청3</a><br/>
<a href="board/c.do">요청4</a><br/>
<h2> 폼요청 </h2>
<!-- 절대경로 : 프로젝트에서부터 시작 -->
<form action='board/request.do' method="post" >
<!-- name 부여시 VO의 멤버이름과 맞추는 것이 중요! -->
번호 : <input type="text" name='id' /><br/>
이름 : <input type="text" name='name' /><br/>
나이 : <input type="text" name='age' /><br/>
<input type="submit" value="전송" />
</form>
<hr/>
<form action='board/request.do' method="get" >
<!-- name 부여시 VO의 멤버이름과 맞추는 것이 중요! -->
번호 : <input type="text" name='id' /><br/>
이름 : <input type="text" name='name' /><br/>
나이 : <input type="text" name='age' /><br/>
<input type="submit" value="전송" />
</form>
</body>
</html>< RequestController.java 전체 소스 코드 >
package spring.mvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import spring.mvc.model.MemberVO;
@Controller
// 클래스와 메소드를 나누어 별칭을 지정할 수도 있음
@RequestMapping("/board")
public class RequestController {
@RequestMapping(value="/c.do", params="id=kim")
public void ccc() {
System.out.println("c.do 요청");
// 뷰 페이지의 경로
// /WEB-INF/view + /board + /c + .jap
}
@RequestMapping(value={"/a.do", "/b.do"})
public String test() {
System.out.println("a.do요청과 b.do 요청 받음");
return "request";
}
/********************
* 리턴형이 String인 경우
* - 문자열 반환이 아님
* - 뷰 페이지명을 지정
*
*/
// 절대경로 : 프로젝트를 빼고 그 다음부터 시작
// @RequestMapping("board/request.do")
@RequestMapping(value="/request.do", method=RequestMethod.POST)
public void request(MemberVO vo) {
System.out.println("request.do 요청");
// ModelAndView 리턴하지 않기
}
/********************
* 함수의 리턴형이 void인 경우
* -> 뷰 페이지가 자동으로 지정된다
* ex) request.do 요청 -> request
* /WEB-INF/view/ + request + .jap
* ex) mapTest.do 요청 -> mapTest
* /WEB-INF/view/ + mapTest + .jsp
*/
}
< c.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> c.jsp </title>
</head>
<body>
c.jsp 뷰 페이지입니다.
</body>
</html>
2. 사용자 입력값을 ArrayList에 담아서 다음 화면에서 테이블로 출력하기 (MultiInsert )
(1) WebContent에 03_list.jap 파일 만든 뒤 테이블 생성
<h2>리스트 타입의 프라퍼티(property)</h2>
<table>
<tr>
<th witdh='100'>선택</th>
<th witdh='200'>아이디</th>
<th witdh='300'>이름</th>
<th witdh='100'>나이</th>
</tr>
<tr>
<td><input type='checkbox' name='' /></td>
<td><input tyep='text' name='' /></td>
<td><input tyep='text' name='' /></td>
<td><input tyep='text' name='' /></td>
</tr>
<tr>
<td><input type='checkbox' name='' /></td>
<td><input tyep='text' name='' /></td>
<td><input tyep='text' name='' /></td>
<td><input tyep='text' name='' /></td>
</tr>
<tr>
<td><input type='checkbox' name='' /></td>
<td><input tyep='text' name='' /></td>
<td><input tyep='text' name='' /></td>
<td><input tyep='text' name='' /></td>
</tr>
</table>
(2) 사용자 입력값을 넘기기 위해 <form> 태그로 <table>을 감싸고, 전송버튼을 만든다.
전송버튼이 가운데로 오도록 컬럼을 병합한 후 align 속성도 함께 작성한다.
<form>
...
<tr>
<td colspan='4' align='center'><input type='submit' value="전송" /></td>
</tr>
</table>
</form>
(3) 전송 번튼 클릭시 전송방식을 post로 하여 multiInsert.do 요청을 하도록 <form>의 속성을 작성한다.
<form action="multiInsert.do" method='post'>
(4) spring.mvc.controller 패키지에 ListController.java 파일 생성 후,
컨트롤러로 작동하고 muliInsert.do 요청을 받도록 애노테이션을 붙인다.
@Controller
public class ListController {
@RequestMapping("multiInsert.do")
public void test() {
System.out.println("multiInsert.do 요청");
}
}
(5) 사용자 입력값이 각 줄마다 MemberVO로 담겨서 함께 전송되려면 List가 필요하다.
spring.mvc.model 패키지에 MemberVOList.java 파일을 생성한다.
(6) MemberVO 타입의 객체만 들어가는 ArrayList의 변수를 선언하고 setter, getter를 생성한다.
이후로, 다른 파일에서 list라는 이름을 똑같이 사용하여 setter와 getter를 호출할 수 있다.
public class MemberVOList {
ArrayList<MemberVO> list;
public ArrayList<MemberVO> getList() {
return list;
}
public void setList(ArrayList<MemberVO> list) {
this.list = list;
}
}
(7) ListController.java 에서 test( ) 메소드가 인자로 MemberVOList를 받도록 수정한다.
public void test(MemberVOList list) {
(8) 03_list.jsp 에서 사용자 입력값에 name을 지정하되 배열 형식처럼 되도록 작성한다.
( list[n].~는 MemberVOList의 setter setList( )를 호출한다. )
<td><input type='checkbox' name='list[0].state' /></td>
<td><input tyep='text' name='list[0].id' /></td>
<td><input tyep='text' name='list[0].name' /></td>
<td><input tyep='text' name='list[0].age' /></td>
....
(9) 뷰 페이지가 될 multiInsert.jsp 파일을 WEB-INF/view에 생성한다.
(10) 사용자 입력값을 모두 입력하고 전송버튼 클릭시 페이지가 넘어가는 것을 확인할 수 있다.
(11) multiInsert.jsp 페이지에서 사용자 입력값이 출력될 테이블을 작성한다.
<table border='2'>
<tr>
<th>아이디</th>
<th>이름</th>
<th>나이</th>
</tr>
<tr>
<td></td>
<td></td>
<td></td>
</tr>
</table>
(12) 동적 테이블 생성시 자바 코드를 최소한으로 사용하고 태그 형식으로 사용하기 위해,
JSTL 태그 라이브러리를 도입한다.
<%@ taglib prefix='c' uri='http://java.sun.com/jsp/jstl/core' %>
(13) memberVOList 객체 list에 담긴 사용자 입력값을 하나씩 꺼내서
vo라는 이름으로 각각의 값을 화면에 출력하도록 스크립트를 작성한다.
( items 속성값으로 작성한 memberVOList.list는 MemberVOList의 getter getList( )를 호출하여 값을 가져온다. )
<c:forEach var='vo' items='${memberVOList.list}'>
<tr>
<td>${vo.id}</td>
<td>${vo.name}</td>
<td>${vo.age}</td>
</tr>
</c:forEach>
( 실행결과 )
(14) ListController.java 에서도 사용자 입력값을 출력할 수 있다.
객체 list로부터 getter를 통해 데이터를 가져오고,
isState( ) 메소드를 통해 vo에 들어있는 값을 하나씩 꺼낼 수 있다.
for(MemberVO vo : list.getList()) {
System.out.println(vo.isState() + "/" + vo.getId() + "/" + vo.getName() + "/" + vo.getAge() + "\n");
( 실행결과 ) 콘솔에서 확인 가능
multiInsert.do 요청
true/aa/에이/1
false/bb/비/2
true/cc/씨/3
(15) 화면에서 체크박스 선택한 것만 결과 페이지에 나오도록 multiInsert.jsp 에서 forEach 다음에 조건문을 작성한다.
vo.state가 true인 값만 화면에 출력된다.
<c:if test="${vo.state}">
( 실행결과 )
< 03_list.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> 03_list.jsp </title>
</head>
<body>
<form action="multiInsert.do" method='post'>
<h2>리스트 타입의 프라퍼티(property)</h2>
<table>
<tr>
<th witdh='100'>선택</th>
<th witdh='200'>아이디</th>
<th witdh='300'>이름</th>
<th witdh='100'>나이</th>
</tr>
<tr>
<td><input type='checkbox' name='list[0].state' /></td>
<td><input tyep='text' name='list[0].id' /></td>
<td><input tyep='text' name='list[0].name' /></td>
<td><input tyep='text' name='list[0].age' /></td>
</tr>
<tr>
<td><input type='checkbox' name='list[1].state' /></td>
<td><input tyep='text' name='list[1].id' /></td>
<td><input tyep='text' name='list[1].name' /></td>
<td><input tyep='text' name='list[1].age' /></td>
</tr>
<tr>
<td><input type='checkbox' name='list[2].state' /></td>
<td><input tyep='text' name='list[2].id' /></td>
<td><input tyep='text' name='list[2].name' /></td>
<td><input tyep='text' name='list[2].age' /></td>
</tr>
<tr>
<td colspan='4' align='center'><input type='submit' value="전송" /></td>
</tr>
</table>
</form>
</body>
</html>< ListController.java 전체 소스 코드 >
package spring.mvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import spring.mvc.model.MemberVO;
import spring.mvc.model.MemberVOList;
@Controller
public class ListController {
@RequestMapping("multiInsert.do")
public void test(MemberVOList list) {
System.out.println("multiInsert.do 요청");
for(MemberVO vo : list.getList()) {
System.out.println(vo.isState() + "/" + vo.getId() + "/" + vo.getName() + "/" + vo.getAge() + "\n");
}
}
}
< MemberVOList.java 전체 소스 코드 >
package spring.mvc.model;
import java.util.ArrayList;
public class MemberVOList {
ArrayList<MemberVO> list;
public ArrayList<MemberVO> getList() {
return list;
}
public void setList(ArrayList<MemberVO> list) {
this.list = list;
}
}
< multiInsert.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix='c' uri='http://java.sun.com/jsp/jstl/core' %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> multiInsert.jsp </title>
</head>
<body>
결과
<hr/>
<table border='2'>
<tr>
<th>아이디</th>
<th>이름</th>
<th>나이</th>
</tr>
<c:forEach var='vo' items='${memberVOList.list}'>
<c:if test="${vo.state}">
<tr>
<td>${vo.id}</td>
<td>${vo.name}</td>
<td>${vo.age}</td>
</tr>
</c:if>
</c:forEach>
</table>
</body>
</html>
3. 파라미터 연습
(1) WebContent 에 04_parameter.jsp 파일 생성 후 body를 작성한다.
<h1>파라메터 연습</h1>
<a href="param.do?cate=book&kind=IT">요청시 파라메터전송</a><br/>
<a href=""></a><br/>
(2) ParamController.java 파일이 컨트롤러 역할을 하고 param.do라는 요청을 받도록 애노테이션을 붙인다.
@Controller
public class ParamController {
@RequestMapping("param.do")
public void param() {
System.out.println("param.do 요청됨");
}
(3) param.do 라는 요청이 컨트롤러를 지나면 뷰 페이지는 자동으로 param.jsp 페이지가 되므로,
WEB-INF/view 안에 param.jsp 페이지를 작성한다.
카테고리 : _____
종류 : ____
( 실행결과 )
(4) 04_parameter.jsp 페이지에서 "요청시 파라메터전송" 글씨 클릭시 쿼리스트링으로 넘어가는 파라미터가 뷰 페이지에서 출력되도록 ParamController.java 에서 param( ) 가 인자를 받게 수정한다.
@RequestMapping("param.do")
public void param(String cate, String kind) {
(5) 값이 정상적으로 받아지는지 콘솔에서 확인해볼 수 있다.
@RequestMapping("param.do")
public void param(String cate, String kind) {
System.out.println("param.do 요청됨");
System.out.println("cate: " + cate);
System.out.println("kind: " + kind);
( 실행결과 )
param.do 요청됨
cate: book
kind: IT
(6) param.jsp 페이지에서 파라미터 값이 출력되도록 EL을 사용하여 스크립트를 작성한다.
카테고리 : ${param.cate}
종류 : ${param.kind}
( 실행결과 )
4. 로그인 연습
(1) 기존의 04_parameter.jsp 를 사용한다.
(2) <form>의 사용자 입력값을 login.do라는 요청으로 보내도록 스크립트를 작성한다.
<h1>로그인</h1>
<form action="login.do" method="get">
아이디 : <input type="text" name='id'><br/>
비밀번호 : <input type="password" name='pass'><br/>
<input type='submit' value="로그인" />
</form>
(3) ParamController.java 에서 login.do 요청을 받는 함수를 작성하여 RequestMapping 해준다.
@RequestMapping("login.do")
public void login(String id, String pass) {
System.out.println("id : " + id);
System.out.println("pass : " + pass);
}
(4) login( ) 함수의 리턴형이 void이므로 뷰 페이지는 자동으로 /WEB-INF/view의 login.jsp가 된다.
해당 경로에 login.jsp 파일 생성 후 사용자 입력값 중 id가 화면에 출력되도록 스크립트를 작성한다.
${param.id}님 로그인하셨습니다.
( 실행결과 )
(5) spring.mvc.model 패키지에 User.java 클래스를 만든 뒤, 변수 선언 및 setter, getter를 생성해준다.
User 클래스는 회원가입시 저장되는 VO 역할을 한다.
public class User {
private String id;
private String pass;
private String name;
private String addr;
private String tel;
public String getId() {
return id;
}
....
(6) ParaController.java 에서 User 클래스에 저장된 사용자 입력값을 가져오기 위해
login.do 요청을 받는 login( ) 함수의 인자를 수정한다.
@RequestMapping("login.do")
public void login(User user) {
System.out.println("id : " + user.getId());
System.out.println("pass : " + user.getPass());
(7) 뷰 페이지인 login.jsp 에서 VO인 user의 값을 화면에 출력하도록 EL로 작성한다.
${user.id}님 로그인 성공
( 실행결과 )
(8) 나중에 DB와 연결하는 상황을 가정하되, 현재는 DB가 없으므로 login( ) 안에 DB 역할을 할 데이터를 작성한다.
@RequestMapping("login.do")
public void login(User user, HttpSession session) {
System.out.println("id : " + user.getId());
System.out.println("pass : " + user.getPass());
// DB의 회원 테이블 값이라 가정
String dbId = "java";
String dbPass = "1234";
(9) DB의 데이터와 사용자 입력값이 동일할 경우 다음 화면에 출력하기 위한 조건문을 작성한다.
if(user.getId().equals(dbId) && user.getPass().equals(dbPass)) {
}
(10) 사용자 입력값을 세션에 저장하기 위해서 HttpSession에 매개변수를 지정해야 한다.
세션을 사용하기 위해서는 함수의 인자로 지정하면 된다.
@RequestMapping("login.do")
public void login(User user, HttpSession session) {
(11) 조건문에서 세션에 로그인 정보를 저장한다.
if(user.getId().equals(dbId) && user.getPass().equals(dbPass)) {
// 세션에 로그인 정보 저장
session.setAttribute("login", dbId);
}
(12) 뷰 페이지인 login.jsp 에서 세션으로 넘어온 데이터를 EL을 사용하여 출력한다.
${sessionScope.login}님 로그인 성공입니다.
( 실행결과 )
<04_parameter.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> 04_parameter.jsp </title>
</head>
<body>
<h1>파라메터 연습</h1>
<a href="param.do?cate=book&kind=IT">요청시 파라메터전송</a><br/>
<a href=""></a><br/>
<h1>로그인</h1>
<form action="login.do" method="get">
아이디 : <input type="text" name='id'><br/>
비밀번호 : <input type="password" name='pass'><br/>
<input type='submit' value="로그인" />
</form>
</body>
</html>< ParamController.java 전체 소스 코드 >
package spring.mvc.controller;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import spring.mvc.model.User;
@Controller
public class ParamController {
@RequestMapping("param.do")
public void param(String cate, String kind) {
System.out.println("param.do 요청됨");
System.out.println("cate: " + cate);
System.out.println("kind: " + kind);
}
@RequestMapping("login.do")
//public void login(String id, String pass) {
public void login(User user, HttpSession session) {
System.out.println("id : " + user.getId());
System.out.println("pass : " + user.getPass());
// DB의 회원 테이블 값이라 가정
String dbId = "java";
String dbPass = "1234";
if(user.getId().equals(dbId) && user.getPass().equals(dbPass)) {
// 세션에 로그인 정보 저장
session.setAttribute("login", dbId);
}
}
/***********
* 세션이 필요할 때 HttpSession session을 매개변수에 지정
*/
}
< login.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
${param.id}님 로그인하셨습니다.
<hr/>
${user.id}님 로그인 성공
<hr/>
${sessionScope.login}님 로그인 성공입니다.
</body>
</html>< User.java 전체 소스 코드 >
package spring.mvc.model;
// 회원가입시 저장되는 VO
public class User {
private String id;
private String pass;
private String name;
private String addr;
private String tel;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPass() {
return pass;
}
public void setPass(String pass) {
this.pass = pass;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
}
5. 리턴타입 연습
(1) WebContent 에 05_returnType.jsp 에서 map.do 요청과 model.do 요청을 받는 화면을 만든다.
<a href='map.do'>1. Map 리턴</a><br/> <!-- 결과 : map.jsp -->
<a href='model.do'>2. Model 리턴</a><br/> <!-- 결과 : model.jsp -->
(2) 컨트롤러가 될 ReturnController.java 파일을 생성 후
각각의 요청에 대해 작업을 수행하도록 애노테이션을 비롯한 스크립트를 작성한다.
@Controller
public class ReturnController {
@RequestMapping("map.do")
public void map() {
System.out.println("map.do 요청됨");
}
@RequestMapping("model.do")
public void model() {
System.out.println("model.do 요청됨");
}
}
(3) 뷰 페이지가 될 map.jsp와 model.jsp를 /WEB-INF/view 안에 생성한다.
( 실행결과 )
(4) 컨트롤러에서 뷰 단으로 데이터를 전달하는 방식은 3가지이다.
| 1. ModelAndView 리턴 |
| 2. Map 리턴 (ex. \HashMap ) |
| 3. Model 이용 (리턴이 아님!) |
① ModelAndView 리턴
알아서 잘~
② Map 리턴
ㄱ) ReturnControll.java 에서 map( ) 함수가 HashMap을 사용하여 데이터를 담고 리턴하도록 수정한다.
@RequestMapping("map.do")
public Map map() {
Map map = new HashMap();
map.put("message", "오늘도 무사히");
map.put("id", "홍길자");
return map;
}
ㄴ) 뷰 페이지인 map.jsp 에서 컨트롤러에서 작성된 HashMap의 값을 화면에 출력하도록 스크립트를 작성한다.
<h1>map.do 요청 결과</h1>
메세지 : ${message} <br/>
ID : ${id} <br/>
( 실행결과 )
② Model 이용 (리턴이 아님!)
: 리턴을 하는 것이 아니라 마지 인자인 것처럼 사용하여 뷰 페이지로 넘어가는 것이다.
ㄱ) ReturnControll.java 에서 model( ) 함수가 Model을 인자로 받아
Model에 속성값을 이용하여 데이터를 추가하고 model.jsp 페이지로 넘어가도록 작성한다.
@RequestMapping("model.do")
public String model(Model m) {
m.addAttribute("message", "우리조 화이팅");
m.addAttribute("pm", "홍길동");
return "model";
}
ㄴ) 뷰 페이지인 map.jsp 에서 컨트롤러에서 작성된 Model의 값을 화면에 출력하도록 스크립트를 작성한다.
<h1>model.do 요청 결과</h1>
메세지 : ${message} <br/>
PM : ${pm} <br/>
( 실행결과 )
< 05_returnType.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> 05_returnType.jsp </title>
</head>
<body>
<a href='map.do'>1. Map 리턴</a><br/> <!-- 결과 : map.jsp -->
<a href='model.do'>2. Model 리턴</a><br/> <!-- 결과 : model.jsp -->
</body>
</html>< ReturnController.java 전체 소스 코드 >
package spring.mvc.controller;
import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class ReturnController {
/*************************
* [참고] 뷰 페이지명 지정
* 1. ModelAndView
* 2. void 리턴형 -> 자동 지정
* 3. String 리턴형 -> 뷰 페이지명 리턴
*/
/*************************
* 컨트롤러에서 뷰 단으로 데이터 전달 방식
* 1. ModelAndView 리턴
* 2. Map 리턴 (ex. \HashMap )
* 3. Model 이용 (리턴이 아님!)
*/
@RequestMapping("map.do")
public Map map() {
Map map = new HashMap();
map.put("message", "오늘도 무사히");
map.put("id", "홍길자");
return map;
}
@RequestMapping("model.do")
public String model(Model m) {
m.addAttribute("message", "우리조 화이팅");
m.addAttribute("pm", "홍길동");
return "model";
}
}
< map.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> map.jsp </title>
</head>
<body>
<h1>map.do 요청 결과</h1>
메세지 : ${message} <br/>
ID : ${id} <br/>
</body>
</html>< model.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> model.jsp </title>
</head>
<body>
<h1>model.do 요청 결과</h1>
메세지 : ${message} <br/>
PM : ${pm} <br/>
</body>
</html>
6. 리다이렉트 연습
(1) WebContent 에 06_redirect.jsp 에서 <a> 태그로 요청을 보내는 스크립트를 작성한다.
<a href='select.do'>목록보기</a><br/>
<a href='insert.do'>입력하기</a><br/>
(2) spring.mvc.controller 패키지에 RedirectController.java 클래스를 생성하여
컨트롤러로 작동하고 요청을 받도록 애노테이션을 붙인다.
@Controller
public class RedirectController {
@RequestMapping("select.do")
public void select() {
System.out.println("select.do 요청됨");
}
@RequestMapping("insert.do")
public void insert() {
System.out.println("insert.do 요청됨");
}
}
(3) 뷰 페이지가 될 select.jsp 와 insert.jsp 를 /WEB-INF/view 안에 생성한다.
( 실행결과 )
(4) 컨트롤러에서 select( ) 함수가 수행될 때 뷰 단으로 데이터를 전달하도록 스크립트를 작성한다.
(이번에는 Model을 이용했으나 ModelAndView 또는 Map 방식을 사용해도 무방하다.)
@RequestMapping("select.do")
public void select(Model m) {
System.out.println("insert.do 요청됨");
m.addAttribute("info", "추후 디비값");
}
(5) select.jsp 에서 Model 에 저장된 데이터를 화면에 출력하도록 스크립트를 작성한다.
목록보기<br/>
${info}
( 실행결과 )
(6) 컨트롤러에서 insert( ) 함수가 수행될 때 목록보기 페이지로 전환하고자 한다.
String 리턴형을 사용하여 뷰 페이지를 지정한다.
@RequestMapping("insert.do")
public String insert() {
System.out.println("insert.do 요청됨");
// 입력 후에 목록보기 페이지 전환하기
return "select";
}
( 실행결과 )
: 목록보기 페이지로 넘어오긴 하지만 데이터를 전혀 가져오지 못한다.
(7) return에 페이지 이름만 기술하면 단순히 출력 페이지를 지정한 것에 불과하다.
리다이렉트가 되기 위해서는 redirect:select라고 작성해야 한다.
@RequestMapping("insert.do")
public String insert() {
System.out.println("insert.do 요청됨");
// 입력 후에 목록보기 페이지 전환하기
// return "select"; ==> 출력 페이지만 지정한 것임
return "redirect:select";
}
( 실행결과 )
: 목록보기 페이지로 데이터까지 가지고 넘어온다.
< 06_redirect.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> 06_redirect.jsp </title>
</head>
<body>
<a href='select.do'>목록보기</a><br/>
<a href='insert.do'>입력하기</a><br/>
</body>
</html>< RedirectController.java 전체 소스 코드 >
package spring.mvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class RedirectController {
@RequestMapping("select.do")
public void select(Model m) {
System.out.println("insert.do 요청됨");
m.addAttribute("info", "추후 디비값");
}
@RequestMapping("insert.do")
public String insert() {
System.out.println("insert.do 요청됨");
// 입력 후에 목록보기 페이지 전환하기
// return "select"; ==> 출력 페이지만 지정한 것임
return "select";
}
}
< select.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> /WEB-INF/view/select.jsp </title>
</head>
<body>
목록보기<br/>
${info}
</body>
</html>< insert.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> /WEB-INF/view/insert.jsp </title>
</head>
<body>
입력하였습니다.
</body>
</html>
7. Spring Legacy Project로 새 프로젝트 만들기
(1) 좌측의 Package Explorer 우클릭
- New
- Spring Legacy Project
- 프로젝트 명 지정
- Templates 에서 Spring MVC Project 선택
- Next
-com.javaclass.basic 기술
- Finish
(2) pom.xml 에서 필요한 라이브러리를 자동으로 다운받아주지만, 자바와 스프링 버전이 너무 낮으므로 수정해준다.
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<!-- 맞는 버전으로 수정 -->
<java-version>1.8</java-version>
<org.springframework-version>5.0.8.RELEASE</org.springframework-version>
(3) src/main/webapp/WEB-INF 폴더 안의 web.xml 의 서블릿 설정에서 <url-pattern>을 * . do 로 수정한다.
(4) 프로젝트명 우클릭 - Properties
ㄱ) Project Facets 클릭 - Java 의 version을 1.8로 변경
ㄴ) Server 클릭 - Tomcat v9.0 Server at localhost 클릭 후 Apply
ㄷ) Apply and Close
(5) 하단에 위치한 View에서 Servers 탭 선택 - Tomcat v9.0 Server at localhost를 더블클릭 - Module 탭에 들어간다.
(6) Edit 를 클릭하여 Document Base와 Path명이 동일하도록 수정하되, Path는 /로 시작해야 한다.
프로젝트가 1개 밖에 없을 경우에는 Path에 / 만 기입해도 작동하지만,
프로젝트가 여러개일 경우에는 알맞게 수정해야 한다.
(7) 기존의 com.javaclass.basic 패키지를 지우고 새롭게 spring.mvc.controller 패키지를 만든다.
(8) src/main/webapp/WEB-INF/spring/appServlet 폴더 안의
servlet.context.xml 에서 오토 스캔할 패키지의 범위를 spring.mvc.controller 로 변경한다.
(9) index.jsp 실행하여 정상적으로 연결되는지 확인한다.
( 실행결과 )
< pom.xml 전체 소스 코드 >
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.javaclass</groupId>
<artifactId>basic</artifactId>
<name>fSpringMVC</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<!-- 맞는 버전으로 수정 -->
<java-version>1.8</java-version>
<org.springframework-version>5.0.8.RELEASE</org.springframework-version>
<org.aspectj-version>1.6.10</org.aspectj-version>
<org.slf4j-version>1.6.6</org.slf4j-version>
</properties>
<dependencies>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- AspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${org.aspectj-version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.15</version>
<exclusions>
<exclusion>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
</exclusion>
<exclusion>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jdmk</groupId>
<artifactId>jmxtools</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jmx</groupId>
<artifactId>jmxri</artifactId>
</exclusion>
</exclusions>
<scope>runtime</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
< web.xml 전체 소스 코드 >
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://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>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
<!-- Creates the Spring Container shared by all Servlets and Filters -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 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>
<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>*.do</url-pattern>
</servlet-mapping>
</web-app>
< HelloController.java 전체 소스 코드 >
package spring.mvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class HelloController {
@RequestMapping("home.do")
public void home() {
System.out.println("home.do 요청됨");
}
}
< index.jsp 전체 소스 코드 >
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title> /webapp/index.jsp </title>
</head>
<body>
<a href='home.do'>시작</a>
</body>
</html>< servlet-context.xml 전체 소스 코드 >
<?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 -->
<!-- Enables the Spring MVC @Controller programming model -->
<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 -->
<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>
<context:component-scan base-package="spring.mvc.controller" />
</beans:beans>