| SPRING 7일차 (socket) (0) | 2024.05.17 |
|---|---|
| SPRING 6일차 (email 전송 & 인증, scheduler, ajax, json방식, RestController, SPA) (0) | 2024.05.16 |
| SPRING 5일차 (자동 로그인, 보안 처리 XSS, 파일 업로드 & 다운로드) (0) | 2024.05.14 |
| SPRING 4일차 (암호화, api, Interceptor) (0) | 2024.05.13 |
| SPRING 3일차 (cookie, session 및 database) (0) | 2024.05.09 |
web socket : 양방향 통신 (채팅)
https://mvnrepository.com/ - spring websocket 검색 - 첫번째 클릭
- 아무버전 클릭 - maven 내용 복사 - pom.xml(${org.springframework-version}) 붙여넣기
https://mvnrepository.com/ - jackson databind 검색 - 첫번째 클릭
- 2.12.1 버전 클릭 - maven 내용 복사 - pom.xml 붙여넣기
socket 관련 class 생성(TestSocket.java)
기본 설정 : servlet-context.xml - Namespaces - websocket 체크
servlet-context.xml - Source -
<beans:bean id="ts" class="socket 관련 class(TestSocket) 경로" /> : 빈 생성
<websocket:handlers>
<websocket:mapping handler="ts" path="/chat" /> : /chat 을 요청하면 ts객체를 바로보게끔 설정
<websocket:sockjs /> : socket api를 사용할 수 있게 설정
</websocket:handlers>
* TestSocket.java - extends TextWebSocketHandler
TestSocket.java - Override/Implement Methods - AbstractWebSocketHandler
- after~closed, after~Established, handleTextMessage 체크 - ok
afterConnectionEstablished : 클라이언트가 연동되면 실행
handleTextMessage : 사용자가 메시지를 보내면 실행
afterConnectionClosed : 클라이언트가 종료 및 연결이 끊기면 실행
해당 test_socket.jsp 페이지에 접속시, 지정한 세션을 부여한다.
"상담사 연결" 버튼을 누르면, chat()함수로 이동한 후, socket이라는 경로의 페이지로 이동한다.
* controller에서 부여한 session과 TestSocket.java에서 받은 session은 타입이 다르다.
따라서, servlet-context.xml - Source -
<websocket:handshake-interceptors>
<beans:bean class="org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor" />
</websocket:handshake-interceptors>
을 추가한다.
session.getId() : WebSocketSession에서 부여한 session
session.getAttributes() : controller에서 부여한 session
List에는 session 전체를 넣고, Map에는 key에 session.getId(), value에는 session.getAttributes().get("name")
TextMessage message로 넘어온 값을 message.getPayload() = 입력한 내용 받아오기
sessionMap.get(session.getId()) : Map에 session.getId()를 통해 밸류가 얻어오기(ex. 홍길동1)
sessionList의 forEach문을 통해, .sendMessage(text)를 통해 문자 전달하기
연결이 끊겼을 때, 알려주는 역할
let sock = null : WebSocket 객체를 저장한 변수 sock 선언
let wsUri : "ws://localhost:8080/root/chat/websocket" : 연결이 설정될 WebSocket URI 지정
sock = new WebSocket(wsUri) : 지정된 uri로 새 WebSocket연결을 생성
sock.onmessage = onMessage : 들어오는 메시지를 처리하는 함수 onMessage를 설정
sock.onclose = onClose : 연결이 닫힐 때 처리하는 함수 onClose를 설정
$("#send_msg").keydown( (key) => {
if (key.keyCode == 13) {} }) : 엔터키를 눌렀을때 함수 실행
sock.send() : 추출한 메시지를 서버로 전송
.append() : 요소 끝에 계속 추가하는 역할
실행 결과
| SPRING 8일차 (0) | 2024.05.20 |
|---|---|
| SPRING 6일차 (email 전송 & 인증, scheduler, ajax, json방식, RestController, SPA) (0) | 2024.05.16 |
| SPRING 5일차 (자동 로그인, 보안 처리 XSS, 파일 업로드 & 다운로드) (0) | 2024.05.14 |
| SPRING 4일차 (암호화, api, Interceptor) (0) | 2024.05.13 |
| SPRING 3일차 (cookie, session 및 database) (0) | 2024.05.09 |
https://mvnrepository.com/ - spring context support 검색 - 첫번째 클릭
- 아무버전 클릭 - maven 내용 복사 - pom.xml 붙여넣기(${org.springframework-version})
https://mvnrepository.com/ - javax 검색 - 첫번째 클릭
- 1.5.4 버전 클릭 - maven 내용 복사 - pom.xml 붙여넣기
https://mvnrepository.com/ - javax 검색 - 세번째 클릭
- 1.5.3 버전 클릭 - maven 내용 복사 - pom.xml 붙여넣기
* google 로그인 - 계정 관리 - 보안 - 2단계 인증 완료
config관련 mail클래스 생성 -
mailController 생성 -
mail Service 생성 -
https://myaccount.google.com/apppasswords - 계정 입력 - 받은 비밀번호 복사
- config 파일의 .setPassword("붙여넣기")
* StringBuffer : 해당 객체는 지우고 새롭게 만드는 것이 아니라, 계속 유지된다.
* .setText(body, true) : 텍스트 형식 말고 html형식으로 보내는 방법
실행 결과
ㅇ
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:if test="${ userId == null }">
<form action="auth">
<input type="text" name="email"><br>
<input type="submit" value="이메일 인증">
</form>
</c:if>
<c:if test="${ userId != null }">
<h3>${userId }님 이메일 인증되었음!!</h3>
</c:if>
</body>
</html>package com.care.root.controller;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.care.root.service.MailServiceImpl;
@Controller
public class MailController {
@Autowired MailServiceImpl ms;
@GetMapping("sendmail")
public void sendMail(HttpServletRequest req,
HttpServletResponse res) throws Exception{
req.setCharacterEncoding("utf-8");
res.setContentType("text/html; charset=utf-8");
PrintWriter out = res.getWriter();
ms.sendMail("xodud5080@gmail.com", "제목 : 테스트", "내용 : 안녕");
out.print("메일을 보냈습니다");
}
@GetMapping("sendmail02")
public void sendMail02(HttpServletRequest req,
HttpServletResponse res) throws Exception{
req.setCharacterEncoding("utf-8");
res.setContentType("text/html; charset=utf-8");
PrintWriter out = res.getWriter();
StringBuffer body = new StringBuffer();
body.append("<html><body>");
body.append("<h1>제품 소개</h1>");
body.append("<a href='https://www.naver.com/'>");
body.append("<img alt='' src='https://search.pstatic.net/common/?src=http%3A%2F%2Fblogfiles.naver.net%2FMjAyNDAxMDRfMjMw%2FMDAxNzA0MzczODA3MTcz.SA2hQyKDRrje6lKrEnljRYPIsiByFlwzXv9fc5clJ9cg.qP2m0LDx9XqYJSJX5hrL73baolQe-8cwpsJr3fF4D40g.JPEG.uiuiui2200%2FIMG_9283.jpg&type=a340'>");
body.append("</a>");
body.append("</body></html>");
ms.sendMail02("xodud5080@gmail.com", "제목 : 푸바오", body.toString());
out.print("메일을 보냈습니다");
}
@GetMapping("auth_form")
public String authForm() {
return "auth";
}
@GetMapping("auth")
public String auth(HttpServletRequest req) {
ms.auth(req);
return "redirect:http://www.google.com";
}
@GetMapping("auth_check")
public String authCheck(@RequestParam String userId,
HttpSession session) {
String userKey = (String)session.getAttribute("xodud5080@gmail.com");
if (userKey.equals(userId)) {
session.setAttribute("userId", "xodud5080");
System.out.println("userId : " + session.getAttribute("userId"));
}
return "redirect:auth_form";
}
}package com.care.root.service;
import java.util.Random;
import javax.mail.internet.MimeMessage;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;
@Service
public class MailServiceImpl {
@Autowired JavaMailSender sender;
public void sendMail(String to, String subject, String body) {
MimeMessage messasge = sender.createMimeMessage(); // 보내는 형식 지정
try {
MimeMessageHelper h = new MimeMessageHelper(messasge, true, "UTF-8");
// true = multipart로 사용하겠다는 의미
h.setSubject(subject);
h.setTo(to);
h.setText(body);
sender.send(messasge); // 메일 전송
} catch (Exception e) {
e.printStackTrace();
}
}
public void sendMail02(String to, String subject, String body) {
MimeMessage messasge = sender.createMimeMessage(); // 보내는 형식 지정
try {
MimeMessageHelper h = new MimeMessageHelper(messasge, true, "UTF-8");
// true = multipart로 사용하겠다는 의미
h.setSubject(subject);
h.setTo(to);
h.setText(body, true); // 텍스트 형식이 아니라고 명시
sender.send(messasge); // 메일 전송
} catch (Exception e) {
e.printStackTrace();
}
}
private String rand() {
Random ran = new Random();
String str = "";
int num;
while(str.length() != 20) {
num = ran.nextInt(75) + 48; // (0 ~ 75) + 48 = 48 ~ 122
if ((num >= 48 && num <= 57) || (num >= 65 && num <= 90) || (num >= 97 && num <= 122)) {
str += (char)num;
}
}
return str;
}
public void auth(HttpServletRequest req) {
HttpSession session = req.getSession();
String userId = req.getParameter("email");
String userKey = rand();
session.setAttribute(userId, userKey);
System.out.println("userId1 : " + session.getAttribute(userId));
String body = "<h3>이메일 인증</h3>"
+ "<a href='http://localhost:8080/root/auth_check?userId="+userKey+"'>인증하기</a>";
sendMail02(userId, "이메일 인증", body);
}
}
실행 결과
scheduler : 지정한 시간대가 되면 동작하게 하는 것(예약)
scheduler 관련 config 클래스 생성
* @EnableScheduling, @Scheduled(cron = "시간 설정") 작성
실행 결과
ajax를 사용 안할 때
ajax를 사용 할 때
ajax 쓰는 이유 : 페이지를 새로고침 하지 않아, 처리속도가 더 빠르다
* <script src="https://code.jquery.com/jquery-3.4.1.min.js"></script> : jquery 라이브러리 가져오기
@ResponseBody : return에 값을 명시해도, jsp파일을 찾아가지 않고 데이터를 돌려준다
https://mvnrepository.com/ - jackson databind 검색 - 첫번째 클릭
- 2.9.5 버전 클릭 - maven 내용 복사 - pom.xml 붙여넣기
JSON.stringify("데이터") : 해당 데이터를 json형식으로 변환
보내는 방식(type) : contentType
받는 방식(type) : dataType
* json형식으로 넘어오는 값은 @RequestBody형식으로 받는다
<%@ 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>
<script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
<script type="text/javascript">
function test() {
let n = document.getElementById("name").value;
let a = $("#age").val();
let form = {name : n, age : a};
$.ajax({
url : "result03", type : "post",
data : JSON.stringify(form),
dataType : "json",
contentType : "application/json; charset=utf-8",
success : (result) => {
console.log(result);
$("#result").html("name : " + result.name+ ", age : " + result.age)
},
error : () => {
console.log("문제 발생!!!");
}
})
}
</script>
</head>
<body>
<input type="text" id="name"><br>
<input type="text" id="age"><br>
<input type="button" value="click" onclick="test()"><br>
결과 : <span id="result"></span>
</body>
</html>package com.care.root;
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* Handles requests for the application home page.
*/
@Controller
public class HomeController {
private static final Logger logger = LoggerFactory.getLogger(HomeController.class);
/**
* Simply selects the home view to render by returning its name.
*/
@RequestMapping(value = "/", method = RequestMethod.GET)
public String home(Locale locale, Model model) {
logger.info("Welcome home! The client locale is {}.", locale);
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);
String formattedDate = dateFormat.format(date);
model.addAttribute("serverTime", formattedDate );
return "home";
}
@GetMapping("ajax03")
public String ajax03() {
System.out.println("ajax03");
return "ajax03";
}
@PostMapping(value = "result03", produces = "application/json; charset=utf-8")
@ResponseBody
public InfoDTO result03(@RequestBody InfoDTO dto) {
System.out.println("result03");
System.out.println("dto.name" + dto.getName());
System.out.println("dto.age" + dto.getAge());
// System.out.println("map.name" + map.get("name"));
// System.out.println("map.age" + map.get("age"));
return dto;
}
}
실행 결과
@RestController : jsp페이지 대신, data를 return으로 돌려주는 controller이다
* @ResponseBody를 쓸 필요가 없어진다.
<%@ 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>
<script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
<script type="text/javascript">
function getFunc() {
$.ajax({
url : "rest", type : "get", dataType : "json",
success : function (result) {
$("#span").html(result.result);
}, error : function () {
alert("문제 발생!!!");
}
})
}
function postFunc() {
$.ajax({
url : "rest", type : "post", dataType : "json",
success : function (result) {
$("#span").html(result.result);
}, error : function () {
alert("문제 발생!!!");
}
})
}
function putFunc() {
$.ajax({
url : "rest", type : "put", dataType : "json",
success : function (result) {
$("#span").html(result.result);
}, error : function () {
alert("문제 발생!!!");
}
})
}
function deleteFunc() {
$.ajax({
url : "rest", type : "delete", dataType : "json",
success : function (result) {
$("#span").html(result.result);
}, error : function () {
alert("문제 발생!!!");
}
})
}
</script>
</head>
<body>
<span id="span"></span><hr>
<button type="button" onclick="getFunc()">get 요청</button>
<button type="button" onclick="postFunc()">post 요청</button>
<button type="button" onclick="putFunc()">put 요청</button>
<button type="button" onclick="deleteFunc()">delete 요청</button>
</body>
</html>package com.care.root;
import java.util.HashMap;
import java.util.Map;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestController {
@GetMapping(value="rest", produces = "application/json; charset=utf-8")
public Map<String, Object> get() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("result", "get : 데이터 요청");
return map;
}
@PostMapping(value="rest", produces = "application/json; charset=utf-8")
public Map<String, Object> post() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("result", "post : 데이터 추가");
return map;
}
@PutMapping(value="rest", produces = "application/json; charset=utf-8")
public Map<String, Object> put() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("result", "put : 데이터 수정");
return map;
}
@DeleteMapping(value="rest", produces = "application/json; charset=utf-8")
public Map<String, Object> delete() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("result", "delete : 데이터 삭제");
return map;
}
}
실행 결과
SPA : 브라우저를 최초에 한번 로드하고, 이후부터는 특정 부분만 ajax를 통해 바인딩하는 방식
* 경로로 전송한 값은, controller에서 {}로 받고, 해당 클래스에서는 @ParhVariable로 받는다
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>안녕 페이지</h1>
<hr>
<a href="index">HOME</a>
<span style="cursor: pointer;" onclick="members()">MEMBERS</span>
<hr>
</body>
</html><%@ 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>
<script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
<script type="text/javascript">
function members() {
$.ajax({
url : "members", type : "get", dataType : "json",
success : (list) => {
console.log(list);
console.log(list[0].id);
let msg = "<table border='1'>";
msg += "<tr><th>id</th><th>name</th><th>age</th></tr>"
for(let i = 0; i < list.length; i++){
msg += "<tr>";
msg += "<td>" + list[i].id + "</td>";
msg += "<td onclick='getMember(\"" + list[i].id + "\")'>" + list[i].name + "</td>";
msg += "<td>" + list[i].age + "</td>";
msg += "</tr>";
}
msg += "</table>";
$("#content").html(msg);
}
});
}
function getMember(userId) {
console.log(userId)
$.ajax({
url : "members/"+userId, type : "get", dataType : "json",
success : (member) => {
console.log(member);
let msg = "id : " + member.id + "<br>";
msg += "name : " + member.name + "<br>";
msg += "age : " + member.age + "<br>";
$("#content").html(msg);
}
});
}
</script>
</head>
<body>
<%@ include file="header.jsp" %>
<div id="content">
<h3>기본 페이지 입니다 </h3>
</div>
</body>
</html>package com.care.root;
import java.util.ArrayList;
import org.springframework.stereotype.Component;
@Component
public class DBClass {
ArrayList<InfoDTO> DB;
public DBClass() {
DB = new ArrayList<InfoDTO>();
for (int i = 0; i < 3; i++) {
InfoDTO dto = new InfoDTO();
dto.setId("aaa" + i);
dto.setName("홍길동" + i);
dto.setAge(10+i);
DB.add(dto);
}
}
}package com.care.root;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestController {
@Autowired DBClass db;
@GetMapping(value="members", produces = "application/json; charset=utf-8")
public ArrayList<InfoDTO> members() {
return db.DB;
}
@GetMapping(value="members/{uId}", produces = "application/json; charset=utf-8")
public InfoDTO getMember(@PathVariable String uId) {
//System.out.println("Asdfasd");
for(InfoDTO d : db.DB) {
System.out.println(d.getId().equals(uId));
if (d.getId().equals(uId)) {
System.out.println(d.getId());
System.out.println(d.getName());
return d;
}
}
return null;
}
}
실행 결과
* serializeArray() : name을 키로 만들어서, 배열 형식으로 만들어준다
<%@ 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>
<script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
<script type="text/javascript">
function members() {
$.ajax({
url : "members", type : "get", dataType : "json",
success : (list) => {
console.log(list);
console.log(list[0].id);
let msg = "<table border='1'>";
msg += "<tr><th>id</th><th>name</th><th>age</th></tr>"
for(let i = 0; i < list.length; i++){
msg += "<tr>";
msg += "<td>" + list[i].id + "</td>";
msg += "<td onclick='getMember(\"" + list[i].id + "\")'>" + list[i].name + "</td>";
msg += "<td>" + list[i].age + "</td>";
msg += "</tr>";
}
msg += "</table>";
$("#content").html(msg);
}
});
}
function getMember(userId) {
console.log(userId)
$.ajax({
url : "members/"+userId, type : "get", dataType : "json",
success : (member) => {
console.log(member);
let msg = "id : " + member.id + "<br>";
msg += "name : " + member.name + "<br>";
msg += "age : " + member.age + "<br>";
msg += "<span onclick='del(\"" + member.id + "\")'>삭제</span>"
msg += "<span onclick='modify_form(\"" + member.id + "\")'>수정</span>"
$("#content").html(msg);
}
});
}
function del(userId) {
$.ajax({
url : "delete?id="+userId, type : "delete",
dataType : "json",
success : function (result) {
if (result == 1) {
alert("삭제 성공");
members();
}else{
alert("문제 발생!!!");
}
}
})
}
function modify_form(userId) {
$.ajax({
url : "members/"+userId, type : "get", dataType : "json",
success : (member) => {
let msg = '<form id="mo">';
msg += '<input type="text" value="'+member.id+'" name="id" ><br>';
msg += '<input type="text" value="'+member.name+'" name="name" ><br>';
msg += '<input type="text" value="'+member.age+'"name="age" ><br>';
msg += '<input type="button" onclick="modify()" value="수정"><br>';
msg += '</form>';
$("#content").html(msg);
}
});
}
function modify() {
let form = {}
let arr = $("#mo").serializeArray();
console.log(arr);
for(let i = 0; i < arr.length; i++){
form[arr[i].name] = arr[i].value;
}
console.log(form);
$.ajax({
url : "modify", type : "put", dataType : "json",
data : JSON.stringify(form),
contentType : "application/json; charset=utf-8",
success : function (result) {
if (result == 1) {
alert("수정 성공");
getMembers(form.id);
}
}
});
}
function checkId() {
console.log($("#id").val());
if ($("#id").val().length < 3) {
$("#id_chk").html("길이가 짧습니다!!!!");
return;
}
$.ajax({
url : "idChk/"+$("#id").val(), type : "get",
dataType : "json",
success : function (data) {
if (data == 0) {
$("#id_chk").html("사용 가능한 아이디 입니다");
}else{
$("#id_chk").html("존재하는 아이디입니다!!")
}
}
})
}
function register() {
let msg = '<form id="fo">';
msg += '<input type="text" id="id" name="id" oninput="checkId()" placeholder="id"><br>';
msg += '<span id="id_chk">아이디 확인</span><br>'
msg += '<input type="text" name="name" placeholder="name"><br>';
msg += '<input type="text" name="age" placeholder="age"><br>';
msg += '<input type="button" onclick="reg()" value="가입"><br>';
msg += '</form>';
$("#content").html(msg);
}
function reg() {
//alert("가입 클릭");
let form = {}
let arr = $("#fo").serializeArray();
console.log(arr);
for(let i = 0; i < arr.length; i++){
form[arr[i].name] = arr[i].value;
}
console.log(form);
$.ajax({
url : "register", type : "post", dataType : "json",
data : JSON.stringify(form),
contentType : "application/json; charset=utf-8",
success : function (result) {
if (result.num == 1) {
alert("저장 성공");
members();
}
}
});
}
</script>
</head>
<body>
<%@ include file="header.jsp" %>
<div id="content">
<h3>기본 페이지 입니다 </h3>
</div>
</body>
</html>package com.care.root;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import oracle.jdbc.proxy.annotation.Post;
@RestController
public class TestController {
@GetMapping(value="rest", produces = "application/json; charset=utf-8")
public Map<String, Object> get() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("result", "get : 데이터 요청");
return map;
}
@PostMapping(value="rest", produces = "application/json; charset=utf-8")
public Map<String, Object> post() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("result", "post : 데이터 추가");
return map;
}
@PutMapping(value="rest", produces = "application/json; charset=utf-8")
public Map<String, Object> put() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("result", "put : 데이터 수정");
return map;
}
@DeleteMapping(value="rest", produces = "application/json; charset=utf-8")
public Map<String, Object> delete() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("result", "delete : 데이터 삭제");
return map;
}
@Autowired DBClass db;
@GetMapping(value="members", produces = "application/json; charset=utf-8")
public ArrayList<InfoDTO> members() {
return db.DB;
}
@GetMapping(value="members/{uId}", produces = "application/json; charset=utf-8")
public InfoDTO getMember(@PathVariable String uId) {
//System.out.println("Asdfasd");
for(InfoDTO d : db.DB) {
System.out.println(d.getId().equals(uId));
if (d.getId().equals(uId)) {
System.out.println(d.getId());
System.out.println(d.getName());
return d;
}
}
return null;
}
@PostMapping(value="register", produces = "application/json; charset=utf-8")
public String register(@RequestBody InfoDTO dto) {
db.DB.add(dto);
return "{\"num\" : 1}";
}
@GetMapping(value="idChk/{uId}", produces = "application/json; charset=utf-8")
public int idChk(@PathVariable String uId) {
for(InfoDTO d : db.DB) {
if (d.getId().equals(uId)) {
return 1;
}
}
return 0;
}
@DeleteMapping(value="delete", produces = "application/json; charset=utf-8")
public int delete(@RequestParam String id) {
for(int i = 0; i < db.DB.size(); i++) {
if (db.DB.get(i).getId().equals(id)) {
db.DB.remove(i);
}
}
return 1;
}
@PutMapping(value="modify", produces = "application/json; charset=utf-8")
public int modify(@RequestBody InfoDTO dto) {
for(int i = 0; i < db.DB.size(); i++) {
if (db.DB.get(i).getId().equals(dto.getId())) {
db.DB.set(i, dto);
}
}
return 1;
}
}
실행 결과
| SPRING 8일차 (0) | 2024.05.20 |
|---|---|
| SPRING 7일차 (socket) (0) | 2024.05.17 |
| SPRING 5일차 (자동 로그인, 보안 처리 XSS, 파일 업로드 & 다운로드) (0) | 2024.05.14 |
| SPRING 4일차 (암호화, api, Interceptor) (0) | 2024.05.13 |
| SPRING 3일차 (cookie, session 및 database) (0) | 2024.05.09 |
* 자동 로그인을 체크하면, 다시 로그인 할 필요 없이 바로 로그인 가능
WebUtils.getCookie(request, "쿠키명"): 해당하는 쿠키를 가져온다
구조
1. login.jsp에서 checkbox를 체크 하면 controller의 user_check로 (on 또는 null)값을 보내준다.
2. user_check 컨트롤러에서 받은 값을 로그인을 성공하면 넘겨줘야 하기 때문에,
RedirectAttributes rs를 통해 rs.addAttribute("키", "밸류")로 값을 넘겨준다.
3. 로그인을 성공하면, redirect:successLogin으로 id와 check유무(on 또는 null) 를 가지고 이동한다.
4. successLogin 컨트롤러로 오게되면, 받아온 id값의 세션을 부여한다.
만약 check가 on일 경우, 받아온 id값의 쿠키를 부여한다.
그리고, db에 현재 회원의 check유무를 부여한다.
5. 그리고 쿠키가 있으면, 자동 로그인을 해야하기 때문에, pre Interceptor에 쿠키값을 가져온다.
만약 쿠키가 있을 경우, 해당 회원이 자동로그인 유무를 db를 통해 가져온다.
만약 체크를 했을 경우, 세션을 부여한다.
6. 로그아웃 선택시, 쿠키를 지우고, db에 check유무를 "nan"으로 바꾸고, 세션을 삭제한다.
<%@ 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>
<%@ include file="/WEB-INF/views/default/header.jsp" %>
<h3>login 페이지</h3>
<form action="user_check" method="post">
<input type="text" name="id"><br>
<input type="text" name="pwd"><br>
<input type="submit" value="로그인" ><br>
<input id="auto" type="checkbox" name="autoLogin">
<label for="auto">자동 로그인!!!</label>
</form>
<a href="register_form">회원가입</a>
</body>
</html>
package com.care.root.member.controller;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import com.care.root.common.SessionCommon;
import com.care.root.member.dto.MemberDTO;
import com.care.root.member.service.MemberService;
import com.care.root.mybatis.member.MemberMapper;
@Controller
@RequestMapping("member")
public class MemberController implements SessionCommon{
@Autowired MemberService ms;
@GetMapping("login")
public String login(HttpSession session) {
if (session.getAttribute(LOGIN) != null) {
return "redirect:/index";
}
return "member/login";
}
@PostMapping("user_check")
public String userCheck( @RequestParam String id,
@RequestParam String pwd ,
@RequestParam(required = false) String autoLogin,
RedirectAttributes rs) {
int result = ms.userCheck(id, pwd);
if(result == 1) {
rs.addAttribute("id", id );
rs.addAttribute("autoLogin", autoLogin );
return "redirect:successLogin";
}
return "redirect:login";
}
@GetMapping("successLogin")
public String successLogin(@RequestParam String id,
@RequestParam(required = false) String autoLogin,
HttpSession session,
HttpServletResponse res) {
session.setAttribute( LOGIN , id);//("loginUser", id)
if (autoLogin != null) {
int limitTime = 60*60*24*90; // 90일동안 자동로그인 유지
Cookie cook = new Cookie("loginCookie", id);
cook.setPath("/");
cook.setMaxAge(limitTime);
res.addCookie(cook);
ms.keepLogin(id, autoLogin);
}
return "member/successLogin";
}
@GetMapping("logout")
public String logout(HttpSession session,
@CookieValue(value="loginCookie", required=false) Cookie cook,
HttpServletResponse res) {
if (cook != null) {
cook.setMaxAge(0);
cook.setPath("/");
res.addCookie(cook);
ms.keepLogin((String)session.getAttribute(LOGIN), "nan");
}
session.invalidate();
return "redirect:login";
}
@GetMapping("memberInfo")
public String memberInfo(Model model, HttpSession session) {
ms.memberInfo( model );
return "member/memberInfo";
}
@GetMapping("info")
public String info(Model model, @RequestParam String id) {
ms.info(model, id);
return "member/info";
}
@GetMapping("register_form")
public String registerForm() {
return "member/register";
}
@PostMapping("register")
public String register(MemberDTO dto, HttpServletRequest req) {
String[] addrs = req.getParameterValues("addr");
int result = ms.register(dto);
if(result == 1) {
return "redirect:login";
}
return "redirect:register_form";
}
}package com.care.root.interceptor;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import org.springframework.web.util.WebUtils;
import com.care.root.common.SessionCommon;
import com.care.root.member.dto.MemberDTO;
import com.care.root.mybatis.member.MemberMapper;
public class AutoLogin extends HandlerInterceptorAdapter implements SessionCommon{
@Autowired MemberMapper mapper;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.out.println("auto login 실행");
Cookie cook = WebUtils.getCookie(request, "loginCookie");
System.out.println("cook : " + cook);
if (cook != null) {
MemberDTO dto = mapper.getData(cook.getValue());
if (dto.getSessionId().equals("on")) {
request.getSession().setAttribute(LOGIN, dto.getId());
}
}
return true;
}
}
실행 결과
* 회원가입 하거나, db에 저장할때 javascript형식으로 저장하면, script 문법이 실행됨
이러한 공격(XSS)을 막기 위한 방법
받아온 데이터 안에 스크립트 문법이 있는지 없는지 체크
첫번째 방법
검증하고 싶은 값을 받아와서, 받아온값.replcae()를 통해 수정
두번째 방법
써있는대로 저장
lucy-xss-servlet-filter-rule.xml
0.00MB
위에 파일 복사 - src/main/resource에 붙여넣기
= 알아서 보안처리를 해준다.
https://mvnrepository.com/ - commons fileupload(파일 업로드) 검색 - 첫번째 클릭
- 1.3.3버전 클릭 - maven내용 복사 - pom.xml 붙여넣기
https://mvnrepository.com/ - commons io(파일 입출력) 검색 - 첫번째 클릭
- 2.4버전 클릭 - maven내용 복사 - pom.xml 붙여넣기
bean 추가하는 두가지 방법
1. config에서 bean 추가 ( 이 방법을 선호!! )
2. servlet-context.xml에서 bean 추가
<input>태그의 text는 @RequestParam이라는 타입으로 받아온다
<input>태그의 file은 MultipartFile이라는 타입으로 받아온다
file을 받아오는 두가지 방법
1. 파라미터 MultipartFile file로 받아온다
2. 파라미터 MultipartHttpServletRequest mReq로 받아온 후,
MultipartFile file = MReq.getFile("파일name")으로 받아온다
파일에 저장
public static final String IMG_REPO = "c:/spring" : 파일 저장 위치
SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss-"); : 시간 형식 지정
String sysFileName = format.format(new Date()) : 지정한 형식으로 현재 시간 저장
File saveFile = new File(IMG_REPO + "/" + sysFileName)
file.transferTo(saveFile) : 해당하는 위치에 파일 저장
db에 파일 저장
화면에 띄우기 및 다운로드
res.addHeader("Content-dispostion", attachment;fileName="+file);
: Content-dispostion = 다운로드 형식, attachment;fileName="+file = 파일명을 붙여서 다운
File f = new File(FileServiceImpl.IMG_REPO + "/" + file) : 해당 파일을 저장할 위치 지정
FileInputStream in = new FileInputStream(f) : FileInputStream()을 이용하여, 파일의 내용을 읽어옴
FileCopyUtils.copy(in, res.getOutputStream()) : 불러온 내용을 복사하여, 클라이언트에게 전송
파일 삭제
| SPRING 7일차 (socket) (0) | 2024.05.17 |
|---|---|
| SPRING 6일차 (email 전송 & 인증, scheduler, ajax, json방식, RestController, SPA) (0) | 2024.05.16 |
| SPRING 4일차 (암호화, api, Interceptor) (0) | 2024.05.13 |
| SPRING 3일차 (cookie, session 및 database) (0) | 2024.05.09 |
| SPRING 2일차 (annotation, redirect) (0) | 2024.05.08 |
https://mvnrepository.com/ - spring security web 검색 - 첫번째꺼 클릭
- 아무버전(최신 버전) 클릭 - maven 부분 복사 -
pom.xml 붙여넣기(버전을 스프링 버전에 맞게 ${org.springframework-version})
service쪽에서 BCryptPasswordEncoder en = new BCryptPasswordEncoder();
en.encode(암호화 할 변수) : 해당 변수가 암호화 된다
en.matches("비교할 변수", "암호화된 변수") : 암호화한 변수를 풀어서 비교하는 방법 (복호화)
다음 주소 api 검색 - 해당하는 api 복사 - register.jsp에 붙여넣기
같은 name의 여러개의 값을 dto로 받아오면 ,(콤마)를 기준으로 한번에 받아온다
* split을 사용하여 ,(콤마)를 기준으로 잘라낼 수 있다.
같은 name의 여러개의 값을 req로 받아오려면, req.getParameterValues()로 받아온다 (배열 형식)
* 해당하는 api관련 script문은 resources폴더 안에서 따로 관리 (javascript 파일)
<%@ 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>
<script src="//t1.daumcdn.net/mapjsapi/bundle/postcode/prod/postcode.v2.js"></script>
<script type="text/javascript" src="<%= request.getContextPath() %>/resources/js/daumPost.js">
</script>
</head>
<body>
<%@ include file="/WEB-INF/views/default/header.jsp" %>
<h3> - 회 원 가 입 -</h3>
<form action="register" method="post">
<input type="text" name="id"><br>
<input type="text" name="pwd"><br>
<input type="text" id="addr1" name="addr" readonly placeholder="우편번호"><br>
<input type="text" id="addr2" name="addr" readonly placeholder="주소"><br>
<input type="text" id="addr3" name="addr" placeholder="상세주소">
<button type="button" onclick="daumPost()">우편번호 검색</button><br>
<input type="submit" value="가입"><br>
</form>
</body>
</html>function daumPost() {
new daum.Postcode({
oncomplete: function(data) {
// 팝업에서 검색결과 항목을 클릭했을때 실행할 코드를 작성하는 부분입니다.
// 예제를 참고하여 다양한 활용법을 확인해 보세요.
console.log(data);
console.log(data.userSelectedType)
let addr = "";
if (data.userSelectedType == "R") {
addr = data.roadAddress;
}else{
addr = data.jibunAddress;
}
document.getElementById("addr1").value=data.zonecode;
document.getElementById("addr2").value=addr;
document.getElementById("addr3").focus();
}
}).open();
} @PostMapping("register")
public String register(MemberDTO dto, HttpServletRequest req) {
System.out.println("addr : " + dto.getAddr());
String[] addrs = req.getParameterValues("addr");
System.out.println(addrs[0]);
System.out.println(addrs[1]);
System.out.println(addrs[2]);
int result = ms.register(dto);
if(result == 1) {
return "redirect:login";
}
return "redirect:register_form";
}
실행 결과
* 컨트롤러 실행 전, 컨트롤러가 실행 후 처리할 게 있으면 Interceptor 사용
Filter : DispatcherServlet이 실행되기 전, web.xml 설정
Interceptor : DispatcherServlet이 실행된 후, spring-web.xml 설정
preHandle : 컨트롤러가 호출되기 전 실행
postHandle : 컨트롤러가 실행된 후 호출
Interceptor 사용 설정
해당 클래스에 extends HandlerInterceptorAdapter 상속을 받아야 Interceptor 사용 가능
(alt + shift + s) - Override/Implement Methods - postHandle, preHandle 체크 - ok
preHandle 실행 전, postHandle 컨트롤러 실행 후
* preHandle, postHandle메소드의 파라미터값 변경 불가
* return true : 해당 경로로 보내줌, return false : 해당 경로로 안 보내줌
Interceptor 빈 생성
servlet-context.xml - <beans:bean id="변수명" class="Interceptor클래스 위치" />
<interceptors><interceptor><mapping path="경로 지정" /><benas:ref bean="변수명" /></interceptor></interceptors>
* 초록색 : 같은 값
package com.care.root.interceptor;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import com.care.root.common.SessionCommon;
public class MemberInterceptor extends HandlerInterceptorAdapter implements SessionCommon{
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.out.println("index 실행 전 출력");
HttpSession session = request.getSession();
if (session.getAttribute(LOGIN) == null) {
//response.sendRedirect("login");
response.setContentType("text/html; charset=utf-8");
PrintWriter out = response.getWriter();
out.print("<script>alert('로그인 먼저 하세요');"
+"location.href='login';</script>");
return false;
}
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
System.out.println("index 실행 후 동작");
}
} <beans:bean id="mi" class="com.care.root.interceptor.MemberInterceptor" />
<interceptors>
<interceptor>
<mapping path="/member/memberInfo" />
<mapping path="/member/info" />
<beans:ref bean="mi" />
</interceptor>
</interceptors>
실행 결과
| SPRING 6일차 (email 전송 & 인증, scheduler, ajax, json방식, RestController, SPA) (0) | 2024.05.16 |
|---|---|
| SPRING 5일차 (자동 로그인, 보안 처리 XSS, 파일 업로드 & 다운로드) (0) | 2024.05.14 |
| SPRING 3일차 (cookie, session 및 database) (0) | 2024.05.09 |
| SPRING 2일차 (annotation, redirect) (0) | 2024.05.08 |
| SPRING 1일차 (설치, 설정 및 실행) (0) | 2024.05.02 |
* src/main/webapp/resources폴더안에 생성
css파일 불러올 땐 <link>, javascript파일 불러올 땐 <script>
* servlet-context.xml(16번째 줄)에서 경로 조절 가능
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>
<c:set var="url" value="<%= request.getContextPath() %>"></c:set>
<html>
<head>
<title>Home</title>
<link href="${url}/css/test.css" rel="stylesheet">
<link href="${url}/css/test2.css" rel="stylesheet">
<script type="text/javascript" src="${url}/js/test.js"></script>
</head>
<body>
<c:url value="/resources/img/asdf.png" var="path" />
path: ${path }<br>
req : <%= request.getContextPath() %>/img/asdf.png<br>
page : ${pageContext.request.contextPath }/img/asdf.png<br>
<img src="${path}" width="100" height="100">
<h1>
Hello world!!!!!!
</h1>
<P> The time on the server is ${serverTime}. </P>
<button type="button" onclick="test()">클릭</button>
</body>
</html>
실행 결과
쿠키 생성
HttpServletResponse를 컨트롤러에서 받아온다.
Cookie c = new Cookie("쿠키명", "쿠키값");
c.setMaxAge(5) : 쿠키 5초 유지
res.addCookie(c) : 쿠키 추가
c.setPath("경로") : 쿠키 path 지정
쿠키 받아오기 (모든 쿠키)
HttpServletRequest를 컨트롤러에서 받아온다.
req.getCookies() : 쿠키값 받아오기(배열 형식으로 받아온다)
원하는 쿠키만 받기
@CookieValue(value="해당 쿠키명", required = false) Cookie 저장할 변수명
: 해당하는 쿠키값은 변수명에다가 저장한다, 존재하지 않을 경우 null로 표현
* document.cookie : 자바스크립트상에서 쿠키값 받아오는 방법(이름, 밸류 다 나옴)
* split을 통해 이름과 밸류를 나눈다(배열 형식으로 저장)
* 인덱스 번호를 통해 본인의 쿠키가 맞는지 확인
package com.care.ex01;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class CookieController {
@GetMapping("cookie")
public String myCookie(HttpServletResponse res,
HttpServletRequest req,
@CookieValue(value="myCookie", required = false) Cookie cook) {
System.out.println("cook : " + cook);
System.out.println(cook.getName());
System.out.println(cook.getValue());
Cookie cookie = new Cookie("myCookie", "testCookie");
cookie.setMaxAge(5);
res.addCookie(cookie);
Cookie[] arrCookie = req.getCookies();
for (Cookie c : arrCookie) {
System.out.println("name : " + c.getName());
System.out.println("value : " + c.getValue());
}
return "cookie/cookie";
}
@GetMapping("cookie02")
public String myCookie02(Model model,
@CookieValue(value="myCookie", required = false) Cookie cook) {
if (cook != null) {
model.addAttribute("cook", cook.getValue());
}
return "cookie/cookie02";
}
@GetMapping("popup02")
public String pop02() {
return "cookie/popup02";
}
@GetMapping("cookieChk")
public void cookieChk(HttpServletResponse res) {
Cookie cook = new Cookie("myCookie", "testCookie");
cook.setMaxAge(5);
cook.setPath("/");
res.addCookie(cook);
}
}<%@ 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>
<script type="text/javascript">
function popup() {
let url = "popup02";
let setWindow = "width=300, height=200, top=500, left=500";
//if ("${cook}" == "") {
// window.open(url, "", setWindow);
//}
console.log("cook : " + document.cookie)
let cookie = document.cookie.split("=");
console.log("cook : " + cookie)
console.log("cook : " + cookie[0])
console.log("cook : " + cookie[1])
if (cookie[0] != "myCookie") {
window.open(url, "", setWindow);
}
}
</script>
</head>
<body onload="popup()">
cook : ${cook }<br>
쿠키 페이지
</body>
</html><%@ 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>
<script type="text/javascript">
function chk() {
location.href="cookieChk";
window.close();
}
</script>
</head>
<body>
<h3>팝 업 창</h3>
<hr>
<input id="check" type="checkbox" onclick="chk()">
<label for="check">하루동안 열지않음!!!</label>
</body>
</html>
실행 결과
HttpSession session = req.getSession(); : 세션 생성
session.setAttribute("키", "밸류") : 세션 추가
* 부여하는 세션 이름이 겹칠 경우, sessionScope.이름 을 사용하면 확인 가능
session.removeAttribute("키명") : 특정 세션만 삭제
session.invalidate() : 모든 세션 삭제
* HttpSession session을 받아와서 처리 가능
package com.care.ex01;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class SessionController {
@GetMapping("makeSession")
public String makeSession(HttpServletRequest req) {
HttpSession session = req.getSession();
session.setAttribute("id", "aaa");
session.setAttribute("name", "홍길동");
session.setAttribute("age", "20");
return "session/makeSession";
}
@GetMapping("resultSession")
public String resultSession(Model model) {
model.addAttribute("id", "asdf모델");
return "session/resultSession";
}
@GetMapping("delSession")
public String delSession(HttpServletRequest req,
HttpSession session) {
HttpSession s = req.getSession();
System.out.println("s.id : " + s.getAttribute("id"));
s.removeAttribute("id");
System.out.println("session.name : " + session.getAttribute("name"));
session.invalidate();
return "session/delSession";
}
}<%@ 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>
<h3>세션 설정</h3>
id : ${id }<br>
name : ${name }<br>
age : ${sessionScope.age }<br>
req.age : <%= session.getAttribute("age") %>
<hr>
<a href="resultSession">세션 확인</a>
<a href="delSession">세션 삭제</a>
</body>
</html><%@ 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>
<h3>세션 확인</h3>
id : ${id }<br>
sessionScope.id : ${sessionScope.id}<br>
name : ${name }<br>
age : ${sessionScope.age }<br>
req.age : <%= session.getAttribute("age") %>
<hr>
<a href="makeSession">세션 설정</a>
<a href="delSession">세션 삭제</a>
</body>
</html><%@ 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>
<h3>세션 삭제</h3>
id : ${id }<br>
sessionScope.id : ${sessionScope.id}<br>
name : ${name }<br>
age : ${sessionScope.age }<br>
req.age : <%= session.getAttribute("age") %>
<hr>
<a href="makeSession">세션 설정</a>
<a href="resultSession">세션 확인</a>
</body>
</html>
실행 결과
* session은 jsp파일에서도 설정 가능, controller에서도 설정 가능
package com.care.ex01;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class SessionController {
@GetMapping("makeSession")
public String makeSession(HttpServletRequest req) {
HttpSession session = req.getSession();
session.setAttribute("id", "aaa");
session.setAttribute("name", "홍길동");
session.setAttribute("age", "20");
return "session/makeSession";
}
@GetMapping("resultSession")
public String resultSession(Model model) {
model.addAttribute("id", "asdf모델");
return "session/resultSession";
}
@GetMapping("delSession")
public String delSession(HttpServletRequest req,
HttpSession session) {
HttpSession s = req.getSession();
System.out.println("s.id : " + s.getAttribute("id"));
s.removeAttribute("id");
System.out.println("session.name : " + session.getAttribute("name"));
session.invalidate();
return "session/delSession";
}
@GetMapping("login")
public String login() {
return "session/login";
}
@PostMapping("check")
public String check(@RequestParam String id,
@RequestParam String pwd,
HttpSession session) {
String DB_id = "1", DB_pwd = "1";
if (DB_id.equals(id) && DB_pwd.equals(pwd)) {
session.setAttribute("loginUser", id);
session.setAttribute("nick", "홍길동");
return "session/main";
}
return "redirect:login";
}
@GetMapping("logout")
public String logout(HttpSession session) {
if (session.getAttribute("loginUser") == null) {
return "redirect:login";
}
session.invalidate();
return "session/logout";
}
}<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:choose>
<c:when test="${loginUser == null }">
<form action="check" method="post">
<input type="text" name="id"><br>
<input type="text" name="pwd"><br>
<input type="submit" value="로그인"><br>
</form>
</c:when>
<c:otherwise>
${nick}님 로그인 상태<br>
<a href="logout">로그아웃</a>
</c:otherwise>
</c:choose>
</body>
</html><%@ 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>
${nick }님 환영합니다<br>
<a href="logout">로그아웃</a>
<a href="login">로그인</a>
</body>
</html><%@ 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>
<script type="text/javascript">
alert("로그아웃 성공!!");
location.href="login";
</script>
</body>
</html>
실행 결과
단위 테스트 : 각각의 메소드 별로 테스트
통합 테스트 : 단위테스트를 통한 메소드들을 결합하여 테스트
단위 test
test를 하기위한 기능 가져오기
https://mvnrepository.com/ - spring-test 검색 - 첫번째 클릭 - 아무거나 버전(6.1.3) - maven내용 복사
- pom.xml(118번쨰줄 밑) 붙여넣기 - 해당 버전 대신 ${org.springframework-version}작성
* ${org.springframework-version} : 알아서 버전 설정
JUnit을 실행하기 위한 라이브러리 추가
프로젝트 우클릭 - Properties - Java Buid Path - Libraries - Add Library - JUnit선택 - next - JUnit-4선택 - finish - apply
서버 구동하지않고, test를 구동하기 때문에 test전용 xml파일 작성
test전용 xml파일 - Namespaces - context 체크
Source - <context:component-scan base-package="해당 test클래스 패키지" />
test클래스에서 작성해야하는 것들
@RunWith(SpringRunner.class) : @Autowired에 해당하는 것들을 확인하도록 설정
@contextConfiguration(locations={"classpath:해당하는 test의 xml파일"}) : 해당하는 파일을 진행
@Autowired 클래스명 변수명 : test를 통해 확인하고 싶은 클래스
@Test : 해당하는 메소드 생성하고, 해당 메소드를 통해 확인
assertNotNull(확인하고싶은 클래스의 변수명) : 성공인지 실패인지 알려줌(성공 = 초록, 실패 = 빨강)
해당메소드 클릭 후 ctrl + F11
DB 연동
* connection pool : 미리 만든 값을 빌려와서 사용(효율적)
* mybatis : 명령어를 통해 실행하도록 해주는 역할
hikaricp 추가
https://mvnrepository.com/ - hikaricp 검색 - 첫번째 클릭 - 3.3.1버전 클릭 - maven내용 복사
- pom.xml - 붙여넣기
jdbc 추가
https://mvnrepository.com/ - spring jdbc 검색 - 첫번째 클릭 - 아무버전 클릭 - maven내용 복사
- pom.xml -붙여넣기 - 해당 버전 대신 ${org.springframework-version}작성
mybatis 추가
https://mvnrepository.com/ - mybatis 검색 - 첫번째 클릭 - 3.4.6버전 클릭 - maven내용 복사
- pom.xml -붙여넣기
mybatis(2) 추가
https://mvnrepository.com/ - mybatis 검색 - 두번째 클릭 - 1.3.2버전 클릭 - maven내용 복사
- pom.xml -붙여넣기
ojdbc 추가
cmd - sqlplus - db버전 확인
11버전일 경우
https://mvnrepository.com/ - ojdbc6 검색 - 첫번째 클릭 - 11.2.0.1버전 클릭 - maven내용 복사
- pom.xml -붙여넣기
19버전 이상일 경우
https://mvnrepository.com/ - ojdbc8 검색 - 첫번째 클릭 - cmd로 확인한 버전 클릭 - maven내용 복사
- pom.xml -붙여넣기
db 설정(연결)
위에 설정한 값들 추가(객체 생성)
root-context.xml - bean 및 property 생성
<bean id="hikariConfig" class="com.zaxxer.hikari.HikariConfig">
<property name="username" value="c##LTY"></property>
<property name="password" value="1213"></property>
<property name="jdbcUrl" value="jdbc:oracle:thin:@localhost:1521:orcl"></property>
<property name="driverClassName" value="oracle.jdbc.OracleDriver"></property>
</bean>
<bean id="ds" class="com.zaxxer.hikari.HikariDataSource">
<constructor-arg ref="hikariConfig"></constructor-arg>
</bean>
<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds"></property>
<property name="mapperLocations" value="classpath:/mappers/**/*Mapper.xml"></property>
</bean>
mybatis 설정
* mybatis는 memberMapper.xml에서 실행한다
mybatis 검색 - 첫번째 - Getting Started - (Exploring Mapped SQL Statements)에 해당하는 문장 복사 -
resources/mappers/member/memberMapper.xml - 붙여넣기
- 필요없는것 지우기 - namespace="dao경로" 작성
root-context.xml - Namsapace - (mybatis -spring) 체크
Source - <mybatis-spring:scan base-package="dao경로" />
* dao에 지정한 메소드명과, mapper.xml에 지정한 <insert>태그 안에 id와 일치하면 실행
넘어온 값은 #{}으로 받는다
통합 test
* @Before : @test전에 실행 된다(초기화 목적)
* 통합 테스트를 하기 위해서 Mock이 필요.
* 따라서 import가 알아서 안되기 때문에 입력해야함
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.*;
MockMvc mock = MockMvcBuilders.standaloneSetup("객체").build : 해당 객체를 동작하는 mock 생성
mock.perform(post("/경로").param("id", "1234").param("name", "아무나"))
: 해당 경로로 post방식으로 요청을 보내고, id와 name이라는 파라미터를 설청하여 요청을 보낸다
.andDo(print()) : 요청 및 응답을 출력
.andExpect(forwardedUrl("index")) : 위에 경로의 요청을 처리한 후, index페이지로 forward한다
.andExpect(status().isOk()) : status가 200이라면
* Status = 200 : 성공
아무 xml(root-context.xml) - <bean id="txMgr" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="ds"></property>
</bean>
: 해당 내용을 실행하고, rollback한다
@Transactional(transactionManager = "txMgr") : rollback기능을 하고싶은 클래스에 추가하는 방법
resultMap : dto값과 db컬럼명이 다를 수 있기 때문에
primary key = <id/>
나머지 = <result/> (proerty = "dto 명", column = "db 컬럼명")
<select> 태그 안에 resultMap="resultMap의 id명" : resultMap 적용
* model().attributeExists("키명") : 모델의 해당 키까지 접근 가능한지 확인
* redirect가 일어날 경우 status가 302이기 때문에, .andExpect(status().is3xxRedirection()); 사용
풀이 과정
위에서 알려준 기본 세팅 작업 후(db 연동 및 encoding)
* ( RedirectAttributes rs )라는 파라미터를 받아오면, redirect를 해도 rs.addAttribute()를 통해 전달 가능
model처럼 따로 보내주는것을 명시 안해도, redirect면 넘어간다.
* 세션명들은 공통파일에서 따로 관리해도 효율적이다 (해당 컨트롤러에서 공통파일을 상속받아 사용 가능)
ex) common파일을 생성 후, 해당하는 common파일에 각 세션들의 키명을 변수로 지정해놓고, 꺼내와서 사용
*mapper.xml 파일 안에서도 if문 등을 사용 할 수 있다
<if test="조건">sql문</if>을 사용하여, 예를들어 같은 select문인데 조금 다른 경우 사용
@Param("변수명") String id : 해당하는 부분은 dao부분에서 mapper.xml로 보내준다.
header.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
ul li{ display: inline; padding: 0 10px;}
</style>
</head>
<body>
<div align="center">
<h1 style="color: burlywood; font-size: 60px; font-family: Gabriloa;">
CARE LAB
</h1>
</div>
<div align="right">
<hr>
<c:set var="log" value='<%=session.getAttribute("id") %>' />
<c:choose>
<c:when test="${log eq null }">
<ul>
<li><a href="/root/index">HOME</a></li>
<li><a href="/root/member/login">회원 정보</a></li>
<li><a href="/root/member/login">로그인</a></li>
</ul>
</c:when>
<c:otherwise>
<ul>
<li><a href="/root/index">HOME</a></li>
<li><a href="/root/member/info">회원 정보</a></li>
<li><a href="/root/member/logout">로그아웃</a></li>
</ul>
</c:otherwise>
</c:choose>
<hr>
</div>
</body>
</html>
main.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>
<div align="center">
<table>
<tr>
<td align="center">
<h3>내 사전에 불가능은 없다<br>
불가능은 소극적인 자의 환영이며<br>
비겁한 자의 도피처 이다.<br>
</h3>
</td>
</tr>
<tr>
<td align="right">
<h3>- 나폴레옹</h3>
</td>
</tr>
</table>
</div>
</body>
</html>
footer.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>
<div align="center" style="padding-top: 100px">
<hr>
<i style="color: pink; font-size: 30px; font-family: Gabriola;">
Copyright © CARE Lab. All rights reserved.
</i>
</div>
</body>
</html>
index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:import url="default/header.jsp"></c:import>
<c:import url="default/main.jsp"></c:import>
<c:import url="default/footer.jsp"></c:import>
</body>
</html>
HomeController.java
package com.care.root;
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
/**
* Handles requests for the application home page.
*/
@Controller
public class HomeController {
private static final Logger logger = LoggerFactory.getLogger(HomeController.class);
/**
* Simply selects the home view to render by returning its name.
*/
@RequestMapping(value = "/", method = RequestMethod.GET)
public String home(Locale locale, Model model) {
logger.info("Welcome home! The client locale is {}.", locale);
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);
String formattedDate = dateFormat.format(date);
model.addAttribute("serverTime", formattedDate );
return "home";
}
@GetMapping("index")
public String index() {
return "index";
}
}
MemberController.java
package com.care.root.member.controller;
import java.util.ArrayList;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.care.root.member.dto.MemberDTO;
import com.care.root.member.service.MemberService;
@Controller
@RequestMapping("member")
public class MemberController {
@Autowired MemberService ms;
@GetMapping("login")
public String login() {
return "member/login";
}
@PostMapping("successLogin")
public String check(MemberDTO dto, HttpServletRequest req, Model model) {
int result = ms.check(dto);
if (result == 1) {
HttpSession session = req.getSession();
session.setAttribute("id", dto.getId());
model.addAttribute(session);
return "member/successLogin";
}else {
return "redirect:login";
}
}
@GetMapping("logout")
public String logout(HttpServletRequest req, Model model) {
HttpSession session = req.getSession();
session.invalidate();
return "index";
}
@GetMapping("info")
public String info(Model model) {
ArrayList<MemberDTO> info = ms.info();
model.addAttribute("info", info);
return "member/info";
}
@GetMapping("memberInfo")
public String memberInfo(@RequestParam("id") String id, Model model) {
ArrayList<MemberDTO> memberInfo = ms.memberInfo(id);
model.addAttribute("memberInfo", memberInfo);
return "member/memberInfo";
}
@GetMapping("register")
public String register() {
return "member/register";
}
@PostMapping("registerSuccess")
public String registerSuccess(MemberDTO dto) {
int result = ms.registerSuccess(dto);
if (result == 1) {
return "redirect:login";
}
return "redirect:register";
}
}
MemberService.java
package com.care.root.member.service;
import java.util.ArrayList;
import com.care.root.member.dto.MemberDTO;
public interface MemberService {
public int check(MemberDTO dto);
public ArrayList<MemberDTO> info();
public ArrayList<MemberDTO> memberInfo(String id);
public int registerSuccess(MemberDTO dto);
}
MemberServiceImpl.java
package com.care.root.member.service;
import java.util.ArrayList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.care.root.member.dto.MemberDTO;
import com.care.root.mybatis.member.MemberMapper;
@Service
public class MemberServiceImpl implements MemberService{
@Autowired MemberMapper mm;
public int check(MemberDTO dto) {
ArrayList<MemberDTO> list = mm.check();
System.out.println(list.get(0).getId());
System.out.println(list.get(0).getPw());
System.out.println(list.get(1).getId());
System.out.println(list.get(1).getPw());
System.out.println("입력 id : " + dto.getId());
System.out.println("입력 pw : " + dto.getPw());
for (int i = 0; i < list.size(); i++) {
if (list.get(i).getId().equals(dto.getId()) &&
list.get(i).getPw().equals(dto.getPw())) {
return 1;
}
}
return 0;
}
public ArrayList<MemberDTO> info() {
ArrayList<MemberDTO> info = mm.check();
return info;
}
public ArrayList<MemberDTO> memberInfo(String id) {
ArrayList<MemberDTO> memberInfo = mm.memberInfo(id);
return memberInfo;
}
public int registerSuccess(MemberDTO dto) {
int result = mm.registerSuccess(dto);
return result;
}
}
MemberDTO
package com.care.root.member.dto;
public class MemberDTO {
private String id;
private String pw;
private String addr;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPw() {
return pw;
}
public void setPw(String pw) {
this.pw = pw;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
}
MemberMapper.java
package com.care.root.mybatis.member;
import java.util.ArrayList;
import com.care.root.member.dto.MemberDTO;
public interface MemberMapper {
public ArrayList<MemberDTO> check();
public ArrayList<MemberDTO> memberInfo(String id);
public int registerSuccess(MemberDTO dto);
}
MemberMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.care.root.mybatis.member.MemberMapper">
<resultMap type="com.care.root.member.dto.MemberDTO" id="member">
<id property="id" column="id"/>
<result property="pw" column="pw" />
<result property="addr" column="addr" />
</resultMap>
<select id="check" resultMap="member">
select * from membership
</select>
<select id="memberInfo" resultMap="member">
select * from membership where id=#{id}
</select>
<insert id="registerSuccess">
insert into membership (id, pw, addr) values(#{id}, #{pw}, #{addr})
</insert>
</mapper>
register.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:import url="../default/header.jsp" />
<div align="center">
<h2>회원등록</h2>
<form action="registerSuccess" method="post">
<input type="text" name="id" placeholder="아이디"><br>
<input type="text" name="pw" placeholder="비밀번호"><br>
<input type="text" name="addr" placeholder="주소"><br>
<input type="submit" value="회원가입">
</form>
</div>
<c:import url="../default/footer.jsp" />
</body>
</html>
login.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:import url="../default/header.jsp" />
<div align="center"><h1>로그인 페이지 입니다</h1></div>
<div align="right">
<form action = "/root/member/successLogin" method="post">
<table>
<tr>
<td>
<input type="text" name="id" placeholder="아이디">
</td>
<td rowspan="2">
<input type="submit" value="로그인"style="width:60px;height:55px;">
</td>
</tr>
<tr>
<td><input type="text" name="pw" placeholder="비밀번호">
</td>
</tr>
<tr>
<td colspan="2" align="left">
<a href="/root/member/register">회원가입</a>
</td>
</tr>
</table>
</form>
</div>
<c:import url="../default/footer.jsp" />
</body>
</html>
successLogin.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:import url="../default/header.jsp" />
<div align="center"><h1>로그인 성공</h1></div>
<c:import url="../default/footer.jsp" />
</body>
</html>
info.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:import url="../default/header.jsp" />
<div align="center">
<h2>회 원 정 보</h2>
<table border="1">
<tr>
<td align="center" style="width: 150px">아이디</td><td align="center" style="width: 150px">비밀번호</td><td align="center" style="width: 150px">주소</td>
</tr>
<c:forEach var="info" items="${info}">
<tr>
<td><a href="/root/member/memberInfo?id=${info.getId()}">${info.getId()}</a></td><td>${info.getPw()}</td><td>${info.getAddr()}</td>
</tr>
</c:forEach>
</table>
</div>
<c:import url="../default/footer.jsp" />
</body>
</html>
memberInfo.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:import url="../default/header.jsp" />
<div align="center">
<h2>${memberInfo[0].getId() } 정 보</h2>
<table>
<tr>
<td align="center" style="width: 150px">아이디</td><td align="center" style="width: 150px">${memberInfo[0].getId() }</td>
</tr>
<tr>
<td align="center" style="width: 150px">비밀번호</td><td align="center" style="width: 150px">${memberInfo[0].getPw() }</td>
</tr>
<tr>
<td align="center" style="width: 150px">주소</td><td align="center" style="width: 150px">${memberInfo[0].getAddr() }</td>
</tr>
</table>
</div>
<c:import url="../default/footer.jsp" />
</body>
</html>
실행 결과
| SPRING 6일차 (email 전송 & 인증, scheduler, ajax, json방식, RestController, SPA) (0) | 2024.05.16 |
|---|---|
| SPRING 5일차 (자동 로그인, 보안 처리 XSS, 파일 업로드 & 다운로드) (0) | 2024.05.14 |
| SPRING 4일차 (암호화, api, Interceptor) (0) | 2024.05.13 |
| SPRING 2일차 (annotation, redirect) (0) | 2024.05.08 |
| SPRING 1일차 (설치, 설정 및 실행) (0) | 2024.05.02 |
* annotation은 어떤걸 붙여도 상관없지만 왼쪽 아래와 같이 이름에 맞게 붙이는게 좋다
@Autowired : 자료형을 기준으로 bean주입, 같은 타입일 경우 이름을 주입(객체 생성)
* @Autowired를 붙이지 않으면 null값이 나온다
* annotation뒤에 ("객체명")을 붙이면 객체명을 바꿀 수 있다
* @Autowired를 쓸 경우, 타입이 겹치면 객체 생성할 때, 객체명을 생성할떄 이름과 동일하게 하면 된다
* @Inject 와 @Qualifier("객체명")을 통해서도 구분 가능하다
req.getMethod() : 어떤 방식으로 보내줬는지(GET, POST)
@RequestMapping안에 method = RequestMethod.GET : get방식만 받겠다.(post방식은 안받음)
@PostMapping : post방식만 받겠다(get방식은 안받음)
@RequestParam("키명") 타입 변수명 : request로 넘어오는 값을 처리(키명과 변수명이 동일하면 키명 생략 가능)
* HttpServletRequest : 사용자가 요청한 값 받아오기
* @Controller 바로 밑에 @RequestMapping("경로") : 해당 경로가 겹치면, 해당 경로 생략 가능
* model.addAttribute("키", 밸류) 형태
* controller에서 넘겨 받는 곳에 dto를 입력하면 setter로 인해 자동으로 dto안으로 들어옴
package com.care.ex02;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
@RequestMapping("ex02")
public class MemberController {
@Autowired
private MemberService ms;
public MemberController() {
System.out.println("---- controller ----");
}
@RequestMapping("index")
public String index(Model model) {
System.out.println("service : " + ms);
ms.getData(model);
return "ex02/index";
}
@RequestMapping(value = "result", method = RequestMethod.GET)
public String result(HttpServletRequest req, Model model) {
System.out.println(req.getMethod());
System.out.println(req.getParameter("name"));
System.out.println(req.getParameter("age"));
model.addAttribute("method", req.getMethod());
model.addAttribute("name", req.getParameter("name"));
model.addAttribute("age", req.getParameter("age"));
return "ex02/result";
}
@PostMapping("result")
public String result02(
@RequestParam("name") String n,
@RequestParam int age,
Model model,
HttpServletRequest req
) {
model.addAttribute("method", req.getMethod());
model.addAttribute("name", n);
model.addAttribute("age", age);
return "ex02/result";
}
@PostMapping("object")
public String object(MemberDTO dto, Model model) {
model.addAttribute("dto", dto);
return "ex02/object";
}
}
package com.care.ex02;
import javax.inject.Inject;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.ui.Model;
@Service("ms")
public class MemberService {
//@Autowired
@Inject
@Qualifier("dao2")
MemberDAO dao;
public MemberService() {
System.out.println("---- service ----");
}
public void getData(Model model) {
System.out.println("get data 연동 : " + dao);
String msg = dao.getData();
model.addAttribute("msg", msg);
}
}package com.care.ex02;
import org.springframework.stereotype.Repository;
@Repository
public class MemberDAO {
public MemberDAO() {
System.out.println("---- dao ----");
}
public String getData() {
return "아무값이나!~";
}
}package com.care.ex02;
public class MemberDTO {
String name;
int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
실행 결과
풀이 과정
package com.care.member.controller;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.care.member.dto.MemberDTO;
import com.care.member.service.MemberService;
@Controller
public class MemberController {
@Autowired(required = false)
MemberService ms;
@GetMapping("index")
public String index() {
return "index";
}
@GetMapping("register_form")
public String registerForm() {
return "register_form";
}
@GetMapping("list")
public String list(Model model ) {
System.out.println("ms : "+ms);
ms.getList( model );
return "list";
}
@PostMapping("register")
public String register(HttpServletRequest req,
@RequestParam String id,
@RequestParam String pwd,
@RequestParam String name,
MemberDTO dto) {
System.out.println( req.getParameter("id"));
System.out.println( req.getParameter("pwd"));
System.out.println( req.getParameter("name"));
System.out.println("--------");
System.out.println(id+","+pwd+","+name);
System.out.println("--------");
System.out.println(dto.getId());
System.out.println(dto.getPwd() );
System.out.println(dto.getName());
ms.register( dto );
return "register";
}
}package com.care.member.service;
import java.util.ArrayList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.ui.Model;
import com.care.member.dao.MemberDAO;
import com.care.member.dto.MemberDTO;
@Service
public class MemberService {
@Autowired
MemberDAO dao;
public void getList( Model model ) {
ArrayList<MemberDTO> list = dao.getList();
model.addAttribute("list", list);
}
public void register( MemberDTO dto ) {
dao.register(dto);
}
}package com.care.member.dao;
import java.util.ArrayList;
import org.springframework.stereotype.Repository;
import com.care.member.dto.MemberDTO;
@Repository
public class MemberDAO {
ArrayList<MemberDTO> list;
public MemberDAO() {
list = new ArrayList<MemberDTO>();
}
public ArrayList<MemberDTO> getList( ){
//select * from table;
return list;
}
public void register( MemberDTO dto ) {
//insert
list.add(dto);
}
}package com.care.member.dto;
public class MemberDTO {
String id, pwd, name;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
실행 결과
redirect:경로 : 사용자에게 경로를 주고, 사용자가 다시 경로를 요청(req값이 안나온다)
forward:경로 : 사용자에게 들리지 않고, 서버딴에서 움직인다, 화면은 이동하지만 경로는 이동되지 않는다(req값 유지)
* req.setAttribute()는 req.getAttribute로 받아온다
package com.care.ex03;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("ex03")
public class Ex03Controller {
@RequestMapping("login")
public String login(HttpServletRequest req) {
System.out.println("login method : " + req.getMethod());
System.out.println("login param id : " + req.getParameter("id"));
System.out.println("login atta id : " + req.getAttribute("test"));
return "ex03/login";
}
@PostMapping("result")
public String result(HttpServletRequest req) {
String uId = req.getParameter("id");
req.setAttribute("test", "아무거나");
if (uId.equals("abc")) {
return "forward:success";
//return "redirect:success";
}
return "redirect:login";
//return "forward:login";
}
@PostMapping("success")
public String success(HttpServletRequest req, Model model) {
System.out.println("id : " + req.getParameter("id"));
System.out.println("test : " + req.getAttribute("test"));
model.addAttribute("id", req.getParameter("id"));
model.addAttribute("test", req.getAttribute("test"));
return "ex03/success";
}
}<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="result" method="post">
<input type="text" name="id"><br>
<input type="submit" value="로그인">
</form>
</body>
</html><%@ 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>
<h3>로그인 성공, 사용자 접근</h3>
id : ${id }<br>
test : ${test }<br>
<a href="login">login</a>
</body>
</html>
실행 결과
풀이과정
package com.care.member.controller;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.care.member.dto.MemberDTO;
import com.care.member.service.MemberService;
@Controller
public class MemberController {
@Autowired(required = false)
MemberService ms;
@GetMapping("index")
public String index() {
return "index";
}
@GetMapping("register_form")
public String registerForm() {
return "register_form";
}
@GetMapping("list")
public String list(Model model ) {
System.out.println("ms : "+ms);
ms.getList( model );
return "list";
}
@PostMapping("register")
public String register(HttpServletRequest req,
@RequestParam String id,
@RequestParam String pwd,
@RequestParam String name,
MemberDTO dto) {
ms.register( dto );
return "register";
}
@RequestMapping("one_list")
public String one_list(HttpServletRequest req, Model model) {
ms.getOneList(req.getParameter("name"), model);
return "one_list";
}
}package com.care.member.service;
import java.util.ArrayList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.ui.Model;
import com.care.member.dao.MemberDAO;
import com.care.member.dto.MemberDTO;
@Service
public class MemberService {
@Autowired
MemberDAO dao;
public void getList( Model model ) {
ArrayList<MemberDTO> list = dao.getList();
model.addAttribute("list", list);
}
public void register( MemberDTO dto ) {
dao.register(dto);
}
public void getOneList(String name, Model model) {
dao.getOneList(name, model);
}
}package com.care.member.dao;
import java.util.ArrayList;
import org.springframework.stereotype.Repository;
import org.springframework.ui.Model;
import com.care.member.dto.MemberDTO;
@Repository
public class MemberDAO {
ArrayList<MemberDTO> list;
public MemberDAO() {
list = new ArrayList<MemberDTO>();
}
public ArrayList<MemberDTO> getList( ){
//select * from table;
return list;
}
public void register( MemberDTO dto ) {
//insert
list.add(dto);
}
public void getOneList(String name, Model model) {
System.out.println("list.size() : " + list.size());
for (int i = 0; i < list.size(); i++) {
if (list.get(i).getName().equals(name)) {
model.addAttribute("id", list.get(i).getId());
model.addAttribute("pwd", list.get(i).getPwd());
model.addAttribute("name", list.get(i).getName());
}
}
}
}<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
list페이지 : ${list.size() }
<table border="1">
<tr>
<th>id</th>
<th>pwd</th>
<th>name</th>
</tr>
<c:choose>
<c:when test="${list.size() == 0 }">
<tr>
<td colspan="3" align="cetner">
<b>데이터가 없음!!!!</b>
</td>
</tr>
</c:when>
<c:otherwise>
<c:forEach var="dto" items="${ list }">
<tr>
<td>${dto.id }</td>
<td>${dto.pwd }</td>
<td><a href="one_list?name=${dto.name}">${dto.name }</a></td>
</tr>
</c:forEach>
</c:otherwise>
</c:choose>
<tr>
<td colspan="3">
<a href="index">index이동</a>
</td>
</tr>
</table>
</body>
</html><%@ 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>
<h2>${name }님 안녕하세요!</h2><br>
아이디 : ${id }<br>
비밀번호 : ${pwd }<br>
<a href="index">index 이동</a><br>
</body>
</html>
실행 결과
| SPRING 6일차 (email 전송 & 인증, scheduler, ajax, json방식, RestController, SPA) (0) | 2024.05.16 |
|---|---|
| SPRING 5일차 (자동 로그인, 보안 처리 XSS, 파일 업로드 & 다운로드) (0) | 2024.05.14 |
| SPRING 4일차 (암호화, api, Interceptor) (0) | 2024.05.13 |
| SPRING 3일차 (cookie, session 및 database) (0) | 2024.05.09 |
| SPRING 1일차 (설치, 설정 및 실행) (0) | 2024.05.02 |
sts(spring tool suite)3 검색 - 첫번째꺼 접속 - Download STS3 -
https://download.springsource.com/release/STS/3.9.18RELEASE/dist/e4.21/spring-tool-suite-3.9.18.RELEASE-e4.21.0-win32-x86_64.zip - 압축풀기(sts-bundle) - STS.exe 실행
Servers - 기존 서버 삭제 / Package Explorer - Servers 삭제 (삭제할때 체크하고 삭제)
Servers - 파란글 클릭 - apache Tomcat v9.0 - Browse 설정 - Finish
https://github.com/ChoHeeWon00/spring - code클릭 - Download ZIP - 압축(plugins, sts템플릿)풀기
plugins - https-content.xml 복사 -
workspace\.metadata\.plugins\org.springsource.ide.eclipse.commons.content.core 붙여넣기
프로젝트 생성 - (crtl + n) - Spring Legacy Project - Spring MVC Project 선택 - next - 다운 안됨
sts템플릿 - (template.xml, template.zip, wizard.json) 복사 -
workspace\.metadata\.sts\content\org.springframework.templates.mvc-3.2.2 붙여넣기
프로젝트 생성 - (crtl + n) - Spring Legacy Project - Spring MVC Project 선택 - next
- 패키지 생성 : com.care.abc(형식 중요) - finish
DI : 객체를 만들고, 그 안에서 또 다른 객체와 연결되어있는 관계
IOC : 개체를 보관하고 있는 틀(저장소)
(ctrl + n) - Spring Legacy Project - Spring MVC Project 선택 - 생성
* 업데이트 : (alt + F5) - ok
Maven Dependencies : Spring에서 제공해주는 기능
webapp - resources : css. javascript, 이미지 등이 들어있는 곳
root-context.xml : db관련 설정
target : 배포된 파일이 저장되는 곳
pom.xml : 특정 기능을 설정하면, Maven Dependencies에 저장된다
(ctrl + n) - Spring Bean Configuration File : xml 파일 생성
객체 생성 : <bean id="이름" class="위치" />
* Beans Graph를 통해 확인 가능
의존성 주입 : 받는 <bean>태그 안에 <property name="이름"><ref bean="객체명"></property>
의존성 주입 및 값 설정 : 받는 <bean>태그 안에 <property name="이름" value="값" />
String path = "classpath:applicationST.xml" : classpath = src/main/resources
GenericXmlApplicationContext ctx = new GenericXmlApplicationContext (path) : 해당 경로에 있는 파일을 IOC에 등록
ctx.getBean("가져올 객체명", 자료형) : 등록한 기능 가죠오기
<?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 id="st01" class="com.care.ex01.Student" />
<bean id="stb" class="com.care.ex01.STBean">
<property name="st">
<ref bean="st01"/>
</property>
<property name="name">
<value>김말이</value>
</property>
<property name="age" value="55">
</property>
</bean>
</beans>package com.care.ex02;
import org.springframework.context.support.GenericXmlApplicationContext;
import com.care.ex01.STBean;
public class MainClass {
public static void main(String[] args) {
String path = "classpath:applicationST.xml"; // classpath : src/main/resources
GenericXmlApplicationContext ctx = // 해당하는 경로에 있는 파일을 번역해, IOC(저장소)에 등록
new GenericXmlApplicationContext(path);
STBean s = ctx.getBean("stb", STBean.class); // 등록한 기능 가져오기 (가져올 객체명, 자료형)
// s.setName("김개똥");
// s.setAge(30);
s.namePrint();
s.agePrint();
}
}
실행 결과
풀이 과정
<?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 id="ps" class="com.care.di_test.PrintString" />
<bean id="pb" class="com.care.di_test.PrintBean">
<property name="ps" ref="ps" />
<property name="print" value="안녕" />
</bean>
</beans>package com.care.di_test;
import org.springframework.context.support.GenericXmlApplicationContext;
public class MainClass {
public static void main(String[] args) {
String path = "classpath:application_test.xml";
GenericXmlApplicationContext ctx =
new GenericXmlApplicationContext(path);
PrintBean s = ctx.getBean("pb", PrintBean.class);
s.print();
}
}package com.care.di_test;
public class PrintBean {
private String print;
private PrintString ps;
public void print() {
ps.printString(print);
}
public String getPrint() {
return print;
}
public void setPrint(String print) {
this.print = print;
}
public PrintString getPs() {
return ps;
}
public void setPs(PrintString ps) {
this.ps = ps;
}
}package com.care.di_test;
public class PrintString {
public void printString(String print) {
System.out.println("입력값 => " + print);
}
}
실행 결과
외부 파일 생성 : src/main/resources - (ctrl + n) - file
외부파일 불러오기 설정 : xmlt파일 - Namespaces - context 체크
- <context:property-placeholder location="classpath:db.properties(불러올 파일 경로)" />
생성자 호출 : <constructor-arg value="가져올 데이터" /> ($표시를 통해 가져옴)
db.id = java
db.pwd = 1234<?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-3.1.xsd">
<context:property-placeholder location="classpath:db.properties"/>
<bean id="db01" class="com.care.ex03.DBClass">
<property name="id" value="aaa"></property>
<property name="pwd" value="bbb"></property>
</bean>
<bean id="db02" class="com.care.ex03.DBClass">
<constructor-arg value="${db.id}"/>
<constructor-arg value="${db.pwd}"/>
</bean>
</beans>package com.care.ex03;
import org.springframework.context.support.GenericXmlApplicationContext;
public class MainClass {
public static void main(String[] args) {
String path = "classpath:application_db.xml";
GenericXmlApplicationContext ctx =
new GenericXmlApplicationContext(path);
DBClass db01 = ctx.getBean("db01", DBClass.class);
System.out.println("id : " + db01.getId());
System.out.println("pwd : " + db01.getPwd());
System.out.println("------------------");
DBClass db02 = ctx.getBean("db02", DBClass.class);
System.out.println("id : " + db02.getId());
System.out.println("pwd : " + db02.getPwd());
}
}package com.care.ex03;
public class DBClass {
String id, pwd;
public DBClass() {
}
public DBClass(String id, String pwd) {
this.id = id;
this.pwd = pwd;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
실행 결과
<list>태그 안에 <value>값 지정
<map>태그 안에 <entry>값 지정
implements "클래스명" : 해당 클래스명이 부모형태이다.
<?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 id="car" class="com.care.ex04.CarServiceImpl02"></bean>
</beans>package com.care.ex04;
public interface CarService {
public void speed();
}package com.care.ex04;
public class CarServiceImpl01 implements CarService{
@Override
public void speed() {
System.out.println("속력을 올립니다!!");
}
}package com.care.ex04;
public class CarServiceImpl02 implements CarService{
@Override
public void speed() {
System.out.println("새로운 기능 속도 올림!!");
}
}package com.care.ex04;
import org.springframework.context.support.GenericXmlApplicationContext;
public class MainClass {
public static void main(String[] args) {
//CarService car = new CarServiceImpl02();
GenericXmlApplicationContext ctx =
new GenericXmlApplicationContext("classpath:application_car.xml");
CarService car = ctx.getBean("car", CarService.class);
System.out.println("main 클래스에서 자동차 사용");
car.speed();
SubClass sc = new SubClass();
sc.subFunc();
}
}package com.care.ex04;
import org.springframework.context.support.GenericXmlApplicationContext;
public class SubClass {
public void subFunc() {
//CarService car = new CarServiceImpl02();
GenericXmlApplicationContext ctx =
new GenericXmlApplicationContext("classpath:application_car.xml");
CarService car = ctx.getBean("car", CarService.class);
System.out.println("서브 클래스 자동차!!");
car.speed();
}
}
실행 결과
pom.xml -
자바 버전 변경 : <java-version>1.8</ java- version>
스프링 버전 변경 : <org.springframework-version>5.2.1.RELEASE</org.springframework-version>
servlet 버전 변경 (95번째 줄, 96번쨰 줄) :
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
maven 버전 변경 (139번째 줄, 141번째 줄, 142번째 줄) :
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
* maven 업데이트 : (alt + F5) - ok
encoding 적용 방법 : web.xml - 마지막 </web-app> 안에 작성
<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>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
서버 에러 발생시 : Servers - tomcat - server.xml
- 다른 프로젝트와 path가 같을 경우, 이전에 사용한 path를 변경 및 주석처리
web broser 설정 : window - WebBroser - chrome
jsp파일 encoding : window - preferences - General - workspace - other - UTF-8설정
window - preferences - web - css & html & jsp - UTF-8 설정
* jsp파일에서 실행하지 않고, 프로젝트에 실행
* 해당 HomeController.java - package명(ex01)을 기준으로 경로를 지정,
@ = annotation
@Controller : 컨트롤러로 인식
@RequestMapping(value="/경로(index)" : localhost:8080/패키지명/해당경로(index) (get, post둘다 가능)(value생략 가능
return "경로" : views를 기준으로 경로 설정
@GetMapping : get방식으로만 보내겠다
Model model : 해당 jsp파일에게 데이터를 보내줄 떄 사용
model.addAttribute("변수명", 데이터) : 해당 jsp파일에 전달
model을 만들어서 전체를 보낼 수 있다.(model type = ModelAndView)
package com.care.ex01;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class MyController {
@RequestMapping(value="/index")
public String memberIndex() {
return "/member/index";
}
@GetMapping("/logout")
public String memberLogout(Model model) {
model.addAttribute("test", "로그아웃 되었습니다");
return "/member/logout";
}
@GetMapping("/login")
public ModelAndView login() {
ModelAndView model = new ModelAndView();
model.addObject("login", "로그인 성공!!!");
model.setViewName("member/login");
return model;
}
}<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>index 페이지</h1>
</body>
</html><%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>login 페이지</h1>
login : ${login }
</body>
</html><%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>logout 페이지</h1>
request : <%= request.getAttribute("test") %><br>
el : ${ test }<br>
</body>
</html>
실행 결과
풀이 과정
실행 결과
Controller : 연결
Service : 연산
DAO : db와 연결
Web Browser에서 사용자가 요청하면, DispatcherServlet에서 요청을 받아,
HandlerMapping에게 정보를 보내, 컨트롤러 위치 정보를 받아,
HandlerAdapter에서 위치정보를 받아 Controller에 연결한 후,
컨트롤러 실행 결과를 ModelAndView객체로 변화 후,
DispatcherServlet에서 .jsp이름을 ViewResolver에게 보낸 후,
jsp 정보를 DispatcherServlet 받은 후,
View에게 jsp를 요청한 후, jsp 랜더링을 전달 받아 사용자에게 전달한다.
web.xml(9번째 줄) : db에 대한 설정은 해당 위치에서 설정
DispatcherServlet 설정 위치 : web.xml(23번째 줄)
| SPRING 6일차 (email 전송 & 인증, scheduler, ajax, json방식, RestController, SPA) (0) | 2024.05.16 |
|---|---|
| SPRING 5일차 (자동 로그인, 보안 처리 XSS, 파일 업로드 & 다운로드) (0) | 2024.05.14 |
| SPRING 4일차 (암호화, api, Interceptor) (0) | 2024.05.13 |
| SPRING 3일차 (cookie, session 및 database) (0) | 2024.05.09 |
| SPRING 2일차 (annotation, redirect) (0) | 2024.05.08 |