✿∘˚˳°∘°

[NOTION] GIT

_HYE_ — Mon, 26 Jun 2023 16:43:08 +0900

https://www.notion.so/GIT-0b15257bc1df4838af9c69ac71ba6fc9

81일차 : ajax, 에러처리, 웹소켓

_HYE_ — Fri, 24 Mar 2023 11:34:14 +0900

20230324

1. Ajax

ajax사용을 위한 GSON라이브러리 추가

		<!-- GSON 라이브러리 추가 -->
		<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
		<dependency>
		    <groupId>com.google.code.gson</groupId>
		    <artifactId>gson</artifactId>
		    <version>2.10.1</version>
		</dependency>

1 - 1 ) 비밀번호 변경

요즘 비밀번호는 마이페이지에서 바로변경X 암호화때문에 굉장히 복잡하기 때문이다.

그러므로 비밀번호 변경페이지를 새로 만들어줄 것

수정한 mypage.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>
	<h1>마이페이지</h1>
	<hr>
	<form action="/updateMember.do" method="post">
		<fieldset>
			<legend>회원정보</legend>
			회원번호 : <input type="text" name="memberNo" value="${sessionScope.m.memberNo }" readonly><br>
			아이디 : <input type="text" name="memberId" value="${sessionScope.m.memberId }" readonly><br>
			비밀번호 : <button type="button" onclick="pwChange();">비밀번호 변경하기</button><br>
			<%-- 비밀번호 : <input type="password" name="memberPw" value="${sessionScope.m.memberPw }" ><br>--%>
			이름 : <input type="text" name="memberName" value="${sessionScope.m.memberName }" readonly><br>
			전화번호 : <input type="text" name="memberPhone" value="${sessionScope.m.memberPhone }"><br>
			이메일 : <input type="text" name="memberEmail" value="${sessionScope.m.memberEmail }" ><br>
			<input type="submit" value="정보수정">
		</fieldset>
	</form>
	<a href="/">메인으로</a>
	<script>
		function pwChange(){
			location.href="/pwChangeFrm.do";
		}
	</script>
</body>
</html>

비밀번호변경페이지 pwChange.jsp(여기서 페이지이동없이 ajax로 데이터를 처리해줄것)

<%@ 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.6.1.js"></script>
<style>
	#pwChangeFrm{
		display: none;
	}
</style>
</head>
<body>
	<h1>비밀번호 변경</h1>
	<hr>
	현재 비밀번호 입력 : <input type="password" name="currentPw">
	<button type="button" id="checkBtn">입력</button>
	<%--현재 비밀번호를 입력해서 ajax를 통해 확인 후 비밀번호가 맞을 경우에 form태그를 보여줄것 --%>
	<form action="/pwChange.do" method="post" id="pwChangeFrm">
		<input type="hidden" name="memberId" value="${sessionScope.m.memberId }">
		비밀번호 : <input type="password" name="memberPw"><br>
		비밀번호 확인 : <input type="password" name="memberPwRe"><br>
		<input type="submit" value="비밀번호 변경하기" onclick="return checkPw();">
	</form>
	
	<script>
		$("#checkBtn").on("click", function(){
			const memberPw = $("[name=currentPw]").val();
			const memberId = $("[name=memberId]").val();
			$.ajax({
				url : "/pwCheck.do",
				type : "post",
				data : {memberId:memberId, memberPw:memberPw},
				success : function(data){
					if(data == "ok"){
						$("#pwChangeFrm").slideDown();
					}else{
						alert("비밀번호를 확인하세요");
					}
				},
				error : function(){
					console.log("실패");
				}
			});
		});
		
		function checkPw(){
			const pw = $("[name=memberPw]").val();
			const pwRe = $("[name=memberPwRe]").val();
			if(pw != pwRe){
				alert("비밀번호를 확인하세요.")
				return false;
			}
		}
	</script>
</body>
</html>

ajax에서 이동하는 Controller

	//페이지 이동이 아닌 값 자체를 return하는 코드가 된다.
	@ResponseBody
	@RequestMapping(value="/pwCheck.do")
	public String pwCheck(Member member) {
		//아이디&패스워드로 회원을 조회해주는 로그인 로직을 이용할것 -> 암호화도 된다
		Member m = service.selectOneMember(member);
		if(m != null) {
			//상단에 ResponseBody를 붙여줬으므로 페이지이동X 값만 넘겨준다.
			return "ok";
		}else {
			return "error";
		}
	}

실제 비밀번호 update를 진행할 Controller

	@RequestMapping(value="/pwChange.do")
	public String pwChange(Member member, String memberPwRe) {
		int result = service.updateMemberPw(member, memberPwRe);
		if(result > 0) {
			return "redirect:/";
		}else {
			return "redirect:/updateMember.do";
		}
	}

Service - update이기 때문에 트랜잭션관리를 해줄 것

	@Transactional
	public int updateMemberPw(Member member, String memberPwRe) {
		return dao.updateMemberPw(member);
	}

Dao

	public int updateMemberPw(Member member) {
		int result = sqlSession.update("member.pwChangeMember", member);
		return result;
	}

memberSQL

  	<update id="pwChangeMember" parameterType="m">
  		update member_tbl set member_pw = #{memberPw} where member_id = #{memberId}
  	</update>

1 - 2 ) 회원가입 시 아이디 중복체크

추가한 joinFrm.jsp - 아이디 input태그 옆에 span태그를 추가하고 ajax코드를 추가하였다

<%@ 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.6.1.js"></script>
</head>
<body>
	<h1>회원가입</h1>
	<hr>
	<form action="/join.do" method="post">
		<fieldset>
			<legend>회원가입</legend>
			아이디 : <input type="text" name="memberId"><span id="idChk"></span><br>
			비밀번호 : <input type="password" name="memberPw"><br>
			이름 : <input type="text" name="memberName"><br>
			전화번호 : <input type="text" name="memberPhone"><br>
			이메일 : <input type="text" name="memberEmail"><br>
			<input type="submit" value="회원가입">
			<input type="reset" value="취소">
		</fieldset>
	</form>
	<a href="/">메인으로</a>
	
	<script>
		$("[name=memberId]").on("change", function(){
			const memberId = $(this).val();
			$.ajax({
				url : "/idCheck.do",
				type : "get",
				data : {memberId : memberId},
				success : function(data){
					if(data == "ok"){
						$("#idChk").text("사용 가능한 아이디 입니다.");
						$("#idChk").css("color", "blue");
					}else{
						$("#idChk").text("이미 사용중인 아이디 입니다.");
						$("#idChk").css("color", "red");
					}
				}
			});
		});
	</script>
</body>
</html>

ajax에서 이동하는 Controller

	@ResponseBody
	@RequestMapping(value="/idCheck.do")
	public String idCheck(Member member) {
		//매개변수를 String memberId로 받아도 된다
		//Member를 사용하는 이유는 Service에서 메소드를 재사용하려고(아이디찾는 메소드가 이미 있기때문에)
		Member m = service.selectOneMemberId(member);
		if( m == null ) {
			//아이디 사용가능
			return "ok";
		}else {
			//아이디 중복
			return "dup";
		}
	}

1 - 3 ) ajax로 전체회원 조회하기(객체를 받기)

객체를 받기 위해서는 GSON이 필요, 이를 위에 제일처음 라이브러리를 추가해줬다.

index.jsp에 추가한 코드

			<button id="allMemberAjax">전체회원조회</button>
			<div id="ajaxResult"></div>
			
			<script>
				$("#allMemberAjax").on("click", function(){
					$.ajax({
						url : "/ajaxAllMember.do",
						//ajax요청에 의한 데이터를 되돌려 줄 때 문제점2
						//1. 문자열 형식 -> 객체로변경 
						//ajax에서 json을 선언해줘도되지만 이러면 한글이 깨짐 -> 따로인코딩을 해줘야함
						//2. 한글깨짐
						//이 두가지를 동시에 해결하기 위해 Controller에서 진행
						success : function(data){
							$("#ajaxResult").empty();
							const table = $("<table>");
							const titleTr = $("<tr>");
							titleTr.html("<th>번호</th>th>아이디</th>th>이름</th>th>전화번호</th>");
							table.append(titleTr);
							for(let i=0; i<data.length; i++){
								const tr = $("<tr>");
								tr.append("<td>"+data[i].memberNo+"</td>");
								tr.append("<td>"+data[i].memberId+"</td>");
								tr.append("<td>"+data[i].memberName+"</td>");
								tr.append("<td>"+data[i].memberPhone+"</td>");
								table.append(tr);
							}
							$("#ajaxResult").append(table);
						}
					});
				});
			</script>

ajax에서 이동하는 Controller

	//application/json;charset=utf-8 되돌려주는타입이 Json이고 한글타입임을 명시
	@ResponseBody
	@RequestMapping(value="/ajaxAllMember", produces = "application/json;charset=utf-8")
	public String ajaxAllMember() {
		
		ArrayList<Member> list = service.selectAllMember();
		Gson gson = new Gson();
		String result = gson.toJson(list);
		System.out.println(result);
		return result;
	}

2. 에러처리 ( 많이 본 에러 : 500, 400, 404 )

Http Response.Status
[ 2xx ] -> 정상적으로 페이지가 떳을 때
200 ok
[ 3xx ] -> redirect
----------------------------------------------------------------------
[ 4xx ] -> 클라이언트가 잘못한 거
400 -> bad request(잘못된 요청)
404 -> not found(사용자가 잘못하는 경우, 개발자잘못)
-> 1) Controller를 잘못요청하는 경우(주소창잘못요청)
       : 사용자가 잘못했을 수도 있고, 개발중에 실수가 있을 수도 있음
        (사용자의 잘못일 수도 있으니 에러페이지로 처리)
-> 2) Controller에서 리턴하는 JSP를 만들지 않았거나 오타가 있는 경우
       : 100% 개발자의 실수 -> 에러페이지로 처리하면 안됨 -> 소스코드수정

[ 5xx ] -> 서버에서 에러난거
500 -> 정보가 유출가능성이 있음 -> 소스코드 수정
502 -> bad gateway(서버터졌을때) : 그냥 에러페이지를 띄우느 사이트도 있지만
    접속자가 많다는 페이지로 빼는 사이트도 있다.

404와 500은 발생하면 안되므로 에러처리를 해줄 것
처리하는 방법

우선 web.xml 의 <servlet></servlet> 사이에 에러관련 설정을 추가해준다.

	<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>
		<!-- 에러처리를 위한 추가 설정 -->
		<init-param>
			<param-name>throwExceptionIfNoHandlerFound</param-name>
			<param-value>true</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

에러 관련 class

package common;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.servlet.NoHandlerFoundException;

//@Component를 포함하고 있는 annotation이기 때문에 이걸 붙여놔도 객체생성O
//@Controller annotation이 포함되어있는 객체에서 에러가 발생했을 때 처리하는 annotation
@ControllerAdvice
public class ErrorUtil {
	
	@ExceptionHandler(Exception.class)
	public String handelException(Exception e) {
		//오류마다 다르게 처리할거면 여러개 생성하면된다.
		System.err.println("에러발생");
		//out으로 해도되지만 색 바꾸려고 err
		System.err.println(e.getMessage());
		return "error/error1";
	}
	@ExceptionHandler(NoHandlerFoundException.class)
	@ResponseStatus(value = HttpStatus.NOT_FOUND) //응답상태가 not_found(404) 오류
	public String notFound(NoHandlerFoundException e) {
		System.err.println("RequestMapping 오류");
		System.err.println(e.getMessage());
		return "error/error2";
	}
}

error1.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>
	<h1>서버에서 에러가 발생했습니다.</h1>
	<hr>
	<h3>잠시후 다시 시도해주세요</h3>
	<a href="/">메인페이지로</a>
</body>
</html>

error2.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>
	<h1>요청 에러 발생</h1>
	<hr>
	<a href="/">메인으로</a>
</body>
</html>

코드를 짜는 단계에서는 에러확인을 해야하기때문에, 완성 후 에러처리작업을 해주는것이 좋다.

3. 웹소켓

웹소켓 사용을 위한 라이브러리 추가 - pom.xml

		<!-- Websocket사용을 위한 라이브러리(spring-websocket, jackson-databind) -->
		<!-- spring-websocket은 spring버전과 맞춰줘야한다. -->
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-websocket -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-websocket</artifactId>
		    <version>5.0.6.RELEASE</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
		<dependency>
		    <groupId>com.fasterxml.jackson.core</groupId>
		    <artifactId>jackson-databind</artifactId>
		    <version>2.13.5</version>
		</dependency>

servlet-context의 namespace 탭에서 웹소켓 선택

servlet-context의 source에서 웹소켓을 처리할 객체 생성

	<!-- 웹소켓 채팅을 처리할 객체 생성 -->
	<beans:bean id="allMemberChat" class="common.AllMemberChat" />
	<!-- 웹소켓 매핑 -->
	<websocket:handlers>
	 	<websocket:mapping handler="allMemberChat" path="/chat.do"/>
	 </websocket:handlers>

3 - 1 ) 채팅

채팅 페이지 이동

<h3><a href="/allMemberChat.do">전체채팅</a></h3>

	@RequestMapping(value="/allMemberChat.do")
	public String allMemberChat() {
		return "member/allMemberChat";
	}

<%@ 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>
<script src="https://code.jquery.com/jquery-3.6.1.js"></script>
<style>
	.chatting{
		width: 500px;
		display: none;
	}
		<%-- y축으로 내부컨텐츠가 넘어가면 스크롤생성 --%>
	.messageArea{
		overflow-y : auto;
		border: 1px solid black;
		height: 500px;
		display: flex;
		flex-direction: column;
		background-color: #b2c7d9;
	}
	.messageArea>p{
		text-align: center;
		width: 100%;
	}
	#sendMsg{
		width: 75%;
	}
	#sendBtn{
		width:20%;
	}
	.chat{
		margin-bottom: 10px;
		padding: 8px;
		border-radius: 3px;
	}
	.left{
		position: relative;
		max-width: 300px;
		align-self: flex-start;
		background-color: #fff;
		border-radius: 10px;
		margin-left: 16px;
		padding: 15px;
	}
	.left:after{
		content:'';
		position: absolute;
		border-style: solid;
		border-width: 15px 15px 15px 0;
		border-color: transparent #fff;
		display: block;
		width: 0;
		z-index: 1;
		left: -15px;
		top: 12px;
	}
	.right{
		position: relative;
		max-width: 300px;
		align-self: flex-end;
		background-color: #ffeb33;
		border-radius: 10px;
		margin-right: 16px;
		padding: 15px;
	}
	.right:after{
		content:'';
		position: absolute;
		border-style: solid;
		border-width: 15px 0 15px 15px;
		border-color: transparent #ffeb33;
		display: block;
		width: 0;
		z-index: 1;
		right: -15px;
		top: 12px;
	}
</style>
</head>
<body>
	<h1>전체채팅</h1>
	<c:if test="${not empty sessionScope.m }">
	<button onclick="initChat('${sessionScope.m.memberId}');">채팅시작하기</button>
	<div class="chatting">
		<div class="messageArea">
		</div>
		<div class="sendBox">
			<input type="text" id="sendMsg">
			<button id="sendBtn" onclick="sendMsg();">전송</button>
		</div>
	</div>
	<script>
		let ws; //웹소켓 객체를 저장하는 변수
		let memberId; // 회원아이디를 저장하는 변수
		function initChat(param){
			memberId = param;
			//웹소켓 연결 시도
			//주의점 127.0.0.1 또는 localhost로 사용하면 소켓연결을 할 수 없으므로 반드시 IP로 작성
			ws = new WebSocket("ws://192.168.10.17/chat.do");
			//웹소켓 연결 성공 시 실행할 함수 지정
			ws.onopen = startChat;
			//서버에서 데이터를 받으면 처리할 함수 지정
			ws.onmessage = receiveMsg;
			//웹소켓 연결이 종료되면 실행될 함수 지정
			ws.onclose = endChat;
			$(".chatting").slideDown();
		}
		function startChat(){
			console.log("웹소켓 연결완료");
			const data = {type:"enter", msg: memberId};
			//문자열이 넘어가야하는데 data는 Object이기 때문에 에러발생 JSON.stringify(data) 형태로 보내줘야한다
			console.log(JSON.stringify(data));
			ws.send(JSON.stringify(data));
			appendChat("<p>채팅방에 입장했습니다.</p>");
		}
		function receiveMsg(param){
			console.log(param);
			appendChat(param.data);
		}
		function endChat(){
			console.log("웹소켓 연결종료");
		}
		function sendMsg(){
			const msg = $("#sendMsg").val();
			if(msg != ''){
				const data = {type:"chat", msg:msg}
				ws.send(JSON.stringify(data)); 
				appendChat("<div class='chat right'>"+msg+"</div>");
				$("#sendMsg").val(''); //input clear
			}
		}
		$("#sendMsg").on("keyup", function(e){
			if(e.keyCode == 13){
				//keyCode == 13 : enter
				sendMsg();
			}
		});
		function appendChat(chatMsg){
			$(".messageArea").append(chatMsg);	
			//스크롤이 생기면 스크롤 위치를 잡아줌
			$(".messageArea").scrollTop($(".messageArea")[0].scrollHeight);
		}
	</script>

	</c:if>
	<hr>
	<a href="/">메인으로</a>
</body>
</html>

채팅 Controller

package common;

import java.util.ArrayList;
import java.util.HashMap;

import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

import com.google.gson.JsonElement;
import com.google.gson.JsonParser;


public class AllMemberChat extends TextWebSocketHandler{
	//접속한 회원 세션을 저장하는 리스트
	private ArrayList<WebSocketSession> sessionList;
	//세션에 대한 아이디 mapping
	private HashMap<WebSocketSession, String> memberList;
	
	public AllMemberChat() {
		super();
		sessionList = new ArrayList<WebSocketSession>();
		memberList = new HashMap<WebSocketSession, String>();
	}

	//클라이언트가 웹소켓으로 최초에 접속했을 때 자동으로 수행되는 메소드
	@Override
	public void afterConnectionEstablished(WebSocketSession session) throws Exception{
		System.out.println("클라이언트 접속");
		//최초 접속한 session정보를 세션목록에 추가
		sessionList.add(session);
	}
	
	//클라이언트가 메세지를 보내면 처리할 메소드
	@Override
	protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception{
		//System.out.println("session : "+session);
		System.out.println("사용자가 전송한 메세지 : "+message.getPayload());
		//message.getPayload() : 문자열 형태로 객체데이터를 쓰기 위해서는 JSON형식으로 변환해서 사용해야함
		//문자열을 JSON으로 변환할 객체
		JsonParser parser = new JsonParser();
		JsonElement element = parser.parseString(message.getPayload());
		//key가 type인 값을 추출
		String type = element.getAsJsonObject().get("type").getAsString();
		//key가 msg인 값을 추출
		String msg = element.getAsJsonObject().get("msg").getAsString();
		System.out.println("type : "+type);
		System.out.println("msg : "+msg);
		if(type.equals("enter")) {
			//최초접속했을 때 memberId가 들어있음
			//최초접속이므로 memberList에 정보저장
			memberList.put(session, msg);
			String sendMsg = "<p>"+msg+"님이 입장하셨습니다.</p>";
			//클라이언트 전송용 객체
			TextMessage tm = new TextMessage(sendMsg);
			for(WebSocketSession s : sessionList) {
				if(!s.equals(session)) {
					s.sendMessage(tm);
				}
			}
		}else if(type.equals("chat")) {
			String sendMsg = "<div class='chat left'><span class='chatId'>"+memberList.get(session)+" : </span>"+msg+"</div>";
			TextMessage tm = new TextMessage(sendMsg);
			for(WebSocketSession s : sessionList) {
				if(!s.equals(session)) {
					s.sendMessage(tm);
				}
			}
		}
	}
	
	//클라이언트와 연결이 끊어졌을 때 자동으로 수행되는 메소드
	@Override
	public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception{
		System.out.println("클라이언트 연결 끊김");
		//연결이 끊기면 세션목록에서 제거
		sessionList.remove(session);
		String sendMsg = "<p>"+memberList.get(session)+"님이 나갔습니다.</p>";
		TextMessage tm = new TextMessage(sendMsg);
		for(WebSocketSession s : sessionList) {
			if(!s.equals(session)) {
				s.sendMessage(tm);
			}
		}
		memberList.remove(session);
	}
}

3 - 2 ) 쪽지

쪽지기능을 위해 DB테이블 생성

-- 쪽지기능
CREATE TABLE DIRECT_MESSAGE(
    DM_NO       NUMBER      PRIMARY KEY,
    SENDER      VARCHAR2(20)    REFERENCES MEMBER_TBL(MEMBER_ID) ON DELETE CASCADE,
    RECEIVER    VARCHAR2(20)    REFERENCES MEMBER_TBL(MEMBER_ID) ON DELETE CASCADE,
    DM_CONTENT  VARCHAR2(300)   NOT NULL,
    DM_DATE     DATE,
    READ_CHECK  NUMBER      -- 0이면 읽지앖음 1이면 읽음
);
CREATE SEQUENCE DM_SEQ;

VO : DM.class

package kr.or.iei.dm.model.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class DM {
	private int dmNo;
	private String sender;
	private String receiver;
	private String dmContent;
	private String dmDate;
	private int readCheck;
}

쪽지 페이지 이동

<h3><a href="/dmMain.do">쪽지함</a></h3>

	@RequestMapping(value="/dmMain.do")
	public String dmMain() {
		return "dm/dmMain";
	}

<%@ 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>
<link rel="stylesheet" href="/resources/css/dm.css">
<script src="https://code.jquery.com/jquery-3.6.1.js"></script>
</head>
<body>
	<h1>쪽지함</h1>
	<hr>
	<h3>쪽지보내기</h3>
	<button onclick="sendDmModal();">쪽지보내기</button>
	<hr>
	<h3>받은쪽지함</h3>
	<table border="1" class="receiveDmTbl">
		<thead>
			<tr>
				<th>보낸사람</th>
				<th>내용</th>
				<th>시간</th>
				<th>읽음여부</th>
			</tr>
		</thead>
		<tbody></tbody>
	</table>
	<hr>
	<h3>보낸쪽지함</h3>
	<table border="1" class="sendDmTbl">
		<thead>
			<tr>
				<th>받은사람</th>
				<th>내용</th>
				<th>시간</th>
				<th>읽음여부</th>
			</tr>
		</thead>
		<tbody></tbody>
	</table>
	
	
	<!-- 쪽지보내기 모달 -->
	<div id="sendDm-modal" class="modal-wrapper">
		<div class="modal">
			<div class="modal-header">
				<h2>쪽지보내기</h2>
			</div>
			<hr>
			<div class="modal-content">
				<div class="sendDmFrm">
					<label>수신자 : </label>
					<select name="receiver"></select>
					<textarea name="dmContent"></textarea>
					<input type="hidden" id="sender" value="${sessionScope.m.memberId }">
					<button onclick="dmSend();">쪽지보내기</button>
					<button onclick="closeModal();">닫기</button> 
				</div>
			</div>
		</div>
	</div>
	
	<script src="/resources/js/dm.js"></script>
</body>
</html>

dmMain - css

@charset "UTF-8";

h1{
    color: pink;

}
.modal-wrapper{
    position: fixed;
    width: 100vw;
    height: 100vh;
    background-color: rgba(0, 0, 0, 0.5);
    top: 0;
    left: 0;
    display: none;
    justify-content: center;
    align-items: center;
}
.modal{
    width: 350px;
    background-color: #fff;
}
.modal-header{
    padding: 10px;
}
.modal-content{
    padding: 20px;
}
textarea[name=dmContent]{
    width: 100%;
    height: 100px;
    resize: none;
}

dmMain - js

/**
 * 
 */

/* 버튼을 클릭하면 회원목록을 아작스로 가져올것*/
/* 회원조회는 memberController에 생성 */
function sendDmModal(){
    $.ajax({
        url : "/selectAllMemberId.do",
        success : function(list){
            //이름 중첩을 하지않기 위해 
            $("[name=receiver]").empty();
            for(let i=0; i<list.length; i++){
                const option = $("<option>");
                option.val(list[i]);
                option.text(list[i]);
                $("[name=receiver]").append(option);
            }
            $("#sendDm-modal").css("display", "flex");
        }
    });
}

function closeModal(){
    $("#sendDm-modal").hide();
    //내용도 전부 삭제해줘야함
    $("textarea[name=dmContent]").val("");
}

function dmSend(){
    //sender receiver dmcotnent를 받아올 것
    const receiver = $("[name=receiver]").val();
    const sender = $("#sender").val();
    const dmContent = $("[name=dmContent]").val();
    console.log(receiver, sender, dmContent);

    $.ajax({
        url : "/insertDm.do",
        type : "post",
        data : {receiver:receiver, sender:sender, dmContent:dmContent},
        success : function(data){
            if(data == "0"){
                alert("쪽지보내기 실패");
            }
            closeModal();
        }
    });
}

function getSendDm(){
    const sender = $("#sender").val();
    $.ajax({
        url : "/myDmList.do",
        data : {sender:sender},
        success : function(list){
            console.log(list);
        }
    });
}

function getReceiverDm(){
    const receiver = $("#sender").val();
    $.ajax({
        url : "/myDmList.do",
        data : {receiver:receiver},
        success : function(list){
            const tbody = $(".receiveDmTbl>tbody");
            tbody.empty();
            for(let i=0; i<list.length; i++){
                const dm = list[i];
                const tr = $("<tr>");
                //보낸사람, 내용, 시간 읽음여부
                const td1 = $("<td>");
                td1.text(dm.sender);
                const td2 = $("<td>");
                td2.text(dm.dmContent);
                const td3 = $("<td>");
                td3.text(dm.dmDate);
                const td4 = $("<td>");
                if(dm.readCheck == 0){
                    td4.text("읽지않음");
                }else{
                    td4.text("읽음");
                }
                tr.append(td1).append(td2).append(td3).append(td4);
                tbody.append(tr);               
            }
        }
    });
}

$(function(){
    getReceiverDm();
    getSendDm();
});

css와 js위치 webapp/resources 아래 각각 css js 폴더를 만들어서 cssFile/JavaScriptFile생성

쪽지보내기 버튼을 클릭 했을 때 회원들의 ID를 받아올 Controller(기존에 생성해놓았던 Service 사용)

	@ResponseBody
	@RequestMapping(value="/selectAllMemberId.do", produces = "application/json;charset=utf-8")
	public String selectAllMemberId() {
		ArrayList<String> list = service.search3();
		//ajax요청이기 때문에 위에 ResponseBody를 붙어야함
		//전달하려는 값이 객체이므로 produces
		return new Gson().toJson(list);
	}

쪽지를 보낼 Controller

	@ResponseBody
	@RequestMapping(value="/insertDm.do")
	public String insertDm(DM dm) {
		int result = service.insertDm(dm);
		return String.valueOf(result);
	}

Service - insert이기 때문에 트랙잭션 관리를 해줌

	@Transactional
	public int insertDm(DM dm) {
		return dao.insertDm(dm);
	}

Dao

	public int insertDm(DM dm) {
		int result = sqlSession.insert("dm.insetDm", dm);
		return result;
	}

dmSQL

	<insert id="insetDm" parameterType="dm">
		insert into direct_message values(dm_seq.nextval, #{sender}, #{receiver}, #{dmContent}, sysdate, 0)
	</insert>

받은쪽지List를 조회해올 Controller

	@ResponseBody
	@RequestMapping(value="/myDmList.do", produces = "application/json;charset=utf-8")
	public String myDmList(DM dm) {
		ArrayList<DM> list = service.selectDmList(dm);
		return new Gson().toJson(list);
	}

Service

	public ArrayList<DM> selectDmList(DM dm) {
		return dao.selectDmList(dm);
	}

Dao

	public ArrayList<DM> selectDmList(DM dm) {
		List list = sqlSession.selectList("dm.selectDmList", dm);
		return (ArrayList<DM>)list;
	}

dmSQL

	<select id="selectDmList" parameterType="dm" resultType="dm">
		select 
			dm_no as dmNo,
			sender,
			receiver,
			dm_content as dmContent,
			to_char(dm_date, 'yyyy-mm-dd hh:mi:ss') as dmDate,
			read_check as readCheck
		from direct_message
		<choose>
			<when test="sender != null">
			where sender = #{sender}
			</when>
			<when test="receiver != null">
			where receiver = #{receiver}
			</when>
		</choose>
		order by dm_no desc
	</select>

79일차 : Dynamic Mybatis

_HYE_ — Tue, 21 Mar 2023 13:26:19 +0900

20230321

Dynamic Query(동적쿼리) : 상황에따라 쿼리문이 동적으로 변화한다.
SQL문을 여러번 호출해야하는경우 DAO를 여러번 호출하여 실행하였지만 Mybatis에서 이를 동적으로 제어하는 구문을 제공하여 쉽게 쿼리를 사용하도록 지원
- if / choose / trim(쿼리문에서특정부분을없앨때사용) / foreach

- login과 searchMemberId의 로직이 굉장히 유사

Controller

	@RequestMapping(value="/login.do")
	public String login(Member m, HttpSession session) {
		Member loginMember = service.selectOneMember(m);
		if(loginMember != null) {
			session.setAttribute("m", loginMember);
		}
		return "redirect:/";
	}

searchMemberId

	@RequestMapping(value="/searchMemberId.do")
	public String searchMemberId(String memberId, Model model) {
		Member m = service.selectOneMember(memberId);
		if(m != null) {
			model.addAttribute("m", m);
			return "member/searchMemberId";
		}else {
			return "redirect:/";
		}
	}

memberMapper

  	<select id="selectOneMember" parameterType="m" resultType="m">
  		select  
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl where member_id=#{memberId} and member_pw=#{memberPw}
  	</select>

searchMemberId

  	<select id="searchMemberId" parameterType="string" resultType="m">
  		select
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl where member_id=#{_parameter}
  	</select>

1. if

-> searchMemberId에서 매개변수를 member형으로 받아도 무관 -> 수정

(매개변수가 동일하여, 오버로딩이 불가능하므로 메소드 이름도 변경해준다)

selectOneMember(String memberId) -> selectOneMemberId(Member member)

Controller

	@RequestMapping(value="/searchMemberId.do")
	public String searchMemberId(Member member, Model model) {
		Member m = service.selectOneMemberId(member);
		if(m != null) {
			model.addAttribute("m", m);
			return "member/searchMemberId";
		}else {
			return "redirect:/";
		}
	}

Service

	public Member selectOneMemberId(Member member) {
		return dao.selectOneMemberId(member);
	}

Dao

public Member selectOneMemberId(Member member) {
		Member m = sqlSession.selectOne("member.selectOneMemberId", member);
		return m;
	}

memberMapper

 	<select id="selectOneMember" parameterType="m" resultType="m">
  		select  
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl where member_id=#{memberId}
  	</select> 
    
   	<select id="searchMemberId" parameterType="m" resultType="m">
  		select
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl where member_id=#{memberId}
  	</select>

login과 searchMemberId의 쿼리문이 where절의 and member_pw = #{memberPw} 를 제외하고 동일한걸 확인할 수 있음

-> 이럴 때 동적쿼리의 if문을 사용

최종 Mapper

  	<select id="selectOneMember" parameterType="m" resultType="m">
  		select  
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl where member_id=#{memberId}
  		<if test="memberPw != null">
  		and member_pw=#{memberPw}  
  		</if>
  	</select>

Mapper에서 쿼리문 하나만 남기고, 동일한 Dao를 불러오면된다.

2. choose

<form action="/searchMember1.do" method="post">
    <select name="type">
        <option value="id">아이디</option>
        <option value="name">이름</option>
    </select>
    <input type="text" name="keyword">
    <input type="submit" value="검색">
</form>

Controller

@RequestMapping(value="/searchMember1.do")
public String searchMember1(String type, String keyword, Model model) {
    //type, keyword라는 변수가 없으므로 VO를 만들어주던지 String으로 받아와야함
    //아이디로 검색하면 : where member_id = ? 
    //이름으로 검색하면 : where member_name like %검색어%
    //조회결과가 1개일수도(아이디) 여러개일수도(이름)있으므로 list로 받는게 좋다
    ArrayList<Member> list = service.search1(type, keyword);
    model.addAttribute("list", list);
    return "member/allMember";
}

Service

public ArrayList<Member> search1(String type, String keyword) {
    //쿼리문 수행을 위해서는 매개변수(type, keyword) 2개를 전송해줘야함
    //Mybatis는 매개변수를 1개만 받을 수 있음
    //해결방법 1) type과 keyword를 묶을 VO생성 - VO를 생성하면 애초에 컨트롤러에서 매개변수로 VO로 받으면된다
    SearchVO search = new SearchVO(type, keyword);
    ArrayList<Member> list = dao.search1(search);
    //해결방법 2) HashMap<String, Object>사용(VO대신 Map으로 묶겠다)
    return list;
}

Dao

public ArrayList<Member> search1(SearchVO search) {
    List list = sqlSession.selectList("member.search1", search);
    return (ArrayList<Member>)list;
}

memberSQL

<!-- choose -->
<select id="search1" parameterType="kr.or.iei.member.model.vo.SearchVO" resultType="m">
    select
        member_no as memberNo, 
        member_id as memberId, 
        member_pw as memberPw, 
        member_name as memberName, 
        member_phone as memberPhone, 
        member_email as memberEmail
    from member_tbl 
    <!-- 조건절이 type에 따라 달라짐 -->
    <choose>
        <when test="type.equals('id')">
        where member_id = #{keyword}
        </when>
        <when test="type.equals('name')">
        where member_name like '%'||#{keyword}||'%'
        </when>
    </choose>
</select>

3. trim

			<h3>아이디 or 이름으로 검색</h3>
			<p>
				아이디만 입력하고 검색하면 아이디로 조회,
				이름만 입력하고 검색하면 이름으로 조회,
				둘 다 입력하고 검색하면 두개 and조건으로 조회
			</p>
			<form action="/searchMember2.do" method="get">
				아이디 : <input type="text" name="memberId"><br>
				이름 : <input type="text" name="memberName"><br>
				<input type="submit" value="입력">
			</form>

Controller

	@RequestMapping(value="/searchMember2.do")
	public String searchMember2(Member member, Model model) {
		ArrayList<Member> list = service.search2(member);
		//넘어오는 값중 id 또는 name을 입력하지 않으면 null이 아닌 빈값('')
		//choose로 처리할 수 있지만 case가 여러개이기 때문에 코드가 굉장히 복잡해짐
		model.addAttribute("list", list);
		return "member/allMember";
	}

Service

	public ArrayList<Member> search2(Member member) {
		ArrayList<Member> list = dao.search2(member);
		return list;
	}

Dao

	public ArrayList<Member> search2(Member member) {
		List list = sqlSession.selectList("member.search2", member);
		return (ArrayList<Member>)list;
	}

memberSQL

 	<!-- trim -->
  	<select id="search2" parameterType="m" resultType="m">
  		select
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl 
  		<!-- 이대로만 작성하면 where가 없기때문에 에러발생(if문이 실행되지않으면 에러X) : trim을 사용 -->
  		<!-- 경우의 수에따라 where가 필요할때도 and가 필요할때도 있음 -->
  		<trim prefix="where" prefixOverrides="and|or">
  		<!-- trim내부에 있는게 하나라도 동작하면, prefix에 있는 값을 붙여라 -->
  		<!-- 실행된게 and 또는 or로 시작되면 그걸 지워라 -->
  		<!-- 
  			1. 둘다 입력 안한 경우 : 아무런동작X
  			2. 아이디만 입력한 경우 : prefix에 의해 where가 붙음 : 
  			   where member_id like '%'||#{memberId}||'%'
  			3. 이름만 입력한 경우 : prefix에 의해 where가 붙고, prefixOverrides에 의해 and가 지워짐
  			   where member_name like '%'||#{memberName}||'%'
  			4. 둘다 입력한 경우 : prefix에 의해 where가 붙고 prefixOverrides는 실행 X
  			   where member_id like '%'||#{memberId}||'%' and member_name like '%'||#{memberName}||'%'
  		 -->
	  		<if test="!memberId.equals('')">
	  			member_id like '%'||#{memberId}||'%'
	  		</if>
	  		<if test="!memberName.equals('')">
	  			and member_name like '%'||#{memberName}||'%'
	  		</if>
  		</trim>
  	</select>

4. foreach

<h3><a href="/searchMember3.do">전체 아이디목록조회</a></h3>

	@RequestMapping(value="/searchMember3.do")
	public String searchMember3(Model model) {
		//전체회원의 아이디만 받아올것 -> 그래도 여러개이기때문에 ArrayList -> 내부자료형은 String
		ArrayList<String> idList = service.search3();
		model.addAttribute("idList", idList);
		return "member/idList";
	}

	public ArrayList<String> search3() {
		ArrayList<String> list = dao.search3();
		return list;
	}

	public ArrayList<String> search3() {
		List list = sqlSession.selectList("member.search3");
		return (ArrayList<String>)list;
	}

  	<select id="search3" resultType="string">
  		select member_id from member_tbl
  	</select>

<%@ 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>
	<h1>아이디 목록</h1>
	<hr>
	<form action="/searchMember4.do" method="post">
	<c:forEach items="${idList }" var="memberId">
		<p>
			<input type="checkbox" name="memberId" value="${memberId }"> 
			${memberId }
		</p>
	</c:forEach>
	<input type="submit" value="선택회원조회">
	</form>
</body>
</html>

Controller

	@RequestMapping(value="/searchMember4.do")
	public String searchMember4(String[] memberId, Model model) {
		ArrayList<Member> list = service.search4(memberId);
		model.addAttribute("list", list);
		return "member/allMember";
	}

Service

	public ArrayList<Member> search4(String[] memberId) {
		ArrayList<Member> list = dao.search4(memberId);
		return list;
	}

Dao

	public ArrayList<Member> search4(String[] memberId) {
		List list = sqlSession.selectList("member.search4", memberId);
		//Mybatis에서 매개변수로 배열을 전달하는 경우
		/* 이방식으로 전달을 한다.
		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put("array", memberId); key가 array value가 memberId
		List list = sqlSession.selectList("member.search4", map);
		*/
		return (ArrayList<Member>)list;
	}

memberSQL

  	<select id="search4" parameterType="map" resultType="m">
  		select
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl
  		where member_id in
  		<!-- collection : 대상이되는 배열의 객체  / item : 배열에서 한바퀴 돌 때마다 꺼낼 값-->
  		<!-- open : foreach시작 시 넣을값 / close : foreach종료 시 넣을 값  / separator : for문 사이 구분자-->
  		<foreach collection="array" item="id" open="(" close=")" separator=",">
  			#{id}
  		</foreach>
  	</select>

5. <![CDATA[ > ]]>

<h3><a href="/searchMember5.do">회원목록조회(특정조건)</a></h3>

Controller

	@RequestMapping(value="/searchMember5.do")
	public String searchMember5(Model model) {
		ArrayList<Member> list = service.serach5();
		model.addAttribute("list", list);
		return "member/allMember";
	}

Service

	public ArrayList<Member> serach5() {
		ArrayList<Member> list = dao.search5();
		return list;
	}

Dao

	public ArrayList<Member> search5() {
		List list = sqlSession.selectList("member.search5");
		return (ArrayList<Member>)list;
	}

memberSQL

  	<!-- 부등호 -->
  	<select id="search5" resultType="m">
  		select
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl
  		<!-- 에러발생 <가 부등호가 아닌 여는태그로 인식되기때문 : 부등호로 인식시켜줘야함 <![CDATA[ > ]]> 
  		  <![CDATA[ > ]]> 대괄호 영역안에 쿼리문 전체를 넣어줘도된다. -->
  		where member_no <![CDATA[ > ]]> 20
  	</select>

- [ Board ]

1. 게시글 목록(+페이징처리)

Controller

	@RequestMapping(value="/boardList.do")
	public String boardList(int reqPage, Model model) {
		BoardPageData bpd = service.selectBoardList(reqPage);
		model.addAttribute("list", bpd.getList());
		model.addAttribute("pageNavi", bpd.getPageNavi());
		return "board/boardList";
	}

Service

	public BoardPageData selectBoardList(int reqPage) {
		//한 페이지당 보여줄 게시물 수 
		int numPerPage = 5;
		//reqPage = 1 : 1~2 / 2 : 3~4
		int end = reqPage * numPerPage;
		int start = end - numPerPage + 1;
		//계산된 start, end를 가지고 게시물 목록 조회
		//Mybatis는 매개변수를 하나만 받을 수 있기 때문에 HashMap 사용
		//String : 쿼리문에서 사용하기 쉽게하려고 / Object : 여러자료형을 받을 수 잇도록
		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put("start", start);
		map.put("end", end);
		ArrayList<Board> list = dao.selectBoardList(map);
		//pageNavi 제작 시작
		//전체페이지 수 계산 필요 -> 전체 게시물 수 조회
		int totalCount = dao.selectBoardCount();
		//전체게시물로 전체 페이지 수 계산
		//방법1
		/*
		int totalPage = 0;
		if(totalCount%numPerPage == 0) {
			totalPage = totalCount/numPerPage;
		}else {
			totalPage = (totalCount/numPerPage) + 1;
		}
		*/
		//방법2
		int totalPage = (int)Math.ceil(totalCount/(double)numPerPage); //ceil : 올림
		//pageNavi 사이즈
		int pageNaviSize = 5;
		
		int pageNo = 1;
		if(reqPage > 3) {
			pageNo = reqPage-2;
		}
		//페이지네비 생성시작
		String pageNavi = "";
		//이전버튼
		if(pageNo != 1) {
			pageNavi +="<a href='/boardList.do?reqPage="+(pageNo-1)+"'>[이전]</a>";
		}
		//페이지 숫자 생성
		for(int i=0; i<pageNaviSize; i++) {
			if(pageNo == reqPage) {
				//현재페이지
				pageNavi += "<span>"+pageNo+"</span>";
			}else {
				pageNavi += "<a href='/boardList.do?reqPage="+pageNo+"'>"+pageNo+"</a>";
			}
			pageNo++;
			if(pageNo > totalPage) {
				break;
			}
		}
		//다음버튼
		if(pageNo <= totalPage) {
			pageNavi +="<a href='/boardList.do?reqPage="+pageNo+"'>[다음]</a>";
		}
		BoardPageData bpd = new BoardPageData(list, pageNavi);
		return bpd;
	}

Dao

	public ArrayList<Board> selectBoardList(HashMap<String, Object> map) {
		List list = sqlSession.selectList("board.selectBoardList", map);
		return (ArrayList<Board>)list;
	}

	public int selectBoardCount() {
		int totalCount = sqlSession.selectOne("board.totalCount");
		return totalCount;
	}

boardSQL

	<select id="selectBoardList" parameterType="map" resultType="b">
		select * from
			(select rownum as rnum, b.* from
				(select 
					board_no as boardNo, 
					board_title as boardTitle, 
					board_writer as boardWriter, 
					board_date as boardDate
				from board
				order by 1 desc)b)
		where rnum between #{start} and #{end}
	</select>
	<select id="totalCount" resultType="_int">
		select count(*) from board
	</select>

2. 게시글 작성

<%@ 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>
	<form action="/boardWrite.do" method="post" enctype="multipart/form-data">
		<table border="1">
			<tr>
				<th>제목</th>
				<td><input type="text" name="boardTitle"></td>
			</tr>
			<tr>
				<th>작성자</th>
				<td>
					${sessionScope.m.memberId }
					<input type="hidden" name="boardWriter" value="${sessionScope.m.memberId }">
				</td>
			</tr>
			<tr>
				<th>첨부파일</th>
				<td><input type="file" name="boardFile" multiple></td>
			</tr>
			<tr>
				<th>내용</th>
				<td><textarea name="boardContent"></textarea></td>
			</tr>
			<tr>
				<th colspan="2"><input type="submit" value="작성하기"></th>
			</tr>
		</table>
	</form>
	<a href="/">메인으로</a>
</body>
</html>

Controller

	@RequestMapping(value="/boardWriteFrm.do")
	public String boardWriteFrm() {
		return "board/boardWriteFrm";
	}
	@RequestMapping(value="/boardWrite.do")
	public String boardWrite(Board b, MultipartFile[] boardFile, HttpServletRequest request) {
		ArrayList<FileVO> fileList = new ArrayList<FileVO>();
		if(!boardFile[0].isEmpty()){
			//파일이 존재할 때
			String savePath = request.getSession().getServletContext().getRealPath("/resources/upload/board/");
			for(MultipartFile file : boardFile) {
				String filename = file.getOriginalFilename();
				String filepath = manager.upload(savePath, file);
				
				FileVO fileVO = new FileVO();
				fileVO.setFilename(filename);
				fileVO.setFilepath(filepath);
				fileList.add(fileVO);
			}
		}
		int result = service.insertBoard(b, fileList);
		if(result == fileList.size()+1) {
			return "redirect:/boardList.do?reqPage=1";
		}else {
			return "redirect:/";
		}
	}

Service

	public int insertBoard(Board b, ArrayList<FileVO> fileList) {
		//DB작업 3번 - 1.board테이블에 insert / 2.파일에서 참조할 board_no를 조회 / 3.file_tbl테이블에 insert
		int result = dao.insertBoard(b);
		//Mybatis에서 boardNo를 넣어주었기 때문에 boardNo가 0 이 아닌 해당 게시글번호로 나온다.
		if(result > 0) {
			//int boardNo = dao.selectBoardNo();
			for(FileVO file : fileList) {
				file.setBoardNo(b.getBoardNo());
				result += dao.insertFile(file);
			}
		}
		return result;
	}

Dao

	public int insertBoard(Board b) {
		int result = sqlSession.insert("board.insertBoard", b);
		return result;
	}

	public int selectBoardNo() {
		int boardNo = sqlSession.selectOne("board.selectBoardNo");
		return boardNo;
	}

	public int insertFile(FileVO file) {
		int result = sqlSession.insert("board.insertFile", file);
		return result;
	}

boardSQL

	<insert id="insertBoard" parameterType="b">
		insert into board values
		(board_seq.nextval, #{boardTitle}, #{boardWriter}, #{boardContent}, to_char(sysdate, 'yyyy-mm-dd'))
		<!-- 정규화가 이루어져있어 외래키로 연결되어있을 경우 selectKey를 사용하면 별도의 select를 진행하지 않아도된다. -->
		<!-- key값을 다시 조회할건데 해당태그(현재insert)가 동작하고나면 조회할 때 -->
		<selectKey resultType="_int" order="AFTER" keyProperty="boardNo">
			<!-- order:insert문 이후에 실행, keyProperty: boardNo변수에 넣어줄것 -->
			select max(board_no) from board
		</selectKey>
	</insert>
	<!-- <select id="selectBoardNo" resultType="_int">
		select max(board_no) from board
	</select> -->
	<insert id="insertFile" parameterType="f">
		insert into file_tbl values(file_seq.nextval, #{boardNo}, #{filename}, #{filepath})
	</insert>
	
	<!--
	<select id="selectOneBoard" parameterType="_int" resultType="b">
		select 
			board_no as boardNo, 
			board_title as boardTitle, 
			board_writer as boardWriter,
			board_content as boardContent, 
			board_date as boardDate
		from board where board_no = ${_parameter}
	</select>
	-->

3. 게시글 상세보기

Controller

	@RequestMapping(value="/boardView.do")
	public String boardView(int boardNo, Model model) {
		Board b = service.selectOneBoard(boardNo);
		model.addAttribute("b", b);
		return "board/boardView";
	}

Service

	public Board selectOneBoard(int boardNo) {
		//1.board테이블조회
		Board b = dao.selectOneBoard(boardNo);
		//2.file테이블조회
		/*
		if(b != null) {
			ArrayList<FileVO> fileList = dao.selectFileList(boardNo);
			b.setFileList(fileList);
		}
		*/
		return b;
	}

Dao

	public Board selectOneBoard(int boardNo) {
		Board b = sqlSession.selectOne("board.selectOneBoard", boardNo);
		return b;
	}

	public ArrayList<FileVO> selectFileList(int boardNo) {
		List list = sqlSession.selectList("board.selectFileList", boardNo);
		return (ArrayList<FileVO>)list;
	}

boardSQL

	<!--
	<select id="selectOneBoard" parameterType="_int" resultType="b">
		select 
			board_no as boardNo, 
			board_title as boardTitle, 
			board_writer as boardWriter,
			board_content as boardContent, 
			board_date as boardDate
		from board where board_no = ${_parameter}
	</select>
	-->
	<select id="selectFileList" parameterType="_int" resultType="f">
		select
			file_no as fileNo,
			board_no as boardNo,
			filename,
			filepath
		from file_tbl where board_no = #{_parameter}
	</select>
	
	<select id="selectOneBoard" parameterType="_int" resultMap="getBoard">
		select * from board where board_no = ${_parameter}
	</select>
	<!-- type:최종적으로 되돌려주는 type / id:연결을 위함 -->
	<!-- 사용은 할 수 있지만 효율은낮음 DB에 쓸데없는 데이터가 많아지기 때문에 -->
	<resultMap type="b" id="getBoard">
		<result column="board_no" property="boardNo" />
		<result column="board_title" property="boardTitle" />
		<result column="board_Writer" property="boardWriter" />
		<result column="board_Content" property="boardContent" />
		<result column="board_date" property="boardDate" />
		<collection property="fileList" 
					select="selectFileList"
					column="board_no"
					ofType="f"
					javaType="java.util.ArrayList"
		/>
	</resultMap>

4. 게시글 수정

<%@ 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>
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
</head>
<body>
	<h1>게시물 수정</h1>
	<hr>
	<form action="/boardUpdate.do" method="post" enctype="multipart/form-data" id="updateFrm">
		<table border="1">
			<tr>
				<th>글번호</th>
				<td>
					${b.boardNo }
					<input type="hidden" name="boardNo" value="${b.boardNo }">
				</td>
				<th>작성자</th>
				<td>${b.boardWriter }</td>
				<th>작성일</th>
				<td>${b.boardDate }</td>
			</tr>
			<tr>
				<th>제목</th>
				<td colspan="5"><input type="text" name="boardTitle" value="${b.boardTitle }"></td>
			</tr>
			<tr>
				<th>첨부파일</th>
				<td colspan="5">
					<c:forEach items="${b.fileList }" var="f">
					<p>
						${f.filename}
						<button type="button" onclick="deleteFile(this, ${f.fileNo}, '${f.filepath }');">삭제</button>
					</p> 
					</c:forEach>
				</td>
			</tr>
			<tr>
				<th>첨부파일 추가</th>
				<td colspan="5"><input type="file" name="boardFile" multiple></td>
			</tr>
			<tr>
				<td colspan="6" style="min-hight:300px;">
					<textarea name="boardContent">${b.boardContent }</textarea>
				</td>
			</tr>
			<tr>
				<td colspan="6">
					<input type="submit" value="작성완료">
				</td>
			</tr>
		</table>
	</form>
	<script>
		function deleteFile(obj, fileNo, filepath){
			const fileNoInput = $("<input>");
			fileNoInput.attr("name", "fileNo");
			fileNoInput.val(fileNo);
			fileNoInput.hide();
			
			const filepathInput = $("<input>");
			filepathInput.attr("name", "filepath");
			filepathInput.val(filepath);
			filepathInput.hide();
			
			$("#updateFrm").append(fileNoInput).append(filepathInput);
			$(obj).parent().remove();
		}
	</script>
</body>
</html>

Controller

	@RequestMapping(value="/boardUpdateFrm.do")
	public String boardUpdateFrm(int boardNo, Model model) {
		Board b = service.selectOneBoard(boardNo);
		model.addAttribute("b", b);
		return "board/boardUpdateFrm";
	}
	
	@RequestMapping(value="/boardUpdate.do")
	public String boardUpdate(Board b, int[] fileNo, String[] filepath, MultipartFile[] boardFile, HttpServletRequest request) {
		System.out.println("넘어오나");
		ArrayList<FileVO> fileList = new ArrayList<FileVO>();
		String savePath = request.getSession().getServletContext().getRealPath("/resources/upload/board/");
		if(!boardFile[0].isEmpty()) {
			for(MultipartFile file : boardFile) {
				String filename = file.getOriginalFilename();
				String newfilepath = manager.upload(savePath, file);
				FileVO fileVO = new FileVO();
				fileVO.setFilename(filename);
				fileVO.setFilepath(newfilepath);
				fileList.add(fileVO);
			}
		}//파일업로드종료
		int result = service.boardUpdate(b, fileList, fileNo);
		if(fileNo != null && result == (fileList.size() + fileNo.length + 1)) {
			for(String delFile : filepath) {
				manager.deleteFile(savePath, delFile);
			}
			return "redirect:/boardView.do?boardNo="+b.getBoardNo();
		}else if(fileNo == null && result == fileList.size()+1){
			return "redirect:/boardView.do?boardNo="+b.getBoardNo();
		}else {
			return "redirect:/boardList.do?reqPage=1";
		}
	}

Service

	public int boardUpdate(Board b, ArrayList<FileVO> fileList, int[] fileNo) {
		int result = dao.updateBoard(b);
		if(result > 0) {
			if(fileNo != null) {
				for(int no : fileNo) {
					result += dao.deleteFile(no);
				}
			}
			for(FileVO f : fileList) {
				f.setBoardNo(b.getBoardNo());
				result += dao.insertFile(f);
			}
		}
		return result;
	}

Dao

	public int updateBoard(Board b) {
		int result = sqlSession.update("board.updateBoard", b);
		return result;
	}

	public int deleteFile(int no) {
		int result = sqlSession.delete("board.deleteFile", no);
		return result;
	}

boardSQL

	<update id="updateBoard" parameterType="b">
		update board set board_title = #{boardTitle}, board_content = #{boardContent} where board_no = #{boardNo}
	</update>
	<delete id="deleteFile" parameterType="_int">
		delete from file_tbl where file_no = #{_parameter}
	</delete>

5. 게시글 삭제

Controller

	@RequestMapping(value="/boardDelete.do")
	public String boardDelete(int boardNo, HttpServletRequest request) {
		ArrayList<FileVO> list = service.deleteBoard(boardNo);
		if(list == null) {
			return "redirect:/boardView.do?boardNo="+boardNo;
		}else {
			String savePath = request.getSession().getServletContext().getRealPath("/resources/upload/board/");
			for(FileVO file : list) {
				manager.deleteFile(savePath, file.getFilepath());
			}
			return "redirect:/boardList.do?reqPage=1";
		}
	}

Service

	public ArrayList<FileVO> deleteBoard(int boardNo) {
		//삭제이후에 조회를 하면 on delete cascade 때문에 이미 지워진 상태이기 때문에 확인불가
		ArrayList<FileVO> fileList = dao.selectFileList(boardNo);
		int result = dao.deleteBoard(boardNo);
		if(result > 0) {
			return fileList;
		}else {
			return null;
		}
	}

Dao

	public int fileDelete(int boardNo) {
		int result = sqlSession.delete("board.deleteBoardFile", boardNo);
		return result;
	}

	public int deleteBoard(int boardNo) {
		int result = sqlSession.delete("board.deleteBoard", boardNo);
		return result;
	}

boardSQL

	<delete id="deleteBoardFile" parameterType="_int">
		delete from file_tbl where board_no = #{_parameter}
	</delete>
	<delete id="deleteBoard" parameterType="_int">
		delete from board where board_no = #{_parameter}
	</delete>

78일차 : Mybatis

_HYE_ — Tue, 21 Mar 2023 00:15:28 +0900

20230320

mybatis : 데이터의 입력,조회,수정,삭제를 보다 편하게 사용하기 위한 영속성 프레임워크

- Mybatis 사용을 위한 사전 Setting

1. pom.xml에 Maven Repository 에서 검색한 라이브러리 2개 추가 - 사전에 있어야하는 라이브러리가 있다

<!-- Mybatis를 사용하기 위한 라이브러리(이미 있어야하는 것 : ojdbc, commons-dbcp, spring-jdbc / 추가할것(mybatis, mybatis-spring)) -->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis(순수Mybatis) -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring(스프링과 연동하기위해, Mybatis는 독립적으로도 사용이 가능하다 Spring에 종속적인게X) -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.2</version>
</dependency>

2. servlet-context.xml에 mybatis 설정객체 추가

<!-- jdbc를 사용하지 않고 mybatis를 사용할 것  -->
<!-- Mybatis 설정 객체 -->
<beans:bean id="sqlSession" class="org.mybatis.spring.SqlSessionFactoryBean">
    <beans:property name="dataSource" ref="dataSource" />
    <beans:property name="configLocation" value="classpath:mybatis-config.xml" />
    <beans:property name="mapperLocations" value="classpath:/mapper/*SQL.xml" />
    <!-- 여기서 말하는 classpath는 scr/main/resources 폴더 -->
</beans:bean>
<!-- 실제 DB작업을 수행하는 객체 -->
<beans:bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
    <beans:constructor-arg ref="sqlSession" />
</beans:bean>

3. window - preferences - XML Catalog - User Specified Entries 추가

[ Config ]

Location : http://mybatis.org/dtd/mybatis-3-config.dtd

Key : -//mybatis.org//DTD Config 3.0//EN

[ Mapper ]

Location : http://mybatis.org/dtd/mybatis-3-mapper.dtd

Key : -//mybatis.org//DTD Mapper 3.0//EN

4. src/main/resources에 mybatis-config와 mapper패키지추가(mapper패키지에 앞으로 작성할 SQL문이 들어갈것)

XML 파일 생성 시 해줘야하는 작업

5. mybatis-config

- 앞으로 새로운 VO를 작성할 때마다 typeAlias를 작성(mapper에서 별명으로 사용하기위함)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd" >
<configuration>
	<settings>
		<!-- null값이 발생하면 빈칸("")이 아닌 null로 처리(null일 때 빈칸으로 처리되는 기본설정이 있기 때문에) -->
		<setting name="jdbcTypeForNull" value="NULL" />
	</settings>
	<typeAliases>
		<typeAlias type="kr.or.iei.member.model.vo.Member" alias="m"/>
		<typeAlias type="kr.or.iei.notice.model.vo.Notice" alias="n"/>
	</typeAliases>
</configuration>

6. mapper

- mapper생성 시 namespace를 지정 -> 자바에서 해당mapper를 찾을 수 있게해준다.

- 명명규칙 : beans에서 설정해준 값대로 이름을 붙여줘야한다. servlet-context에서 *SQL이라고 작성했으므로 규칙을 따라야함(앞에 무슨문자가와도 마지막은 SQL로 끝나야함, 대문자 중요)

- [ Member ]

Controller / Service / Dao 에 Component를 해주는것은 물론 Component-scan / 사용할 객체에 @Autowired해주는것은 기존과 동일 단, Dao에서 jdbcTemplate이 아닌 sqlSessionTemplate을 사용할것

DAO

@Repository
public class MemberDao {
	@Autowired
	private SqlSessionTemplate sqlSession;
	//private JdbcTemplate jdbc;
	//import - jdbc / rowMapper 다 지워도 된다(rowmapper는 mybatis를 사용하면 필요없기때문에 클래스도 삭제)
}

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>
	<h1>Spring_Mybatis</h1>
	<hr>
	<c:choose>
		<c:when test="${empty sessionScope.m }">
			<form action="login.do" method="post">
				<fieldset>
					<legend>로그인</legend>
					아이디 : <input type="text" name="memberId"><br>
					비밀번호 : <input type="password" name="memberPw"><br>
					<input type="submit" value="로그인">
				</fieldset>
			</form>
			<h3><a href="/joinFrm.do">회원가입</a></h3>
		</c:when>
		<c:otherwise>
			<h2>[${sessionScope.m.memberName }]</h2>
			<h3><a href="/logout.do">로그아웃</a></h3>
			<form action="/searchMemberId.do">
				조회할 아이디 입력 : 
				<input type="text" name="memberId">
				<input type="submit" value="조회">
			</form>
			<h3><a href="/allMember.do">전체회원조회</a></h3>
			<h3><a href="/mypage.do">마이페이지</a></h3>
			<h3><a href="/noticeList.do">공지사항</a></h3>
			<h3><a href="/deleteMember.do?memberNo=${sessionScope.m.memberNo }">회원탈퇴</a></h3>
		</c:otherwise>
	</c:choose>
</body>
</html>

1. 로그인 / 로그아웃

Controller

	@RequestMapping(value="/login.do")
	public String login(Member m, HttpSession session) {
		Member loginMember = service.selectOneMember(m);
		if(loginMember != null) {
			session.setAttribute("m", loginMember);
		}
		return "redirect:/";
	}
	
	@RequestMapping(value="/logout.do")
	public String logout(HttpSession session) {
		session.invalidate();
		return "redirect:/";
	}

Service

	public Member selectOneMember(Member member) {
		return dao.selectOneMember(member);
	}

Dao

	public Member selectOneMember(Member member) {
		/*
		 	String query = "select * from member_tbl where member_id = ? and member_pw = ?";
			Object[] params = {m.getMemberId(), m.getMemberPw()};
			List list = jdbc.query(query, params, new MemberRowMapper());
			return (Member)list.get(0);
		 */
		//조회결과가 하나이기 때문에 selectOne
		//selectOneMember앞의 member는 Mapper 중 namespace를 찾는 것
		//즉, mapper가 여러개 있을 텐데 namespace가 member인 Mapper를 찾아가서 id가 selectOneMember인 쿼리를 수행하라는 의미
		Member m = sqlSession.selectOne("member.selectOneMember",member); //dao코드 완료 -> mapper에 sql코드 작성
		return m;
	}

memberSQL(mapper)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="member">
	<!-- mapper를 만들면 cache-ref를 지워주고 mapper에 이름을 붙여준다. -->
  	
  	<!-- Member가 여러개이기 때문에 패키지까지 다 적어줘야함(kr.or.iei.member.model.vo.Member) : 다 적어주기 힘드므로 config에서 별명으로 지정 가능 -->
  	<select id="selectOneMember" parameterType="m" resultType="m">
  		<!-- 세미콜론(;) 찍으면 안됨 -->
  		<!-- 위치홀더에 넣어줄 값은 파라미터로 들어온 m에 들어가있음 -->
  		select  
  			<!-- 컬럼명의 별칭을 Member(VO)의 변수명으로 지정해주면 resultType의 m에 자동으로 넣어준다 -->
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl where member_id=#{memberId} and member_pw=#{memberPw}
  	</select>

2. 아이디 검색으로 회원조회

Controller

	@RequestMapping(value="/searchMemberId.do")
	public String searchMemberId(String memberId, Model model) {
		Member m = service.selectOneMember(memberId);
		if(m != null) {
			model.addAttribute("m", m);
			return "member/searchMemberId";
		}else {
			return "redirect:/";
		}
	}

Service

	public Member selectOneMember(String memberId) {
		return dao.selectOneMember(memberId);
	}

Dao

	public Member selectOneMember(String memberId) {
		Member m = sqlSession.selectOne("member.searchMemberId", memberId);
		return m;
	}

memberSQL

  	<select id="searchMemberId" parameterType="string" resultType="m">
  		select
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl where member_id=#{_parameter}
  		<!-- where에 memberId를 넣어줘도 되지만  매개변수가 vo형태가 아니라 단일갯수이면 _parameter를 적어주면된다. 문자/숫자 상관없이 하나이기만 하면 전부! -->
  	</select>

3. 전체회원조회

Controller

	@RequestMapping(value="/allMember.do")
	public String allMember(Model model) {
		ArrayList<Member> list = service.selectAllMmeber();
		model.addAttribute("list", list);
		return "member/allMember";
	}

Service

	public ArrayList<Member> selectAllMmeber() {
		return dao.selectAllMember();
	}

Dao

	public ArrayList<Member> selectAllMember() {
		List list = sqlSession.selectList("member.selectAllMember");
		return (ArrayList<Member>)list;
	}

memberSQL

  	<!-- 쿼리문 실행을 위한 매개변수가 없는경우 parameterType 생략 -->
  	<!-- 이미 dao에서 selectList()를 사용했으므로 list로 오는건 확정 -> list안에 들어가는 자료형으로 지정해주면된다 "m" -->
  	<select id="selectAllMember" resultType="m">
  		select
  			member_no as memberNo, 
  			member_id as memberId, 
  			member_pw as memberPw, 
  			member_name as memberName, 
  			member_phone as memberPhone, 
  			member_email as memberEmail
  		from member_tbl
  		order by member_no
  	</select>

4. 회원가입

Controller

	@RequestMapping(value="/joinFrm.do")
	public String joinFrm() {
		return "member/joinFrm";
	}
	
	@RequestMapping(value="/join.do")
	public String join(Member member) {
		int result = service.insertMember(member);
		if(result > 0) {
			return "redirect:/";
		}else {
			return "redirect:/joinFrm.do";
		}
	}

Service

	public int insertMember(Member member) {
		return dao.insertMember(member);
	}

Dao

	public int insertMember(Member member) {
		int result = sqlSession.insert("member.insertMember", member);
		return result;
	}

memberSQL

  	<!-- insert/update/delete는 무조건 resultType이 int로 고정되어있으므로 명시하면 안된다. 쓰지않고 항상 int로 빠지는것 -->
  	<insert id="insertMember" parameterType="m" >
  		insert into member_tbl values(member_seq.nextval, #{memberId}, #{memberPw}, #{memberName}, #{memberPhone}, #{memberEmail})
  	</insert>

5. 회원탈퇴

Controller

	@RequestMapping(value="/deleteMember.do")
	public String deleteMember(int memberNo) {
		int result = service.deleteMember(memberNo);
		if(result > 0) {
			return "redirect:/logout.do";
		}else {
			return "redirect:/";
		}
	}

Service

	public int deleteMember(int memberNo) {
		return dao.deleteMember(memberNo);
	}

Dao

	public int deleteMember(int memberNo) {
		int result = sqlSession.delete("member.deleteMember", memberNo);
		return result;
	}

memberSQL

  	<delete id="deleteMember" parameterType="_int">
  		delete from member_tbl where member_no = #{_parameter}
  	</delete>

6. 마이페이지(정보수정)

Controller

	@RequestMapping(value="/mypage.do")
	public String mypage() {
		return "member/mypage";
	}
	@RequestMapping(value="/updateMember.do")
	public String updateMember(Member member, @SessionAttribute(required = false) Member m) {
		int result = service.updateMember(member);
		if(result > 0) {
			m.setMemberPw(member.getMemberPw());
			m.setMemberPhone(member.getMemberPhone());
			m.setMemberEmail(member.getMemberEmail());
			return "redirect:/mypage.do";
		}else {
			return "redirect:/";
		}
	}

Service

	public int updateMember(Member member) {
		return dao.updateMember(member);
	}

Dao

	public int updateMember(Member member) {
		int result = sqlSession.update("member.updateMember", member);
		return result;
	}

memberSQL

  	<update id="updateMember" parameterType="m">
  		update member_tbl set 
  			member_pw = #{memberPw}, 
  			member_phone = #{memberPhone}, 
  			member_email = #{memberEmail}
  		where member_no = #{memberNo}
  	</update>

- [ Notice ]

Controller

package kr.or.iei.notice.controller;

import java.util.ArrayList;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import kr.or.iei.notice.model.service.NoticeService;
import kr.or.iei.notice.model.vo.Notice;

@Controller
public class NoticeController {
	@Autowired
	private NoticeService service;
	/*
	 <공지사항>
	 1. 전체목록
	 2. 글쓰기
	 3. 상세보기
	 4. 수정
	 5. 삭제
	 */
	@RequestMapping(value="/noticeList.do")
	public String noticeList(Model model) {
		ArrayList<Notice> list = service.selectAllNotice();
		if(list != null) {
			model.addAttribute("list", list);
			return "notice/noticeList";
		}else {
			return "redirect:/";
		}
	}
	@RequestMapping(value="/noticeView.do")
	public String noticeView(int noticeNo, Model model) {
		Notice n = service.selectOneNotice(noticeNo);
		if(n != null) {
			model.addAttribute("n", n);
			return "notice/noticeView";
		}else {
			return "redirect:/noticeList.do";
		}
	}
	@RequestMapping(value="/noticeWriteFrm.do")
	public String noticeWriteFrm() {
		return "notice/noticeWriteFrm";
	}
	@RequestMapping(value="/insertNotice.do")
	public String insertNotice(Notice n) {
		int result = service.insertNotice(n);
		if(result > 0) {
			return "redirect:/noticeList.do";
		}else {
			return "notice/noticeWriterFrm";
		}
	}
	@RequestMapping(value="/updateNoticeFrm.do")
	public String updateNoticeFrm(int noticeNo, Model model) {
		Notice n = service.selectOneNotice(noticeNo);
		if(n != null) {
			model.addAttribute("n", n);
			return "notice/updateNoticeFrm";
		}else {
			return "redirect:/noticeList.do";
		}
	}
	@RequestMapping(value="/updateNotice.do")
	public String updateNotice(Notice n) {
		int result = service.updateNotice(n);
		if(result > 0) {
			return "redirect:/noticeView.do?noticeNo="+n.getNoticeNo();
		}else {
			return "redirce:/noticeList.do";
		}
	}
	@RequestMapping(value="/deleteNotice.do")
	public String deleteNotice(int noticeNo) {
		int result = service.deleteNotice(noticeNo);
		if(result>0) {
			return "redirect:/noticeList.do";
		}else {
			return "redirect:/noticeView.do?noticeNo="+noticeNo;
		}
	}
}

Service

package kr.or.iei.notice.model.service;

import java.util.ArrayList;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import kr.or.iei.notice.model.dao.NoticeDao;
import kr.or.iei.notice.model.vo.Notice;

@Service
public class NoticeService {
	@Autowired
	private NoticeDao dao;

	public ArrayList<Notice> selectAllNotice() {
		return dao.selectAllNotice();
	}

	public Notice selectOneNotice(int noticeNo) {
		return dao.selectOneNotice(noticeNo);
	}

	public int insertNotice(Notice n) {
		return dao.insertNotice(n);
	}

	public int updateNotice(Notice n) {
		return dao.updateNotice(n);
	}

	public int deleteNotice(int noticeNo) {
		return dao.deleteNotice(noticeNo);
	}
}

Dao

package kr.or.iei.notice.model.dao;

import java.util.ArrayList;
import java.util.List;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import kr.or.iei.notice.model.vo.Notice;

@Repository
public class NoticeDao {
	@Autowired
	private SqlSessionTemplate sqlSession;

	public ArrayList<Notice> selectAllNotice() {
		List list = sqlSession.selectList("notice.selectAllNotice");
		return (ArrayList<Notice>)list;
	}

	public Notice selectOneNotice(int noticeNo) {
		Notice n = sqlSession.selectOne("notice.selectOneNotice", noticeNo);
		return n;
	}

	public int insertNotice(Notice n) {
		int result = sqlSession.insert("notice.insertNotice", n);
		return result;
	}

	public int updateNotice(Notice n) {
		int result = sqlSession.update("notice.updateNotice", n);
		return result;
	}

	public int deleteNotice(int noticeNo) {
		int result = sqlSession.delete("notice.deleteNotice", noticeNo);
		return result;
	}
}

noticeSQL

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="notice">
	<select id="selectAllNotice" resultType="n">
		select 
			notice_no as noticeNo,
			notice_title as noticeTitle,
			notice_writer as noticeWriter,
			notice_date as noticeDate
		from notice
		order by 1 desc
	</select>
	<select id="selectOneNotice" parameterType="_int" resultType="n">
		select 
			notice_no as noticeNo,
			notice_title as noticeTitle,
			notice_writer as noticeWriter,
			notice_content as noticeContent,
			notice_date as noticeDate
		from notice where notice_no = #{_parameter}
	</select>
	<insert id="insertNotice" parameterType="n">
		insert into notice values(notice_seq.nextval, #{noticeTitle}, #{noticeWriter}, #{noticeContent}, to_char(sysdate, 'yyyy-mm-dd'))
	</insert>
	<update id="updateNotice" parameterType="n">
		update notice set notice_title = #{noticeTitle}, notice_content = #{noticeContent} where notice_no = #{noticeNo}
	</update>
	<delete id="deleteNotice" parameterType="_int">
		delete from notice where notice_no = #{_parameter}
	</delete>
</mapper>

77일차 : SpringMVC - 게시판2

_HYE_ — Fri, 17 Mar 2023 17:03:54 +0900

20230317

어제 작성했던 파일네이밍을 클래스의 메소드로 따로빼서 사용할것 (다른데에서도 똑같이 사용하기 때문에)

파일 업로드시 board notice 둘다 파일업로드를 한다고 가정하면 달라지는 부분은 파일이 올라가는 경로+실제파일
-> 공통적인 부분을 따로 만들어서 매개변수를 받아 달라지는 부분만 수정(모듈화)

FileManager.java

@Component //객체생성을 위한것 - servlet-context.xml의 component-scan과 함께 이루어져야한다.
public class FileManager {
	//파일업로드를 위한 메소드
	public String upload(String savePath, MultipartFile file) {
		String filename = file.getOriginalFilename();
		String onlyFilename = filename.substring(0, filename.lastIndexOf("."));
		String extention = filename.substring(filename.lastIndexOf(".")); 
		String filepath = null;
		int count = 0; 
		while(true) {
			if(count == 0) {
				filepath = onlyFilename+extention;				
			}else {
				filepath = onlyFilename+"_"+count+extention;	
			}
			File checkFile = new File(savePath+filepath);
			if(!checkFile.exists()) {
				break;
			}
			count++;
		}
		try {
			FileOutputStream fos = new FileOutputStream(savePath+filepath);
			BufferedOutputStream bos = new BufferedOutputStream(fos);
			byte[] bytes = file.getBytes();
			bos.write(bytes);
			bos.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//filepath를 return을 String으로 잡아준것
		return filepath;
	}
}

- servlet-context.xml에서 component-scan을 잊지말자

	<context:component-scan base-package="common" />

1. 수정된 글작성하기(INSERT)

FileManager를 사용하기위해 상단에 선언

	@Autowired
	private FileManager fileManager;

Controller

	
	@RequestMapping(value="/boardWrite.do")
	//파일업로드를 진행하기위해 request를 불러옴
	public String boardWrite(Board b, MultipartFile[] boardFile, HttpServletRequest request) {
		//파일목록을 저장할 list생성
		ArrayList<FileVO> fileList = new ArrayList<FileVO>();
		//제목,내용,작성자는 매개변수 b에 모두 들어있음
		//파일이름은 b에 들어있지X 매개변수로 받음 -> 여러개를 받을거기때문에 자료형은 배열형태로
		//첨부파일은 input type="file"의 name으로 매개변수를 생성 -> 첨부파일 갯수만큼 배열길이 생성
		//첨부파일을 첨부하지 않아도 배열은 길이가 1
		//System.out.println(b);
		//System.out.println(boardFile.length);
		//첨부파일 존재유무를 구분하는 법 - 배열의 첫번째가 비어있는지 아닌지 확인
		//if(!boardFile[0].isEmpty()) {} if문은 이렇게 작성해주는게 좋다.
		if(boardFile[0].isEmpty()) {
			//첨부파일이 없는경우 진행할 로직이 없음
		}else {
			//첨부파일이 있는경우 파일업로드작업 수행
			//1. 파일업로드 경로 설정
			//getRealPath까지가 webapp
			String savePath = request.getSession().getServletContext().getRealPath("/resources/upload/board/");
			//2. 배열이므로 반복문을 이용해서 파일업로드 처리
			for(MultipartFile file : boardFile) {
				//파일명이 기존업로드한 파일명과 중복되면 기존파일을 삭제하고 새파일로 덮어쓰기됨 -> 파일명이 중복되지않게 처리해야 함
				//(cos라이브러리에서는 new DefaultFileRenamePolicy가 파일이름이 중복일 경우 새로운이름을 붙여줬음 name1 name2)
				String filename = file.getOriginalFilename(); //사용자가 업로드한 이름
				//이걸 그대로 업로드하면 파일명이 중복되엇을 때 문제가 발생
				//가정 : filename => test.txt인데 중복인 경우 => test_1.txt 확장자기준 앞을 바꿈
				String filepath = fileManager.upload(savePath, file);
				
				
				/*
				//우선 text    .txt를 분리함
				String onlyFilename = filename.substring(0, filename.lastIndexOf("."));//test 0부터 뒤에서부터 .의 위치의 숫자를세서 그만큼까지
				String extention = filename.substring(filename.lastIndexOf(".")); //.txt 매개변수를 하나만주면 그 매개변수부터 끝까지라는 의미
				//실제 업로드할 파일명
				String filepath = null;
				//파일명 중복 시 뒤에 붙일 숫자
				int count = 0; //횟수가 정해져있지 않음 > while문을 무한으로 돌리고 중복이아닐때 빠져나옴
				while(true) {
					if(count == 0) {
						//첫번째 검증인 경우 숫자를 붙이지X
						filepath = onlyFilename+extention;				//test.txt
					}else {
						filepath = onlyFilename+"_"+count+extention;	//test_1.txt
					}
					File checkFile = new File(savePath+filepath);
					if(!checkFile.exists()) {
						//checkFile이 존재하는지 물어보는 것 -> 중복이 아닐 때 break 
						break;
					}
					count++;
				}
				//파일명 중복체크 끝 -> 업로드할 파일명 확정 -> 파일업로드진행
				//2-2. 중복처리가 끝난 파일 업로드
				try {
					//파일업로드를 위한 주스트림생성
					FileOutputStream fos = new FileOutputStream(savePath+filepath);
					//성능향상을 위한 보조스트림 생성
					BufferedOutputStream bos = new BufferedOutputStream(fos);
					//파일업로드
					byte[] bytes = file.getBytes();
					bos.write(bytes);
					bos.close();
				} catch (FileNotFoundException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} */
				
				
				
				//파일업로드 끝(1개)
				//DB에 저장하기 위해 FileVO형태의 객체를 생성해서 fileList추가
				FileVO fileVO = new FileVO();
				fileVO.setFilename(filename);
				fileVO.setFilepath(filepath);
				fileList.add(fileVO);
			}//for문 끝
		}
		//비즈니스로직(board와 file_tbl에 insert진행)
		int result = service.insertBoard(b, fileList);
		if(result == (fileList.size()+1)) {
			//insert가 총 첨부파일+1개만큼 일어남 -> board인서트(1번) + 첨부파일인서트(여러번)
			//result를 누계했으므로 
			return "redirect:/boardList.do"; //컨트롤러를 거쳐가지않으면 리스트내용이 보이지않음
		}else {
			return "redirect:/";
		}
	}

- 주석 제외 Controller

	
	@RequestMapping(value="/boardWrite.do")
	public String boardWrite(Board b, MultipartFile[] boardFile, HttpServletRequest request) {
		ArrayList<FileVO> fileList = new ArrayList<FileVO>();
		if(boardFile[0].isEmpty()) {
		}else {
			String savePath = request.getSession().getServletContext().getRealPath("/resources/upload/board/");
			for(MultipartFile file : boardFile) {
				String filename = file.getOriginalFilename(); //사용자가 업로드한 이름
				String filepath = fileManager.upload(savePath, file);	
				FileVO fileVO = new FileVO();
				fileVO.setFilename(filename);
				fileVO.setFilepath(filepath);
				fileList.add(fileVO);
			}
		}
		int result = service.insertBoard(b, fileList);
		if(result == (fileList.size()+1)) {
			return "redirect:/boardList.do"; 
		}else {
			return "redirect:/";
		}
	}

Service + Dao는 변화없음

2. 게시글 전체 목록(BoardList)

Controller

	@RequestMapping(value="/boardList.do")
	public String boardList(Model model) {
		ArrayList<Board> list = service.selectBoardList();
		model.addAttribute("list", list);
		return "board/boardList";
	}

Service

	public ArrayList<Board> selectBoardList() {
		ArrayList<Board> list = dao.selectBoardList();
		return list;
	}

Dao

	public ArrayList<Board> selectBoardList() {
		String query = "select board_no, board_title, board_writer, board_date from board order by 1 desc";
		List list = jdbc.query(query, new BoardListRowMapper());
		return (ArrayList<Board>)list;
	}

List를 확인할때만 사용할 RowMapper - BoardListRowMapper.java( boardContent 가 없는걸 확인)

-> RowMapper는 필요한 만큼 생성하면 된다.

package kr.or.board.model.vo;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

public class BoardListRowMapper implements RowMapper{
	
	@Override
	public Object mapRow(ResultSet rset, int rowNum) throws SQLException {
		Board b = new Board();
		b.setBoardNo(rset.getInt("board_no"));
		b.setBoardTitle(rset.getString("board_title"));
		b.setBoardWriter(rset.getString("board_writer"));
		b.setBoardDate(rset.getString("board_date"));
		return b;
	}
}

화면구현 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>
	<h1>게시물 목록</h1>
	<hr>
	<c:if test="${not empty sessionScope.m}">
		<h3><a href="/boardWriteFrm.do">게시글 작성하기</a></h3>
	</c:if>
	<table border="1">
		<tr>
			<th>글번호</th>
			<th>제목</th>
			<th>작성자</th>
			<th>작성일</th>
		</tr>
		<c:forEach items="${list }" var="b">
			<tr>
				<td>${b.boardNo }</td>
				<td><a href="/boardView.do?boardNo=${b.boardNo}">${b.boardTitle }</a></td>
				<td>${b.boardWriter }</td>
				<td>${b.boardDate }</td>
			</tr>
		</c:forEach>
	</table>
	<a href="/">메인으로</a>
</body>
</html>

3. 게시글 상세보기(BoardView)

Controller

	@RequestMapping(value="/boardView.do")
	public String boardView(int boardNo, Model model) {
		Board b = service.selectOneBoard(boardNo);
		if(b != null) {
			model.addAttribute("b", b);
			return "board/boardView";			
		}else {
			return "redirect:/boardList.do";
		}
	}

Service

	public Board selectOneBoard(int boardNo) {
		//보드 조회
		Board b = dao.selectOneBoard(boardNo);
		//파일 조회
		if(b != null) {
			ArrayList<FileVO> fileList = dao.selectFileList(boardNo);
			b.setFileList(fileList);
		}
		return b;
	}

Dao 1 : Board 테이블 조회

	public Board selectOneBoard(int boardNo) {
		String query = "select * from board where board_no = ?";
		Object[] params = {boardNo};
		//이번엔 content가 있기 때문에 BoardListRowMapper는 사용할 수 없음(boardContent가 없음)
		List list = jdbc.query(query, params, new BoardRowMapper());
		if(list.isEmpty()) {
			return null;
		}else {
			return (Board)list.get(0);		
		}
	}

Dao 2 : File_tbl 테이블 조회

	public ArrayList<FileVO> selectFileList(int boardNo) {
		String query = "select * from file_tbl where board_no = ?";
		Object[] params = {boardNo};
		List list = jdbc.query(query, params, new FileRowMapper());
		return (ArrayList<FileVO>)list;
	}

파일도 전부 조회해서 Board VO에 있는 fileList에 set으로 넣어준다.

화면구현 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>
	<h1>게시물 상세보기</h1>
	<hr>
	<table border="1">
		<tr>
			<th>글번호</th>
			<td>${b.boardNo }</td>
			<th>제목</th>
			<td>${b.boardTitle }</td>
			<th>작성자</th>
			<td>${b.boardWriter }</td>
			<th>작성일</th>
			<td>${b.boardDate }</td>
		</tr>
		<tr>
			<th>첨부파일</th>
			<td colspan="7">
				<%--첨부파일은 여러개일 수 있으므로 for문을 돌림 --%>
				<c:forEach items="${b.fileList }" var="f">
					<a href="/boardFileDown.do?fileNo=${f.fileNo }">${f.filename }</a>
				</c:forEach>
			</td>
		</tr>
		<tr>
			<th>내용</th>
			<td colspan="7">${b.boardContent }</td>
		</tr>
	</table>
	<c:if test="${not empty sessionScope.m && sessionScope.m.memberId eq b.boardWriter }">
			<a href="/boardUpdateFrm.do?boardNo=${b.boardNo }">수정</a>
			<a href="/boardDelete.do?boardNo=${b.boardNo }">삭제</a>
	</c:if>
</body>
</html>

4. 파일다운로드

Controller

	@RequestMapping(value="/boardFileDown.do")
	public void boardFileDown(int fileNo, HttpServletRequest request, HttpServletResponse response) {
		//fileNo : DB에서 filename, filepath를 조회해오기위한 용도
		//request : 파일위치 찾을 때 사용
		//response : 파일다운로드 로직 구현 시 사용
		//리턴을 하지않음 - 페이지이동이 필요없으므로
		
		//filename과 filepath를 찾아오기위해서
		FileVO file = service.getFile(fileNo);
		
		//파일경로
		String root = request.getSession().getServletContext().getRealPath("/resources/upload/board/");
		String downFile = root+file.getFilepath();
		
		//파일을 읽어오기위한 주스트림생성(속도개선을위한 보조스트림생성)
		try {
			FileInputStream fis = new FileInputStream(downFile);
			BufferedInputStream bis = new BufferedInputStream(fis);
			//읽어온 파일을 사용자에게 내보낼 스트림생성
			ServletOutputStream sos = response.getOutputStream();
			BufferedOutputStream bos = new BufferedOutputStream(sos);
			
			//파일명 처리
			String resFilename = new String(file.getFilename().getBytes("UTF-8"), "ISO-8859-1");
			response.setContentType("application/octet-stream");//파일형식이란것을 알려줌
			response.setHeader("Content-Disposition", "attachment;filename="+resFilename);//파일이름을 알려줌
			//파일전송
			while(true) {
				int read = bis.read();
				//파일을 계속 읽다가 다읽으면 종료
				if(read != -1) {
					bos.write(read);
				}else {
					break;
				}
			}
			bos.close();
			bis.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

Service(파일path와 name을 찾기위한 로직)

	public FileVO getFile(int fileNo) {
		return dao.getFile(fileNo);
	}

Dao

	public FileVO getFile(int fileNo) {
		String query = "select * from file_tbl where file_no = ?";
		Object[] params = {fileNo};
		List list = jdbc.query(query, params, new FileRowMapper());
		return (FileVO)list.get(0);
	}

5. 게시글 삭제( deleteBoard )

Controller

	@RequestMapping(value="/boardDelete.do")
	public String boardDelete(int boardNo, HttpServletRequest request) {
		//int result = service.deleteBoard(boardNo);
		//원래는 int로 받는게 맞지만 file또한 지워야 하기 때문에 file목록을 가져올것
		//DB를 삭제하고, 서버에 업로드 되어있는 파일을 지우기 위해서 파일목록을 가져옴
		ArrayList<FileVO> list = service.deleteBoard(boardNo);
		//list가 null이면 실패, 아니면 성공
		if(list == null) {
			return "redirect:/boardView.do?boardNo="+boardNo;
		}else {
			//성공 시 실제 file을 삭제
			String savePath = request.getSession().getServletContext().getRealPath("/resources/upload/board/");
			for(FileVO file : list) {
				boolean deleteResult = fileManager.deleteFile(savePath, file.getFilepath());
				if(deleteResult) {
					System.out.println("파일삭제성공");
				}else {
					System.out.println("파일삭제실패");
				}
			}
			return "redirect:/boardList.do";
		}
	}

Service - 파일또한 삭제해줘야 하기 때문에 파일먼저 조회 후 게시글 삭제진행

	public ArrayList<FileVO> deleteBoard(int boardNo) {
		//삭제이후에 조회를 하면 on delete cascade 때문에 이미 지워진 상태이기 때문에 확인불가
		ArrayList<FileVO> fileList = dao.selectFileList(boardNo);
		int result = dao.deleteBoard(boardNo);
		if(result > 0) {
			return fileList;
		}else {
			return null;
		}
	}

Dao 1 : 파일목록 조회

	public ArrayList<FileVO> selectFileList(int boardNo) {
		String query = "select * from file_tbl where board_no = ?";
		Object[] params = {boardNo};
		List list = jdbc.query(query, params, new FileRowMapper());
		return (ArrayList<FileVO>)list;
	}

Dao 2 : 게시글 삭제

	public int deleteBoard(int boardNo) {
		String query = "delete from board where board_no = ?";
		Object[] params = {boardNo};
		int result = jdbc.update(query, params);
		return result;
	}

6. 게시글 수정(BoardUpdate)

- 기존 게시글 정보를 가지고 수정폼으로 이동

	@RequestMapping(value="/boardUpdateFrm.do")
	public String boardUpdateFrm(int boardNo, Model model) {
		Board b = service.selectOneBoard(boardNo);
		model.addAttribute("b", b);
		return "board/BoardUpdateFrm";
	}

수정폼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>
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
</head>
<body>
	<h1>게시글 수정</h1>
	<hr>
	<form action="/boardUpdate.do" method="post" enctype="multipart/form-data" id="updateFrm">
		<table border="1">
			<tr>
				<th>글번호</th>
				<td>
					<input type="hidden" name="boardNo" value="${b.boardNo }">
					${b.boardNo }
				</td> 
			</tr>
			<tr>
				<th>제목</th>
				<td>
					<input type="text" name="boardTitle" value="${b.boardTitle }">
				</td>
			</tr>
			<tr>
				<th>작성자</th>
				<td>${b.boardWriter }</td>
			</tr>
			<tr>
				<th>작성일</th>
				<td>${b.boardDate }</td>
			</tr>
			<tr>
				<th>첨부파일</th>
				<td>
					<c:forEach items="${b.fileList }" var="f">
						<p>
							${f.filename }
							<button type="button" onclick="deleteFile(this, ${f.fileNo}, '${f.filepath }');">삭제</button>
						</p>
					</c:forEach>
				</td>
			</tr>
			<tr>
				<th>첨부파일 추가</th>
				<td>
					<input type="file" name="boardFile" multiple>
				</td>
			</tr>
			<tr>
				<th>내용</th>
				<td>
					<textarea name="boardContent">${b.boardContent }</textarea>
				</td>
			</tr>
			<tr>
				<th colspan="2"><input type="submit" value="수정하기"></th>
			</tr>
		</table>	
	</form>
	<script>
		function deleteFile(obj, fileNo, filepath){
			//화면에서 파일을 안보여주게 하기위해 obj(this)를 가져옴 -> p태그를 지워줄것
			//file인풋을 만들어서 form에 넣어줄것 -> DB삭제를 위한 fileNo / 파일삭제를 위한 filepath
			//<input>
			const fileNoInput = $("<input>");
			//<input name="fileNo">
			fileNoInput.attr("name", "fileNo");
			//<input name="fileNo" value="글번호숫자">
			fileNoInput.val(fileNo);
			//<input name="fileNo" value="글번호숫자" style="display:none;">
			fileNoInput.hide();
			
			const filepathInput = $("<input>");
			filepathInput.attr("name", "filepath");
			filepathInput.val(filepath);
			filepathInput.hide();
			
			$("#updateFrm").append(fileNoInput).append(filepathInput);
			$(obj).parent().remove();
		}
	</script>
</body>
</html>

수정 Controller

	@RequestMapping(value="/boardUpdate.do")
	public String boardUpdate(Board b, int[] fileNo, String[] filepath, MultipartFile[] boardFile, HttpServletRequest request) {
		//fileVO file로 받으면 문제점 발생 -> 하나만 지우면 fileVO로 받으면 되지만 여러개이기 때문에 각각 배열을 받아야함 
		//b -> boardNo, boardTitle, boardContent
		//fileNo : 삭제할 파일번호(DB) / filepath : 삭제할 파일이름(물리적으로 파일폴더에서삭제) 
		//boardFile : 새로올릴 파일 / request : 새파일 경로잡기위함
		//file -> fileNo, filepath 
		//첨부파일이 추가로 들어왔으면 INSERT
		ArrayList<FileVO> fileList = new ArrayList<FileVO>();
		String savePath = request.getSession().getServletContext().getRealPath("/resources/upload/board/");
		if(!boardFile[0].isEmpty()) {
			for(MultipartFile file : boardFile ) {
				String filename = file.getOriginalFilename();
				String upFilepath = fileManager.upload(savePath, file);
				FileVO fileVO = new FileVO();
				fileVO.setFilename(filename);
				fileVO.setFilepath(upFilepath);
				fileList.add(fileVO);
				//파일업로드 작업 완료
			}
		}
		int result = service.boardUpdate(b, fileList, fileNo);
		//업데이트 성공 조건 : result == 삭제한 파일수 + 추가한파일수 + 1
		if(fileNo != null && (result == (fileList.size() + fileNo.length + 1))) {
			//삭제한 파일이 있는 상태에서 모든 로직을 성공 했을 때
			//실제파일 지우기
			for(String delFile : filepath) {
				boolean delResult = fileManager.deleteFile(savePath, delFile);
				if(delResult) {
					System.out.println("삭제성공");
				}else {
					System.out.println("삭제실패");
				}
			}
			return "redirect:/boardView.do?boardNo="+b.getBoardNo();
		}else if(fileNo == null && (result == fileList.size()+1)) {
			//삭제한 파일이 없는 상태에서 모든 로직을 성공 했을 때
			return "redirect:/boardView.do?boardNo="+b.getBoardNo();
		}else {
			//실패
			return "redirect:/boardList.do";
		}
	}

Service

	public int boardUpdate(Board b, ArrayList<FileVO> fileList, int[] fileNo) {
		//1. board테이블 수정
		int result = dao.updateBoard(b);
		if(result > 0) {
			//2. 기존 첨부파일 삭제
			//기존첨부파일을 삭제하지 않을 경우 -> 추가한 input이 없음 -> int[] fileNo 가 null
			if(fileNo != null) {
				//삭제할 첨부파일이 있는경우
				for(int no : fileNo) {
					result += dao.deleteFile(no);
				}
			}
			//3. 새로운 첨부파일이 있으면 추가
			for(FileVO f : fileList) {
				f.setBoardNo(b.getBoardNo());
				result += dao.insertFile(f);
			}
		}
		return result;
	}

Dao 1 : 게시글 업데이트

	public int updateBoard(Board b) {
		String query = "update board set board_title=?, board_content=? where board_no =?";
		Object[] params = {b.getBoardTitle(), b.getBoardContent(), b.getBoardNo()};
		int result = jdbc.update(query, params);
		return result;
	}

Dao 2 : 삭제할 파일이 있으면 파일 삭제

	public int deleteFile(int no) {
		String query = "delete from file_tbl where file_no = ?";
		Object[] params = {no};
		int result = jdbc.update(query, params);
		return result;
	}

Dao 3 : 새로추가된 파일이 있으면 INSERT(기존 파일INSERT 이용)

	public int insertFile(FileVO file) {
		String query = "insert into file_tbl values(file_seq.nextval, ?, ?, ?)";
		Object[] params = {file.getBoardNo(), file.getFilename(), file.getFilepath()};
		int result = jdbc.update(query, params);
		return result;
	}

76일차 : 정규화, SpringMVC - 게시판

_HYE_ — Thu, 16 Mar 2023 16:46:36 +0900

20230316

1. 테이블생성을 위한 정규화이론

/*
    1. 학생테이블이 존재
    2. 학생은 수업을 듣는다. -> 수업갯수는 학생마다 다름(어떻게 표현?)
       방법1)가장 원시적인 방법은 과목컬럼(SUBJECT1)을 과목마다 추가하는 것 
       -> 문제점 : 수업갯수가 학생마다 다르므로 몇개를 해야할지 모름
       방법2)과목을 모두 입력할 컬럼을 하나 추가
       -> 문제점 : 특정과목에 대한 조회/입력/수정/삭제 부분이 어려워짐
       방법3) 과목을 저장할 컬럼을 1개추가하고 ROW를 늘려준다
       REG_CLASS 컬럼에 독립적인 데이터 1개만 저장하는 경우 과목에 대한 추가,수정,삭제,조회가 수월해짐
       --> 제 1정규화 : 컬럼에 데이터를 독립적으로 1개씩 저장하는 형태
       -> 문제점 : 쓸데없이 중복된 데이터가 너무많다 / 수정 시 수정해야 하는 ROW가 너무많음
                  제1정규화가 끝나면 과목에 대한 처리는 쉬워지는 대신 중복데이터가 너무 많다
                  학생관련된 데이터의 수정/삭제 로직이 불편하다.
       -> 해결법 : 과목은 학생의 주정보가 아닌 서브정보 -> (방법4)과목관련 테이블을 만들어준다.
       방법4) 과목관련 테이블 생성 
       --> 제 2정규화 : 제 1정규화가 완련된 상태에서 메인주제와 관련이 없는 컬럼(REG_CLASS)을 테이블로 분리하는 것
       --> 관계형 데이터베이스는 제2정규화를 하지만, 비관계형 데이터베이스는 중복에대한 단점을 안고 제2정규화를 하지 않는 경우도 있음.
       -> 문제점 : 테이블의 특정컬럼을 업데이트 할 때 수정할 컬럼이 너무 많음(CLASS_NAME - CLASS_PRICE가 종속관계)
       -> 해결법 : CLASS_PRICE 를 새로운 테이블로 생성
       방법5) 과목테이블 / 금액테이블 추가
       --> 제 3정규화 : 제 2정규화가 완료된 상태에서 종속적인 컬럼을 테이블로 분리하는 것
*/
-- 방법1 : 과목수만큼 컬럼추가
CREATE TABLE STUDENT(
    STUDENT_ID      VARCHAR2(20),
    STUDENT_PW      VARCHAR2(20),
    STUDENT_NAME    VARCHAR2(20),
    STUDENT_PHONE   CHAR(13)
    
);

-- 방법2 : 과목전체를 작성할 컬럼 추가
CREATE TABLE STUDENT(
    STUDENT_ID      VARCHAR2(20),
    STUDENT_PW      VARCHAR2(20),
    STUDENT_NAME    VARCHAR2(20),
    STUDENT_PHONE   CHAR(13),
    REG_CLASS       VARCHAR2(1000) -- 자바, 오라클, HTML 을 전부 작성할 컬럼
);
INSERT INTO STUDENT VALUES('stu1', '1234', '학생1', '010-1234-4321', '자바, 오라클');
INSERT INTO STUDENT VALUES('stu2', '2345', '학생2', '010-4321-4321', '자바, 오라클, HTML');
SELECT * FROM STUDENT;
SELECT * FROM STUDENT WHERE REG_CLASS LIKE '%HTML%';
DROP TABLE STUDENT;

-- 방법3 : ROW수를 늘림(제 1정규화)
CREATE TABLE STUDENT(
    STUDENT_ID      VARCHAR2(20),
    STUDENT_PW      VARCHAR2(20),
    STUDENT_NAME    VARCHAR2(20),
    STUDENT_PHONE   CHAR(13),
    REG_CLASS       VARCHAR2(30)    -- 한 과목만 저장
);
-- 한과목만 저장하고 ROW를 늘림
INSERT INTO STUDENT VALUES('stu1', '1234', '학생1', '010-1234-4321', '자바');
INSERT INTO STUDENT VALUES('stu1', '1234', '학생1', '010-1234-4321', '오라클');
INSERT INTO STUDENT VALUES('stu2', '2345', '학생2', '010-4321-4321', '자바');
INSERT INTO STUDENT VALUES('stu2', '2345', '학생2', '010-4321-4321', '오라클');
INSERT INTO STUDENT VALUES('stu2', '2345', '학생2', '010-4321-4321', 'HTML');
SELECT * FROM STUDENT;

-- 방법4 : 과목테이블추가(제 2정규화)
CREATE TABLE STUDENT(
    STUDENT_ID      VARCHAR2(20),
    STUDENT_PW      VARCHAR2(20),
    STUDENT_NAME    VARCHAR2(20),
    STUDENT_PHONE   CHAR(13)
);
CREATE TABLE REG_CLASS(
    STUDENT_ID      VARCHAR2(20),
    CLASS_NAME      VARCHAR2(20),
    CLASS_PRICE     NUMBER
);
INSERT INTO STUDENT VALUES('stu1', '1234', '학생1', '010-1234-4321');
INSERT INTO STUDENT VALUES('stu2', '2345', '학생2', '010-4321-4321');

INSERT INTO REG_CLASS VALUES('stu1', '자바', 1000000);
INSERT INTO REG_CLASS VALUES('stu1', '오라클', 500000);
INSERT INTO REG_CLASS VALUES('stu2', '자바', 1000000);
INSERT INTO REG_CLASS VALUES('stu2', '오라클', 500000);
INSERT INTO REG_CLASS VALUES('stu2', 'HTML', 800000);

SELECT * FROM STUDENT;
SELECT * FROM REG_CLASS;
DROP TABLE REG_CLASS;

-- 방법5 : 과목테이블 / 금액(과목에 종속)테이블(제3정규화)
CREATE TABLE STUDENT(
    STUDENT_ID      VARCHAR2(20),
    STUDENT_PW      VARCHAR2(20),
    STUDENT_NAME    VARCHAR2(20),
    STUDENT_PHONE   CHAR(13)
);
CREATE TABLE REG_CLASS(
    STUDENT_ID      VARCHAR2(20),
    CLASS_NAME      VARCHAR2(20)
);
CREATE TABLE A_CLASS(
    CLASS_NAME      VARCHAR2(30),
    CLASS_PRICE     NUMBER
);
INSERT INTO A_CLASS VALUES('자바', 1000000);
INSERT INTO A_CLASS VALUES('오라클', 500000);
INSERT INTO A_CLASS VALUES('HTML', 800000);
SELECT * FROM A_CLASS;
INSERT INTO REG_CLASS VALUES('st1', '자바');
INSERT INTO REG_CLASS VALUES('st1', '오라클');
INSERT INTO REG_CLASS VALUES('st2', '자바');
INSERT INTO REG_CLASS VALUES('st2', '오라클');
INSERT INTO REG_CLASS VALUES('st2', 'HTML');

2. 게시판

- 파일 업로드가 되는 게시판

- 사전작업

BOARD 테이블과 시퀀스

CREATE TABLE BOARD(
    BOARD_NO        NUMBER          PRIMARY KEY,
    BOARD_TITLE     VARCHAR2(100)   NOT NULL,
    BOARD_WRITER    VARCHAR2(20)    REFERENCES MEMBER_TBL(MEMBER_ID) ON DELETE CASCADE,
    BOARD_CONTENT   VARCHAR2(1000)  NOT NULL,
    BOARD_DATE      CHAR(10)
);
CREATE SEQUENCE BOARD_SEQ;

FILE_TBL 테이블과 시퀀스

CREATE TABLE FILE_TBL(
    FILE_NO     NUMBER          PRIMARY KEY,
    BOARD_NO    NUMBER          REFERENCES BOARD ON DELETE CASCADE, -- BOARD테이블의 PK참조
    FILENAME    VARCHAR2(100)   NOT NULL,
    FILEPATH    VARCHAR2(100)   NOT NULL
);
CREATE SEQUENCE FILE_SEQ;

패키지/클래스 생성

패키지를 새로 생성했으므로 sevlet-context에 component-scan 추가(추가해야 @AutoWired 사용가능)

	<context:component-scan base-package="kr.or.board" />

파일 업로드를 위해 파일업로드용 객체 생성

	<!-- 파일업로드용 객체 -->
	<beans:bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<beans:property name="maxUploadSize" value="10485760" />
	</beans:bean>

파일업로드를 위해 라이브러리 추가 - commons-io / commons-fileupload

		<!-- 파일 업로드를 위해 필요한 라이브러리 추가 2개(commons-io, commons-fileupload -->
		<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
		<dependency>
		    <groupId>commons-fileupload</groupId>
		    <artifactId>commons-fileupload</artifactId>
		    <version>1.5</version>
		</dependency>		
		<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
		<dependency>
		    <groupId>commons-io</groupId>
		    <artifactId>commons-io</artifactId>
		    <version>2.11.0</version>
		</dependency>

1. 글작성하기

boardWriteFrm.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>
	<h1>게시글 작성</h1>
	<hr>
	<%-- 첨부파일일 때, method="post" / enctype="multipart/form-data" 반드시 입력 --%>
	<form action="/boardWrite.do" method="post" enctype="multipart/form-data">
		<fieldset>
			제목 : <input type="text" name="boardTitle"><br>
			첨부파일 : <input type="file" name="boardFile" multiple><br>
			<%--
				보통 name은 vo의 변수명과 동일하게 만들어주지만, 첨부파일은 반드시 vo와 다르게 넣어야한다 
				file타입이라 문자열로 들어가지 않기때문에 겹쳐서 에러발생 
				multiple : 파일을 여러개 받기 위해추가 / shift로 선택가능 / 하나선택하고 또 하나선택은X
				기존에는 cos.jar 라이브러리를 사용했지만 이번엔 다른 라이브러리를 추가할것
				-> 라이브러리추가는 항상 pom.xml에 추가
			--%>
			내용 : <textarea name="boardContent"></textarea>
			<input type="submit" value="작성하기">
			<input type="hidden" name="boardWriter" value="${sessionScope.m.memberId }">
		</fieldset>
	</form>
	<a href="/">메인으로</a>
</body>
</html>

Controller

	@RequestMapping(value="/boardWrite.do")
	//파일업로드를 진행하기위해 request를 불러옴
	public String boardWrite(Board b, MultipartFile[] boardFile, HttpServletRequest request) {
		//파일목록을 저장할 list생성
		ArrayList<FileVO> fileList = new ArrayList<FileVO>();
		//제목,내용,작성자는 매개변수 b에 모두 들어있음
		//파일이름은 b에 들어있지X 매개변수로 받음 -> 여러개를 받을거기때문에 자료형은 배열형태로
		//첨부파일은 input type="file"의 name으로 매개변수를 생성 -> 첨부파일 갯수만큼 배열길이 생성
		//첨부파일을 첨부하지 않아도 배열은 길이가 1
		//System.out.println(b);
		//System.out.println(boardFile.length);
		//첨부파일 존재유무를 구분하는 법 - 배열의 첫번째가 비어있는지 아닌지 확인
		//if(!boardFile[0].isEmpty()) {} if문은 이렇게 작성해주는게 좋다.
		if(boardFile[0].isEmpty()) {
			//첨부파일이 없는경우 진행할 로직이 없음
		}else {
			//첨부파일이 있는경우 파일업로드작업 수행
			//1. 파일업로드 경로 설정
			//getRealPath까지가 webapp
			String savePath = request.getSession().getServletContext().getRealPath("/resources/upload/board/");
			//2. 배열이므로 반복문을 이용해서 파일업로드 처리
			for(MultipartFile file : boardFile) {
				//파일명이 기존업로드한 파일명과 중복되면 기존파일을 삭제하고 새파일로 덮어쓰기됨 -> 파일명이 중복되지않게 처리해야 함
				//(cos라이브러리에서는 new DefaultFileRenamePolicy가 파일이름이 중복일 경우 새로운이름을 붙여줬음 name1 name2)
				String filename = file.getOriginalFilename(); //사용자가 업로드한 이름
				//이걸 그대로 업로드하면 파일명이 중복되엇을 때 문제가 발생
				//가정 : filename => test.txt인데 중복인 경우 => test_1.txt 확장자기준 앞을 바꿈
				//우선 text    .txt를 분리함
				String onlyFilename = filename.substring(0, filename.lastIndexOf("."));//test 0부터 뒤에서부터 .의 위치의 숫자를세서 그만큼까지
				String extention = filename.substring(filename.lastIndexOf(".")); //.txt 매개변수를 하나만주면 그 매개변수부터 끝까지라는 의미
				//실제 업로드할 파일명
				String filepath = null;
				//파일명 중복 시 뒤에 붙일 숫자
				int count = 0; //횟수가 정해져있지 않음 > while문을 무한으로 돌리고 중복이아닐때 빠져나옴
				while(true) {
					if(count == 0) {
						//첫번째 검증인 경우 숫자를 붙이지X
						filepath = onlyFilename+extention;				//test.txt
					}else {
						filepath = onlyFilename+"_"+count+extention;	//test_1.txt
					}
					File checkFile = new File(savePath+filepath);
					if(!checkFile.exists()) {
						//checkFile이 존재하는지 물어보는 것 -> 중복이 아닐 때 break 
						break;
					}
					count++;
				}
				//파일명 중복체크 끝 -> 업로드할 파일명 확정 -> 파일업로드진행
				//2-2. 중복처리가 끝난 파일 업로드
				try {
					//파일업로드를 위한 주스트림생성
					FileOutputStream fos = new FileOutputStream(savePath+filepath);
					//성능향상을 위한 보조스트림 생성
					BufferedOutputStream bos = new BufferedOutputStream(fos);
					//파일업로드
					byte[] bytes = file.getBytes();
					bos.write(bytes);
					bos.close();
				} catch (FileNotFoundException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				//파일업로드 끝(1개)
				//DB에 저장하기 위해 FileVO형태의 객체를 생성해서 fileList추가
				FileVO fileVO = new FileVO();
				fileVO.setFilename(filename);
				fileVO.setFilepath(filepath);
				fileList.add(fileVO);
			}//for문 끝
		}
		//비즈니스로직(board와 file_tbl에 insert진행)
		int result = service.insertBoard(b, fileList);
		if(result == (fileList.size()+1)) {
			//insert가 총 첨부파일+1개만큼 일어남 -> board인서트(1번) + 첨부파일인서트(여러번)
			//result를 누계했으므로 
			return "board/boardList";
		}else {
			return "redirect:/";
		}
	}

Service

	public int insertBoard(Board b, ArrayList<FileVO> fileList) {
		//board insert, file_tbl insert - board테이블에 먼저 insert를 해줘야한다
		int result = dao.insertBoard(b);
		if(result > 0) {
			//실패하면 file_tbl insert를 할 필요가 없음 - 트랜잭션관리는 나중에
			//여기서 b.getBoardNo()는 0 - 화면에서 번호를 준게 아니라 insert하면서 시퀀스로 주었기때문에
			//보드번호를 조회해와야한다.
			//file_tbl에 insert를 하기 위해서는 boardNo가 필요 -> 방금 insert한 boardNo를 조회 -> 가장 최근의 board_no
			int boardNo = dao.selectBoardNo(); //최근걸 조회할 것이므로 매개변수 필요없음!
			//insert는 list에 담긴 갯수만큼 해줘야하므로 for문 사용
			for(FileVO file : fileList) {
				file.setBoardNo(boardNo);
				//최종적으로 잘 끝났는지 확인하기위해 결과를 result에 누계
				result += dao.insertFile(file);
			}
		}
		return result;
	}

Dao

- BOARD 테이블에 INSERT

	public int insertBoard(Board b) {
		String query = "insert into board values(board_seq.nextval, ?, ?, ?, to_char(sysdate, 'yyyy-mm-dd'))";
		Object[] params = {b.getBoardTitle(), b.getBoardWriter(), b.getBoardContent()};
		int result = jdbc.update(query, params);
		return result;
	}

- BOARD 테이블의 BOARD_NO를 찾기위한 SELECT

	public int selectBoardNo() {
		String query ="select max(board_no) from board"; //max : board_no중에 가장큰걸 가져와라는 의미
		//만약에 조회결과가 1행 1열인 경우 rowMapper를 만들기 너무 귀찮음
		//List list = jdbc.query(query, rowMapper);
		//jdbc에서 제공하는 queryForObject 이용
		int boardNo = jdbc.queryForObject(query, int.class); //쿼리, 내가받을 자료형
		return boardNo;
	}

- FILE_TBL 테이블에 INSERT

	public int insertFile(FileVO file) {
		String query = "insert into file_tbl values(file_seq.nextval, ?, ?, ?)";
		Object[] params = {file.getBoardNo(), file.getFilename(), file.getFilepath()};
		int result = jdbc.update(query, params);
		return result;
	}

75일차 : SpringMVC - 회원, 공지사항

_HYE_ — Wed, 15 Mar 2023 21:40:02 +0900

20230315

1. Member : 전체회원조회 / 로그인 / 로그아웃 / 회원가입 / 마이페이지(정보수정) / 회원탈퇴

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>
	<h1>Spring MVC CRUD</h1>
	<hr>
	<c:choose>
		<c:when test="${not empty sessionScope.m }">
			<h3>[${sessionScope.m.memberName }]님 환영합니다.</h3>
			<h3><a href="/logout.do">로그아웃</a></h3>
			<form action="/searchMember.do" method="get">
				조회할 회원 아이디 입력 : 
				<input type="text" name="memberId">
				<input type="submit" value="조회">
			</form>
		<h3><a href="/allMember.do">전체회원조회</a></h3>
		<h3><a href="/mypage.do">마이페이지</a></h3>
		<h3><a href="/deleteMember.do?memberNo=${sessionScope.m.memberNo }">회원탈퇴</a></h3>
		<h3><a href="/noticeList.do">공지사항</a></h3>
		</c:when>
		<c:otherwise>
			<form action="/login.do" method="post">
				<fieldset>
					<legend>로그인</legend>
					아이디 : <input type="text" name="memberId"><br>
					비밀번호 : <input type="password" name="memberPw"><br>
					<input type="submit" value="로그인">
				</fieldset>
			</form>
			<h3><a href="/joinFrm.do">회원가입</a></h3>
		</c:otherwise>
	</c:choose>
</body>
</html>

Member

package kr.or.member.model.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Member {
	private int memberNo;
	private String memberId;
	private String memberPw;
	private String memberName;
	private String memberPhone;
	private String memberEmail;
}

MemberRowMapper

package kr.or.member.model.vo;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

//select를 하고 while 또는  if 에서 해주던 rset.getString 작업을 해줄 것
public class MemberRowMapper implements RowMapper{

	@Override
	public Object mapRow(ResultSet rset, int rowNum) throws SQLException {
		Member m = new Member();
		m.setMemberNo(rset.getInt("member_no"));
		m.setMemberId(rset.getString("member_id"));
		m.setMemberPw(rset.getString("member_pw"));
		m.setMemberName(rset.getString("member_name"));
		m.setMemberPhone(rset.getString("member_phone"));
		m.setMemberEmail(rset.getString("member_email"));
		return m;
	}
}

1 - 1 ) 회원가입

Controller : joinFrm으로 이동하기 위한 메소드(joinFrm.do)

	@RequestMapping(value="/joinFrm.do")
	public String joinFrm() {
		return "member/joinFrm";
	}

joinFrm.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>
	<form action="/join.do" method="post">
		<fieldset>
			<legend>회원가입</legend>
			아이디 : <input type="text" name="memberId"><br>
			비밀번호 : <input type="password" name="memberPw"><br>
			이름 : <input type="text" name="memberName"><br>
			전화번호 : <input type="text" name="memberPhone" placeholder="010-0000-0000"><br>
			이메일 : <input type="text" name="memberEmail"><br>
			<input type="submit" value="회원가입">
			<input type="reset" value="취소">
		</fieldset>
	</form>
</body>
</html>

Controller : insert를 진행하기위한 controller(join.do)

	@RequestMapping(value="/join.do")
	public String join(Member m) {
		//String memberId, String memberPw, String memberName, String memberPhone, String memberEmail
		//값추출할 name값과 매개변수명을 반드시 맞춰줘야한다.
		//lombok에서 기능을 지원해줘서 Member m 으로도 받을 수 있음
		//만약 jsp에서 넘겨주지 않은 값이 있으면 기본값을 받는다.(int면 0)
		int result = service.insertMember(m);
		if(result > 0) {
			//메인페이지로 보내주기
			//viewresolver를 거치지 않고 페이지를 이동하고 싶은 경우(다른 컨트롤러를 호출할경우)
			//(viewresolver는 WEB-INF/view/...jsp를 포함하므로)
			return "redirect:/"; //redirect: 를 사용하면 viewresolver를 거치지않음
		}else {
			return "member/joinFrm";			
		}
	}

Service

	public int insertMember(Member m) {
		int result = dao.insertMember(m);
		return result;
	}

Dao

	public int insertMember(Member m) {
		String query = "insert into member_tbl values(member_seq.nextval, ?, ?, ?, ?, ?)";
		Object[] params = {m.getMemberId(), m.getMemberPw(), m.getMemberName(), m.getMemberPhone(), m.getMemberEmail()};
		int result = jdbc.update(query, params);
		return result;
	}

1 - 2 ) 로그인

Controller

	@RequestMapping(value="/login.do")
	public String login(Member member, HttpSession session) {
		//매개변수 두개로 받아도 되고, Member로 받아도된다.(보내준 값만 값이 들어있고 나머지는 기본값(0, null)
		Member loginMember = service.selectOneMember(member);
		if(loginMember != null) {
			session.setAttribute("m", loginMember);
		}
		return "redirect:/";
	}

Service

	public Member selectOneMember(Member member) {
		/*
		Member loginMember = dao.selectOneMember(member);
		return loginMember;
		*/
		return dao.selectOneMember(member);
	}

Dao

	public Member selectOneMember(Member member) {
		String query = "select * from member_tbl where member_id = ? and member_pw = ?";
		Object[] params = {member.getMemberId(), member.getMemberPw()};
		List list = jdbc.query(query, params, new MemberRowMapper());
		if(list.isEmpty()) {
			return null;
		}else {
			Member loginMember = (Member)list.get(0);
			return loginMember;
		}		
	}

1 - 3 ) 로그아웃

Controller

	@RequestMapping(value="/logout.do")
	public String logout(HttpSession session) {
		session.invalidate();
		return "redirect:/";
	}

1 - 4 ) 회원탈퇴

Controller

	@RequestMapping(value="/deleteMember.do")
	public String deleteMember(int memberNo) {
		int result = service.deleteMember(memberNo);
		if(result > 0) {
			return "redirect:/logout.do";
		}else {
			return "redirect:/";
		}
	}

Service

	public int deleteMember(int memberNo) {
		return dao.deleteMember(memberNo);
	}

Dao

	public int deleteMember(int memberNo) {
		String query = "delete from member_tbl where member_no = ?";
		Object[] params = {memberNo};
		int result = jdbc.update(query, params);
		return result;
	}

1 - 5 ) 전체회원조회

Controller

	@RequestMapping(value="/allMember.do")
	public String allMember(Model model) {
		//매개변수가 없으므로 값추출할게 X 바로 비즈니스로직으로 가면된다.
		ArrayList<Member> list = service.selectAllMember();
		model.addAttribute("list", list);
		return "member/allMember";
	}

Service

	public ArrayList<Member> selectAllMember() {
		ArrayList<Member> list = dao.selectAllMember();
		return list;
	}

Dao

	public ArrayList<Member> selectAllMember() {
		String query = "select * from member_tbl";
		//위치홀더가 없기 때문에 Object[] params = {} 생략
		List list = jdbc.query(query, new MemberRowMapper());
		return (ArrayList<Member>)list;
	}

화면구현 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>
	<h1>전체회원조회</h1>
	<hr>
	<table border="1">
		<tr>
			<th>회원번호</th>
			<th>아이디</th>
			<th>비밀번호</th>
			<th>이름</th>
			<th>전화번호</th>
			<th>이메일</th>
		</tr>
		<c:forEach items="${list}" var="m">
			<tr>
				<td>${m.memberNo }</td>
				<td>${m.memberId }</td>
				<td>${m.memberPw }</td>
				<td>${m.memberName }</td>
				<td>${m.memberPhone }</td>
				<td>${m.memberEmail }</td>
			</tr>
		</c:forEach>
	</table>
</body>
</html>

1 - 6 ) 마이페이지+정보수정

Controller

- mypage이동 메소드

	@RequestMapping(value="/mypage.do")
	public String mypage(){
		return "member/mypage";
	}

- mypage 화면 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>
	<form action="/updateMember.do" method="post">
		<fieldset>
			<legend>마이페이지</legend>
			회원 번호 : <input type="text" name="memberNo" value="${sessionScope.m.memberNo }" readonly><br>
			아이디 : <input type="text" name="memberId" value="${sessionScope.m.memberId }" readonly><br>
			비밀번호 : <input type="text" name="memberPw" value="${sessionScope.m.memberPw }"><br>
			이름 : <input type="text" name="memberName" value="${sessionScope.m.memberName }" readonly><br>
			전화번호 : <input type="text" name="memberPhone" value="${sessionScope.m.memberPhone }"><br>
			이메일 : <input type="text" name="memberEmail" value="${sessionScope.m.memberEmail }"><br>
			<input type="submit" value="정보수정">
		</fieldset>
	</form>
	<a href="/">메인페이지로</a>
</body>
</html>

- 정보수정 Controller

	@RequestMapping(value="/updateMember.do")
	//Member m : 변경값을 적어준 변수
	//Member member : 세션에 저장되어 있는 값을 불러올 변수 
	//@SessionAttribute(required = false) Member member
	// : 세션에서 이름이 m인 객체를 꺼내서 Member타입으로 저장(자료형 맞아야함, 세션에 저장되어있는 정보가 Member)
	// : required = false 가 없는 경우, 이름이 m인 객체가 없으면 에러발생 
	public String upadateMember(Member member, @SessionAttribute(required = false) Member m) {
		int result = service.updateMember(member);
		if(result > 0) {
			//세션에 m이라는 이름으로 로그인 객체를 넣어둔걸 가져옴 
			//정석방법
			//Member member = (Member)session.getAttribute("m");
			m.setMemberPw(member.getMemberPw());
			m.setMemberPhone(member.getMemberPhone());
			m.setMemberEmail(member.getMemberEmail());
			
			return "member/mypage";
		}else {
			return "redirect:/";
		}
	}

Service

	public int updateMember(Member member) {
		return dao.updateMember(member);
	}

Dao

	public int updateMember(Member member) {
		String query = "update member_tbl set member_pw = ?, member_phone = ?, member_email = ? where member_no = ?";
		Object[] params = {member.getMemberPw(), member.getMemberPhone(), member.getMemberEmail(), member.getMemberNo()};
		int result = jdbc.update(query, params);
		return result;
	}

2. Notice : 공지사항리스트 / 공지사항 상세 / 공지사항작성 / 수정(작성자만) / 삭제 (작성자만)

- 사전작업 : Controller / Service / Dao / VO

@Controller
//spring한테 객체를 만들라고 지시(context-scan과 함께 이루어져야한다.)
public class NoticeController {
	
	@Autowired //이거없이 선언만 해놓으면 안에는 null이 들어있지만 AutoWired를 사용하면 null(X)
	private NoticeService service;
	
	public NoticeController() {
		super();
	}
}

@Service
public class NoticeService {
	@Autowired
	private NoticeDao dao;

	public NoticeService() {
		super();
	}
}

@Repository
public class NoticeDao {
	@Autowired
	private JdbcTemplate jdbc;

	public NoticeDao() {
		super();
		// TODO Auto-generated constructor stub
	}
}

package kr.or.notice.model.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Notice {
	private int noticeNo;
	private String noticeTitle;
	private String noticeWriter;
	private String noticeContent;
	private String noticeDate;
}

package kr.or.notice.model.vo;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

public class NoticeRowMapper implements RowMapper{
	@Override
	public Object mapRow(ResultSet rset, int rowNum) throws SQLException {
		Notice n = new Notice();
		n.setNoticeContent(rset.getString("notice_content"));
		n.setNoticeDate(rset.getString("notice_date"));
		n.setNoticeNo(rset.getInt("notice_no"));
		n.setNoticeTitle(rset.getString("notice_title"));
		n.setNoticeWriter(rset.getString("notice_writer"));
		return n;
	}
}

2 - 1 ) 공지사항 리스트

Controller

	@RequestMapping(value="/noticeList.do")
	public String noticeList(Model model) {
		ArrayList<Notice> list = service.selectAllNotice();
		model.addAttribute("list", list);
		return "notice/noticeList";
	}

Service

	public ArrayList<Notice> selectAllNotice() {
		return dao.selectAllNotice();
	}

Dao

	public ArrayList<Notice> selectAllNotice() {
		String query = "select * from notice";
		List list = jdbc.query(query, new NoticeRowMapper());
		return (ArrayList<Notice>)list;
	}

화면구현 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>
	<h1>공지사항</h1>
	<hr>
	<c:if test="${not empty sessionScope.m }">
		<a href="/noticeFrm.do">글작성</a>
	</c:if>
	<table border="1">
		<tr>
			<th style="width:10%">글번호</th>
			<th style="width:50%">제목</th>
			<th style="width:20%">작성자</th>
			<th style="width:20%">작성일</th>
		</tr>
		<c:forEach items="${list }" var="n">
			<tr onclick = "location.href='/noticeView.do?noticeNo=${n.noticeNo}'">
				<td>${n.noticeNo }</td>
				<td>${n.noticeTitle }</td>
				<td>${n.noticeWriter }</td>
				<td>${n.noticeDate }</td>
			</tr>
		</c:forEach>
	</table>
	<a href="/">메인으로</a>
</body>
</html>

2 - 2 ) 공지사항 상세보기

Controller

	@RequestMapping(value="/noticeView.do")
	public String noticeView(int noticeNo, Model model) {
		Notice n = service.selectOneNotice(noticeNo);
		if(n != null) {
			model.addAttribute("n", n);
			return "notice/noticeView";
		}else {
			return "notice/noticeList";
		}
	}

Service

	public Notice selectOneNotice(int noticeNo) {
		return dao.selectOneNotice(noticeNo);
	}

Dao

	public Notice selectOneNotice(int noticeNo) {
		String query = "select * from notice where notice_no = ?";
		Object[] params = {noticeNo};
		List list = jdbc.query(query, params, new NoticeRowMapper());
		Notice n = (Notice)list.get(0);
		return n;
	}

화면구현 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>
	<h1>공지사항 상세</h1>
	<hr>
	<table border="1">
		<tr>
			<th colspan="2">제목</th>
			<td colspan="2">${n.noticeTitle }</td>
		</tr>
		<tr>
			<th>작성자</th>
			<td>${n.noticeWriter }</td>
			<th>작성일</th>
			<td>${n.noticeDate }</td>
		</tr>
		<tr style="height:500px; padding: 20px;">
			<td colspan="4">${n.noticeContent }</td>
		</tr>
	</table>
	<c:if test="${not empty sessionScope.m && sessionScope.m.memberId.equals(n.noticeWriter)}">
		<a href="/updateNoticeFrm.do?noticeNo=${n.noticeNo }">수정</a>
		<a href="/deleteNotice.do?noticeNo=${n.noticeNo }">삭제</a>
	</c:if>
	<a href="/noticeList.do">목록으로</a>
</body>
</html>

2 - 3 ) 공지사항 작성

Controller - 작성폼으로 이동해주는 메소드

	@RequestMapping(value="/noticeFrm.do")
	public String noticeFrm(){
		return "notice/noticeFrm";
	}

공지사항 작성폼 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>
	<h1>공지사항 작성</h1>
	<hr>
	<form action="/insertNotice.do" method="post">
		<fieldset>
			<legend>공지사항작성</legend>
			<table border="1">
				<tr>	
					<th>제목</th>
					<td><input type="text" name="noticeTitle"></td>
				</tr>
				<tr>
					<th>작성자</th>
					<td><input type="text" name="noticeWriter" value="${sessionScope.m.memberId }" readonly></td>
				</tr>
				<tr>
					<th colspan="2">내용</th>
				</tr>
				<tr>
					<td colspan="2"><textarea name="noticeContent"></textarea></td>
				</tr>
			</table>
			<input type="submit" value="작성하기">
			<input type="reset" value="취소">
		</fieldset>
	</form>
	
</body>
</html>

Controller - 공지사항 Insert

	@RequestMapping(value="/insertNotice.do")
	public String insertNotice(Notice n) {
		int result = service.insertNotice(n);
		if(result > 0) {
			//list를 가려면 controller를 통해가야 값을 넣기때문에 redirect:/noticeList.do로 먼저가야한다
			return "redirect:/noticeList.do";
		}else {
			return "notice/noticeFrm";
		}
	}

Service

	public int insertNotice(Notice n) {
		return dao.insertNotice(n);
	}

Dao

	public int insertNotice(Notice n) {
		String query = "insert into notice values(notice_seq.nextval, ?, ?, ?, to_char(sysdate, 'yyyy-mm-dd'))";
		Object[] params = {n.getNoticeTitle(), n.getNoticeWriter(), n.getNoticeContent()};
		int result = jdbc.update(query, params);
		return result;
	}

2 - 4 ) 공지사항 수정

Controller - 수정입력폼으로 이동해줄 메소드

	@RequestMapping(value="/updateNoticeFrm.do")
	public String updateNoticeFrm(int noticeNo, Model model) {
		Notice n = service.selectOneNotice(noticeNo);
		if(n != null) {
			model.addAttribute("n", n);
			return "notice/updateNoticeFrm";			
		}else {
			return "redirect:/";
		}
	}

수정입력폼 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>
	<h1>공지사항 수정</h1>
	<hr>
	<form action="/updateNotice.do" method="post">
		<fieldset>
			<legend>공지사항수정</legend>
			<table border="1">
				<tr><td><input type="hidden" name="noticeNo" value="${n.noticeNo }"></td></tr>
				<tr>	
					<th>제목</th>
					<td><input type="text" name="noticeTitle" value="${n.noticeTitle }"></td>
				</tr>
				<tr>
					<th>작성자</th>
					<td><input type="text" name="noticeWriter" value="${n.noticeWriter}" readonly></td>
				</tr>
				<tr>
					<th colspan="2">내용</th>
				</tr>
				<tr>
					<td colspan="2"><textarea name="noticeContent">${n.noticeContent }</textarea></td>
				</tr>
			</table>
			<input type="submit" value="작성하기">
			<input type="reset" value="취소">
		</fieldset>
	</form>
</body>
</html>

Controller - update를 진행할 메소드

	@RequestMapping(value="/updateNotice.do")
	public String updateNotice(Notice n) {
		int result = service.updateNotice(n);
		if(result > 0) {
			return "redirect:/noticeView.do?noticeNo="+n.getNoticeNo();
		}else {
			return "redirect:/updateNoticeFrm.do";
		}
	}

Service

	public int updateNotice(Notice n) {
		return dao.updateNotice(n);
	}

Dao

	public int updateNotice(Notice n) {
		String query = "update notice set notice_title = ?, notice_content = ? where notice_no = ?";
		Object[] params = {n.getNoticeTitle(), n.getNoticeContent(), n.getNoticeNo()};
		int result = jdbc.update(query, params);
		return result;
	}

2 - 5 ) 공지사항 삭제

Controller

	@RequestMapping(value="/deleteNotice.do")
	public String deleteNotice(int noticeNo) {
		int result = service.deleteNotice(noticeNo);
		if(result > 0) {
			return "redirect:/noticeList.do";
		}else {
			return "redirect:/noticeView.do?noticeNo="+noticeNo;
		}
	}

Service

	public int deleteNotice(int noticeNo) {
		return dao.deleteNotice(noticeNo);
	}

Dao

	public int deleteNotice(int noticeNo) {
		String query = "delete from notice where notice_no = ?";
		Object[] params = {noticeNo};
		int result = jdbc.update(query, params);
		return result;
	}

74일차 : loC, DI, springMVC

_HYE_ — Tue, 14 Mar 2023 11:55:50 +0900

1. loC / DI

loC : Inversion of Control 제어의 역행
프로그램을 구동하는데 필요한 객체 생성에 대한 생성/변경등을 프로그램을 구동하는 컨테이너에서 직접관리
역할 - 객체의 생명주기와 의존성 관리

DI : 의존성 주입 / 컨테이너가 빈의 설정정보를 읽어와 자동으로 해당 객체를 연결
장점 - 개발자가 작성해야할 코드가 단순해짐

MemberService service = new MemberService();

@Autowired
MemberService service;
스프링에서 객체를 자동적으로 저장해주게 만듬(의존성 주입)
필요한건 한번씩만 파일로 만들어두고 서버시작때마다 사용하기때문에 개발자가 작성할 코드가 적어짐

B class를 수정할 때 A class에 연쇄적으로 수정해야하는게 많은 경우를 결합도가 강하다고 표현
(코드를 칠때는 결합도가 약할수록 좋다 - 수정사항이 적어지니까)
결합도를 낮출 때 스프링이 좋다.

WEB-INF 아래 web.xml 파일을 보면 서블릿의 생성유무에 따라 코드가 다르다
서블릿을 생성하면 서블릿에 대한 정보가 들어가는 것

spring mvc : 일반 mvc보다 구조는 복잡하지만 개발자가 작성하는 코드는 적다(나머지는 spring에서 제공하는기능을 사용)
모든 클라이언트의 요청을 Dispatcher Servlet으로 받음

index.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>
	<h1>Hello Spring</h1>
	<hr>
	<h3>결합도와 응집도</h3>
	<form action="/test1.do" method="get">
		<input type="radio" name="brand" value="samsung" id="samsung">
		<label for="samsung">SAMSUNG</label>
		<input type="radio" name="brand" value="lg" id="lg">
		<label for="lg">LG</label>
		<input type="submit" value="제출">
	</form>
	<h3><a href="/test2.do">DI 테스트</a></h3>
</body>
</html>

- Controller

test1Servlet.java

package kr.or.iei.controller;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import kr.or.iei.vo.BeanFactory;
import kr.or.iei.vo.LgTV;
import kr.or.iei.vo.TV;

/**
 * Servlet implementation class Test1Servlet
 * 이클립스에서 서블릿을 사용할 때는 
 * @WebServlet(name = "Abcd", urlPatterns = { "/abcd.do" })
 * 라고 정의가 되어있지만 Spring에는 정의가 없는대신 web.xml에 서블릿정보가 기재되어있음.  
 * 서블릿을 잘못만들어서 삭제해야하는 경우 web.xml에서 해당 서블릿 관련정보도 지워줘야한다
 */
public class Test1Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public Test1Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		
		/*
		SamsungTV tv = new SamsungTV();
		tv.powerOn();
		tv.powerOff();
		tv.volumUp();
		tv.volumDown();
		
		LgTV tv = new LgTV();
		tv.on();
		tv.off();
		tv.soundUp();
		tv.soundDown();
		//거의 동일한 코드를 다시 작성해줘야하기 때문에 번거로움 - 이럴 때 사용하는게 인터페이스
		*/
		//SamsungTV tv = new SamsungTV();
		//현재는 객체를 생성하는 코드만 변경해주면 된다 - 결합도를 낮추는 작업
		//LgTV tv = new LgTV();
		//부모객체를 사용해서 SamsungTV만 변경해주면된다.(다형성이용)
		//LgTV()라는 객체도 사용하고 싶지 않을 때 -> 사용자가 선택한걸 가져오고 싶을 때
		//TV tv = new LgTV();
		
		String brand = request.getParameter("brand");
		System.out.println(brand);
		BeanFactory factory = new BeanFactory();
		TV tv = factory.getBean(brand);
		tv.powerOn();
		tv.powerOff();
		tv.volumeUp();
		tv.volumeDown();
		
		response.sendRedirect("/");
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}
}

test2Servlet.java

package kr.or.iei.controller;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

import kr.or.iei.vo.Member;
import kr.or.iei.vo.MemberMgr;

/**
 * Servlet implementation class Test2Servlet
 */
public class Test2Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public Test2Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//spring 설정파일을 읽어오는 객체 생성
		AbstractApplicationContext cntx = new GenericXmlApplicationContext("memberContext.xml");
		//여러개의 bean중에 필요한 bean의 id를 가져옴 - 항상 Object로 리턴하기 때문에 형변환이 필요
		Member member1 = (Member)cntx.getBean("member1");
		
		System.out.println(member1.getName());
		System.out.println(member1.getAge());
		System.out.println(member1.getAddr());
		
		
		MemberMgr mm = (MemberMgr)cntx.getBean("mm");
		Member member3 = mm.getMember();
		System.out.println(member3.getName());
		System.out.println(member3.getAge());
		System.out.println(member3.getAddr());
		
		Member member2 = (Member)cntx.getBean("member2");
		System.out.println(member2.getName());
		System.out.println(member2.getAge()); //20
		System.out.println(member2.getAddr());
		member2.setAge(1000);
		System.out.println(member2.getAge()); //1000
		Member member22 = (Member)cntx.getBean("member2");
		// 위코드 실행마다 새로운 객체가 생성된다 - 20
		// 이미 만들어진 객체를 이용하는것이다 - 1000
		// 옵션을 줄 수 있음(옵션이 없으면 아래가 기본값) scope="prototype"을 하면 계속 새로운 객체를 만듬
		System.out.println(member22.getAge()); 
		
		
		response.sendRedirect("/");
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

- VO

TV ( Inteface)

package kr.or.iei.vo;

public interface TV {
	public void powerOn();
	public void powerOff();
	public void volumeUp();
	public void volumeDown();
}

- lombok이 해주는 일

package kr.or.iei.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//lombok이 해주는 일 - getter/setter/생성자를 작성하지 않아도 다 만들어준다.
@Data // getter/setter
@NoArgsConstructor // 매개변수 없는 생성자
@AllArgsConstructor //모든 매개변수가 있는 생성자
//변수추가삭제의 경우 전부 수정해줘야하는데 lombok을 사용하면 모두 자동으로 생성된다.
//단, 매개변수가 일부만 있는 경우에는 직접 만들어줘야한다.
public class Member {
	private String name;
	private int age;
	private String addr;	
}

- test

package kr.or.test;

import org.springframework.stereotype.Component;

//Component : 서버가 시작될 때 객체를 만들지말지 결정

@Component 
//component를 붙여도 s(스프링에서 클래스를만들었다는 뜻)가 생기지 않음
//WEB-INF/spring/appServlet/servlet-context.xml 에 해당 패키지 <context:component-scan base-package="패키지" /> 를 작성해주어야함.
//Component와 Scan이 항상 함께 이루어져야한다.
public class TestClass2 {
	public TestClass2() {
		super();
		System.out.println("TestClass2 생성완료!");
	}
}

2. SpringMVC (DB연결 X)

index.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>
	<h1>Spring MVC</h1>
	<hr>
	<form action="/login.do" method="post">
		아이디 : <input type="text" name="memberId"><br>
		비밀번호 : <input type="password" name="memberPw"><br>
		<input type="submit" value="로그인">
	</form>
	<hr>
	<form action="/search.do" method="get">
		조회 할 아이디 : <input type="text" name="memberId">
		<input type="submit" value="조회">
	</form>
</body>
</html>

- controller

DispatcherServlet

package kr.or.iei.controller;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class DispatcherServlet
 */
public class DispatcherServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public DispatcherServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//(1) 최초요청받기
		request.setCharacterEncoding("utf-8");
		//사용자가 요청한 컨트롤러 주소 확인
		String uri = request.getRequestURI();
		System.out.println("사용자 요청 URI : "+uri);
		HandlerMapping map = new HandlerMapping();
		//(2)
		Controller controller = map.getController(uri);
		//(3), (5)
		String result = controller.request(request);
		ViewResolver resolver = new ViewResolver();
		//(6)
		String view = resolver.getView(result);
		//(7)
		response.sendRedirect(view);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

HandlerMapping

package kr.or.iei.controller;

import java.util.HashMap;

public class HandlerMapping {
	private HashMap<String, Controller> mappings;

	public HandlerMapping() {
		super();
		mappings = new HashMap<String, Controller>();
		mappings.put("/login.do", new LoginController());
		mappings.put("/search.do", new SearchMember());
	}
	
	public Controller getController(String uri) {
		return mappings.get(uri);
	}
}

LoginController

package kr.or.iei.controller;

import javax.servlet.http.HttpServletRequest;

public class LoginController implements Controller{

	@Override
	public String request(HttpServletRequest request) {
		//2.값추출
		String memberId = request.getParameter("memberId");
		String memberPw = request.getParameter("memberPw");
		//3. 비즈니스로직
		//-> memberId : user01 이고, memberPw : 1234면 로그인 성공 아니면 실패
		if(memberId.equals("user01") && memberPw.equals("1234")) {
			return "loginSuccess";
		}else {
			return "loginFail";
		}
	}
}

SearchMember

package kr.or.iei.controller;

import javax.servlet.http.HttpServletRequest;

public class SearchMember implements Controller{

	@Override
	public String request(HttpServletRequest request) {
		//2. 값추출
		String memberId = request.getParameter("memberId");
		//3. 비즈니스로직
		//memberId가 user01이면 조회성공 아니면 실패
		if(memberId.equals("user01")) {
			return "searchSuccess";
		}else {
			return "searchFail";			
		}
	}

}

ViewResolver

package kr.or.iei.controller;

public class ViewResolver {
	public String getView(String result) {
		return "/view/"+result+".jsp";
	}
}

3. SpringMVC 2(DB연결 O)

[ 프로젝트 생성 시 해줘야하는 Setting]

0. Spring Lagacy Project 생성

1. 프로젝트우클릭 - propertice - project Facets - java version 1.8 / Runtimes - apach-tomcat 8.5 선택

2. 서버 add and remove 후 더블클릭해서 modules의 path 를 /로변경 -> 서버에 프로젝트 add시마다 해줘야한다.

3. pom.xml의 overview 설정변경

4. jstl 라이브러리추가(경로 : webapp/WEB-INF/lib)

[ 사전 Setting ]

- pom.xml (mavenrepository에서 검색 후 추가)

: Spring JDBC 사용을 위한 라이브러리 추가 [ Spring-jdbc / commons-dbcp ]

Spring jdbc / 첫번째 클릭 / 5.0.6ver

commons-dbcp / 두번째 클릭 / 최신ver

: Oracle 연동을 위한 ojdbc 추가

ojdbc6 검색 / 버전 1개 / 복사

: lombok 추가

lombok / 첫번째 클릭 / 1.18.12복사

		<!-- Spring JDBC 사용을 위한 라이브러리 추가 2개(spring-jdbc, commons-dbcp) -->
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-jdbc</artifactId>
		    <version>5.0.6.RELEASE</version>
		</dependency>		
		<!-- https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp -->
		<dependency>
		    <groupId>commons-dbcp</groupId>
		    <artifactId>commons-dbcp</artifactId>
		    <version>1.4</version>
		</dependency>		
		<!-- ORACLE 연동을 위한 ojdbc -->
		<!-- https://mvnrepository.com/artifact/com.oracle.database.jdbc/ojdbc6 -->
		<dependency>
		    <groupId>com.oracle.database.jdbc</groupId>
		    <artifactId>ojdbc6</artifactId>
		    <version>11.2.0.4</version>
		</dependency>
			
		<!-- lombok -->
		<dependency>
		    <groupId>org.projectlombok</groupId>
		    <artifactId>lombok</artifactId>
		    <version>1.18.12</version>
		    <scope>provided</scope>
		</dependency>

- web.xml

: 인코딩 추가

	<!-- 인코딩 필터 설정 -->
	<filter>
		<filter-name>EncodingFilter</filter-name>	
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>utf-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>EncodingFilter</filter-name>
		<url-pattern>*.do</url-pattern>
	</filter-mapping>

: 마지막 url-pattern *.do로 변경

	<servlet-mapping>
		<servlet-name>appServlet</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>

- WEB-INF/spring/appServlet/servlet-context.xml

: DB접속정보 + JDBCTemplet 추가

	<!-- DB 접속정보를 저장하는 객체 생성 -->
	<beans:bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<beans:property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
		<beans:property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:xe" />
		<beans:property name="username" value="spring" />
		<beans:property name="password" value="spring" />
	</beans:bean>
	<!-- JDBCTemplet -->
	<beans:bean id="jdbcTemplet" class="org.springframework.jdbc.core.JdbcTemplate">
		<beans:property name="dataSource" ref="dataSource"></beans:property>
	</beans:bean>

: 하단에 패키지 추가(패키지가 추가될때마다 해야하는 작업)

	<context:component-scan base-package="kr.or.iei" />
	<context:component-scan base-package="kr.or.member" />

- Controller / Service / Dao 사전작업

@Controller
public class MemberController {
	//선언만 해놓으면 안에는 null이 들어있지만 AutoWired를 사용하면 null(X)
	@Autowired
	private MemberService service;
	
	public MemberController() {
		super();
		System.out.println("MemberController 생성");
	}
}

@Service
public class MemberService {
	@Autowired
	private MemberDao dao;
	
	public MemberService() {
		super();
		System.out.println("MemberService 생성");
	}
}

@Repository
public class MemberDao {

	@Autowired
	private JdbcTemplate jdbc;
	
	public MemberDao() {
		super();
		System.out.println("MemberDao 생성");
	}
}

3 - 1 ) 아이디 조회하기

index.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>
	<h1>Spring MVC CRUD</h1>
	<hr>
	<form action="/searchMember.do" method="get">
		조회할 아이디 입력 : <input type="text" name="memberId">
		<input type="submit" value="조회">
	</form>
</body>
</html>

Controller

	@RequestMapping(value="/searchMember.do")
	public String searchMember(String memberId, Model model) {
		//searchMember.do를 처리할 컨트롤러임을 알려줘야함 : 메소드 위에 기재
		//이제 서블릿은 Spring이 만들기 때문에 메소드만 생성해줌
		//값추출은 매개변수로 받음 - name값이랑 변수명이 동일해야한다.
		//3. 비즈니스로직
		Member member = service.selectOneMember(memberId);
		//4. 결과처리
		if(member == null) {
			return "member/searchFail";
		}else {
			//request.setAttribute와 같은 역할을 해줌
			model.addAttribute("member", member);
			return "member/searchMember";
		}
	}

Service

	public Member selectOneMember(String memberId) {
		//트랜잭션 관리는 우선 자동으로
		Member member = dao.selectOneMember(memberId);
		return member;
	}

Dao

	public Member selectOneMember(String memberId) {
		//1. preparedStatement 방식으로 query 작성
		String query = "select * from member_tbl where member_id = ?";
		//2. 위치홀더가 한개라도 있는 경우(만약, 위치홀더가 0개인 경우 2번과정 생략)
		//위치홀더의 순서에 맞춰서 Object 배열에 추가
		Object[] params = {memberId};
		//3. 쿼리문 실행(select 인 경우 객체생성 - query()메소드 사용)
		//query 매개변수 3개(쿼리문, 위치홀더에 들어갈 값 배열, 결과를 처리할 객체)
		List list = jdbc.query(query, params, new MemberRowMapper());
		//조회결과는 1개이건, 여러개건 무조건 List로 반환
		if(list.isEmpty()) {
			return null;			
		}else {
			Member m = (Member)list.get(0);
			return m;
		}
	}

73일차 : Action Tag, EL, JSTL, Filter

_HYE_ — Tue, 14 Mar 2023 11:54:29 +0900

20230313

1. Action Tag

: JSP 문법을 확장하는 메커니즘을 제공하는 태그
<jsp:include> : 페이지에 특정페이지를 포함할 때(예를들어 페이지에 헤더푸터)
<jsp:forward> : 현재 페이지 접근 시 특정 페이지로 이동 시킬 때
( URL이 변경되지 않아 파라미터를 보낼 때 편함)

	<!-- 기존방식 : 지시자 태그를 이용 -->
	<%-- <%@include file="/WEB-INF/views/common/header.jsp" %> --%>
	<%-- <jsp:include page="/WEB-INF/views/common/header.jsp"></jsp:include> --%> 
	<jsp:include page="/WEB-INF/views/common/header.jsp" />
	<!-- 위 두개 모두 같은 문법 끝이라는 의미로 /를 해주면 /jsp:include와 같은의미를 갖는다. -->
	<h1>index</h1>
	<h3><a href="/test1.do">필터테스트</a></h3>
	
	<h3><a href="/jspForward.do?name=test">jsp:forward</a></h3>

package kr.or.iei.controller;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class test1Servlet
 */
@WebServlet(name = "test1", urlPatterns = { "/test1.do" })
public class test1Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public test1Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("서블릿 시작지점");
		//1. 인코딩
		//2. 값추출
		//3. 비즈니스로직
		//4. 결과처리
		System.out.println("서블릿 끝지점");
		response.sendRedirect("/");
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

package kr.or.iei.controller;

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class JspForwardServlet
 */
@WebServlet(name = "JspForward", urlPatterns = { "/jspForward.do" })
public class JspForwardServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public JspForwardServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1. 인코딩
		request.setCharacterEncoding("utf-8");
		//2. 값추출
		String name = request.getParameter("name");
		//3. 비즈니스로직
		//4. 결과처리
		RequestDispatcher view = request.getRequestDispatcher("/WEB-INF/views/action/forward.jsp");
		request.setAttribute("name", name);
		view.forward(request, response);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <%
    	String name = (String)request.getAttribute("name");
    %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<%if(name != null) {%>
	<!-- 
	<script>
		location.href="/forward2.do" 
	</script>
	이 방법으로 서블릿을 하나 더 생성해서 이동하는 방법도 있지만 위방식의 경우 name파라미터를 또 보내줘야함
	태그가 나왔다가 자바코드가 나왔다가 하는 것을 태그만 사용해서 이용하는 것
	 -->
	<jsp:forward page="/WEB-INF/views/action/forward2.jsp" />
	<!-- include처럼 추가한게 아닌 이동한 것이므로 아래 forward name은나오지않고 forward2로 페이지이동 -->
	<%} %>
	<h1>forward</h1>
	<h2><%= name %></h2>
	<!-- web-inf에 있는 jsp는 반드시 서블릿을 통해 이동해야함 : 이과정을 생략해주는게 action:forward -->
	<!-- action태그를 이용하면 바로 이동이 가능하다. -->
</body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <!-- 주소창은 Servlet주소가 여전히 유지(jspFoward.do?name=test) 
    forward방식으로 이동하면 forward2에서도 name=test라는 파라미터를 이용 가능 -->
    <%
    	String name = (String)request.getAttribute("name");
    %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<h1>forward2</h1>
	<h3><%=name %></h3>
</body>
</html>

2. EL

: <%=%>, out.print()를 좀더 간결하게 사용하는 방법 ${value}의 형식으로 표현

	<h2>EL(Expression Language)</h2>
	<h3><a href="/eLTest1.do">1. EL test1(기본문법)</a></h3>
	<h3><a href="/eLTest2.do">2. EL test2(VO)</a></h3>
	<h3><a href="/eLTest3.do">3. EL test3(list, array)</a></h3>
	<h3><a href="/eLTest4.do">4. EL test4(연산)</a></h3>
	<h3><a href="/eLTest5.do">5. EL test5(내장객체)</a></h3>

2 - 1 ) 기본문법

Servlet

package kr.or.iei.controller;

import java.io.IOException;

import javax.security.auth.message.callback.PrivateKeyCallback.Request;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class ELTest1Servlet
 */
@WebServlet(name = "ELTest1", urlPatterns = { "/eLTest1.do" })
public class ELTest1Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public ELTest1Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1. 인코딩
		request.setCharacterEncoding("utf-8");
		//2. 값추출
		//3. 비즈니스로직
		//4. 결과처리
		RequestDispatcher view = request.getRequestDispatcher("/WEB-INF/views/el/elTest1.jsp");
		request.setAttribute("name", "유저1");
		request.setAttribute("age", 20);
		request.setAttribute("addr", "서울시 영등포구");
		view.forward(request, response);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

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>
	<h2>이름 : ${name}</h2>
	<h2>나이 : ${age}</h2>
	<h2>주소 : ${addr}</h2>
	<h2>전화번호 : ${phone}</h2>
	<!-- 기존문법과 달리 phone이 null이 아니고 공백으로 나온다 -->
	<!-- 위에 변수를 선언하지 않아도 사용이 가능하다. -->
</body>
</html>

2 - 2 ) VO

Servlet

package kr.or.iei.controller;

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class ELTest2Servlet
 */
@WebServlet(name = "ELTest2", urlPatterns = { "/eLTest2.do" })
public class ELTest2Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public ELTest2Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1. 인코딩
		request.setCharacterEncoding("utf-8");
		//2. 값추출
		//3. 비즈니스로직
		Member m = new Member("유저2", 30, "서울시 강남구");
		//4. 결과처리
		RequestDispatcher view = request.getRequestDispatcher("/WEB-INF/views/el/elTest2.jsp");
		request.setAttribute("m", m);
		view.forward(request, response);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

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>
	<h3>이름 : ${m.name }</h3> 
	<!-- 적는건 name으로 적지만 getName()을 알아서 호출하고 있는 것 -->
	<h3>나이 : ${m.age }</h3>
	<h3>주소 : ${m.addr }</h3>
	<h3>${m.test }</h3> 
	<!-- Member에 test라는게 없으므로 에러발생 -->
	<!-- 단, Member에 getTest메소드만 만들어도 사용가능 : 변수를 가져오는게 아닌 getter를 가져오는 것 -->
</body>
</html>

2 - 3 ) List, Array

Servlet

package kr.or.iei.controller;

import java.io.IOException;
import java.util.ArrayList;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class ELTest3Servlet
 */
@WebServlet(name = "ELTest3", urlPatterns = { "/eLTest3.do" })
public class ELTest3Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public ELTest3Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1. 인코딩
		request.setCharacterEncoding("utf-8");
		//2. 값추출
		//3. 비즈니스로직
		int[] numArr = {100,200,300};
		ArrayList<Integer> numList = new ArrayList<Integer>();
		numList.add(10);
		numList.add(20);
		numList.add(30);
		
		ArrayList<Member> memberList = new ArrayList<Member>();
		Member m1 = new Member("유저1", 30, "서울");
		Member m2 = new Member("유저2", 40, "인천");
		memberList.add(m1);
		memberList.add(m2);
		//4. 결과처리
		RequestDispatcher view = request.getRequestDispatcher("/WEB-INF/views/el/elTest3.jsp");
		request.setAttribute("numArr", numArr);
		request.setAttribute("numList", numList);
		request.setAttribute("memberList", memberList);
		view.forward(request, response);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

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>
	<h2>배열 사용 방법</h2>
	<p>${numArr[0] }</p>
	<p>${numArr[1] }</p>
	<p>${numArr[2] }</p>
	<h2>리스트 사용 방법 1</h2>
	<p>${numList[0] }</p>
	<p>${numList[1] }</p>
	<p>${numList[2] }</p>
	<h2>리스트 사용 방법 2</h2>
	<p>${memberList[0].name }</p>
	<p>${memberList[0].age }</p>
	<p>${memberList[0].addr }</p>
	<p>${memberList[1].name }</p>
	<p>${memberList[1].age }</p>
	<p>${memberList[1].addr }</p>
</body>
</html>

2 - 4 ) 연산

Servlet

package kr.or.iei.controller;

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class ELTest4Servlet
 */
@WebServlet(name = "ELTest4", urlPatterns = { "/eLTest4.do" })
public class ELTest4Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public ELTest4Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1. 인코딩
		request.setCharacterEncoding("utf-8");
		//2. 값추출
		//3. 비즈니스로직
		//4. 결과처리
		RequestDispatcher view = request.getRequestDispatcher("/WEB-INF/views/el/elTest4.jsp");
		request.setAttribute("num1", 10);
		request.setAttribute("num2", 20);
		request.setAttribute("str", "abc");
		view.forward(request, response);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

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>
	<h1>EL 연산</h1>
	<ul>
		<li>${num1 }</li>
		<li>${num2 }</li>
		<li>${str }</li>
		<li>${str1 }</li>
	</ul>
	<hr>
	<table border="1">
		<tr>
			<th>표현식</th>
			<th>결과</th>
		</tr>
		<tr>
			<td>\${num1 }+\${num2 }</td> <!-- 화면은 10+20 으로 만들어질것 \를사용하면 el로 사용하지 말라는 의미 -->
			<td>${num1 }+${num2 }</td>
		</tr>
		<tr>
			<td>\${num1 - num2 }</td>
			<td>${num1 - num2 }</td>
		</tr>
		<tr>
			<td>\${num1 * num2 }</td>
			<td>${num1 * num2 }</td>
		</tr>
		<tr>
			<td>\${num1 / num2 }</td>
			<td>${num1 / num2 }</td>
		</tr>
		<tr>
			<td>\${num1 % num2 }</td>
			<td>${num1 % num2 }</td>
		</tr>
		<tr>
			<td>\${num1 > num2 }</td>
			<td>${num1 gt num2 }</td>
		</tr>
		<tr>
			<td>\${num1 < num2 }</td>
			<td>${num1 lt num2 }</td>
		</tr>
		<tr>
			<td>\${num1 >= num2 }</td>
			<td>${num1 ge num2 }</td>
		</tr>
		<tr>
			<td>\${num1 <= num2 }</td>
			<td>${num1 le num2 }</td>
		</tr>		
		<tr>
			<td>\${num1 == num2 }</td>
			<td>${num1 eq num2 }</td>
		</tr>
		<tr>
			<td>\${num1 != num2 }</td>
			<td>${num1 ne num2 }</td>
		</tr>
		<tr>	
			<td>\${str == "abc" }</td>
			<td>${str eq "abc" }</td>
		</tr>
		<tr>
			<td>\${str == null }</td>
			<td>${empty str }</td>
		</tr>
		<tr>
			<td>\${str == null }</td>
			<td>${not empty str }</td>
		</tr>
		<tr>
			<td>\${str1 == null }</td>
			<td>${empty str }</td>
		</tr>
		<tr>
			<td>\${str1 == null }</td>
			<td>${not empty str }</td>
		</tr>
	</table>
	<%--
		>	 	->	 	 gt(greater)
		<	 	->   	 lt(little)
		>=	 	->	 	 get(greater or equal)
		<=	 	->	 	 le(little or equal)
		==	 	->	 	 eq(equal)
		!=	 	->	  	 ne(not equal)
	 --%>
</body>
</html>

2 - 5 ) 내장객체

Servlet

package kr.or.iei.controller;

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * Servlet implementation class ELTest5Servlet
 */
@WebServlet(name = "ELTest5", urlPatterns = { "/eLTest5.do" })
public class ELTest5Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public ELTest5Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1. 인코딩
		request.setCharacterEncoding("utf-8");
		//2. 값추출
		Member m1 = new Member("유저1", 20, "서울");
		Member m2 = new Member("유저2", 30, "부산");
		//3. 비즈니스로직
		//4. 결과처리
		RequestDispatcher view = request.getRequestDispatcher("/WEB-INF/views/el/elTest5.jsp");
		request.setAttribute("m", m1);
		HttpSession session = request.getSession();
		session.setAttribute("m", m2);
		view.forward(request, response);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

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>
	<h1>request data</h1>
	<p>${requestScope.m.name }</p>
	<p>${requestScope.m.age }</p>
	<p>${requestScope.m.addr }</p>
	<h2>session data</h2>
	<p>${sessionScope.m.name }</p>
	<p>${sessionScope.m.age }</p>
	<p>${sessionScope.m.addr }</p>
	<%-- key값이 겹칠 경우 session에 있는 데이터는 가져오지 않음 requestScope / sessionScope 명시 
	session보다 request에서 더 많이 가져오므로 기본적으로 명시하지 않을 경우 request로 가져온다
	request는 생략해도 되지만, session은 key값이 겹치지 않더라도 명시해주는게 좋음(사용에는 문제가 없지만 코드를 봤을 때 구분이 안되므로) --%>
</body>
</html>

3. JSTL : 사용하는 코드의 집합을 태그화 하여 표준으로 제공한것
1. 라이브러리등록 jstl
2. 선언<%@taglib uri="링크" @>
3. 사용 <c:if ~~ />

core tag : 변수와 url, 조건문, 반목문과 관련된 문법제공

<c:set> : 변수를 선언하고 그 변수에 초기앖을 대입하는 기능의 태그(자바변수선언과 유사)
int num = 100 / <c:set var="num" value="100" scope="request" />

<c:out> : 데이터를 출력할 때 사용
<c:out value="야호">

<c:if> : if문 조건식은 test라는 속성의 값으로 지정
<c:if test="${num1>num2}"> 야호 </c:if>

<c:choose> : switch / if~else if 문
<c:when test="조건"></c:when> 과 <c:otherwise></c:otherwise>함께사용
(c:otherwise는 else)

<c:forEach> : forEach문
items : 반복할 객체명 / var : 반복횟수에 해당하는 변수명 / step : 반복할 횟수번호

<c:forTokens> : 구분자를 통해 토큰을 분리해서 반복처리
items : 토큰을 포함하는 문자열 / delims 토큰구분자

<c:url> : url경로를 생성

	<h2>JSTL(JSP Standard Tag Library)</h2>
	<h3><a href="/jstlTest1.do">1. JSTL 기본사용법</a></h3>
	<h3><a href="/jstlTest2.do">2. JSTL if</a></h3>
	<h3>3. JSTL choose</h3>
	<form action="/jstlTest3.do">
		<input type="text" name="num">
		<input type="submit" value="전송">
	</form>
	<h3><a href="/jstlTest4.do">4. JSTL forEach</a></h3>

3 - 1 ) 기본사용법

Servlet

package kr.or.iei.controller;

import java.io.IOException;

import javax.security.auth.message.callback.PrivateKeyCallback.Request;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class JstlTest1Servlet
 */
@WebServlet(name = "JstlTest1", urlPatterns = { "/jstlTest1.do" })
public class JstlTest1Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public JstlTest1Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		RequestDispatcher view = request.getRequestDispatcher("/WEB-INF/views/jstl/jstlTest1.jsp");
		view.forward(request, response);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

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>
	<h1>JSTL 기본문법</h1>
	<h3>1. 변수를 선언(기본 변수 선언으로 해당페이지에서만 사용 가능)</h3>
	<%-- 
	<%
		int num = 10;
	%> 
	위 코드를 core tag를 사용해서 선언
	--%>
	<c:set var="num" value="10" />
	<c:set var="str" value="안녕" />
	<%-- page < request < session < application 
	페이지 내에서만 사용할 수 있는 pageScope에 생성된다. --%>
	<p>request: ${requestScope.num }</p>
	<p>session: ${sessionScope.num }</p>
	<p>page : ${pageScope.num }</p>
	<p>page : ${pageScope.str }</p>
	
	<h3>2. 변수 선언(영역 지정)</h3>
	<%--scope를 지정해서 원하는 영역에 변수를 만들 수 도 있다. --%>
	<c:set var="num1" value="200" scope="request" />
	<c:set var="num1" value="300" scope="session" />
	<p> request : ${requestScope.num1 }</p>
	<p> session : ${sessionScope.num1 }</p>
	
	<h3>3. 변수 삭제</h3>
	<c:remove var="num1" scope="session" />
	<%--num1이라는 변수가 request에도 session에도 있으므로 어느영역에 있는 num1를 삭제할 지 지정해 주어야함 --%>
	<p> request : ${requestScope.num1 }</p>
	<p> session : ${sessionScope.num1 }</p>
	
	<h3>4. core를 이용한 출력</h3>
	<p>EL : ${num1 }</p>
	<p>core : <c:out value="${num1 }" /></p>
	<%-- coreTag는 기본값설정이 가능하다 --%>
	<p>core(session) : <c:out value="${sessionScope.num1 }" default="값없음" />
	<c:set var="test" value="<b>진한글씨</b>" />
	<p>EL : ${pageScope.test }</p> 
	<%--그냥 출력 시에는 EL이 쉽지만 아래처럼 태그포함출력이라거나 설정을 주고싶을 때는 c:out태그를 사용 --%>
	<p>core1 : <c:out value="${pageScope.test }" escapeXml="true" /></p>
	<p>core2 : <c:out value="${pageScope.test }" escapeXml="false" /></p>
</body>
</html>

3 - 2 ) if

Servlet

package kr.or.iei.controller;

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class JstlTest2Servlet
 */
@WebServlet(name = "JstlTest2", urlPatterns = { "/jstlTest2.do" })
public class JstlTest2Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public JstlTest2Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		RequestDispatcher view = request.getRequestDispatcher("/WEB-INF/views/jstl/jstlTest2.jsp");
		request.setAttribute("num", 100);
		view.forward(request, response);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

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>
	<h1>c:if</h1>
	<c:if test="${num%2 eq 0 }">
	<h3>짝수</h3>
	</c:if>
	<c:if test="${num%2 eq 1 }">
	<h3>홀수</h3>
	</c:if>
</body>
</html>

3 - 3 ) choose : switch/if~else if와 유사

Servlet

package kr.or.iei.controller;

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class JstlTest3Servlet
 */
@WebServlet(name = "JstlTest3", urlPatterns = { "/jstlTest3.do" })
public class JstlTest3Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public JstlTest3Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1. 인코딩
		request.setCharacterEncoding("utf-8");
		//2. 값추출
		int num = Integer.parseInt(request.getParameter("num"));
		//3. 비즈니스로직
		//4. 결과처리
		RequestDispatcher view = request.getRequestDispatcher("/WEB-INF/views/jstl/jstlTest3.jsp");
		request.setAttribute("num", num);
		view.forward(request, response);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

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>
	<h1>c:choose</h1>
	<hr>
	<c:choose>
		<c:when test="${num%3 == 0 && num%4 == 0}">
			<h1>3의 배수이면서 4의배수입니다.</h1>
		</c:when>
		<c:when test="${num%4 == 0 }">
			<h1>4의 배수입니다.</h1>
		</c:when>
		<c:when test="${num%3 == 0 }">
			<h1>3의 배수입니다.</h1>
		</c:when>
		<c:otherwise>
			<h1>3의 배수도 4의 배수도 아닙니다.</h1>
		</c:otherwise>
		<%--else if의 경우에는 c:when을 한번더 입력 / else의 경우 c:otherwise사용 --%>
	</c:choose>
</body>
</html>

3 - 4 ) forEach

Servlet

package kr.or.iei.controller;

import java.io.IOException;
import java.util.ArrayList;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class JstlTest4Servlet
 */
@WebServlet(name = "JstlTest4", urlPatterns = { "/jstlTest4.do" })
public class JstlTest4Servlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public JstlTest4Servlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1. 인코딩
		request.setCharacterEncoding("utf-8");
		//2. 값추출
		//3. 비즈니스로직
		ArrayList<Member> list = new ArrayList<Member>();
		Member m1 = new Member("유저1", 20, "서울");
		Member m2 = new Member("유저2", 30, "인천");
		Member m3 = new Member("유저3", 40, "경기");
		list.add(m1);
		list.add(m2);
		list.add(m3);
		//4. 결과처리
		RequestDispatcher view = request.getRequestDispatcher("/WEB-INF/views/jstl/jstlTest4.jsp");
		request.setAttribute("list", list);
		view.forward(request, response);;
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

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>
	<h1>c:forEach</h1>
	<hr>
	<h3>1. 리스트 순회 반복</h3>
	<table border="1">
		<tr style="background-color: #ccc">
			<th>순서</th><th>이름</th><th>나이</th><th>주소</th>
		</tr>
		<%-- for(Member m : list) // items="list"로 넣지않도록 주의 저렇게하면 list라는 문자열이 들어간 것 --%>
		<c:forEach items="${list }" var="m" varStatus="i">
		<tr>
			<td>${i.index }</td> <%--index는 0부터시작 count는 1부터시작 --%>
			<td>${m.name }</td>
			<td>${m.age }</td>
			<td>${m.addr }</td>
		</tr>
		</c:forEach>
	</table>
	<hr>
	<h3>2. 반복회차 지정하는 반복문</h3>
	<ul>
		<c:forEach begin="1" end="10" step="1" varStatus="i">
			<li>${i.count }_번째 반복</li>
		</c:forEach>
	</ul>
</body>
</html>

4. Filter

클라이언트와 서버사이에서 request / response객체를 필터가 먼저 받아 공통적으로 필요한 부분을 처리
인코딩 같은거 할때(공통적임) Filter에 추가해두면 좋음

package common;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class EncodingFilter implements Filter{

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		System.out.println("필터 종료");
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		// TODO Auto-generated method stub
		System.out.println("서블린 가기 전");
		request.setCharacterEncoding("utf-8");
		System.out.println("인코딩 완료");
		chain.doFilter(request, response);//서블릿 수행코드
		System.out.println("서블릿 종료 후");
	}

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// TODO Auto-generated method stub
		System.out.println("초기화 완료");
	}
}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>08_etcProject</display-name>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  <filter>
	  <filter-name>EncodingFilter</filter-name>
	   //패키지경로 반드시
	  <filter-class>common.EncodingFilter</filter-class>
  </filter>
</web-app>

61일차 : Editor, GitHub

_HYE_ — Thu, 23 Feb 2023 14:34:20 +0900

20230223

1. Editor - summernote

공지사항 작성폼에 summernote에디터추가하기

<%@ 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>
<style>
	#noticeWrite td, #noticeWrite th{
		border: 1px solid #ccc;
	}
</style>
</head>
<body>
	<!-- textarea에 텍스트에디터만들기 -->
	<%@include file="/WEB-INF/views/common/header.jsp" %>
	<script src="/summernote/summernote-lite.js"></script>
    <script src="/summernote/lang/summernote-ko-KR.js"></script>
    <link rel="stylesheet" href="/summernote/summernote-lite.css">
	<div class="page-content">
		<div class="page-title">공지사항 작성</div>
		<form action="/noticeWrite.do" method="post" enctype="multipart/form-data">
		<!-- 
			첨부파일이 존재하는 경우 
			일단 양이 많기때문에 method = post
			파일이 포함되는 경우 enctype="multipart/form-data
			이 양식을 반드시 지켜줘야한다. 
		-->
			<table class="tbl" id="noticeWrite">
				<tr class="tr-1">
					<th class="td-3">제목
					<td colspan="3">
						<input type="text" name="noticeTitle" class="input-form">
					</td>
				</tr>
				<tr class="tr-1">
					<th class="td-3">작성자
					<td>
						<%=m.getMemberId() %>
						<input type="hidden" name="noticeWriter" value="<%=m.getMemberId() %>">
					</td>
					<th class="td-3">첨부파일</th>
					<td><input type="file" name="upfile"></td>
				</tr>
				<tr class="tr-1">
					<td colspan="4" style="text-align:left">
						<textarea id="noticeContent" name="noticeContent" class="input-form"></textarea>
					</td>
				</tr>
				<tr class="tr-1">
					<td colspan="4">
						<button type="submit" class="btn bc4 bs4">공지사항작성</button>
					</td>
				</tr>
			</table>
		</form>
	</div>
	<script>
      $("#noticeContent").summernote({
         height : 400,
         lang : "ko-KR",
         callbacks : {
        	 onImageUpload : function(files){
        		 uploadImage(files[0], this);
        		 //이미지는 files에 들어가고 this는 이 에디터를 의미
        	 }
         }
      });
      function uploadImage(file, editor){
    	  //file : 업로드용 / editor는 <img src=>로 보여주기 위해
    	  //ajax를 통해에서 서버에 이미지를 업로드 -> 업로드된 이미지의 경로를 받아오는 역할
    	  //받아온 이후 -> editor에 이미지 경로를 전달에서 화면에 표현
    	  
    	  //<form method="post" enctyle="multipart/form-data">태그의 역할을 해줌
    	  const form = new FormData();
    	  
    	  /*
    	  <form>
    	  	<input type="file" name="file">
    	  </form>
    	  */
    	  form.append("file", file);
    	  $.ajax({
    		 url : "/uploadImage.do",
    		 type : "post",//파일업로드를 하려면 반드시 post
    		 data : form,
    		 processData : false,
    		 contentType : false,
    		 success : function(data){
    			 //console.log(data); 이미지경로를 data로 받아옴
    			 $(editor).summernote("insertImage", data); //알아서 img태그로 집어넣음
    			 //<p><img style="width: 740.99px;" src="/upload/editor/flower11.png"></p><p><br></p><p>기절</p>
    			 //데이터베이스의 본문에 위형식으로 들어감 -> 태그가 포함되므로 본문데이터를 넉넉하게 주어야함
    		 }
    	  });
    	  //자바에서 ajax가 데이터를 받을 땐 기본적으로 문자열로 전송받음
    	  //processData : 전송하는 데이터를 기본적으로 문자열로 전송 
    	  //              -> 파일전송을 위해서 기본값인 문자열전송을 제거
    	  //contentType : enctype="application/x-www-form-urlencoded;charset=UTF-8"
    	  //		      -> 파일 전송을 위해서 encType 기본값을 제거
    	  //이 두 설정이 빠지면 ajax로 파일업로드가 불가능하다
      }
   </script>
	<%@include file="/WEB-INF/views/common/footer.jsp" %>
</body>
</html>

이미지 upload를 위한 서블릿

package kr.or.iei.notice.cotroller;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.oreilly.servlet.MultipartRequest;
import com.oreilly.servlet.multipart.DefaultFileRenamePolicy;

/**
 * Servlet implementation class UploadImageServlet
 */
@WebServlet(name = "UploadImage", urlPatterns = { "/uploadImage.do" })
public class UploadImageServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public UploadImageServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1. 인코딩
		request.setCharacterEncoding("utf-8");
		//2. 값추출
		//2-1. 업로드경로
		String root = getServletContext().getRealPath("/");
		String saveDirectory = root+"upload/editor";
		//2-2. 최대사이즈 지정
		int maxSize = 10*1024*1024;//10MB
		//2-3. request -> MutipartRequest로 변환(파일업로드가 될때)
		MultipartRequest mRequest = new MultipartRequest(request, saveDirectory, maxSize, "utf-8", new DefaultFileRenamePolicy());
		String filepath = mRequest.getFilesystemName("file");
		//3. 비즈니스로직 - DB에 파일업로드를 하지 않으므로 로직없음
		//4. 결과처리
		//업로드된 파일경로를 되돌려주면 끝
		response.setCharacterEncoding("utf-8");//파일명이 한글일 수 도 있으므로
		PrintWriter out = response.getWriter();
		out.print("/upload/editor/"+filepath);//이게 되돌아간다
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

git
로컬저장소
파일이 생기거나, 수정되거나, 삭제가 발생하면 저장여부알림이 뜸
github
원격저장소

VCS(Version Control System)

undo commit -> 커밋된걸 취소
Revert -> 삭제된 파일 복구(안하는게 좋음)

branch -> 폴더를 복사한것과 비슷한상태 물리적으로 2개는 아님(git이 논리적으로 관리)
원본폴더 - main
branch폴더 - br1 - br인 상태에서 생성수정삭제한 작업은 main에 영향을 미치지 안흠

서로 같은폴더에서 다른작업을 하다가 합치는 작업이 가능하다(merge)

원본파일이 있는 상태에서 branch에서 사용하고 잘되엇을 때 merge

다른컴퓨터랑 연동 :
1. <>code에서 https url을 따옴
2. clone a repository 의 URL에 url입력 후 경로 잡아주고 생성
3. 2번째 피시에서 작업하고 push로 깃에 올리고
4. 1번째 피시에서 2피시작업물을 받을때는 pull로 받음

혼자 git사용시 문제가 별로 없는이유
1. 개발환경이 크게 다르지않음
2. 동시에 작업하는 일이 없음
- 동시에 작업 시 수정파일이 같은데 push가 동시에 들어가게되면, 에러발생(git충돌)

- 팀GIT 작업순서1. pull [ctrl + shift + p]
2. 개인 작업 브랜치 생성
3. 개발작업 (작업중인 브랜치명은 이클립스 프로젝트 폴더명 우측에서 확인)
4. 개발 완료 후 commit (개인 브랜치)
5. master branch로 변경6-1 master branch에서 변경사항이 없는경우
-> 개인 브랜치 merge
-> 후 변경사항 매인에서 push
6-2 master branch에서 변경사항이 있는경우.
-> 개인 브랜치로 변경
-> 개인 브랜치에서 메인브랜치 변경사항 merge;
6-2-1 충돌이 없는경우
-> master branch에서 개인브랜치 merge;
-> merge 후 push (master branch에서);
6-2-2 충돌 있는경우
-> 개인 브랜치에서 충돌이 발생
-> 충돌 해결...
7. 6과정 종료 후 5번부터 다시 개발 시작.