딸기말차

[Java web] 5. EL, JSTL, Java Beans 본문

Bootcamp/Java web

[Java web] 5. EL, JSTL, Java Beans

딸기말차 2023. 7. 18. 01:36

엔코아 플레이데이터(Encore Playdata) Backend 2기 백엔드 개발 부트캠프 (playdata.io)

 

백엔드 개발 부트캠프

백엔드 기초부터 배포까지! 매력있는 백엔드 개발자 포트폴리오를 완성하여 취업하세요.

playdata.io

1. EL 표현식

EL 표현식이란, JSP에서 값을 꺼낼 때 사용하는 하나의 방법이다.

일반적인 JSP 에선  <%= %> 을 사용하지만, EL 표현식을 사용하면 ${"출력내용"} 으로 값을 가져와 사용할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>el_basic.jsp</title>
</head>
<body>
<%-- 	EL 표현식 : <%= %> 대신 ${"출력내용"} 를 이용하여 화면에 출력 --%>
	1. JSP 방식 <br>
	<% out.print("EL"); %> <br><br>
	
	2. JSP 방식 <br>
	<%= "EL" %> <br><br>
	
	3. EL 방식 <br>
	${"EL"} <br><br>
</body>
</html>

 

EL 표현식으로 여러 데이터 타입도 출력할 수 있고, 내부에서 간단한 산술 연산 및 비교도 가능하다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>다양한 데이터형 출력 및 산술 연산 및 비교 결과 출력</title>
</head>
<body>
	정수형 : ${10} <br>
	실수형 : ${5.6} <br>
	문자열 : ${"문자열"} <br>
	논리형 : ${false} <br>
	null : ${null} <br>
    
    	<%-- ${ } 앞에 \ 를 붙이면 문자열로 인식한다 --%>
	\${5 + 2} : ${5 + 2} <br> 
	\${5 - 2} : ${5 - 2} <br> 
	\${5 mod 2} : ${5 mod 2} <br> <!-- 나머지 연산 --> 
	\${5 gt 2} : ${5 gt 2} <br> <!-- greater than --> 
	\${5 > 2 || (2 < 10) } : ${5 > 2 || (2 < 10) } <br> <!-- 논리 비교 -->
	
	<!-- if문을 연산식으로 표현 : 3항연산자 -->
	<!-- (비교조건) ? 참 : 거짓 --> 
	\${5 > 2} : ${5 > 2 ? 5 : 2} -> 만약 5가 2보다 크면 5를 출력, 아니면 2를 출력 <br>
	
	<!-- 어떤 변수의 값이 null 인지 확인 : empty -->
	<% String input = null; %>
	\${empty input} : ${empty input} <br>
</body>
</html>

 

간단한 실습으로 form 태그를 이용하여 두 수를 입력하고, 입력한 수를 꺼내 연산을 해보았다.

본래 JSP 방식을 사용하면 request.getParameter로 값을 꺼내고 <%= %> 연산자 안에 값을 넣어 계산을 해야하지만, EL 태그를 사용하면 간결한 코드가 되는 것을 확인할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>el_addition_input.jsp : 두 개의 수를 입력받는 화면</title>
</head>
<body>
	<form action="el_addition_result.jsp" method="post">
		<input type="text" name="num1"><br>
		<input type="text" name="num2"><br>
		<input type="submit" value="전송"><br>
	</form>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>el_addition_result.jsp : 입력받은 수 출력</title>
</head>
<body>
	1. JSP 방식 <br>
	<%
		int num1 = Integer.parseInt(request.getParameter("num1"));
		int num2 = Integer.parseInt(request.getParameter("num2"));
	%>
	<%= num1 %> + <%= num2 %> = <%= num1 + num2 %>
	<br><hr><br>
	2. EL 방식 <br>
	${param.num1} + ${param.num2} = ${param.num1 + param.num2}
	<br><hr><br>
</body>
</html>

 

다음으로 [ ] 기호를 이용해 EL 태그를 사용하는 방식과, String 값으로 input이 들어왔을 때 EL 태그를 사용한 비교구문을 실습해 보았다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>el_test_input.jsp : 사용자 입력</title>
</head>
<body>
	<form action="el_test_result.jsp" method="post">
		<input type="email" name="email"> <br>
		<input type="url" name="url"> <br>
		<input type="submit" value="전송">	
	</form>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>el_test_result.jsp : 입력받은 이메일, url 출력</title>
</head>
<body>
	<%-- EL 방식 : ${param.파라미터명} --%>
	email : ${param.email} <br>
	url : ${param.url} <br>
	
	<hr>
	<%-- EL 방식 : ${param["파라미터명"]} : 파라미터명을 for문을 돌릴 수 있다. --%>
	email : ${param["email"]} <br>
	url : ${param["url"]}
</body>
</html>

 

눈여겨볼 점은, 일반적으로 Java에선 String의 null 값을 확인할 때 String 값 == null 이나, isEmpty() 를 사용하지만 EL 태그를 이용하면 좀 더 간편하게 작성할 수 있다는 점이다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>el_test2_input : 여러 사용방법 테스트용 입력</title>
</head>
<body>
	<form action="el_test2_result.jsp" method="post">
		<input type="text" name="id"> <!-- admin -->
		<input type="submit" name="전송">
	</form>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>el_test2_result.jsp : </title>
</head>
<body>
	1. == 비교 결과 : ${param.id == "admin"} <br>
	2. .equals 비교 결과 : ${param.id.equals("admin")} <br>
	3. String 객체로 비교 <br>
		String s1 = "test" <br>
		String s2 = new String("test2") <br>
	4. 값이 없을 경우 확인 <br>
		${empty param.id} : null 이면 true, 아니면 false <br>
</body>
</html>

 

마지막으로, 변수의 Scope에 대한 실습을 진행하였다.

한 페이지 내에서 해당 내용을 보면 이해하기 약간 어려울 수 있지만, 우리가 servlet에서 자주 사용하는 request 객체나 session 객체가 어디서 생성되고, 어디로 운반되고, 어디서 종료되는지를 생각한다면 좀 더 쉽게 이해할 수 있을 것이다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<%
	// 어떤 값을 저장할 때, 해당 값에 대한 수명 설정 : setAttribute() 를 이용
	// 1. 현재 페이지 내에서만 사용가능
	pageContext.setAttribute("name", "page Name");
	
	// 2. request객체가 살아있을 때 까지 사용가능
	request.setAttribute("name", "request Name");
	
	// 3. session객체가 invalidate 될 때까지 or 지정한 수명값이 다 될때까지 사용가능
	session.setAttribute("name", "session Name");
	
	// 4. application이 구동되는 동안 사용가능
	application.setAttribute("name", "application Name");
%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>el_scope.jsp : 데이터를 저장하는 변수에 대한 scope</title>
</head>
<body>
	EL 방식으로 추출<br>
	pageContext (현재 페이지 내에 선언) : ${name} <br>
	request (request 객체 내에 선언) : ${requestScope.name} <br> <!-- request.getAttribute("name") 과 동일 -->
	session (session 객체 내에 선언) : ${sessionScope.name} <br> <!-- session.getAttribute("name") 과 동일 -->
	application (application 내에 선언) : ${applicationScope.name} <br>
	params (외부에서 전달받은 파라미터) : ${param.name} <br>	
</body>
</html>

2.  JSTL

우리는 JSP 내 HTML 부분에서 코딩을 할 때, 반복되는 태그들을 <% %> 를 사용해 for문으로 바꿔 구현하거나, 조건에 따라 다른 태그를 출력하고 싶을 때 if문을 사용해 구현했다. 해당 방식은 기능은 구현하기 간편하지만, 코드의 가독성이 많이 떨어지는 단점이 있다. 

그렇기 때문에 JSTL을 사용하면, 기존 JSP 방식과 동일한 기능을 좀 더 가독성이 좋은 코드로 변경해 사용할 수 있는 장점이 있다.

1. JSTL에 대하여
jstl.jar / standard.jar 두 파일이 필요

2. JSTL 사용목적
JSP로 작업할 경우, HTML 내부 코드에 대한 가독성이 떨어지고 웹 디자이너 & 퍼블리셔가 작업 시, 실수로 JSP관련 코드를 수정 또는 삭제하는 경우를 방지하기 위해.
JSP / EL / Action Tag 등과 달리 JSTL은 별도의 라이브러리가 필요하고 반드시 선언이 필요하다.

3. JSTL 라이브러리 설치 방법
WEB-INF -> lib 폴더에 해당 라이브러리 파일을 넣어주면 된다.

4. JSTL이 제공하는 5가지 라이브러리
1) Core : 출력, 제어문, 반복문에 대한 tag 형태 
2) Format : 출력 형식에 관련된 tag 형태 제공
3) Function : JSTL이 제공하는 함수들을 tag 형태로 제공
4) XML : XML 문서를 읽거나 내보내기 위한 tag를 제공
5) SQL : SQL 쿼리문을 작성할 수 있는 tag를 제공 : Mybatis에서 주로 사용

5. JSTL 라이브러리 사용 방법
1) <%@ taglib를 이용하여 사용할 라이브러리 선언
<% taglib uri = "라이브러리가 제공하는 태그를 해석할 수 있는 참조 URL" prefix="태그구분" %>

ex) Core 라이브러리를 사용할 경우
<%@ taglib uri="http://java.sum.com/jsp/jstl/core" prefix="core" %>
<core:out></core:out>

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

 

JSTL은 우리가 사용하는 대부분의 기능에 구현되어있다. 단지 표기 방식이 달라 그 사용법을 모를 뿐이다. 때문에,

자주 사용하는 JSTL 태그를 정리해 보았다.

1. 출력
- <c:out value="출력값"></c:out>
- <c:out value="출력값" default="기본값"></c:out>
- <c:out value="출력값" default="기본값" escapeXml="true / false"></c:out> : 출력, 기본값 내부에 HTML 태그가 존재하는 경우

2. 변수 선언
- <c:set var="변수명"></c:set>
- <c:set var="변수명" value="초기값"></c:set>
- <c:set var="변수명" value="초기값" scope="변수선언위치"></c:set>

3. 변수 제거
- <c:remove var="제거할 변수명" scope="변수선언위치"></c:remove>

4. 예외 처리
- <c:catch var="변수명"></c:catch>

5. if문
- <c:if test="조건" var="조건처리 변수명" scope="범위"></c:if>

6. 제어문(switch)
- <c:choose>
	<c:when test="조건"> 처리내용 </c:when>
 </c:choose>
 
7. 조건문(if ~ else)
- <c:choose>
	<c:when test="조건"> 처리내용 </c:when>
	<c:oterwise> 처리내용 </c:otherwise>
 </c:choose>
  
8. 반복문(for)
- <c:foreach var="변수명" items="객체" begin="시작인덱스" end="끝인덱스" step="건너뛸 값"> </c:foreach>
- begin~step 까지는 생략가능하다. 생략되면 0~객체끝 까지 하나씩 가져온다.

9. 파라미터 전달
- <c:param name="파라미터 명" value="전달값"></c:param>

10. 페이지 이동 (sendRedirect)
- <c:redirect url="이동할 주소"></c:redirect>

3. JSTL TAG_1) c:set, c:out, c:remove, c:catch, c:forTokens

c:set 태그는 말 그대로 변수를 set, 선언하는 태그이다.

원하는 변수명을 var, 변수의 값을 value로 설정하거나 태그 사이에 변수의 값을 넣는 방법도 존재한다.

<%@ page import="com.lhs.beans.MemberBean"%>
<%@ 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>jstl_set : set 태그</title>
</head>
<body>
	변수 설정 <br>
	<c:set var="msg" value="Hello"></c:set>
	\${msg} : ${msg}
	<hr>
	<c:set var="age">100</c:set>
	\${age} : ${age}
	<hr>
	<c:set var="add" value="${100 + 200}"></c:set>
	\${add} : ${add}
	<hr>
	<c:set var="flag" value="${10 > 5}"></c:set>
	\${flag} : ${flag}
	<hr>
	<c:set var="member" value="<%= new MemberBean() %>"></c:set>
	\${member} : ${member}
	<hr>
</body>
</html>

 

c:out은 우리가 system.out.print를 하는 것 처럼 out, 출력을 하는 태그이다.

또한 set을 이용해 생성한 변수를 c:remove를 통해 제거할 수 있고, 예외가 발생한 경우 c:catch를 사용해 에러 메세지를 출력할 수도 있다.

<%@ 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>jstl_set_remove_out_catch.jsp</title>
</head>
<body>
	<h4>set 태그 이용 변수 초기화</h4>
	<c:set var="age" value="30" scope="page"></c:set>
	
	<h4>out 태그를 이용하여 변수값 출력</h4>
	<c:out value="${age}"></c:out>
	
	<h4>remove 태그를 이용하여 변수 제거</h4>
	<c:remove var="age" scope="page"/>
	<c:out value="${age}"></c:out>
	
	<h4>예외처리</h4>
	<c:catch var="errorMsg">
		예외 발생 전 <br>
		<%= 10 / 0 %> <br>
		예외 발생 후 <br>
	</c:catch>
	<c:out value="${errorMsg}"></c:out>	
</body>
</html>

 

c:forTokens는 우리가 Java에서 사용하는 split과 완전히 동일한 기능이다. delims에 분리할 기준 문자를 넣어주어 사용할 수 있다.

<%@ 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>forTokens.jsp : 문자열을 구분하여 분리(split)</title>
</head>
<body>
	<c:forTokens items="서울.부산.인천.제주.대구" delims="." var="city">
		${city} <br>
	</c:forTokens>
</body>
</html>

4. JSTL TAG_2) c:url, c:redirect, c:import, fmt:requestEncoding

c:url은 말 그대로 url을 저장하는 태그인데, var을 통해 선언한 변수, value를 통해 url 경로를 선언해 변수 내에 url 경로를 저장할 수 있다. 

<%@ 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>jstl_url.jsp : url 태그</title>
</head>
<body>
	<c:url value="./images/pic.jpg" var="data"></c:url>
	<img src="${data}" width="150" height="150">
</body>
</html>

 

c:redirect는 원하는 페이지로 redirect 할 수 있는 기능이다. response.redirect("경로")와 동일한 기능이라 볼 수 있다.

<%@ 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>jstl_redirect.jsp : redirect 태그 (response.sendRedirect()</title>
</head>
<body>
	이동 전
	<c:redirect url="jstl_url.jsp"></c:redirect>
	이동 후
</body>
</html>

 

c:import는 원하는 페이지의 결과 값을 var로 선언한 변수에 담아, 출력 등 추가 작업을 할 수 있는 태그이다.

<%@ 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>jstl_import.jsp : import 태그</title>
</head>
<body>
	<c:import url="http://localhost:8080/jstl_all/jstl_url.jsp" var="data"></c:import>
	${data}
</body>
</html>

 

fmt:requestEncoding은 가져온 값을 formatting 하는 기능을 말한다. 

일반적으로 post 방식으로 데이터를 전송하면 한글이 무조건 깨지기 때문에, 가져온 후 request.setCharacterEncoding을 통해 UTF-8로 인코딩을 변경해 준다. 이 과정과 완전히 동일한 기능으로, 표기법만 태그 형식으로 바뀌었다 볼 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>fmt_input.jsp : 한글 입력</title>
</head>
<body>
	<form action="fmt_result.jsp" method="post">
		<input type="text" name="text" maxlength="20" placeholder="text">
		<input type="submit" value="전송">
	</form>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>fmt_result.jsp : 한글 깨짐 방지 (post 방식일때)</title>
</head>
<body>
	<fmt:requestEncoding value="UTF-8"/> <!-- request.setCharacterEncoding("UTF-8") -->
	<c:out value="${param.text}"></c:out>
</body>
</html>

5. JSTL TAG_3) c:foreach, c:if, c:choose

c:foreach는 Java의 foreach문과 동일한 기능을 가지고 있다. 해당 태그를 사용하면, <% %> 를 통한 for문을 사용할 때 보다 코드가 훨씬 간결해진다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%
	String[] movieList = {"분질", "알라딘", "위맨", "범죄도시", "범죄도시2"};
	/* 해당 페이지 내에서만 사용하기 위해 */
	pageContext.setAttribute("movieList", movieList); 
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>foreach_movie.jsp : forEach</title>
</head>
<body>
	<c:forEach var="movie" items="${movieList}">
		${movie} <br>
	</c:forEach>
</body>
</html>

 

일반적으로 var에 변수명, items에 변수를 넣고 사용하는데 만약 for문을 진행하는 과정에서 index나 count 기능이 필요하면 어떻게 사용해야할까?

c:foreach 태그의 varStatus 옵션을 사용하면 두 기능을 모두 사용할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%
	String[] movieList = {"분질", "알라딘", "위맨", "범죄도시", "범죄도시2"};
	/* 해당 페이지 내에서만 사용하기 위해. JSTL에 movieList를 쓰려면 있어야한다. */
	pageContext.setAttribute("movieList", movieList); 
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>foreach_movie_table.jsp : forEach</title>
</head>
<body>
	<table>
		<tr>
			<th>INDEX</th>
			<th>COUNT</th>
			<th>TITLE</th>
		<tr>
		<!-- varStatus : index, count 값을 가지고 있다. -->
		<c:forEach var="movie" items="${movieList}" varStatus="status">
			<tr>
				<td>${status.index}</td>
				<td>${status.count}</td>
				<td>${movie}</td>
			</tr>
		</c:forEach>
	</table>
</body>
</html>

 

c:if, c:choose는 Java의 if, if-else if-else 문과 동일하다 볼 수 있다. 주의할 점으로 c:if 태그가 존재한다고 c:else 태그를 사용하는 것이 아니라, c:if는 단 하나의 if문을 사용하는 경우에만 쓴다는 점이다.

만약 if-else if-else 같이 여러 조건을 줘야할 경우, c:choose 내에 c:when을 통해 else if의 기능을, c:otherwise를 통해 else의 기능을 구현하면 된다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%
	String[] movieList = {"분질", "알라딘", "위맨", "범죄도시", "범죄도시2"};
	/* 해당 페이지 내에서만 사용하기 위해. JSTL에 movieList를 쓰려면 있어야한다. */
	pageContext.setAttribute("movieList", movieList); 
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>foreach_movie_ul.jsp : </title>
</head>
<body>
	<!-- 목록을 만들어주는 태그들. 내부에 li 태그가 있어야 한다. -->
	<ul>
		<li style="color: red; font-weight: bold;">테스트1</li>
		<li>테스트2</li>
		<li>테스트3</li>		
	</ul>
	<hr>
	<ol>
		<li>테스트1</li>
		<li>테스트2</li>
		<li>테스트3</li>		
	</ol>
	<hr>
	<ul>
		<c:forEach var="movie" items="${movieList}" varStatus="status">
			<c:choose>
				<c:when test="${status.count == 1}">
					<li style="color: red; font-weight: bold;">${movie}</li>
				</c:when>
				<c:otherwise>
					<li>${movie}</li>
				</c:otherwise>
			</c:choose>
		</c:forEach>
	</ul>
	<hr>
	<c:forEach var="movie" items="${movieList}" varStatus="status">
		${movie}
		<c:if test="${not status.last}">,</c:if>
	</c:forEach>
</body>
</html>

6. Java Beans

Java bean이란 특정 규칙을 지켜 만든, 데이터를 표현하기 위한 목적을 가진 클래스를 의미한다.

Java bean 규약을 지켜 만든 클래스는 다음과 같다.

package com.lhs.beans;

/*
 * 자바 빈 객체를 위한 클래스선언
 * 1. 멤버 변수는 반드시 private
 * 2. 멤버 변수에 대한 getter / setter
 * 3. 기본 생성자가 반드시 있어야 한다. -> 자바에서 객체를 생성하는게 아니라 태그에서 생성하기 때문에
 * 4. 그 외 기본 생성자를 이용한 오버로딩 생성자는 필요하면 사용한다.
 * 5. form 태그의 name이 가지고있는 이름과 멤버변수 이름이 동일하면 get이나 setAttribute를 사용할 필요 없이 알아서 찾아 들어간다.
 */
public class MemberBean {
	private String name;
	private String userid;
	private String nickname;
	private String pwd;
	private String email;
	private String phone;	
	
	public MemberBean() {
		super();
	}
	public MemberBean(String name, String userid) {
		super();
		this.name = name;
		this.userid = userid;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getUserid() {
		return userid;
	}
	public void setUserid(String userid) {
		this.userid = userid;
	}
	public String getNickname() {
		return nickname;
	}
	public void setNickname(String nickname) {
		this.nickname = nickname;
	}
	public String getPwd() {
		return pwd;
	}
	public void setPwd(String pwd) {
		this.pwd = pwd;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getPhone() {
		return phone;
	}
	public void setPhone(String phone) {
		this.phone = phone;
	}
	@Override
	public String toString() {
		return "MemberBean [name=" + name + ", userid=" + userid + ", nickname=" + nickname + ", pwd=" + pwd
				+ ", email=" + email + ", phone=" + phone + "]";
	}
}

 

이렇게만든 Java Bean 객체를 일반적인 JSP를 통해 사용하려면 <% %> 를 이용해 객체를 만들어야하지만, JSTL의 <jsp:useBean> 태그를 사용하면 간편하게 선언해 사용할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>자바 빈(beans) 객체 다루는 action tag(jsp:태그명)</title>
</head>
<body>
	<h4>1. Spring의 의존성 주입 (DI : IoC)</h4>
	<h4>2. Spring의 데이터베이스 자동 매핑</h4>
	<h4>3. Spring의 관점 지향(AOP) : 공통 라이브러리 개발</h4>
	
	<!-- id : MemberBean member & class : new MemberBean() -->
	<jsp:useBean id="member" class="com.lhs.beans.MemberBean"></jsp:useBean>
	이름 : <%= member.getName() %> <br> 
	아이디 : <%= member.getUserid() %> <br>
	<hr>
	<%
		member.setName("lhs");
		member.setUserid("lhs");
	%>
	설정 된 이름 : <%= member.getName() %> <br>
	설정 된 아이디 : <%= member.getUserid() %> <br>
</body>
</html>

 

우리는 일반적으로 객체를 선언하면 get을 이용해 값을 가져오거나 set을 이용해 값을 집어넣을 수 있다. 위 코드에선 해당 부분을 <%= %> 를 통해 해결하였지만, 이 또한 JSTL의 <jsp:getProperty>, <jsp:setProperty> 태그를 사용하면 간편히 해결할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>자바 빈(beans) 객체 다루는 action tag(jsp:태그명)</title>
</head>
<body>
	<!-- id : MemberBean member & class : new MemberBean() -->
	<jsp:useBean id="member" class="com.lhs.beans.MemberBean"></jsp:useBean>
	
	<!-- property : 클래스 내부의 변수명 & name : 객체의 이름 -->
	<jsp:getProperty property="name" name="member"/> <!-- member.getName() -->
	<jsp:getProperty property="userid" name="member"/> <!-- member.getUserid() -->
	<hr>
	<!-- property : 클래스 내부의 변수명 & name : 객체의 이름 & value : 설정할 값 -->
	<jsp:setProperty property="name" name="member" value="lhs"/> <!-- member.setName() -->
	<jsp:setProperty property="userid" name="member" value="lhs"/> <!-- member.setUserid() -->
	
	<jsp:getProperty property="name" name="member"/>
	<jsp:getProperty property="userid" name="member"/>
</body>
</html>

 

해당 기능의 실습을 위해 form 태그로 데이터를 입력받고, 입력 받은 데이터를 bean 객체에 넣어 추출해보았다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>useBeans_add_form.jsp : 사용자 값 입력</title>
</head>
<body>
	<form action="useBeans_result.jsp" method="post">
		<input type="text" name="name" size="20"> <br>
		<input type="text" name="userid" size="20"> <br>
		<input type="text" name="nickname" size="20"> <br>
		<input type="password" name="pwd" size="20"> <br>
		<input type="email" name="email" size="20"> <br>
		<input type="tel" name="phone" size="20"> <br>
		<input type="submit" value="전송">
		<input type="reset" value="입력취소">
	</form>
</body>
</html>

 

여기서 참고하면 좋은 점은, setProperty 태그를 사용 시 property 옵션을 * 로 설정하면 일일이 set으로 넣어주지 않아도, 읽어온 데이터명이 bean의 멤버변수명과 동일하다면, 한번에 데이터를 입력할 수 있다는 점이다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<% request.setCharacterEncoding("UTF-8"); %>
<jsp:useBean id="member" class="com.lhs.beans.MemberBean"></jsp:useBean>
<jsp:setProperty property="*" name="member"/> <!-- property 값의 * 을 통해 파라미터 명과 동일한 멤버변수 명에 값을 set -->
<% out.print(member); %>
	
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>useBeans_result.jsp : 전달 된 파라미터 명과 MemberBean의 멤버 변수를 자동 매핑</title>
</head>
<body>
	<hr>
	name : <jsp:getProperty property="name" name="member"/> <br>
	userid : <jsp:getProperty property="userid" name="member"/> <br>
	nickname : <jsp:getProperty property="nickname" name="member"/> <br>
	pwd : <jsp:getProperty property="pwd" name="member"/> <br>
	email : <jsp:getProperty property="email" name="member"/> <br>
	phone : <jsp:getProperty property="phone" name="member"/> <br>	 
</body>
</html>

7.  17일차 후기

기존에 JSP를 사용할 때는 Java 코드를 사용해 좀 더 유동적으로 HTML 태그를 작성할 수는 있었으나, <% %>, <%= %> 같은 태그를 사용해야했기 때문에 코드작성이 불편하고 가독성이 떨어지는 단점이 있었다.

하지만 EL 표기법이나 JSTL을 통해 해당 불편함을 많이 줄일 수 있는 것을 알게 되었고, 이를 활용해 코드를 더욱 깔끔하게 작성할 수 있을거란 생각이 들었다.

 

JSTL은 생각보다 많은 기능의 태그들을 지원해준다. 이를 적절히 사용하면 좋지만, 만약 모든 로직을 JSTL을 사용해 처리한다면 Java 영역과 화면을 위한 View 영역이 구별하기 어려워지는 문제 또한 존재한다.

 

때문에 아무리 JSTL이 편리하다고 해도 너무 과하게 사용하지 않고, 비즈니스 로직을 위한 부분은 Java에서 처리, 화면을 위한 로직은 JSTL로 처리해 영역을 확실히 나눠 구현하는 것이 중요하다는 생각이 들었다.

'Bootcamp > Java web' 카테고리의 다른 글

[Java web] 7. Web 복습, Oracle  (0) 2023.07.24
[Java web] 6. Mini Project_2  (0) 2023.07.22
[Java web] 4. Session, JSP tag  (0) 2023.07.15
[Java web] 3. Servlet 실습  (0) 2023.07.14
[Java web] 2. JSP 실습  (0) 2023.07.13
'Bootcamp/Java web' Related Articles more