eomcs-java-web
web
web #ex01
Servlet01 -> Servlet이 가지고 있는 5개의 메소드 // init(), destroy(), service(), getServletInfo(), getServletConfig()
// init(), destroy(), service() // 3개 // Servlet의 Lifecycle 메서드
// init() // 생성 // 서블릿 객체를 생성하고 초기 작업을 시행하게 하는 메서드
// 서블릿을 실행할 때 사용할 자원을 이 메서드에서 준비한다. // 서블릿 객체 생성 직후 1회만 메서드가 실행된다.
// 파라미터로 받은 ServletConfig 객체는 인스턴스 변수에 보관해 두었다가 필요할 때 사용
// destroy() // 소멸 // 소멸하기전에 서블릿 객체를 불러 마지막 작업을 수행하게 하는 메서드
// 웹 애플리케이션이나 서버를 종료할 때 이 서블릿이 만든 자원을 해제할 수 있도록
// 서블릿 컨테이너가 이 메서드를 호출한다. // 서블릿 객체 소멸 직전 1회만 메서드가 실행된다.
// init()에서 준비한 자원을 보통 이 메서드에서 해제한다.
// service() // 실행 // 서블릿 객체를 불러서 클라이언트가 요청한 작업을 수행 시키는 메소드
// 클라이언트가 이 서블릿의 실행을 요청할 때마다 호출된다.
// getServletConfig() // 서블릿에서 작업을 수행하는 중에 서블릿 관련 설정 정보를 꺼낼 때 이 메서드를 호출
// getServletInfo() // 서블릿 컨테이너가 관리자 화면을 출력할 때 이 메서드를 호출
// Servlet 클래스 사용 //
// 서블릿 클래스를 만든 후 배치 파일(web.xml; DD 파일)에 서블릿 정보를 등록해야만 실행될 수 있다.
// WEB-INF/web.xml // DD File // Deployment Descriptor File
// 서블릿 실행 방법 // http://서버주소:포트번호/웹애플리케이션이름/서블릿URL
// http://localhost:9999/bitcamp-java-web/ohora/haha
// 서블릿 구동 과정 //
// 1. 웹 브라우저(ClientApp)가 서블릿 실행을 요청한다.
// 2. 서블릿 컨테이너는 해당 URL의 서블릿 객체를 찾는다.
// 3.1 서블릿 객체가 없다면,
// 서블릿 클래스에 대해 인스턴스를 생성 - 서블릿 객체의 생성자를 호출 - init()를 호출 - service()를 호출
// 3.2 서블릿 객체가 있다면, service()를 호출
// 4. 웹 애플리케이션이 종료된다면, 생성된 모든 서블릿들의 destroy() 메서드를 호출
// Servlet 사용 주의 //
// 클라이언트마다 구분되어야 할 데이터는 서블릿 인스턴스 변수에 보관해서는 안된다.
// 서블릿 인스턴스는 오직 클래스 마다 한 개만 생성되어
// 모든 클라이언트가 같은 서블릿 인스턴스를 사용 // 인스턴스를 모든 클라이언트가 공유하기 때문
Servlet02 -> GenericServlet 추상 클래스
// javax.servlet.Servlet 인터페이스를 service() 메서드만 남겨두고 나머지 메서드들은 모두 구현
// 이 클래스를 상속 받는 서브 클래스는 service() 만 구현하면 된다.
// GenericServlet 추상 클래스는 java.io.Serialize 인터페이스를 구현하였다.
// serialVersionUID 변수 값을 설정해야 한다.
Servlet03 -> HttpServlet 추상 클래스 상속
// doGet(), doPost(), doHead(), doPut() 등을 호출하게 프로그램 되어 있다.
// service()를 오버라이딩 하는 대신에 doGet(), doPost(), doHead() 등을 오버라이딩 해야 한다.
// 호출과정 //
// 1. 웹브라우저가 톰캣 서버에 요청
// 2. 톰캣 서버가 서블릿 객체에 대해 service(ServletRequest, ServletResponse) 호출
// 3. service(HttpServletRequest, HttpServletResponse) 호출
// 4. doGet(HttpServletRequest, HttpServletResponse) 호출
Servlet04 -> @WebServlet 애노테이션
// web.xml 에 서블릿 정보를 설정하는 대신에 애노테이션을 사용하여 서블릿을 설정할 수 있다.
// metadata-complete="false" // web.xml의 태그에 false로 속성을 추가해야 한다.
web #ex02
Filter01 -> 서블릿 컨테이너가 관리하는 컴포넌트 // 서블릿, 필터, 리스너
// Filter 만들기 // javax.servlet.Filter 인터페이스 규칙에 따라 작성
// 필터 배포하기 // DD 파일(web.xml)에 설정하거나 애노테이션으로 설정하면 된다.
// 필터의 용도 // 서블릿을 실행하기 전후에 필요한 작업을 수행
// 서블릿 실행 전 //
// ex) 웹브라우저가 보낸 암호화된 파라미터 값을 서블릿으로 전달하기 전에 암호 해제하기
// ex) 웹브라우저가 보낸 압축된 데이터를 서블릿으로 전달하기 전에 압축 해제
// ex) 서블릿의 실행을 요청할 권한이 있는지 검사
// ex) 로그인 사용자인지 검사 // ex) 로그 남기기
// 서블릿 실행 후 //
// ex) 클라이언트로 보낼 데이터를 압축하기
// ex) 클라이언트로 보낼 데이터를 암호화시키기
// Filter이 가지고 있는 5개의 메소드 // init(), destroy(), doFilter()
// init() // 필터 객체를 생성한 후 제일 처음으로 호출 // 필터가 사용할 자원을 이 메서드에서 준비
// 필터 객체 생성 직후 1회만 메서드가 실행된다.
// destroy() // 웹 애플리케이션이 종료될 때 호출 // init()에서 준비한 자원을 해제
// 필터 객체 소멸 직후 1회만 메서드가 실행된다.
// doFilter() // 필터를 설정할 때 지정된 URL의 요청이 들어 올 때 마다 호출 //
// 서블릿이 실행되기 전에 필터가 먼저 실행 // 서블릿을 실행한 후 다시 필터로 리턴
Filter02 -> 필터 실행 순서
// 필터의 실행 순서를 임의로 조정할 수 없다.
// 필터의 실행 순서에 상관없이 각 필터가 독립적으로 동작하도록 작성해야 한다.
Listener01 -> 리스너 만들기
// 서블릿 컨테이너 또는 서블릿, 세션 등의 객체 상태가 변경되었을 때 보고 받는 옵저버
// "Observer" 디자인 패턴 적용
// ServletContextListener //
// 서블릿 컨테이너를 시작하거나 종료할 때 보고 받고 싶다면 이 인터페이스를 구현
// ServletRequestListener //
// 요청이 들어오거나 종료될 때 보고 받고 싶다면 이 인터페이스를 구현
// HttpSessionListener //
// 세션이 생성되거나 종료될 때 보고 받고 싶다면 이 인터페이스를 구현
// XxxListener
// 기타 다양한 인터페이스가 있어, 문서를 참고
// 리스너 배포하기 // DD 파일(web.xml)에 설정하거나 애노테이션으로 설정하면 된다.
// 리스너의 용도 // 서블릿 컨테이너나, 세션 등이 특별한 상태일 때 필요한 작업을 수행한다.
// ServletContextListener // 웹 애플리케이션을 시작할 때 Spring IoC 컨테이너 준비하기
// 웹 애플리케이션을 시작할 때 DB 커넥션 풀 준비하기
// 웹 애플리케이션을 종료할 때 DB 커넥션 풀에 들어 있는 모든 연결을 해제하기
// ServletRequestListener // 요청이 들어 올 때 로그 남기기
Listener02 ->리스너 테스트
web #ex03
Servlet01 -> 문자표 지정하기 전 // 기본적으로 아스키 코드(ASCII)로 변환하여 출력
// 자바(Unicode2;UTF-16) -> 출력문자(ASCII) // 자바코드를 자동적으로 아스키 코드로 변환한다.
Servlet02 -> 한글 깨짐 현상 처리
// res.setContentType("text/plain;charset=UTF-8"); // text/plain 으로 ContentType 지정 // UTF-16 -> UTF-8
Servlet03 -> HTML 출력하기
// res.setContentType("text/html;charset=UTF-8"); // text/html으로 ContentType 지정
// HTML 출력할 때, MIME 타입에 HTML을 지정하지 않으면 웹 브라우저는 일반 텍스트로 간주한다.
Servlet04 ->바이너리 데이터 출력하기
// /WEB-INF/photo.jpeg 파일의 실제 경로 알아내기
// 1. 서블릿의 환경 정보를 다루는 객체를 먼저 얻는다.
// ServletContext ctx = req.getServletContext();
// 2. ServletContext를 통해 웹 자원의 실제 경로를 알아낸다.
// getRealPath(현재 웹 애플리케이션의 파일 경로) // 실제 전체 경로를 리턴
// String path = ctx.getRealPath("/WEB-INF/photo.jpeg");
// FileInputStream in = new FileInputStream(path);
// 3. 바이너리를 출력할 때 MIME 타입을 지정해야 웹 브라우저가 제대로 출력할 수 있다.
// 웹 브라우저가 모르는 형식을 지정하면 웹 브라우저는 처리하지 못하기 때문에 다운로드 대화상자를 띄운다.
web #ex04
Servlet01 -> GET 요청 데이터 읽기 // 응답, 요청 프로토콜 https://te-ma.tistory.com/209 에서 상세 확인
// GET 요청 // 웹 브라우저에 URL을 입력한 후 엔터를 치면 GET 요청을 보낸다.
// 웹 페이지에서 링크를 클릭하면(자바스크립트 처리하지 않은 상태) GET 요청을 보낸다.
// 웹 페이지의 폼(method='GET' 일 때)에서 전송 버튼을 클릭하면 GET 요청을 보낸다.
// 웹 브라우저에서 웹 서버의 자원 요청하는 방법 //
// 1. 서블릿 클래스를 실행하고 싶을 때
// servlet class 실제 위치 : ex) wtpwebapps/eomcs-java-web/WEB-INF/classes/com/eomcs/web/ex04/servlet01.class
// 요청시 : http://localhost:9999/eomcs-java-web/ex04/s1
// 해당 서블릿을 서버에 등록할 때 사용한 URL을 지정해야 한다.
// 2. HTML, CSS, JavaScript, JPEG 등 정적 파일을 받고 싶을 때
// 정적 파일 실제 위치 : ex) wtpwebapps/eomcs-java-web/ex04/test01.html
// 요청 : ex) http://localhost:9999/eomcs-java-web/ex04/test01.html
// 3. /WEB-INF/ 폴더에 있는 정적 파일을 받고 싶을 때
// 정적 파일 실제 위치 : ex) wtpwebapps/eomcs-java-web/WEB-INF/ex04/test01.html
// 요청 : ex) WEB-INF 폴더 아래에 있는 파일은 클라이언트에서 요청할 수 없다.
// 웹 애플리케이션의 정보를 두는 폴더이기 때문이다.
// HTTP 요청 프로토콜 //
// method sp request-URI sp http_version CRLF // Request-Line 이라고 함.
// (general header | request header | entity header) CRLF
// CRLF // CRLF는 텍스트 줄의 끝을 의미
// message-body
// method는 GET, POST, PUT, DELETE, TRACE, CONNECT, HEAD, OPTIONS // 8가지이다. // 나머지는 밑에 설명
// GET 요청은 데이터를 request-URI에 붙여서 보낸다.
// ex) /java-web/ex04/s1?name=%ED%99%8D%EA%B8%B8%EB%8F%99&age=20
// 서블릿 URL // /java-web/ex04/s1
// 데이터(Query String) // name=%ED%99%8D%EA%B8%B8%EB%8F%99&age=20
// 데이터 형식 // 이름=값&이름=값&이름=값
// URL 인코딩 // 데이터를 보낼 때 7bit 네트워크 장비를 거치면 8비트 데이터가 깨진다.
// 이를 방지하고자 보내는 데이터를 7비트로 변환 // 원래 코드 값을 아스키(ASCII) 문자 코드로 변환
// ASCII 코드는 7비트이기 때문에 데이터를 주고 받을 때 깨지지 않는다.
// 단 8비트 데이터를 ASCII 코드(7비트)로 변환하면, 1데이터 손실이 일어나게 된다.
// 따라서 이 손실을 막기 위해, URL인코딩을 해야한다.
// URL 인코딩이란? 문자 코드의 값을 ASCII 코드화시키는 것
// http_version // HTTP 버전을 의미
// "HTTP" "/" 1*DIGIT "." 1*DIGIT 와 같이 정의되는데 현재 HTTP/1.0과 HTTP/1.1이 있다.
// header // header는 general-header, request-header, entity-header // 3가지 종류가 있다.
// General Header // Cache-Control, Connection, Date, Pragma, Trailer, Transfer-Enco, Upgrade, Via, Warning
// Request Header // Accept, Accept-Charset, Accept-Encoding, Accept-Language, Authorization, Expect, From,
// Host, If-Match, If-Modified-Since, If-None-Match, If-Range, If-Unmodified-Since, Max-Forwards,
// Proxy-Authorization, Range, Referer, TE, User-Agent 등
// Entity Header // Allow, Content-Encoding, Content-Language, Content-Length, Content-Location,
// Content-MD5, Content-Range, Content-Type, Expires, Last-Modified, extension-header
// name : content // 헤더마다 위와 같은 name을 가지고 있고, 해당하는 content를 넣어 표현한다.
// 각 값들은 공백이나, 탭으로 구분될 수 있고, 각 해더는 CRLF로 구분된다.
GET /java-web/ex04/s1?name=%ED%99%8D%EA%B8%B8%EB%8F%99&age=20 HTTP/1.1 Host: localhost:8080
Connection: keep-alive Pragma: no-cache Cache-Control: no-cache Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like
Gecko) Chrome/73.0.3683.86 Safari/537.36 Accept:
text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng, Accept-Encoding:
gzip, deflate, br Accept-Language: ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7,la;q=0.6 빈 줄// HTTP 응답 프로토콜 //
// HTTP-Version SP Status-Code SP Reason-Phrase CRLF // status-line이라 함.
// (general header | response header | entity header) CRLF
// CRLF
// message-body
// Status-Code // 3자리 숫자로 된 상태를 나타내는 코드
// 1xx // 요청을 받았고, 처리중임을 표현
// 2xx // 성공했음을 표현
// 200 // 요청을 정상적으로 처리했음
// 201 // 요청한 자원을 생성했음
// 3xx // 요청한 자원이 다른 장소로 옮겨졌음을 표현
// 301 // 요청한 자원이 다른 장소로 이동 했음
// 304 // 요청한 자원이 변경되지 않았음. 따라서 기존에 다운로드 받은 것을 그대로 사용하라고 요구함.
// 4xx // 잘못된 형식으로 요청했음을 표현
// 401 요청 권한이 없음.
// 403 // 요청한 자원에 대한 권한이 없어 실행을 거절함.
// 404 // 요청한 자원을 찾을 수 없음.
// 5xx // 서버쪽에서 오류가 발생했음을 표현
// 500 // 서버에서 프로그램을 실행하다가 오류 발생함.
// header // general header와 Entity header는 요청부분과 동일
// Response Header // Accept-Ranges, Age, ETag, Location, Proxy-Authenticate, Retry-After,
// Server, Vary, WWW-Authenticate
HTTP/1.1 200 OK Content-Type: text/plain;charset=UTF-8 Content-Length: 27 Date: Thu, 28 Mar 2019
05:46:08 GMT CRLF 이름=홍길동 나이=20// URI (Uniform Resource Identifier) // 웹 자원의 위치를 가리키는 식별자 // URL과 URN이 있다.
// URL(Uniform Resource Locator) // scheme:[//[user:password@]host[:port]][/]path[?query][#fragment]
// ex) http://localhost:8080/ex04/s1?name=홍길동&age=20
// URN(Uniform Resource Name) // <URN> ::= "urn:" <NID> ":" <NSS>
// ex) urn:lex:eu:council:directive:2010-03-09;2010-19-UE
Servlet02 -> POST 요청 데이터 읽기
// POST 요청 // 웹 페이지의 폼(method='POST' 일 때)에서 전송 버튼을 클릭하면 POST 요청을 보낸다.
// 웹 브라우저가 보낸 데이터 읽기 // 데이터를 읽을 때는 GET 요청과 POST 요청이 같다.
// ServletRequest.getParameter("파라미터이름") // POST로 보낸 데이터는 영어(ISO-8859-1)로 간주한다
// 그래서 영어 코드를 자바에서 사용하는 UTF-8로 변환한다.
// ex) ABC가각 // 웹에서 보낸다고 가정하고 설명함.
// 실제 웹 브라우저가 "ABC가각" 문자열을 보낼 때 UTF-8 코드를 보낸다. // 414243EAB080EAB081
// 그런데 서블릿에서는 이 코드 값을 ISO-8859-1 코드라고 간주
// getParameter()로 값을 꺼내면 UTF-16으로 바꾼 값을 리턴 // 0041 0042 0043 00EA 00B0 0080 00EA 00B0 0081
// 바이트에 00을 붙여 문자열을 만들어 리턴 // 영어를 2바이트 유니코드로 바꿀 때 앞에 00을 붙이면 되기 때문
// ABCê°ê° // 변환된 코드를 화면에 출력하면 이렇게 나온다.
req.setCharacterEncoding("UTF-8");
String age = req.getParameter("age");
String name = req.getParameter("name");
res.setContentType("text/plain;charset=UTF-8");// getParameter()를 최초로 호출하기 전에 클라이언트가 보낸 데이터의 인코딩 형식을 먼저 알려줘야 한다.
// getParameter가 이전에 한번이라도 호출 된 후라면 적용되지 않는다.
// GET 요청 vs POST 요청
// 1. 전송 데이터 용량
// GET // 게시글 조회나 검색어 입력 같은 간단한 데이터 전송
GET /ex01/s1?id=a@naver.com&pwd=1111 HTTP/1.1
HOST :
.
.
.
// 대부분의 웹서버가 request-line과 헤더의 크기를 8KB로 제한하고 있다.
// 위 예제처럼 GET은 값이 헤더에 들어가게 된다.
// 따라서 긴 게시글과 같은 큰 용량의 데이터를 GET 방식으로 전송할 수 없다.
// POST // 게시글 등록이나 첨부파일 같은 큰 데이터 전송
POST /ex01/s1 HTTP/1.1
HOST:
.
.
.
id=a@test.com&pwd=1111// HTTP 요청 헤더 다음에 message-body 부분에 데이터를 두기 때문에
// 용량의 제한 없이 웹 서버에 전송할 수 있다.
// 위의 예제처럼 POST는 값이 message-body에 들어가게 된다.
// 즉 웹 서버가 제한하지 않는 한 전송 데이터의 크기에 제한이 없다.
// 웹 서버가 제한 한다? // 특정 사이트에서는 게시글의 크기나 첨부파일의 크기에 제한을 둔다.
// 2. 바이너리 데이터 전송
// GET // 바이너리 Data 전송 불가 // 어거지로 가능은 하나 그렇게 안쓴다.
// request-URI가 텍스트로 되어 있다. // 따라서 바이너리 데이터를 request-URI에 붙여서 전송할 수 없다.
// URL에 Data가 포함되기 때문이다.
// 꼭 GET 요청으로 바이너리 데이터를 보내고자 한다면? // 바이너리 데이터를 텍스트로 변환하면 된다.
// ex) 바이너리 데이터를 Base64로 인코딩하여 텍스트를 만든 후, GET 요청 방식대로 이름=값으로 보내면 된다.
// 그래도 결국 용량 제한 때문에 바이너리 데이터를 GET 요청으로 전송하는 것은 바람직하지 않다.
// POST // multipart 형식으로 보낼 때는 바이너리 Data 전송 가능 // 첨부파일 전송때 사용
// POST도 이름=값 형태로는 바이너리 값을 전송할 수 없다. // multipart 형식을 사용하면 전송 가능
// 3. 보안 // 보안이 가장 좋은건 POST가 아니라, HTTPS 방식을 사용하는 것이다.
// GET // URL에 전송 데이터가 포함되어 있기 때문에
// 사용자 아이디나 암호 같은 데이터를 GET 방식으로 전송하는 것은 위험하다.
// 웹 브라우저는 주소 창에 입력한 값을 내부 캐시에 보관해 두기 때문이다.
// POST // mesage-body 부분에 데이터가 있기 때문에 웹 브라우저는 캐시에 보관하지 않는다.
// 또한 주소 창에도 보이지 않는다. // 사용자 암호 같은 데이터를 전송할 때는 POST로 보내는 것이 바람직 하다.
// 보내는 데이터를 웹 브라우저의 캐시 메모리에 남기고 싶지 않을 때는 POST 방식을 사용한다.
// 특정 페이지를 조회하는 URL일 경우 POST 방식을 사용하면
// URL에 조회하려는 정보의 번호나 키를 포함할 수 없기 때문에 POST 방식이 적절하지 않다.
// 4. 쓰임
// GET // Request URL에 Data가 포함되어 있다. // 조회하는 페이지의 URL을 주고 받을 수 있어 편리하다.
// ex) /news/detail?no=117 // 뒤의 값이 나오기 때문에 즐겨찾기에 추가가 가능하다.
// POST // Request URL에 Data가 없다. // 특정 페이지로 바로 이동이 불가능하다.
// ex) /news/detail // 이 URL에 message body로 값을 보내기 때문에 URL은 고정되어 있다.
// URL은 계속 같은데, 넘겨지는 값에 따라 달라지기 때문에 북마크가 불가능하다.
Servlet03 -> 파일 업로드 처리하기
req.setCharacterEncoding("UTF-8");
String age = req.getParameter("age");
String name = req.getParameter("name");
String photo = req.getParameter("photo");
res.setContentType("text/plain;charset=UTF-8");<form action="/eomcs-java-web/ex04/s3" method="post">
이름: <input type="text" name="name"><br>
나이: <input type="number" name="age"><br>
사진: <input type="file" name="photo"><br>
<input type="submit" value="전송">
</form>// GET 요청으로 파일 전송하기 //
// GET 으로 파일을 전송할 수 없다. 단지 파일 이름만 전송한다.
// POST 요청으로 파일 전송하기 //
// POST 요청만 적용해서 보낸다면, form의 데이터 인코딩 형식은 "application/x-www-form-urlencoded"이다.
// 즉 "이름=값&이름=값&이름=값" 형식으로 데이터를 보낸다. // 첨부한 파일의 데이터를 보내지 못한다.
// 단지 파일 이름만 전송한다.
<form action="/eomcs-java-web/ex04/s3" enctype="multipart/form-data" method="post">
이름: <input type="text" name="name"><br>
나이: <input type="number" name="age"><br>
사진: <input type="file" name="photo"><br>
<input type="submit" value="POST 전송">
</form>// POST 요청 + multipart/form-data 형식으로 파일 전송하기 //
// enctype="multipart/form-data"
// 파일 업로드할때 꼭 encodingtype을 "multipart/form-data"로 지정해야 한다.
// multipart/form-data 형식으로 데이터를 전송하지 않으면 첨부 파일의 데이터는 받을 수 없다.
// 파일을 업로드 하려면, 반드시 multipart/form-data 형식으로 POST 요청해야 한다.
Servlet04 -> apache 라이브러리 사용 // 멀티파트 파일 업로드 처리
// 멀티파트 형식으로 전송된 데이터는 별도의 처리과정이 필요하다.
// Apache 재단에서 제공하는 fileupload 라이브러리가 이 별도의 처리과정을 대신 해준다.
// mvnmvnrepository.com 또는 search.maven.org 접속 - 'commons-fileupload' 검색
// org.springframework:spring-context // 버전 클릭 // Gradle Groovy DSL 복사
// - 라이브러리 정보를 dependencies {} 블록에 추가 - 'gradle cleanEclipse' - 'gradle eclipse'
private static final long serialVersionUID = 1L;
private String uploadDir;
@Override
public void init() throws ServletException {
this.uploadDir = this.getServletContext().getRealPath("/upload");
}// init(ServletCondig)가 호출될 때 이 메서드(init())를 호출한다. // 파일을 저장할 디렉토리 경로를 준비
// 멀티파트 형식으로 보낸 첨부 파일 데이터를 읽는 방법 //
// Content-Type 헤더에 지정한 구분자를 사용하여 각 파트를 분리한 다음 데이터를 읽는다.
// 문제는 기존에 제공하는 getParameter()로는 멀티파트 형식으로 전송된 데이터를 읽을 수 없다.
// 해결방법 //
// 1. 개발자가 직접 멀티파트 형식을 분석하여 데이터를 추출한다. // 미친짓이다.
// 2. apache.org 사이트에서 제공하는 멀티파트 데이터 분석기를 사용 // 과거에는 많이 사용했었음.
// 3. Servlet 3.0 부터 제공하는 기능을 이용 // 과거에 쓰던 방식에 젖어 이 방법을 모르기도 한다.
// 4. Spring WebMVC를 사용한다면 해당 프레임워크에서 제공하는 기능을 이용 // 나중에 추후 설명
// req.setCharacterEncoding("UTF-8"); // 멀티파트 데이터를 처리할 때는 인코딩 설정이 적용되지 않는다.
// 멀티파트 형식으로 전송된 데이터는 getParameter()로 꺼낼 수 없다.
// 2번 방법 // 실무에서는 아직도 이 방법을 사용하기 때문에 짚고 넘어간다.
DiskFileItemFactory fileItemFactory = new DiskFileItemFactory();
ServletFileUpload multipartDataHandler = new ServletFileUpload(fileItemFactory);
HashMap<String, String> paramMap = new HashMap<>();
try {
List<FileItem> parts = multipartDataHandler.parseRequest((HttpServletRequest) req);
for (FileItem part : parts) {
if (part.isFormField()) {
paramMap.put(part.getFieldName(), part.getString("UTF-8"));// DiskFileItemFactory // 멀티파트 데이터를 분석하여 FileItem 객체에 담아 줄 공장을 준비
// ServletFileUpload(fileItemFactory) // 공장 객체를 사용하여 클라이언트가 보낸 데이터를 처리할 객체
// HashMap<String, String> // 분석한 데이터를 보관할 맵 객체를 준비
// multipartDataHandler.parseRequest((HttpServletRequest) req); //
// 멀티파트 데이터 처리기를 이용하여 클라이언트 요청을 분석
// part.isFormField() // 파트의 데이터가 일반 데이터라면
// paramMap.put(part.getFieldName(), part.getString("UTF-8") //
// 클라이언트가 보낸 파라미터 이름, 파라미터의 값. 값 꺼낼 때 인코딩을 지정
} else {
String filename = UUID.randomUUID().toString();
File file = new File(this.uploadDir + "/" + filename);
System.out.println(file.getCanonicalPath());
part.write(file);
paramMap.put(part.getFieldName(), filename);
}
}// 파트의 데이터가 파일이라면 upload/ 디렉토리에 파일을 저장한다.
// UUID.randomUUID().toString(); // 업로드 파일을 저장할 때 사용할 파일명을 준비한다. // 원래 파일명 사용 x
// 다른 클라이언트가 같은 이름의 파일을 업로드 하면 기존 파일을 덮어쓸 수 있기 때문
// new File(this.uploadDir + "/" + filename); // /java-web/upload/파일명 // 전체 파일 경로를 준비한다.
// part.write(file); // 파일 경로에 업로드 파일을 저장한다.
Servlet05 -> Servlet 3.0의 기본 라이브러리 사용
// 멀티파트 형식의 데이터를 처리할 서블릿으로 선언
// 사용방법은 두가지가 있다. // 1. DD 파일(web.xml)에 설정 2. 애노테이션으로 설정
// 1. DD 파일(web.xml)에 설정
<servlet>
<servlet-name>ex04.Servlet05</servlet-name>
<servlet-class>com.eomcs.web.ex04.Servlet05</servlet-class>
<multipart-config>
<max-file-size>10000000</max-file-size>
</multipart-config>
</servlet>
<servlet-mapping>
<servlet-name>ex04.Servlet05</servlet-name>
<url-pattern>/ex04/s5</url-pattern>
</servlet-mapping>// 2. 애노테이션으로 설정
@MultipartConfig(maxFileSize = 1024 * 1024 * 10)
@WebServlet("/ex04/s5")
public class Servlet05 extends GenericServlet {
private static final long serialVersionUID = 1L;
private String uploadDir;
@Override
public void init() throws ServletException {
this.uploadDir = this.getServletContext().getRealPath("/upload");
}
@Override
public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException {
req.setCharacterEncoding("UTF-8");
HttpServletRequest httpReq = (HttpServletRequest) req;
res.setContentType("text/html;charset=UTF-8");
PrintWriter out = res.getWriter();
out.println("<html>");
out.println("<head><title>servlet04</title></head>");
out.println("<body><h1>파일 업로드 결과</h1>");
out.printf("이름=%s<br>\n", httpReq.getParameter("name"));
out.printf("나이=%s<br>\n", httpReq.getParameter("age"));
Part photoPart = httpReq.getPart("photo");
String filename = "";
if (photoPart.getSize() > 0) {
filename = UUID.randomUUID().toString();
photoPart.write(this.uploadDir + "/" + filename);
out.printf("사진=%s<br>\n", filename);
out.printf("<img src='../upload/%s'><br>\n", filename);
}
out.println("</body></html>");
}
}
// @MultipartConfig(maxFileSize=값) // 최대 FileSize를 설정한다.
// req.setCharacterEncoding("UTF-8"); //
// Servlet 3.0의 멀티파트 처리 기능을 이용할 때는 클라이언트가 보낸 데이터의 인코딩을 지정해야 한다.
// (HttpServletRequest) req; // 파라미터로 받은 ServletRequest를 원래의 타입으로 변환한다.
// HttpServletRequest : 요청Data 클라이언트 정보 // HttpServletResponse : 출력스트림, 응답정보 다루는 도구
// httpReq.getParameter("name") // 일반 폼 데이터를 원래 하던 방식대로 값을 꺼낸다.
// Part photoPart = httpReq.getPart("photo"); // 파일 데이터는 getPart()를 이용한다.
// 밑에 반복문은 업로드 한 후에 이름 무작위 부여와 저장에 대한 내용이다. // Servlet04에서 설명함.
Servlet06 -> 여러 개의 데이터를 같은 이름으로 보낸 경우 // 문제
<form action="s6" method="get">
<input type="checkbox" name="genre1">로맨틱<br>
<input type="checkbox" name="genre2">스릴러<br>
<input type="checkbox" name="genre3">호러<br>
<input type="checkbox" name="genre4">드라마<br>
<input type="checkbox" name="genre5">액션<br>
<input type="checkbox" name="genre6">SF<br>
<input type="submit" value="전송">
</form>// HTML에서 서로 다른 이름으로 값을 보낼 경우 각각의 이름에 대해 값을 꺼내 확인해야 한다.
String genre1 = req.getParameter("genre1");
String genre2 = req.getParameter("genre2");
String genre3 = req.getParameter("genre3");
String genre4 = req.getParameter("genre4");
String genre5 = req.getParameter("genre5");
String genre6 = req.getParameter("genre6");
res.setContentType("text/plain;charset=UTF-8");
PrintWriter out = res.getWriter();
out.println("선택한 장르:");
if (genre1 != null) {
out.println("로맨틱");
}
if (genre2 != null) {
out.println("스릴러");
}
if (genre3 != null) {
out.println("호러");
}
if (genre4 != null) {
out.println("드라마");
}
if (genre5 != null) {
out.println("액션");
}
if (genre6 != null) {
out.println("SF");
}Servlet06_2 -> 여러 개의 데이터를 같은 이름으로 보낸 경우 // 해결
// 같은 값을 여러 개 입력 받아야 하는 경우 같은 이름을 사용하자 // 단 value로 구분하자.
<form action="s6_2" method="get">
<input type="checkbox" name="genre" value="1">로맨틱<br>
<input type="checkbox" name="genre" value="2">스릴러<br>
<input type="checkbox" name="genre" value="3">호러<br>
<input type="checkbox" name="genre" value="4">드라마<br>
<input type="checkbox" name="genre" value="5">액션<br>
<input type="checkbox" name="genre" value="6">SF<br>
<input type="submit" value="전송">
</form>// 그러면 위와 같이 한 번에 배열로 그 값들을 받을 수 있다.
// 배열로 받으면 반복문을 이용하여 보다 쉽고 간결하게 처리할 수 있다.
String[] genres = req.getParameterValues("genre");
String[] genreData = {"", "로맨틱", "스릴러", "호러", "드라마", "액션", "SF"};
res.setContentType("text/plain;charset=UTF-8");
PrintWriter out = res.getWriter();
out.println("선택한 장르:");
for (String genre : genres) {
out.println(genreData[Integer.parseInt(genre)]);
}Servlet07 -> 빈 값과 null
<form action="s7" method="get">
a: <input type="text" name="a" value="aaaa"><br>
b: <input type="text" name="b"><br>
c: <input type="checkbox" name="c"><br>
<input type="submit" value="전송">
</form>// a 입력상자에는 값을 넣고, b 입력상자에는 값을 입력하지 않고 전송을 한다.
// 파라미터 이름만 넘어갈 때 getParameter()의 리턴 값은 빈 문자열 객체이다.
// 즉 b는 null이 아닌 빈 문자열이 들어 있다.
// c 체크박스를 체크한 경우와, 체크하지 않은 경우
// 파라미터 이름 자체가 없으면 getParameter()는 null을 리턴한다.
// 즉 체크하지 않은 경우에는 null을 리턴한다.
Servlet08 -> 썸네일 이미지 만들기
// 돈 받고 프로그램 짤거면 사진에 대한 썸네일을 꼭 만들어야 한다. // 선택이 아닌 필수
// 클라이언트가 요청하지 않아도 3가지 버전은 필수로 만들어 놔야 한다.
// 1. 원본사진 2. 크기별 썸네일 1, 2 // 3장
// 썸네일은 원본 사진의 크기를 단순히 줄인 것이 아니다. // 화질을 떨구어 용량도 떨구어야 한다.
// mvnmvnrepository.com 또는 search.maven.org 접속 - 'thumbnailator' 검색
// org.springframework:spring-context // 버전 클릭 // Gradle Groovy DSL 복사
// - 라이브러리 정보를 dependencies {} 블록에 추가 - 'gradle cleanEclipse' - 'gradle eclipse'
// 썸네일 만드는 라이브러리는 굉장히 많다. // 검색해서 사용하고 싶은 것 사용해도 된다.
// 썸네일 이미지 만들기 //
// ex) Thumbnails.of(this.uploadDir + "/" + filename).size(20, 20).outputFormat("jpg")
// .toFiles(Rename.PREFIX_DOT_THUMBNAIL);
// ex) Thumbnails.of(this.uploadDir + "/" + filename) .size(80, 80) .outputFormat("jpg")
// .toFiles(Rename.PREFIX_DOT_THUMBNAIL);
// ex) Thumbnails.of(this.uploadDir + "/" + filename) .size(160, 160) .outputFormat("jpg")
// .toFiles(Rename.PREFIX_DOT_THUMBNAIL);
// 원본 이미지 파일이 저장된 경로를 알려주고 // 어떤 썸네일 이미지를 만들어야 하는지 설정한다.
// 이미지 불러올 때 // 위에 ex) 순서대로
out.printf("<img src='../upload/thumbnail.%s.jpg'><br>\n", filename);
out.printf("<img src='../upload/%s' height='80'><br>\n", filename);
out.printf("<img src='../upload/%s'><br>\n", filename);
web #ex05
Servlet01 -> HttpServletRequest와 GET/POST // MyHttpServlet 상속 전
// HTTP 프로토콜로 통신을 하는 서블릿 컨테이너는 service() 메서드를 호출할 때
// ServletRequest의 값으로 HttpServletRequest를, ServletResponse의 값으로 HttpServletResponse를 전달한다.
// service() 메서드의 파라미터 값은 원래 HttpServletRequest와 HttpServletResponse이다.
// 이들 객체(HTTP객체)에는 HTTP 프로토콜을 다루는 메서드가 추가되어 있다.
// 따라서 HTTP 프로토콜을 다루려면 파라미터 값을 HTTP로 변환하여 사용하여야 한다.
HttpServletRequest httpReq = (HttpServletRequest) req; // HttpServletResponse httpRes = (HttpServletResponse) res;
if (httpReq.getMethod().equals("GET")) {
out.println("GET 요청입니다.");
} else if (httpReq.getMethod().equals("POST")) {
out.println("POST 요청입니다.");
} else {
out.println("이 서블릿이 다루지 못하는 요청 방식입니다.");
}// HttpServletRequest.getMethod() // HttpServletRequest의 HTTP 프로토콜의 요청 방식을 리턴하는 메서드
// getMethod()를 사용해서, 요청이 GET인지, POST인지 구분이 가능하다.
Servlet02 -> HttpServletRequest와 GET/POST // MyHttpServlet 상속 후
// Servlet01의 문제점 // Http 프로토콜을 다루려고 할 때마다, Http로 형변환을 해야 한다.
@SuppressWarnings("serial")
public abstract class MyHttpServlet extends GenericServlet {
@Override
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
this.service(request, response);
}
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
}
}// 서블릿 클래스를 만들 때 HTTP 프로토콜을 쉽게 다룰 수 있도록
// service(HttpServletRequest,HttpServletResponse) 메서드를 추가하였다.
// 서블릿 컨테이너가 service(ServletRequest req, ServletResponse res)를 호출하면,
// service(HttpServletRequest request, HttpServletResponse response)를 호출하게 만든 것이다.
// 단, Http를 파라미터로 받는 Service는 아무런 메서드가 구현되어있지 않기 때문에,
// 상속받아 사용하는 쪽에서 Service를 오버라이딩 해서 사용해야 한다. // Servlet02가 구현
// GenericServlet을 상속 받아 서블릿을 만들기보다 MyHttpServlet을 상속받아 사용한다면,
// 편하게 service()를 구현할 수 있다. // MyHttpServlet은 GenericServlet을 상속받는다.
Servlet03 -> HttpServletRequest와 Method // MyHttpServlet02 상속
// MyHttpServlet 클래스를 사용하여 서블릿을 만드는 것도 편하지만,
// 여기에다가 HTTP 요청 방식에 따라 메서드를 구분해 놓는다면 서브 클래스를 만들기가 더 편리할 것이다.
@SuppressWarnings("serial")
public abstract class MyHttpServlet2 extends GenericServlet {
@Override
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
this.service(request, response);
}
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String httpMethod = request.getMethod();
switch (httpMethod) {
case "GET":
doGet(request, response);
return;
case "POST":
doPost(request, response);
return;
case "PUT":
doPut(request, response);
return;
case "HEAD":
doHead(request, response);
return;
default:
error(request, response);
}
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
error(request, response);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
error(request, response);
}
protected void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
error(request, response);
}
protected void doHead(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
error(request, response);
}
private void error(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
PrintWriter out = response.getWriter();
out.println("해당 HTTP 요청을 처리할 수 없습니다.");
}
}//미리 MyHttpServlet2에서 Client에서 넘어온 Method를 구분하여 메서드를 구분해 놓는다면,
// 요청 들어온 Method에 따라, 필요한 MyHttpServlet2에서 만든 메서드를 상속받아 사용하자.
// 서브 클래스에서 오버라이딩 할 메서드라면 private으로 선언하지 않게 한다.
// 서브 클래스에서 이 메서드를 오버라이딩 하지 않으면 오류를 출력하도록 한다.
// 클라이언트 요청이 들어오면 서블릿 컨테이너 - service(ServletRequest,ServletResponse) 호출
// service(HttpServletRequest,HttpServletResponse) 호출 - doXxx(HttpServletRequest,HttpServletResponse) 호출
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/plain;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("GET 요청입니다.");
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/plain;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("POST 요청입니다.");
}// Servlet03에서는 단순히 만들어놓은 메서드를 용도에 맞게 오버라이딩하여 사용한다.
Servlet04 -> HttpServlet 클래스를 활용하기
// HttpServlet는 기존 라이브러리에서 이미 MyHttpServlet2처럼 만들어 놓은 클래스이다.
// Http 프로토콜을 사용할 때에는 HttpServlet을 상속받아,
// 요청들어온 Method에 맞게 메서드를 오버라이딩하여 사용하자.
web #ex06
Servlet01 -> load on startup // 서블릿 객체 자동 생성 // 애노테이션으로 설정
// @WebServlet(value = "/ex06/s1", loadOnStartup = 1) // 객체를 미리 만들고 싶은 서블릿에 애노테이션 설정
// loadOnStartup=실행순서 // 미리 생성할 서블릿이 여러 개 있다면, loadOnStartup에 지정한 순서대로 생성
// 클라이언트가 실행을 요청하지 않아도 서블릿을 미리 생성할 때, loadOnStartup 프로퍼티 값을 지정한다.
// 서블릿을 미리 생성하는 경우 //
// 서블릿이 작업할 때 사용할 자원을 준비하는데 시간이 오래 걸리는 경우
// 웹 애플리케이션을 시작시킬 때 미리 서블릿 객체를 준비
// ex) DB 연결, 소켓 연결, 필요한 환경 변수 로딩, 스프링 IoC 컨테이너 준비 등
Servlet02 -> load on startup // 서블릿 객체 자동 생성 // web.xml에 설정
<servlet>
<servlet-name>ex06.Servlet02</servlet-name>
<servlet-class>com.eomcs.web.ex06.Servlet02</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>ex06.Servlet02</servlet-name>
<url-pattern>/ex06/s2</url-pattern>
</servlet-mapping>// DD파일에 미리 객체를 생성시키고 싶은 서블릿의 정보를 넣는다.
// 현재 프로젝트(v55_2)에서는 listener를 사용해서 IoC 컨테이너를 준비하지만,
// Servlet01과 Servlet02처럼 loadOnStartup 방법으로 준비할 수도 있다.
Servlet03 -> 서블릿 초기화 파라미터 // 애노테이션으로 설정
@WebServlet(value = "/ex06/s3", loadOnStartup = 1, initParams = {
@WebInitParam(name = "jdbc.driver", value = "org.mariadb.jdbc.Driver"),
@WebInitParam(name = "jdbc.url", value = "jdbc:mariadb://localhost/bitcampdb"),
@WebInitParam(name = "jdbc.username", value = "bitcamp"), @WebInitParam(name = "jdbc.password", value = "1111") })
@SuppressWarnings("serial")
public class Servlet03 extends HttpServlet {
@Override
public void init(ServletConfig config) throws ServletException {
super.init(config);
}
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletConfig config = this.getServletConfig();
resp.setContentType("text/plain;charset=UTF-8");
PrintWriter out = resp.getWriter();
}
}// 서블릿이 사용할 값을 애노테이션 설정으로 지정할 수 있다.
// 서블릿 초기화 파라미터 // @WebInitParam()으로 설정된 값을 말한다.
// 그러나 위의 코드처럼 언제든 변경될 수 있는 값을 소스코드에 직접 적는 방식은 좋지 않다.
// 애노테이션으로도 이렇게 설정할 수 있다는 것을 보여주기 위한 예제이다.
// 보통 DD(web.xml) File에 보관한다. // 애노테이션으로 설정하지말고 DD File에 별도로 관리하자.
Servlet04 -> 서블릿 초기화 파라미터 // web.xml에서 설정
<servlet>
<servlet-name>ex06.Servlet04</servlet-name>
<servlet-class>com.eomcs.web.ex06.Servlet04</servlet-class>
<init-param>
<param-name>jdbc.driver</param-name>
<param-value>org.mariadb.jdbc.Driver</param-value>
</init-param>
<init-param>
<param-name>jdbc.url</param-name>
<param-value>jdbc:mariadb://localhost:3306/studydb</param-value>
</init-param>
<init-param>
<param-name>jdbc.username</param-name>
<param-value>study</param-value>
</init-param>
<init-param>
<param-name>jdbc.password</param-name>
<param-value>1111</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>// 별도로 web.xml에 지정하여 사용한다.
@Override
public void init() throws ServletException {
ServletConfig config = this.getServletConfig();
System.out.printf("driver=%s\n", config.getInitParameter("jdbc.driver"));
System.out.printf("url=%s\n", config.getInitParameter("jdbc.url"));
System.out.printf("username=%s\n", config.getInitParameter("jdbc.username"));
System.out.printf("password=%s\n", config.getInitParameter("jdbc.password"));
}// init-param을 사용할 때에는 ServeltConfig를 사용한다.
Servlet05 -> 컨텍스트 초기화 파라미터 // web.xml에서 설정
<context-param>
<param-name>jdbc2.driver</param-name>
<param-value>org.mariadb.jdbc.Driver</param-value>
</context-param>
<context-param>
<param-name>jdbc2.url</param-name>
<param-value>jdbc:mariadb://localhost:3306/studydb</param-value>
</context-param>
<context-param>
<param-name>jdbc2.username</param-name>
<param-value>study</param-value>
</context-param>
<context-param>
<param-name>jdbc2.password</param-name>
<param-value>1111</param-value>
</context-param> @Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletContext sc = this.getServletContext();
resp.setContentType("text/plain;charset=UTF-8");
PrintWriter out = resp.getWriter();
out.printf("driver=%s\n", sc.getInitParameter("jdbc2.driver"));
out.printf("url=%s\n", sc.getInitParameter("jdbc2.url"));
out.printf("username=%s\n", sc.getInitParameter("jdbc2.username"));
out.printf("password=%s\n", sc.getInitParameter("jdbc2.password"));
}// this.getServletContext(); // 컨텍스트 초기화 파라미터 값을 꺼내려면 ServletContext 객체가 필요하다.
// context-param을 사용할 때에는 ServletContext를 사용한다.
// 특정 Servlet에서만 사용한다면 init-param으로 선언한다. // Servlet04처럼
// 모든 Servlet에서 공통으로 사용한다면 context-param으로 선언한다. // Servlet05
web #ex07
Servlet01 -> 포워딩(forwarding) // 다른 Servlet에게 작업을 위임.
String op = request.getParameter("op");
if (!op.equals("+")) {
RequestDispatcher dispatcher = request.getRequestDispatcher("/ex07/s2");
dispatcher.forward(request, response);
return;
}
int a = Integer.parseInt(request.getParameter("a"));
int b = Integer.parseInt(request.getParameter("b"));
out.printf("%d + %d = %d\n", a, b, (a + b));
}// URL에서 +는 공백으로 인식한다. // URL 인코딩시 +는 %2b로 처리한다.
// Servlet01, 02, 03 모두 ContentType을 설정해주어야 한다.
// op 뒤의 값이 "+"가 아니라면, /ex07/s2로 보낸다는 의미이다.
// ex) localhost:9999/bitcamp-java-web/ex07/s1?a=100&b=200&op=%2b
// 위 예시를 실행시, URL은 그대로인 상태에서 값이 300이 출력된다. // Servlet01 실행
// ex) localhost:9999/bitcamp-java-web/ex07/s1?a=100&b=200&op=-
// 위 예시를 실행시, URL은 그대로인 상태에서 값이 -100이 출력된다. // Servlet02 실행
// ex) localhost:9999/bitcamp-java-web/ex07/s1?a=100&b=200&op=*
// 위 예시를 실행시, URL은 그대로인 상태에서 해당 연산을 수행할 수 없습니다.가 출력된다. // Servlet03 실행
// 즉, URL은 그대로인 상태에서 이미 출력한 결과를 취소하는 것이다.
// 출력한 것이 취소 될 수 있다 ??? //
// PrintWriter 객체를 통해 출력하는 내용은 즉시 웹 브라우저로 전달되는 것이 아니라,
// 내부 출력 버퍼(보통 8KB 크기)에 보관한다.
// 서블릿의 service() 메서드 호출이 종료될 때 비로서 버퍼의 내용이 웹 브라우저로 전송된다.
// 물론 그 전에 버퍼가 꽉 차면 자동으로 출력된다.
// 그래서 다른 서블릿으로 실행을 위임하기 전에 서블릿이 출력한 내용을 취소할 수 있는 것이다.
// 포워딩은 서블릿을 실행한 후 리턴된다. // Servlet03까지 호출 됐어도, Servlet02, Servel01까지 실행함.
// 그러나, Servlet03에게 위임을 시켰기 때문에, Servlet02와 Servlet01의 출력 결과를 반영하지 않는다.
// 즉 Servlet03의 결과만 출력된다. // Servlet02, Servlet01의 결과는 Client에게 출력되지 않는다.
// 결론, URL에서 작업하는 Servlet이 바뀌어도 출력 결과만 바뀌고 URL은 바뀌지 않는다.
Servlet11 -> 인클루딩(including) // 다른 Servlet 작업을 포함.
// forward()는 다른 서블릿으로 위임할 때 현재 서블릿의 출력이 취소된다.
// include()는 다른 서블릿으로 실행을 위임하더라도 현재 서블릿의 실행 결과를 유지한다.
// forward() 코드의 경우, Servlet01에서 Servlet02로, Servlet02에서 Servlet03으로 넘어간다.
// Servlet03까지 가면, 해당 Servlet03의 내용만 출력된다.
// include()의 경우, Servlet11에서 Servlet11_error로, Servlet11_minus로, Servlet11_plus로 넘어간다.
// Servlet11_xxx로 넘어가더라도, Servlet11의 출력 결과를 유지한다.
// 인클루드의 경우 이전 서블릿에서 setContentType()을 설정해야 한다. // 최초 한번 설정하면 계속 유지
// 포워드는 현재 서블릿에서 설정한 setContentType()이 무시된다. // 서블릿 마다 설정을 해주어야 한다.
web #ex08
Servlet01 -> 리프래시(refresh) // java 코드로 설정 // 클라이언트에게 다른 URL을 요청하라는 명령
// refresh // ex) 결제완료 안내메세지 출력 후 메인페이지 요청
// 1. Client가 Servlet01에게 요청 // 2. Servlet01이 콘텐트+refresh url을 Client에게 응답
// 3. 콘텐트 출력
// 4. Client에서 일정시간 경과 후 Servlet02로 자동 요청 // 5. Servlet02이 Clinet에게 응답
// redirect // ex) 로그인 후 바로 메인페이지 요청
// 1. Client가 Servlet01에게 요청 // 2. Servlet01이 redirect url을 Client에게 응답
// 3. Client에서 응답 받는 즉시 Servlet02로 요청 // 4. Servlet02이 Clinet에게 응답
// forward // 오류 발생시 오류 처리 서블릿으로 포워딩
// 1. Client가 Servlet01에게 요청 // 2. Servlet01이 Servlet02에게 forward
// 3. Servlet02가 Client에게 응답
// include // 꼬리말 출력을 할 서블릿을 인클루딩
// 1. Client가 Servlet01에게 요청 // 2. Servlet01이 Servlet02에게 including
// 3. Servlet02가 Servlet01에게 리턴 // 4. Servlet01가 Client에게 응답
// refresh //
// 서버로부터 응답을 받고 내용을 출력한 후 특정 URL을 자동으로 요청하도록 만들 수 있다.
// 보통 웹 페이지를 자동으로 이동시키고 싶을 때 사용한다.
// ex) 로그인 후 메인페이지로 자동 이동, 메일을 전송한 후 메일 목록 페이지로 자동 이동
// ex) 게시글 등록한 후 게시글 목록으로 자동 이동, 결제 완료 후 결제 상태 페이지로 자동 이동
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/plain;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("안녕하세요! - /ex08/s1");
for (int i = 0; i < 200; i++) {
out.println(i + " ===> 1234567890123456789012345678901234567890");
}
response.setHeader("Refresh", "3;url=s100");
}// for문은 없다고 생각하고 이해 // for문은 이후에 넣어서 얘기함
// response.setHeader("Refresh", "3;url=s100"); // 응답 헤더에 Refresh 정보를 추가한다.
// 이미 println("안녕하세요...)를 출력한 상태에서 헤더를 어떻게 변경하는가?? //
// out.println()이 출력한 것은 출력스트림 버퍼에 보관되어 있다.
// 따라서 아직 클라이언트에게 응답한 상태가 아니다.
// 그래서 다음과 같이 출력을 한 후에 응답 헤더 값을 추가하거나 변경할 수 있는 것이다.
// 메서드 호출이 완료될 때 비로소 클라이언트로 응답헤더와 버퍼에 저장된 message-body가 출력된다.
// "반가워요 - /ex08/s100" // 따라서 3초 후에 Servlet100이 실행 된다.
public class Servlet100 extends HttpServlet {
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/plain;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("반가워요 - /ex08/s100");
}HTTP/1.1 200
Refresh: 3;url=s100
Content-Type: text/plain;charset=UTF-8
Content-Length: 28 Date: Tue, 07 Apr 2020 06:46:25 GMT
Keep-Alive: timeout=20
Connection:keep-alive
안녕하세요! - /ex08/s1// HTTP 응답 프로토콜을 확인해보면 Refresh 응답헤더가 적용 된 것을 확인할 수 있다.
// Refresh: 3;url=s100 // 웹 브라우저는 이 헤더의 정보에 따라 다시 요청한다.
// for 반복문을 넣고 돌린다면, 헤더를 추가하거나 변경하는 코드는 적용되지 않는다.
// 반복문으로 인해 8KB 버퍼가 꽉 차기 때문에 헤더를 설정하기 전에 이미 버퍼 내용이 출력된다.
// 즉 응답이 완료된다. // 응답을 완료한 다음에 응답 헤더의 값을 변경하거나 추가해도 적용이 되지 않는다.
Servlet02 -> 리프래시(refresh) // HTML 태그로 설정
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("<html><head>");
out.println("<meta http-equiv='Refresh' content='3;url=s100'>");
out.println("</head><body>");
out.println("안녕하세요! - /ex08/s2");
out.println("</body></html>");
}// HTML 태그로 설정하는 경우에는, <head> 태그 사이에 넣어야 한다.
Servlet03 -> 리다이렉트(redirect) // 응답할 때 콘텐트를 보내지 않고 바로 다른 페이지를 요청하라고 명령
// redirect //
// 클라이언트의 요청을 받은 후 콘텐트를 보내는 대신 다른 페이지의 URL을 알려줄 때 사용한다.
// 웹 브라우저는 응답 받는 즉시 해당 페이지를 요청한다.
// 웹 서버로부터 콘텐트를 받지 않았기 때문에 어떤 것도 출력하지 않는다. // 바로 다른 페이지로 이동
// 리프래시와 달리 서버는 콘텐트(message-body)를 보내지 않는다.
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("<html><head>");
out.println("<title>리다이렉트</title>");
out.println("</head><body>");
for (int i = 0; i < 4000; i++) {
out.println("안녕하세요! - /ex08/s3");
}
out.println("</body></html>");
response.sendRedirect("s100");
}HTTP/1.1 302
Location: s100
Content-Type: text/html;charset=UTF-8
Content-Length: 0
Date: Tue, 07 Apr 2020 07:04:42 GMT
Keep-Alive: timeout=20
Connection: keep-alive// 전과 같이 for문이 있으면 redirect 적용되지 않는다. // 이유는 전과 같이 버퍼 때문에 응답이 되어버려서이다.
// for문이 없다고 가정하고 얘기함.
// HTTP 응답 프로토콜 //
// HTTP/1.1 302 // 요청한 자원이 다른 URL에 있음을 표시한다.
// Location: s100 // 다른 URL의 주소를 알려준다.
// refresh때와 다르게 안녕하세요! 같은 메세지가 없다.
// response.sendRedirect("URL"); // 클라이언트에게 URL을 알려줄 때 상대 경로를 지정할 수 있다.
// forward/include 와 달리 '/'는 컨텍스트 루트(웹 애플리케이션 루트)가 아닌 웹 서버 루트를 의미한다.
// forward/include 때의 Servlet02, 03의 경우에는 컨텍스트 루트였다.
// 리다이렉트를 하는 순간 이전까지 버퍼로 출력된 내용은 모두 버려진다.
// 이유 // 리다이렉트는 클라이언트에게 콘텐트를 보내지 않는다.
// 단, 버퍼가 꽉 차서 클라이언트에게 응답한 경우에는, 리다이렉트는 적용되지 않는다.
web #ex09
Servlet01 -> 보관소에 값 넣기 // ServletContext, HttpSession, ServletRequest
ServletContext sc = this.getServletContext();
sc.setAttribute("v1", "aaa");
HttpSession session = request.getSession();
session.setAttribute("v2", "bbb");
request.setAttribute("v3", "ccc");
response.setContentType("text/plain;charset=UTF-8");
PrintWriter out = response.getWriter();
// 보관소는 총 3가지가 있다. //
// ServletContext // this.getServletContext(); // ServletContext 객체는 애플리케이션이 시작될 때 생성된다.
// HttpSession // request.getSession(); // HttpSession 객체는 웹 브라우저에서
// '세션 아이디(예:고객번호, 스탬프 카드)'를 제공하지 않으면, getSession()을 호출할 때 생성된다.
// 웹 브라우저에서 '세션 아이디'를 제공하면, getSession()을 호출할 때 기존에 생성했던 세션 객체를 리턴한다.
// ServletRequest // request.setAttribute("v3", "ccc"); // ServletRequest 객체는 클라이언트가 요청할 때마다 생성
// ServletContext와 HttpSession은 객체를 생성 및 load를 하고 사용해야 한다.
// ServletRequest는 파라미터로 받았기 때문에 단순히 호출하면 된다.
Servlet02 -> 보관소에서 값 꺼내기
// ServletContext // this.getServletContext(); // Context를 먼저 불러와야 한다.
// HttpSession // request.getSession(); // ServletRequest에서 Session을 먼저 불러와야 한다.
// request.getAttribute("v3"); // ServletRequest에서 꺼내면 된다.
Servlet11 -> forward/include 서블릿끼리 ServletRequest 공유하는 것 테스트 // 값 넣기
// request.getRequestDispatcher("s12").forward(request, response);
// 포워드(인클루드 포함)할 때 이 서블릿이 파라미터로 받은 ServletRequest와 ServletResponse를 전달한다.
// 따라서 포워드/인클루드 서블릿들은 응답을 완료할 때까지 이 객체들을 공유하는 것이다.
Servlet12 -> forward/include 서블릿끼리 ServletRequest 공유하는 것 테스트 // 값 꺼내기
web #ex10
Servlet01 -> 쿠키(cookie) 보내기
// 쿠키 // 웹서버가 웹브라우저에게 맡기는 데이터 // 응답할 때 응답 헤더에 포함시켜 보낸다.
// 웹브라우저는 응답헤더로 받은 쿠키 데이터를 보관하고 있다가
// 지정된 URL을 요청할 때 요청 헤더에 포함시켜 웹 서버에게 쿠키를 다시 보낸다.
HTTP/1.1 200 Set-Cookie: name=hong
Set-Cookie: age=20
Set-Cookie: working=true
Set-Cookie: name2=홍길동 // 인코딩 하지 않은 예시
Set-Cookie: name3=%ED%99%8D%EA%B8%B8%EB%8F%99
Content-Type: text/plain;charset=UTF-8 Content-Length: 35 Date: Wed, 03 Apr
2019 01:03:37 GMT// HTTP 응답 프로토콜 예시 //
// HTTP/1.1 200 Set-Cookie: // Set-Cookie 헤더에 '이름=값' 형태로 쿠키를 보낸다.
// 값은 반드시 문자열이여야 한다. // 객체 전송 불가능하다.
// name2=홍길동 // 홍길동은 URL인코딩하지 않은 상태이다. // 저렇게 보내면 안된다. // 코드에도 적어둠
// name3= // URL 인코딩을 한 상태의 예제이다.
// 쿠키 생성 // 이름과 값으로 생성
// 쿠키의 유효기간을 설정하지 않으면 웹브라우저가 종료될 때 까지 유지된다.
// 웹브라우저를 종료하면 유효기간이 지정되지 않은 쿠키는 모두 삭제된다.
// 쿠키의 사용범위를 지정하지 않으면 현재 경로에 한정한다.
// 쿠키를 보낼 때 URL이 /ex10/s1 이라면, 브라우저는 /ex10/* 경로를 요청할 때만 서버에게 쿠키를 보낸다.
Cookie c1 = new Cookie("name", "hong");
Cookie c2 = new Cookie("age", "20");
Cookie c3 = new Cookie("working", "true");
Cookie c4 = new Cookie("name2", "홍길동");
Cookie c5 = new Cookie("name3", URLEncoder.encode("홍길동", "UTF-8"));
response.addCookie(c1);
response.addCookie(c2);
response.addCookie(c3);
response.addCookie(c4);
response.addCookie(c5);// c1 프로토콜 예 // Set-Cookie: name=hong
// c2, c3 // 값은 반드시 문자열이어야 한다 // 만약 문자열이 아닌 값을 보내려면,
// Base64와 같은 인코딩 기법을 이용하여 바이너리 데이터를 문자화시켜서 보내야 한다.
// c4, c5 // 또한 값은 반드시 ISO-8859-1 이어야 한다.
// 만약 UTF-8을 보내고 싶다면 URL 인코딩 같은 기법을 사용하여 ASCII 코드화시켜 보내야 한다.
// response.addCookie(쿠키); // 쿠키를 응답 헤더에 포함시키는 방법
Servlet02 -> 쿠키(cookie) 읽기 // 사용 범위가 지정된 쿠키 읽기
// Cookie[] cookies = request.getCookies(); // 쿠키 꺼내기
// 쿠키를 이름으로 한 개씩 추출할 수 없다. // 한번에 배열로 받아야 한다.
// 만약 요청 헤더에 쿠키가 없으면, 리턴되는 것은 null이다. // 사용할 때 유의하자.
if (c.getName().equals("name3")) {
out.printf(" => %s\n", URLDecoder.decode(c.getValue(), "UTF-8"));
}// 쿠키 값이 URL 인코딩한 값이라면 원래의 값으로 되돌리기 위해 URL 디코딩 해야한다.
Servlet11 -> 쿠키(cookie) // 유효기간 설정하기
// 유효기간을 설정하면 웹브라우저를 종료해도 삭제되지 않는다.
// 단 유효기간이 지나면 웹서버에 보내지 않고 삭제한다.
// 웹 브라우저는 로컬 디스크에 쿠키를 보관한다.
Cookie c1 = new Cookie("v1", "aaa");
Cookie c2 = new Cookie("v2", "bbb");
c2.setMaxAge(30);
Cookie c3 = new Cookie("v3", "ccc");
c3.setMaxAge(60);
response.addCookie(c1);
response.addCookie(c2);
response.addCookie(c3);// setMaxAge(시간) // 쿠키를 보낸 이후 시간 동안만 유효
HTTP/1.1 200 Set-Cookie: v1=aaa <---- 유효기간이 설정되지 않은 쿠키
Set-Cookie: v2=bbb; Max-Age=30; Expires=Wed, 08-Apr-2020 02:41:43 GMT
Set-Cookie: v3=ccc; Max-Age=60; Expires=Wed, 08-Apr-2020 02:42:13 GMT
Content-Type: text/plain;charset=UTF-8
Content-Length: 36
Date: Wed, 08 Apr 2020 02:41:40 GMT// c1 : 시간설정 x // c2 : 30초 // c3 : 60초
Servlet12 -> 쿠키(cookie) // 유효기간이 설정된 쿠키 읽기
// 유효기간이 설정된 쿠키는, 유효기간이 지나기 전까지 브라우저를 껐다켜도 컴퓨터를 껐다켜도,
// 사라지지 않는다. // 유저 하드디스크에 보관하기 때문 또한 같은 브라우저에서만 사용된다.
// 시간이 남아있어도 다른 브라우저를 사용하면 나타나지 않는다. // 해당 브라우저에는 남아있음.
// 유효기간이 설정되지 않은 쿠키는 브라우저를 껐다 키면 사라진다. // 브라우저를 안끄면 계속 남아있음.
Servlet21 -> 쿠키(cookie) // 쿠키 사용 범위 지정
// 쿠키의 사용 범위를 지정하지 않으면 쿠키를 발행한 URL 범위에 한정된다.
// 즉 같은 URL로 요청할 때만 쿠키를 보내야 한다.
// ex) 쿠키를 발행한 URL : /ex10/s21 // 쿠키를 보낼 수 있는 URL : /ex10/*
// 쿠키를 보낼 수 없는 URL : /ex10 이외의 모든 URL
HTTP/1.1 200 Set-Cookie: v1=aaa
Set-Cookie: v2=bbb; Path=/bitcamp-java-web/ex10/a
Set-Cookie: v3=ccc; Path=/bitcamp-java-web
Content-Type: text/plain;charset=UTF-8
Content-Length:36
Date: Wed, 08 Apr 2020 02:51:12 GMT// Path=값 // 값의 경로 안에 있는 것들로 제한한다.
// 사용 범위를 지정하지 않은 쿠키 //
// 쿠키를 발급한 서블릿과 같은 경로이거나 하위 경로의 서블릿을 요청할 때만 웹 브라우저가 서버에 쿠키를 보낸다.
// 사용 범위 지정한 쿠키 //
// 쿠키를 발급한 서블릿의 경로에 상관없이 지정된 경로의 서블릿을 요청할 때 웹 브라우저가 서버에 쿠키를 보낸다.
// 쿠키의 경로를 적을 때 웹 애플리케이션 루트(컨텍스트 루트)로 적어야 한다.
// 쿠키 경로는 서블릿 컨테이너가 사용하는 경로가 아니거 웹 브라우저가 사용하는 경로이다.
// 웹 브라우저에서 '/' 은 서버 루트를 의미한다.
// 서버 루트를 의미하는 '/' // 포트번호 다음에 오는 '/'를 말한다.
// 따라서 웹 브라우저가 사용하는 경로를 지정할 때는 조심해야 한다. '/'가 서버 루트를 의미하기 때문이다.
// 그래서 쿠키의 경로를 지정할 때는 웹 애플리케이션 루트(컨텍스트 루트)를 정확하게 지정해야 한다.
// Servlet22, 23, 24는 테스트용
web #ex11
Servlet01 -> 세션(session) //
// 세션(session) // 클라이언트를 식별하는 기술
// HTTP 프로토콜은 Stateless 방식으로 통신을 한다. // 연결한 후 요청하고 응답을 받으면 연결을 끊는다.
// 서버는 클라이언트가 요청할 때 마다 누구인지 알 수 없다.
// 이를 해결하기 위해 클라이언트가 접속하면 웹 서버는 그 클라이언트를 위한 고유 번호를 발급(쿠키 이용)한다.
// 이 고유 번호를 '세션 아이디'라 부른다.
// 웹 브라우저는 세션 아이디를 쿠키에 보관해 두었다가 그 서버에 요청할 때 마다 세션 아이디를 보낸다.
// 세션 아이디 쿠키는 유효기간을 설정하지 않았기 때문에 웹 브라우저를 종료하면 세션 아이디 쿠키는 삭제된다.
// 세션 아이디 쿠키의 사용 범위는 웹 애플리케이션이다.
// 따라서 같은 웹 애플리케이션의 서블릿을 실행할 때는 무조건 세션 아이디를 보낸다.
// 세션 아이디 발급 시기 //
// 새 세션을 생성할 때 세션 아이디를 발급한다.
// 새 세션 생성 시기 //
// 세션이 없는 상태에서 request.getSesssion()을 호출할 때 생성한다.
// 생성한 세션의 ID는 쿠키를 통해 응답할 때 웹 브라우저로 보낸다.
// 세션ID 무효화 //
// 1. 세션에 지정된 timeout 초과했을 때 // 2. session.invalidate() 호출
Servlet02 -> 세션(session) // 세션에서 값 꺼내기
// 세션 아이디 보내기 //
// 서버로부터 쿠키를 통해 받은 세션아이디는 웹 브라우저가 해당 서버에 요청할 때마다 쿠키로 세션 아이디를 보낸다.
GET /java-web/ex11/s2 HTTP/1.1
Host: localhost:9999
...
Cookie:JSESSIONID=9909D09693CE9E0B8D23BE824313C834// 1-1. 세션 아이디가 있고, 유효하다면, 기존에 생성한 HttpSession 객체를 리턴한다.
// 1-2. 세션 아이디가 있고, 유효하지 않다면, 2번으로 진행함. // 없다고 취급함 유효하지 않으면 있으나 마나임.
// 2. 세션아이디가 없다면, 새 HttpSession 객체를 생성하여 리턴한다.
// 응답 프로토콜에 새로 생성한 HttpSession 객체의 세션ID를 쿠키로 보낸다.
// 세션에서 값 꺼내기 //
// 웹 브라우저를 종료하면 이전에 서버로부터 받은 세션 아이디 쿠기가 삭제된다.
// 그런 후에 웹 브라우저에서 이 서블릿을 요청하면 getSession() 메서드를 새 세션 객체를 생성한 후 리턴한다.
// 새 세션에 값을 넣어주지 않았다면 null을 출력한다.
Servlet11 -> Servlet12,13,14와 묶음이다.
// Servlet11은 이름을 입력하라는 창을 띄우고 버튼을 누르면 Servlet12로 넘어간다.
// Servlet12는 나이를 입력하라는 창을 띄우고 버튼을 누르면 Servlet13으로 넘어간다.
// Servlet13은 전화번호를 입력하라는 창을 띄우고 버튼을 누르면 Servlet14로 넘어간다.
// 14는 이전에 입력받은 이름과 나이를 세션에서 꺼내고 전화번호를 파라미터에서 꺼낸다.
// 왜 전화번호는 세션에서 꺼내지 않는가 ? //
// Servlet11을 잘 보면 이름을 입력후 버튼을 눌러 넘어간다. 입력 값은 12로 넘어간다.
// 값을 11에서 받고 넘어가는게 아니기 때문이다.
Servlet21 -> 세션(session) // 타임아웃 설정
// session.setMaxInactiveInterval(시간); // 마지막 요청으로부터 시간동안 요청이 없으면, 세션이 무효화 된다.
// session.setMaxInactiveInterval(10); // 마지막 요청으로부터 10초동안 요청이 없으면, 세션이 무효화 된다.
// 무효화된 세션은 사용할 수 없기 때문에 getSession()은 새 세션을 만들어 리턴한다.
Servlet22 -> 세션(session) // 타임아웃 설정 확인
// 마지막 요청으로부터 정해진 시간이 지나 세션이 무효화 된 이후 요청이 들어온다면,
// 새 세션을 만들어 리턴하면 값이 null로 표기된다.
Servlet31 -> 세션(session) // 무효화시키기 1
<session-config>
<session-timeout>1</session-timeout>
</session-config>// DD File(web.xml)에 설정하는데, 여기서 time 기준은 분이다 // 위 예시는 1분
Servlet32 -> 세션(session) // 무효화시키기 // 값 꺼내기
// 1분이 지나고 해당 Session이 호출되면 새 세션 객체를 만들어 리턴된다.
Servlet33 -> 세션(session) // 무효화시키기 2
// session.invalidate(); // 세션을 무효화시킨다.
'IT Developer > Bitcamp' 카테고리의 다른 글
| 비트캠프 프론트엔드 및 벡엔드 개발자 Webapp js (1) | 2020.04.28 |
|---|---|
| 비트캠프 프론트엔드 및 벡엔드 개발자 Webapp css (0) | 2020.04.27 |
| 비트캠프 프론트엔드 및 백엔드 개발자 Spring-webmvc, java-web-library (0) | 2020.04.17 |
| 비트캠프 프론트엔드 및 벡엔드 개발자 Webapp el, jsp, jstl (0) | 2020.04.13 |
| 비트캠프 프론트엔드 및 백엔드 개발자 #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 |