비트캠프 프론트엔드 및 벡엔드 개발자 Webapp el, jsp, jstl

2020. 4. 13. 10:53

webapp

ex01.jsp -> EL(Expression Language) 표기법 //

// EL(Expression Language) // 콤마(.)와 대괄호([]) 등을 사용하여 객체의 프로퍼티나,

// 리스트, 셋, 맵 객체의 값을 쉽게 꺼내고 설정하게 도와주는 문법

// 값을 꺼낼 때는 OGNL 표기법을 사용한다

// OGNL(Object Graph Navigation Language) // 객체의 프로퍼티 값을 가리킬 때 사용하는 문법

// 파일의 경로처럼 객체에 포함된 객체를 탐색하여 값을 쉽게 조회할 수 있다.

// 문법 //

// 객체명.프로퍼티명.프로퍼티명.프로퍼티명 // 객체명["프로퍼티명"]["프로퍼티명"]["프로퍼티명"]

// EL에서 사용할 수 있는 객체 //

// pageContext // JSP의 PageContext 객체

// servletContext // pageContext.servletContext.프로퍼티명

// 자바코드 // pageContext.getServletContext().get프로퍼티()

// session // pageContext.session.프로퍼티명 // ex) pageContext.session.name

// 자바코드 // pageContext.getSession().getName();

// request // pageContext.request.프로퍼티명

// response //

// param // param.파라미터명

// 자바코드 // request.getParameter("파라미터명");

// paramValues // paramValues.파라미터명

// 자바코드 // request.getParameterValues("파라미터명");

// header // header.헤더명

// 자바코드 // request.getHeader("헤더명");

// headerValues // headerValues.헤더명

// 자바코드 // request.getHeaders("헤더명");

// cookie // cookie.쿠키

// initParam // initParam.파라미터명

// 보관소에서 값을 꺼내는 문법 //

// pageScope // pageScope.객체이름

// 자바코드 // pageContext.getAttribute("객체이름");

// requestScope // requestScope.객체이름

// 자바코드 // request.getAttribute("객체이름");

// sessionScope // sessionScope.객체이름 // ex) sessionScope.name

// 자바코드 // session.getAttribute("객체이름"); // ex) session.getAttribute("name");

// applicationScope // applicationScope.객체이름

// 자바코드 // application.getAttribute("객체이름");

ex02.jsp -> 보관소에 값 꺼내기

<%
pageContext.setAttribute("name", "홍길동");
request.setAttribute("name", "임꺽정");
session.setAttribute("name", "유관순");
application.setAttribute("name", "안중근");
%>

// ${pageScope.name} // <%=pageContext.getAttribute("name")%>

// ${requestScope.name} // <%=request.getAttribute("name")%>

// ${sessionScope.name} // <%=session.getAttribute("name")%>

// ${applicationScope.name} // <%=application.getAttribute("name")%>

ex03.jsp -> 보관소에서 값 꺼내기 // 순서

// 보관소의 이름을 지정하지 않으면 다음 순서로 값을 찾는다.

// 1. pageScope // 2. requestScope // 3. sessionScope // 4. applicationScope

// ${name} // pageScope에 값이 없으면, requestScope에서, requestScope에 값이 없으면 sessionScope에서,

// sessionScope에 값이 없으면, applicationScope에서, applicationScope에 값이 없으면 빈문자열을 리턴한다.

// 보관소에 저장된 값을 찾지 못하면 빈 문자열을 리턴한다.

ex04.jsp -> 리터럴

문자열: ${"홍길동"}<br>
문자열: ${'홍길동'}<br>
정수: ${100}<br>
부동소수점: ${3.14}<br>
논리값: ${true}<br>
null: ${null}<br>

// EL에서 문자열이나 숫자를 표현하는 방법

// eclipse에서는 논리값과 null값이 오류로 표기 되는데, eclipse가 잘못 된 것이다. // 실행 잘 된다.

ex05.jsp -> 배열에서 값 꺼내기

<%
pageContext.setAttribute("names", new String[]{"홍길동","임꺽정","유관순"});
%>

${names[0]}<br>
${names[1]}<br>
${names[2]}<br>
${names[3]}<br>

// 배열에 값이 없는 경우 // names{3] // 빈 배열로 출력된다.

ex06.jsp -> List 객체에서 값 꺼내기 // 뭘 나갔는지 모르겠음.

// 보관소가 아닌 로컬 변수는 EL에서 사용할 수 없다.

ex07.jsp -> Map 객체에서 값 꺼내기

<%
HashMap<String,Object> map = new HashMap<>();
map.put("s01", "김구");
map.put("s02", "안중근");
map.put("s03", "윤봉길");
map.put("s04 ^^", "오호라");

pageContext.setAttribute("map", map);
%>

${map["s01"]}<br>
${map['s01']}<br>
${map.s01}<br>

// ${map.s04 ^^} // 실행 오류 //

// 프로퍼티 이름이 변수 이름 짓는 규칙에 맞지 않다면 OGNL 표기법을 쓸 수 없다.

// 문자열에 공백이나 특수 문자가 포함된 경우에는 점(.)을 사용할 수 없다.

${map["s04 ^^"]}<br>
${map['s04 ^^']}<br>

// 문자열에 공백이나 특수 문자가 포함된 경우에는 이렇게 사용하여야 한다. // .은 사용 불가라는 것.

ex08.jsp -> 일반 객체에서 값 꺼내기

<%
Member member = new Member();
member.setNo(100);
member.setName("홍길동");
member.setEmail("hong@test.com");
member.setTel("1111-2222");

pageContext.setAttribute("member", member);
%>

${member.no}<br>
${member["no"]}<br>
${member['no']}<br>
${member.getNo()}<br>

ex09.jsp -> 연산자

// 산술 연산자 //

100 + 200 = ${100 + 200}<br>
100 - 200 = ${100 - 200}<br>
100 * 200 = ${100 * 200}<br>
100 / 200 = ${100 / 200}<br>
100 div 200 = ${100 div 200}<br>
100 % 200 = ${100 % 200}<br>
100 mod 200 = ${100 mod 200}<br>

// 출력 결과 //

100 + 200 = 300
100 - 200 = -100
100 * 200 = 20000
100 / 200 = 0.5
100 div 200 = 0.5
100 % 200 = 100
100 mod 200 = 100

// 논리 연산자 //

true && false = ${true && false}<br>
true and false = ${true and false}<br>
true || false = ${true || false}<br>
true or false = ${true or false}<br>
!true = ${!true}<br> 
not true = ${not true}<br>

// 출력 결과 //

true && false = false
true and false = false
true || false = true
true or false = true
!true = false
not true = false

// 관계 연산자 //

100 == 200 = ${100 == 200}<br>
100 eq 200 = ${100 eq 200}<br>
100 != 200 = ${100 != 200}<br>
100 ne 200 = ${100 ne 200}<br>
100 > 200 = ${100 > 200}<br>
100 gt 200 = ${100 gt 200}<br>
100 >= 200 = ${100 >= 200}<br>
100 ge 200 = ${100 ge 200}<br>
100 &lt; 200 = ${100 < 200}<br>
100 lt 200 = ${100 lt 200}<br>
100 &lt;= 200 = ${100 <= 200}<br>
100 le 200 = ${100 le 200}<br>

// 출력 결과 //

100 == 200 = false
100 eq 200 = false
100 != 200 = true
100 ne 200 = true
100 > 200 = false
100 gt 200 = false
100 >= 200 = false
100 ge 200 = false
100 < 200 = true
100 lt 200 = true
100 <= 200 = true
100 le 200 = true

// empty // 보관소에 해당 객체가 없는지 검사한다.

<%
pageContext.setAttribute("name", new String("홍길동"));
%>
name 값이 없는가? ${empty name}<br>
name2 값이 없는가? ${empty name2}<br>

// 출력 결과 //

name 값이 없는가? false
name2 값이 없는가? true

// 조건 연산자 // 조건 ? 식1 : 식2

name == "홍길동" : ${name == "홍길동" ? "맞다!" : "아니다!"}<br>

// 출력 결과 //

name == "홍길동" : 맞다!
== : 다르다!
equals() : 같다!

jsp

ex01.jsp -> jsp 구동원리 //

// 1. 웹브라우저에서 서블릿 컨테이너로 JSP 실행 요청한다.

// 2. 서블릿 컨테이너가 실행 //

// 2.1 JSP의 서블릿 객체를 찾는다. // 2.2.1 있다면, 서블릿 객체를 호출한다. // service() ---> _jspService()

// 2.2.1 없으면, JSP 엔진을 이용하여 JSP 파일을 가지고 서블릿 자바 소스 파일을 생성한다.

// 2.2.2 자바 컴파일러를 이용하여 소스 파일을 컴파일한다.

// 2.2.3 서블릿 객체를 생성한다. // init() 호출 ---> jspInit()

// 2.2.4 그 서블릿 객체를 호출한다. // service() ---> _jspService()

// 3. 서블릿 컨테이너에서 웹브라우저로 서블릿 실행 결과를 응답한다.

// JSP 파일을 가지고 생성한 서블릿 소스(.java)와 클래스 파일(.class)의 위치 //

// org.eclipse.wst.server.core\tmp1\work\Catalina\localhost\bitcamp-java-web

// JSP 파일은 Python이나 PHP 처럼 직접 그 스크립트가 인터프리팅 되는 것이 아니다.

// JSP 엔진의 역할을 JSP 파일을 분석하여 서블릿 클래스를 생성하는 것 // JSP 파일이 직접 실행되지 않는다.

// JSP // 자바 서블릿 클래스를 만드는 재료로 사용 // 템플릿 기술이라 부른다.

// 서블릿 클래스를 만드는 "틀"이라 해서 "템플릿(template)"이라 부른다.

// JSP 실행을 요청 // JSP 파일이 있는 위치를 지정 // http://localhost:9999/bitcamp-java-web/jsp/ex01.jsp접속

// \org.eclipse.wst.server.core\tmp1\work\Catalina\localhost\bitcamp-java-web\org\apache\jsp\jsp

// 위 경로에 ex01_jsp.class, ex01_jsp_java 파일이 생성 된다.

// JSP 엔진이 서블릿을 만들 때 지켜야할 규칙

// JSP 파일을 가지고 서블릿을 만들 때 HttpJspPage를 구현해야 한다.

// 클래스 계층도 //

// Servelt // Init(ServletConfig) : void // destroy() : void // service(ServletRequest, ServletResponse) : void //

// getServletInfo() : String // getServletConfig() : ServletConfig

// JspPage // jspInit() : void // jspDestroy() : void

// HttpJspPage // _jspService(HttpServletRequest, HttpServletResponse) : void

ex02.jsp -> 템플릿 데이터 //

// JSP 파일에 그냥 작성하는 텍스트는 자바 출력 코드를 생성한다.

ex03.jsp -> 스크립트릿(scriptlet)과 JSP 주석

// 스크립트릿(scriptlet) // JSP 파일 안에 실행할 자바 코드를 넣은 태그 // ex <% 자바 코드 %>

// 스크립트릿 안에 작성한 코드는 자바 클래스를 생성할 때 _jspService() 메서드 안에 작성한 순서 그대로 복사된다.

// JSP 주석 // 이 태그 안에 작성한 것은 자바 클래스를 생성할 때 제거 // <%-- 주석 --%>

// Html 주석()과 JSP 주석(<%-- --%>) // Html 주석을 사용하면 JSP는 이를 템플릿 데이터로 인식한다.

// 즉 java 코드에 out.write가 붙어서 전달된다. // .java 파일 확인해보면 안다.

// JSP 주석의 경우 JSP에서 무시된다. // .java 파일에서 확인할 수 없다.

// 결론 JSP에서는 HTML 주석을 주석으로 인식하지 않는다. // 템플릿 데이터로 인식.

ex04.jsp -> 스크립트릿(scriptlet) 응용

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
String[] names = {"홍길동", "임꺽정", "유관순"};
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>ex04</title>
</head>
<body>
<h1>스크립트릿(scriptlet) 응용</h1>
<ul>
<%
for (String name : names) {
  out.println("<li>" + name + "</li>");
}
%>
</ul>
</body>
</html>

// 이번만 전체 다 넣는다. // 다음번엔 엔터키로 위 아래 구분하겠음.

// 이렇게 자바코드 그대로 사용할 수 있다. // _jspService() 메서드 안에 코드가 들어간다.

// 즉 메서드 안에 적을 수 있는 것이라면 다 적을 수 있다. // 메서드 안에 적을 수 없다면 불가능하다.

// ex) 클래스를 선언하는데 private, protect 등으로 선언하는 것(x) // 클래스 선언은 가능하다. // 이너클래스

// 그러나 이너클래스는 private. protect 등은 사용이 원래 불가능하다. //

ex05.jsp -> 응용표현식(expression element) // 프로그래머는 element라 하고, 일반인은 태그라고 한다.

// 문장(statement) //

   if () {...}
   else {...}
   for () {...}
   int a = 100;

// 표현식(expression) // 문장 중에 값을 리턴하는 문장

   a * b
   (..)? a : b
   plus(10, 20)

// 곱하기 결과, 조건에 따라 a나 b 값, plus()의 실행 값 리턴 // 값을 리턴하는 문장을 표현식이라 한다.

// out.println("okok") // 이것은 값을 리턴하는 것이 아니기 때문에 표현식이라고 하지 않는다.

// 표현식(expression element) 문법 // <%= 표현식 %> // 표현식에는 값을 리턴하는 문장이 와야한다.

// 자바코드 // out.print(표현식), out.write(표현식) // print나 write 문 안에 들어간다.

// 유의해야 할 점 // 작성한 코드가 되는 지 안되는지 확인하는 방법은 print문 안에 넣어봐라.

// ex) out.print(out.println("okok");); // out.print(//); // 될 리가 없다. // 뒤의 주석처리는 );까지 주석처리 돼버린다.

</head>
<body>
<h1>표현식(expression element)</h1>
<ul>
<%for (String name : names) {%>
<li><%=name%></li>
<%}%>
</ul>
</body>
</html>

ex06.jsp -> 선언부(declaration element) // 클래스에 멤버를 추가할 때 사용 // <%!로 지정

<%!
// 다음과 같이 상속 받은 메서드를 오버라이딩 할 수 있다.
public void jspInit() {
  System.out.println("ex06.jsp의 jspInit()");
}

public void jspDestroy() {
  System.out.println("ex06.jsp의 jspDestroy()");
}
%>
<body>
<h1>선언부(declaration element)</h1>

100,000,000 입금 = <%=calculate(100000000)%>
</body>

<%!
double interest = 0.025; // 인스턴스 변수

private String calculate(long money) { // 인스턴스 메서드 
  return String.format("%.2f", money + (money * interest));
}
%>

<%!
{ // 인스턴스 블록
  System.out.println("ex06 인스턴스 생성!");
}

static { // 스태틱 블록
  System.out.println("ex06 클래스 로딩");
}
%>
</html>

// jspInit()나 jspDestroy()와 같은 메서드를 오버라이딩 할 때도 사용할 수 있다. // 선언 위치는 상관 없다.

// JSP 문법 // <%! 멤버 선언 %>

// 자바 코드 // class JSP클래스{ 멤버선언 void _jspService() { ... } }

ex07.jsp -> 지시문(directive element) // page // <%@로 지정

// 지시문은 3가지가 있다. // 1. page 2. include 3. taglib

// page 지시문 // 서블릿 실행과 관련하여 특정 기능을 설정

<%@ page 
    language="java" 
    contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"
    import="java.net.Socket"
    import="java.net.ServerSocket"
    import="java.util.List,java.util.Map,java.util.Set"
    trimDirectiveWhitespaces="true"
    buffer="8kb"
    autoFlush="false"%>
<%@ page import="java.sql.Connection"%>
<%@ page import="java.sql.Statement"%>

// 1. language="java" // JSP 페이지에서 코드를 작성할 때 사용할 언어를 지정

// 즉 <% 코드 %>, <%= 표현식 %>, <%! 코드 %> 태그에 코드를 작성할 때 사용할 언어

// 원래는 다양한 언어를 사용할 경우를 고려해 설계되었지만, 현재는 java 언어만 사용 가능 // 생략가능

// 2. contentType="text/html; charset=UTF-8" // 자바 코드를 생성

// response.setContentType("text/html; charset=UTF-8"); // 이 코드를 작성하는 단축 명령이라고 생각

// 3. pageEncoding="UTF-8" // JSP 파일의 인코딩을 설정

// JSP 파일을 UTF-8로 저장할 때 선언 // 생략한다면 에디터에 설정된 문자집합으로 인코딩

// 4. import="java.net.Socket" // 자바의 import 문을 생성

// 사용법 //

// 5. import="java.net.Socket" // import="java.net.Socket,java.net.ServerSocket,java.util.List"

// 한 개의 page 지시문에 여러 개의 import를 작성할 수 있다. // 여러 개의 page 지시문을 작성할 수 있다.

// trimDirectiveWhitespaces="true" // 지시문 끝에 줄바꿈 코드를 무시하고 싶을 때 사용

// 6. buffer="8kb" // 출력 버퍼의 크기를 변경할 때 사용 // 지정하지 않으면 기본이 8kb 이다.

// 출력 내용이 버퍼의 크기를 넘으면 예외가 발생 // 서블릿에서는 자동으로 출력하였다.

// 그러나 JSP는 예외가 발생한다. // autoFlush가 false일 때 예외 발생

// 7. autoFlush="true" // 출력 버퍼가 찼을 때 자동으로 출력 // 기본은 true

// false로 설정하면 출력 버퍼가 찼을 때 예외가 발생

ex08.jsp -> 지시문(directive element) // include

// include지시문 // 다른 파일의 내용을 복사해온다.

<body>
<h1>지시문(directive element) - include</h1>
<%@ include file="./ex08_header.txt"%>
<p>테스트</p>
<%@ include file="./ex08_footer.txt" %>
</body>

// file="JSP에 포함시킬 파일 경로" //

// 지정한 파일을 JSP로 포함시킨 후에 자바 서블릿 클래스를 생성한다. //

// 일반 텍스트 파일이면 된다. JSP 파일일 필요가 없다.

<%@ page pageEncoding="UTF-8"%>
<header>머리말</header>

// ex08_header.txt 내용 // txt 파일이다.

<%@ page pageEncoding="UTF-8"%>
<footer>꼬리말</footer>

// ex08_footer.txt 내용 // txt 파일이다.

// RequestDispatcher의 include()와 다르다. // include()는 실제 해당 Servlet에 갔다가 오는 것이고,

// JSP의 include는 코드를 갖다 붙히는 방식이다.

// <%@ page pageEncoding="UTF-8"%> // JSP 파일이 아니더라도 해당 파일의 문자집합을 지정해야 한다.

// JSP 엔진에 해당 파일의 내용을 가져올 때 pageEncoding에 지정된 문자집합으로 내용을 인식한다.

// JSP 엔진은 <%@ page ...%>는 참고만 할 뿐 가져오지는 않는다. // 그 밑의 코드만 가져온다.

ex09.jsp -> 지시문(directive element) // taglib

// taglib 지시문 // JSTL 등 외부에서 정의한 태그 정보를 가져온다.

// 외부에 따로 정의된 JSP 확장 태그를 가져올 때 사용

// 따라서 jsp에 가급적 java 코드를 한 줄도 안적게 하는 것이 궁극적인 목표이다.

// java코드는 정말 부득이한 경우에만 사용

// JSP 확장 태그 //

// 1. JSTL(JSP Standard Tag Library) // JSP 명세에 추가로 정의된 태그

// Servlet/JSP API에서는 JSTL 구현체를 제공하지 않는다.

// 따로 구현된 라이브러리를 다운로드 받아야 한다.

// mvnmvnrepository.com 또는 search.maven.org 접속 - 'jstl' 검색

// org.springframework:spring-context // 버전 클릭 // Gradle Groovy DSL 복사

// - 라이브러리 정보를 dependencies {} 블록에 추가 - 'gradle cleanEclipse' - 'gradle eclipse'

// jstl을 열어보면 javax.servlet.jsp.jstl과 org.apache.taglibs.standard 두개가 있다.

// .jstl은 interface 이고, .standard는 구현체가 들어있다. // 따라서 jstl을 둘 다 들어있는 것을 받자.

// <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> // jsp 파일에 이 태그가 들어있어야 하며,

// 해당 java project에 jstl이 작성되어 있어야 한다. // build.gradle에 라이브러리 정보 넣는 것.

<body>
<h1>지시문(directive element) - tablib</h1>
<c:forEach items="홍길동,임꺽정,유관순,안중근,윤봉길,김구,김원봉" var="n">
이름=<%=pageContext.getAttribute("n")%>, ${n}<br>
</c:forEach>
</body>

// 더 자세한 작성 법은 추후 다시 배운다.

// 2. 개발자가 정의한 태그 // 개발자가 따로 태그를 정의

// 그러나 실무에서는 유지보수를 일관성을 위해 JSTL과 같은 표준 API를 사용한다.

// 즉 개발자가 자신의 회사에서만 사용할 태그를 따로 정의하지 않는다.

// 사용법 //

// <%@ taglib uri="확장 태그를 정의할 때 부여한 확장 태그 URI"

// prefix="확장태그를 사용할 때 붙이는 접두사"%>

// JSP 페이지에서 사용 //

// <확장_태그_접두사:사용자_태그명 속성명="값" .../>

ex10.jsp -> JSP 빌트인 객체

// JSP 빌트인 객체 // JSP에서 기본으로 사용할 수 있는 객체

// JSP를 가지고 서블릿 클래스를 만들 때 _jspService() 메서드에서 기본으로 준비하는 객체

// JSP 엔진은 반드시 다음과 같은 이름으로 레퍼런스를 선언해야 한다.

// 즉 서블릿 컨테이너(ex: 톰캣, jetty, resin 등)에 상관없이 이름이 같다.

// 1. request - HttpServletRequest // _jspService() 파라미터이다.

// 2. response - HttpServletResponse // _jspService() 파라미터이다.

// 3. pageContext - PageContext // _jspService()의 로컬 변수이다.

// 4. session - HttpSession // _jspService()의 로컬 변수이다.

// 5. application - ServletContext // _jspService()의 로컬 변수이다.

// 6. config - ServletConfig // _jspService()의 로컬 변수이다.

// 7. out - JspWriter // _jspService()의 로컬 변수이다.

// 8. page - 서블릿 객체를 가리킨다. 즉 this 이다. // _jspService()의 로컬 변수이다.

// 9. exception - Throwable // _jspService()의 로컬 변수이다.

// 이 변수는 JSP 페이지가 <%@ page isErrorPage="true"%>로 설정되었을 때만 존재한다.

// 주로 오류가 발생되었을 때 실행되는 JSP 페이지인 경우 위 설정을 붙인다.

// 위 9가지의 변수는 반드시 선언되어 있어야 하며, 이름도 동일해야 한다. // JSP에서 자동으로 준비하는 변수

// req 이런식으로 변수 선언 불가 // 따라서 위의 이름 그대로 호출하여 사용하여야 한다.

<%
request.setAttribute("aaa", "okok");
session.setAttribute("bbb", "nono");
application.setAttribute("ccc", "haha");
out.println("okok");
%>

// JSP에서 기본으로 준비한 변수를 사용할 수 있다. // JSP에서 기본으로 준비하는 변수이다.

ex11.jsp -> JSP 액션 태그 // jsp:useBean, jsp:setProperty

// JSP 액션 태그 // JSP에서 기본으로 제공하는 JSP 전용 태그

// 따로 taglib를 사용하여 라이브러리를 선언할 필요가 없다.

// JSP에서 기본으로 제공하기 때문에 그대로 사용하면 된다.

// <jsp:태그명 ..../> // 네임스페이스 이름은 jsp 이다.

// jsp:useBean // JSP에서 사용할 객체를 생성할 때 사용할 수 있다.

<jsp:useBean id="b1" class="com.eomcs.web.vo.Board" scope="page"/>

// 보관소(ServletContext, HttpSession, ServletRequest, PageContext)에 저장된 객체를 꺼낼 때도 사용한다.

// HttpSession // 클라이언트마다 독자적으로 관리하게 하는 보관소

// ServletRequest // 클라이언트가 요청할때 생기는 보관소 // 요청에 응답하면 사라진다.

// PageContext // JSP 보관소

// 사용법 // <jsp:useBean scope="보관소명" id="객체명" class="클래스명"/>

// 주요 속성 // 1. scope 2. id 3.class // 그 외 type 등등

// scope // 객체를 꺼내거나 생성된 객체를 저장할 보관소 이름

// 다음 4개의 값 중 한 개를 지정할 수 있다. // 값을 지정하지 않으면 기본이 "page" 이다.

// application(ServletContext), session(HttpSession), request(ServletRequest), page(PageContext)

<jsp:useBean id="b2" class="com.eomcs.web.vo.Board"/>
<jsp:useBean id="b3" class="com.eomcs.web.vo.Board"/>

// id // 객체를 꺼내거나 저장할 때 사용할 이름

// class // 보관소에서 객체를 찾을 수 없을 때 생성할 객체의 클래스명

// 반드시 패키지 이름을 포함해 클래스명(fully-qualified name; FQName)을 지정해야 한다.

// <%@ page import="..."%> 를 선언해도 소용없다.

// 객체를 꺼내는 경우 레퍼런스의 타입으로도 사용된다.

// 객체를 생성할 때도 사용할 수 있기 때문에 반드시 콘크리트(concrete) 클래스명이어야 한다.

// 추상 클래스와 인터페이스는 객체를 생성할 수 없기 때문에 안된다.

// 객체의 setter 메서드 호출 //

// 자바 원시 타입과 문자열을 제외한 속성의 값을 지정할 수 없다. // 별도로 처리해야 한다.

// ex) <jsp:setProperty name="b3" property="createdDate" value="2019-4-8"/> // 사용 불가.

// 그 이외의 속성을 처리하고 싶다면, 스크립트릿(scriptlit)으로 처리하자 // 태그핸들러 만드는건 너무 귀찮다.

<jsp:setProperty name="b3" property="no" value="100"/>
<jsp:setProperty name="b3" property="contents" value="내용입니다."/>
<jsp:setProperty name="b3" property="viewCount" value="88"/>

ex12.jsp -> JSP 액션 태그 // jsp:useBean // String 사용

// 보관소에 값 넣는 방법 // 보관소명.setAttribute("id", "value)

<%
application.setAttribute("s1", "홍길동");
session.setAttribute("s2", "임꺽정");
request.setAttribute("s3", "안중근");
pageContext.setAttribute("s4", "윤봉길");
%>

// 값 꺼내는 방법 // <jsp:useBean id="래퍼런스명" type="래퍼런스타입" scope="보관소명"/>

<jsp:useBean id="s1" type="java.lang.String" scope="application"/>
<jsp:useBean id="s2" type="java.lang.String" scope="session"/>
<jsp:useBean id="s3" type="java.lang.String" scope="request"/>
<jsp:useBean id="s4" type="java.lang.String" scope="page"/>

// <jsp:useBean id="s1" type="java.lang.String" scope="application"/>

// String s1 = (String)application.getAttribute("s1"); // Java 코드로 변환 //

// <jsp:useBean id="s2" type="java.lang.String" scope="session">

// String s2 = (String)session.getAttribute("s2"); // Java 코드로 변환 //

// <jsp:useBean id="s3" type="java.lang.String" scope="request"/>

// String s3 = (String)request.getAttribute("s3"); // Java 코드로 변환 //

// <jsp:useBean id="s4" type="java.lang.String" scope="page"/>

// String s4 = (String)pageContext.getAttribute("s4"); // Java 코드로 변환

// 얘는 java에서 이름이 pageContext이다. // 얘만 이름이 다르기 때문에 유의 해야 한다.

// scope명은 JSP에서 호출 할 때의 이름이고, Java 코드로 변환돼서는 pageContext를 호출해야 한다.

// type // 보관소에서 꺼낸 객체의 타입을 지정할 때 사용한다.

// 보관소에 없는 객체를 꺼내려 한다면 예외가 발생한다. //

ex13.jsp -> JSP 액션 태그 // jsp:useBean // ArrayList<String> 사용

<%@page import="java.util.ArrayList"%>

// ArrayList를 사용하기 위해 상단부에 import문을 선언한다. // page 지시문

<%
ArrayList<String> names = new ArrayList<>();
names.add("홍길동");
names.add("임꺽정");
names.add("안중근");
names.add("윤봉길");

pageContext.setAttribute("list", names);
%>

// java 코드에서 pageContext에 ArrayList를 담는다.

// <jsp:useBean id="list" type="java.util.ArrayList<String>" scope="page"/>

// java.util.ArrayList<String> list = (java.util.ArrayList<String>) pageContext.getAttribute("list"); // 자바코드로 변환

// list도 해당 보관소에 없다면 오류가 발생한다.

ex14.jsp -> JSP 액션 태그 // jsp:useBean // List<String> 사용

<%@page import="java.util.List"%>

// List를 사용하기 위해 상단부에 import문을 선언한다. // page 지시문

<%
ArrayList<String> names = new ArrayList<>();
names.add("홍길동");
names.add("임꺽정");
names.add("안중근");
names.add("윤봉길");

pageContext.setAttribute("list", names);
%>

<jsp:useBean id="list" type="java.util.List<String>" scope="page"/>

// ArrayList를 담았어도, type을 인터페이스로 지정해도 된다.

ex15.jsp -> JSP 액션 태그 // jsp:useBean //

// id로 지정된 객체를 찾지 못하면 예외가 발생한다

ex16.jsp -> JSP 액션 태그 // jsp:useBean

<jsp:useBean id="list" class="java.util.ArrayList" scope="page"/>

// type 속성 대신에 class 속성을 사용하면 id로 지정한 객체를 찾지 못했을 때 해당 객체를 만들고,

// 그 id로 보관소에 저장 // class 속성에는 generic 문법을 사용할 수 없다.

// 보관소에 객체가 없을 때 생성해야 하기 때문에 class 속성에는 인터페이스를 설정할 수 없다.

ex17.jsp -> JSP 액션 태그 // jsp:useBean

// id가 가리키는 객체가 보관소에 없을 때 class 속성에 지정된 타입의 인스턴스를 생성한다.

// class 속성에는 인터페이스나 추상 클래스를 지정할 수 없다.

// 인터페이스나 추상클래스는 인스턴스를 생성할 수 없기 때문이다.

ex18.jsp -> JSP 액션 태그 // jsp:useBean

// for ( : ) 문을 제대로 사용하려면 목록에 보관된 객체의 타입이 무엇인지 제네릭으로 지정해야 한다.

// 그러나 class에서는 제네릭을 지정할 수 없다. // type과 class를 함께 사용한다.

// type으로 제네릭을 표현하고 class로 객체를 생성할 클래스를 지정한다.

<jsp:useBean id="list"
    type="java.util.List<String>" 
    class="java.util.ArrayList" scope="page"/>

// type 속성에서 제레릭으로 String을 지정했기 때문에 항목의 타입을 String으로 선언할 수 있다.

<%
for (String n : list) {
  out.println(n + "<br>");
}
%>

ex19.jsp -> JSP 액션 태그 // 인클루딩과 포워드

// jsp:include // 다른 페이지로 실행을 위임한 후 그 실행 결과를 포함시킬 때 사용

// 실행이 끝난 후 제어권이 되돌아 온다. // 따라서 page 속성에 지정하는 URL은 서블릿/JSP 이어야 한다.

// RequestDispatcher.include() 코드를 생성한다.

// jsp:forward // 다른 페이지로 실행을 위임할 때 사용

// 제어권이 넘어가면 되돌아 오지 않는다. // 따라서 page 속성에 지정하는 URL은 서블릿/JSP 이어야 한다.

// RequestDispatcher.forward() 코드를 생성한다.

ex20.jsp -> JSP 액션 태그 // errorPage 속성과 isErrorPage 속성

<%@ page 
    language="java" 
    contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"
    trimDirectiveWhitespaces="true"
    errorPage="ex20_error.jsp"%>

// errorPage // <%@ page errorPage="URL"%>

// JSP를 실행하는 중에 오류가 발생했을 때 실행할 JSP를 지정할 수 있다.

// 이 속성에 URL을 지정하지 않으면 오류가 발생했을 때 서블릿 컨테이너의 기본 오류 출력 페이지가 실행된다.

// isErrorPage //

// 오류가 발생했을 때 실행되는 JSP 쪽에서 그 오류 내용을 받을 때 사용한다.

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



<%=exception.getMessage()%>

// 에러페이지로 설정한 ex20_error.jsp //

// isErrrorPage="true"를 적용한다. // exception에서 에러 메세지를 받게 한다.

// 오류가 발생했을 때 실행되는 JSP 페이지는 exception이라는 변수를 통해 오류 내용을 받을 수 있다.

// isErrorPage 속성이 true이어야 해당 변수가 준비된다.

jstl

ex01.jsp -> JSTL(JSP Standard Tag Library)

// JSTL(JSP Standard Tag Library) // JSP 확장 태그이다. // 기본으로 제공하지 않는다. //

// mvnmvnrepository.com 또는 search.maven.org 접속 - 'jstl' 검색

// org.springframework:spring-context // 버전 클릭 // Gradle Groovy DSL 복사

// - 라이브러리 정보를 dependencies {} 블록에 추가 - 'gradle cleanEclipse' - 'gradle eclipse'

// 위에 jsp 할 때 다운받은거 맞다.

// JSTL 라이브러리 모듈 //

// Core(c) // http://java.sun.com/jsp/jstl/core

// XML(x) // http://java.sun.com/jsp/jstl/xml

// I18N(fmt) // http://java.sun.com/jsp/jstl/fmt

// Database(sql) // http://java.sun.com/jsp/jstl/sql

// Functions(fn) // http://java.sun.com/jsp/jstl/functions

// JSP 페이지에서 JSTL 라이브러리의 모듈 사용하기 //

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

// JSTL 태그 사용 // <접두어명:태그명 속성="값" 속성="값"/>

// I18N(Internationalization 의 약자) //

// 프로그램을 짤 때 여러 언어를 고려해서 코딩하는 것을 말한다.

// 특히 화면에서 버튼에 제목이나 라벨을 출력할 때 특정 언어로 고정된 값을 출력하지 않고,

// 외부 파일(예: label_ko_KR.properties)에서 읽어 온 값을 출력하도록 프로그래밍 하는 것.

// L10N(Localization 의 약자) //

// 특정 언어에 대해 라벨 텍스트를 담은 프로퍼티 파일(예: label_ko_KR.properties)을 작성하는 것을 말한다.

ex02.jsp -> c:out // 출력문을 만드는 태그

// <c:out value="출력될 값" default="기본 값"/> // <c:out value="출력될 값>기본값<c:out>

<c:out value="임꺽정"/><br>
<c:out value="${null}" default="홍길동"/><br>
<c:out value="${null}">홍길동</c:out><br>
<c:out value="${'임꺽정'}" default="홍길동"/><br>
<c:out value="${name}" default="홍길동"/><br>
<c:out value="${name2}" default="홍길동"/><br>

// 출력 결과 // 임꺽정 홍길동 홍길동 임꺽정 홍길동 홍길동

// ${} 안의 값이 없거나 불러오지 못할 때, default 값을 넣는다.

ex03.jsp -> c:set // 보관소에 값을 저장하는 태그

// <c:set scope="request" var="name1" value="홍길동"/>

// scope에 적은 request 보관소에 name1이라는 이름으로 value 홍길동을 저장한다.

// 자바코드 // request.setAttribute("name1", "홍길동");

// <c:set var="name2" value="임꺽정"/> // scope를 생략하면 기본이 PageContext이다.

// <c:set var="name3">유관순</c:set> // value에 넣지 않고 이렇게 넣을 수도 있다.

// <jsp:useBean id="m1" class="com.eomcs.web.vo.Member"/> // 멤버 객체를 m1이라는 이름으로 만든다.

// <jsp:setProperty name="m1" property="no" value="100"/> // 불러온 m1의 no 값에 값을 넣는다.

// <c:set target="${pageScope.m1}" property="email" value="hong@test.com"/>

// c:set 태그를 이용해서 값을 넣을 수도 있다.

// jsp:setProperty하고 공통점은 둘다 m1이라는 객체를 미리 만들어 둬야 한다는 점이다.

// 그러나 다른 점은 jsp:setProperty는 항상 useBean을 먼저 호출해서 m1을 불러내야 하고,

// c:set은 호출이 필요 없이, 바로 넣을 수 있다. // 만들어둔 m1을 호출하고 넣느냐 그냥 넣느냐의 차이.

ex04.jsp -> c:remove // 보관소에 저장된 값을 제거하는 태그

// <c:remove var="name" scope="page"/> // scope=보관소에 저장된 var=값을 삭제한다.

ex05.jsp -> c:if // 조건문을 만드는 태그

<c:set var="name" value="홍길동"/>
<c:set var="age" value="26"/>
<c:set var="gender" value="man"/>

<c:if test="${not empty name}">
    <p>${name}님 환영합니다!
</c:if>
<c:if test="${age < 19}">
    <p>미성년입니다.</p>
</c:if>
<c:if test="${age >= 19}">
    <p>성년입니다.</p>
</c:if>

// 조건문의 결과를 보관소에 저장하기 //

// var 속성으로 변수이름을 설정하면, 조건문의 테스트 결과는 지정된 이름으로 보관소에 저장된다.

// <c:if test="${gender == 'woman'}" var="r1"/> ${pageScope.r1 ? "여성" : "남성"}

// 위에서 이미 gender 값에 man을 넣어놨고, c:if문에서 gender 값이 woman이니?의 결과 값을 r1에 담는다.

// r1의 값은 false이며, r1의 값이 true라면, 여성을 // false라면 남성을 출력하게 했으니 // 남성이 출력된다.

ex06.jsp -> c:choose // 다중 조건문을 만드는 태그 // 자바의 switch와 유사

<c:set var="name" value="홍길동"/>
<c:set var="age" value="26"/>

<c:choose>
    <c:when test="${age < 19}">
        <p>미성년입니다.</p>
    </c:when>
    <c:when test="${age >= 19 and age < 65}">
        <p>성년입니다.</p>
    </c:when>
    <c:otherwise>
        <p>노인입니다.</p>
    </c:otherwise>
</c:choose>

ex07.jsp -> c:forEach // 반복문을 만드는 태그

// 배열 // /* */는 자바코드이다.

<%
pageContext.setAttribute("names", new String[]{"홍길동", "임꺽정", "유관순"});

/*
String[] names = (String[]) pageContext.getAttribute("names");
for (String n : names) {
  out.println("<li>" + n + "</li>");
}
*/
%>

<ul>
<c:forEach items="${pageScope.names}" var="n">
    <li>${n}</li>
</c:forEach>
</ul>

// Collection 객체 //

<%
List<String> names2 = new ArrayList<>();
names2.add("홍길동");
names2.add("임꺽정");
names2.add("유관순");
pageContext.setAttribute("names2", names2);
%>

<ul>
<c:forEach items="${pageScope.names2}" var="n">
    <li>${n}</li>
</c:forEach>
</ul>

// java와 다른 점은, 자바에서 n은 단순히 변수로 취급하고 사용 한데에 반해,

// c:forEach 에서 배열과 Collection의 값이 n이라는 이름으로 저장이 된다. // 저장한 보관소에

// Map 객체 //

<%
Map<String,Object> names3 = new HashMap<>();
names3.put("s01", "홍길동");
names3.put("s02", "임꺽정");
names3.put("s03", "유관순");
pageContext.setAttribute("names3", names3);
%>

<ul>
<c:forEach items="${pageScope.names3}" var="n">
    <li>${n.key} : ${n.value}</li>
</c:forEach>
</ul>

// Map 객체에 대해 반복문을 돌리면, key값과 value값을 같이 가지고 있는 n이 저장된다.

// CVS 문자열(comma separated value) //

<%
pageContext.setAttribute("names4", "홍길동,임꺽정,유관순,김구");
%>

<ul>
<c:forEach items="${pageScope.names4}" var="n">
    <li>${n}</li>
</c:forEach>
</ul>

ex08.jsp -> c:forTokens // 반복문을 만드는 태그

// CVS 문자열 //

<h2>CVS 문자열</h2>
<%
pageContext.setAttribute("names1", "홍길동,임꺽정,유관순,김구");

/*
String str = (String) pageContext.getAttribute("names1");
String[] values = str.split(",");
for (String n : values) {
  out.println("<li>" + n + "</li>");
}
*/
%>

<ul>
<c:forTokens items="${pageScope.names1}" var="n" delims=",">
    <li>${n}</li>
</c:forTokens>
</ul>

// Query String 문자열 //

<%
pageContext.setAttribute("qs", "name=홍길동&age=20&tel=1111-2222");
%>

<ul>
<c:forTokens items="${pageScope.qs}" var="n" delims="&">
    <li>${n}</li>
</c:forTokens>
</ul>

// foreach는 문자열을 ,로 밖에 못 자르지만,

// forTokens는 delims에 값을 지정하여 해당 값을 기준으로 자를 수 있다.

ex09.jsp -> c:url // 복잡한 URL을 만드는 태그

<pre>
https://search.naver.com/search.naver?where=nexearch&sm=top_hty&fbm=1&ie=utf8&query=%ED%99%8D%EA%B8%B8%EB%8F%99
</pre>

<c:url value="https://search.naver.com/search.naver" var="naverUrl">
    <c:param name="where" value="nexearch"/>
    <c:param name="sm" value="top_hty"/>
    <c:param name="fbm" value="1"/>
    <c:param name="ie" value="utf8"/>
    <c:param name="query" value="홍길동"/>
</c:url>

<pre>${naverUrl}</pre>

// url을 관리하여 복잡하게, 혹은 복잡한 url을 쉽게 관리 할 수 있다.

ex10.jsp -> c:import // HTTP 요청을 수행하는 코드를 만드는 태그

<c:url value="http://localhost:8888/bitcamp-java-web/jstl/ex10_sub.jsp" 
       var="url1">
    <c:param name="name" value="홍길동"/>
    <c:param name="age" value="20"/>
    <c:param name="gender" value="woman"/>
</c:url>
<pre>${url1}</pre>


<c:import url="${url1}" var="contents"/>

<textarea cols="120" rows="20">${pageScope.contents}</textarea>

<c:import url="https://www.naver.com" var="contents2"/>
<textarea cols="120" rows="20">${pageScope.contents2}</textarea>
</body>

// <pre> 태그는 HTML에서 쭉 나열하다가, 벽을 만나도 그대로 출력한다 //

// import 태그는 지정된 URL을 요청하고 서버로부터 받은 콘텐트를 contents라는 이름으로 저장한다.

ex11.jsp -> c:redirect // redirect 응답하기

<c:if test="${param.search == 'naver'}">
    <c:redirect url="http://www.naver.com"/>
</c:if>

<c:if test="${param.search == 'daum'}">
    <c:redirect url="http://www.daum.net"/>
</c:if>

ex12.jsp -> fmt:parseDate // 문자열로 지정된 날짜 값을 java.util.Date 객체로 만들기

<fmt:parseDate value="2018-10-08" pattern="yyyy-MM-dd" var="d1"/>
<fmt:parseDate value="10/08/2018" pattern="MM/dd/yyyy" var="d2"/>

<%
Date date1 = (Date)pageContext.getAttribute("d1");
Date date2 = (Date)pageContext.getAttribute("d2");

out.println(date1.toString() + "<br>");
out.println(date2.toString() + "<br>");

%>

// MM은 꼭 대문자로 사용해야 한다. // 자바코드에서 05형식처럼 쓰려면 MM으로 쓰기 때문,

// java에서 사용할 수 있게 parseDate로 바꾼 값을 꺼내서, 자바에서 Date 값에 받고 사용하면 된다.

// 단, util.Date는 우리가 생각하는 형식으로 날짜가 출력되는 게 아니라서, 잘 사용하지 않는다.

ex13.jsp -> fmt:formatDate // java.util.Date 객체의 값을 문자열로 만들기

<fmt:formatDate value="${pageScope.today}" 
    pattern="yyyy-MM-dd"/><br>
<fmt:formatDate value="${pageScope.today}" 
    pattern="MM/dd/yyyy"/><br>
<fmt:formatDate value="${pageScope.today}" 
    pattern="yyyy-MM-dd hh:mm:ss"/><br>
    
<fmt:formatDate value="${pageScope.today}" 
    pattern="yyyy-MM-dd"
    var="str1"/>
    
<p>오늘 날짜는 '${pageScope.str1}'입니다.</p>

// value="${보관소.값}" // ""를 꼭 사용해야 한다.

// var=str1은 str 값으로 보관소에 저장한다는 이야기이다.

저작자표시 비영리 변경금지

'IT Developer > Bitcamp' 카테고리의 다른 글

비트캠프 프론트엔드 및 벡엔드 개발자 Webapp js (0)	2020.04.28
비트캠프 프론트엔드 및 벡엔드 개발자 Webapp css (0)	2020.04.27
비트캠프 프론트엔드 및 백엔드 개발자 Spring-webmvc, java-web-library (0)	2020.04.17
비트캠프 프론트엔드 및 벡엔드 개발자 Web (0)	2020.04.03
비트캠프 프론트엔드 및 백엔드 개발자 #Project v55~60 (0)	2020.03.31
비트캠프 프론트엔드 및 벡엔드 개발자 DB (0)	2020.03.26
비트캠프 프론트엔드 및 벡엔드 개발자 net, netty, reflect (0)	2020.03.11
비트캠프 프론트엔드 및 벡엔드 개발자 ioc, jdbc, mybatis, (0)	2020.03.11

태마의 테마

비트캠프 프론트엔드 및 벡엔드 개발자 Webapp el, jsp, jstl

'IT Developer > Bitcamp' 카테고리의 다른 글

+ Recent posts

티스토리툴바