싱글톤패턴(Singleton Pattern)

 

GoF의 디자인 패턴 중 하나인 싱글톤 패턴은 인스턴스를 오직 하나만 생성해서 메모리를 절약?할 수 있다.

 

package common.db;

import java.sql.SQLException;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

public class PoolManager2 {
	InitialContext context;
	DataSource ds;
	private static PoolManager2 instance;
	private PoolManager2() {
		try {
			context = new InitialContext();
			ds = (DataSource)context.lookup("java:comp/env/jdbc/myoracle");
		} catch (NamingException e) {
			e.printStackTrace();
		}
	}
	public static PoolManager2 getInstance() {
		if(instance==null) {
			return instance = new PoolManager2();
		}
		return instance;
	}
}
  • 위 코드는 커넥션풀 관리하도록 만든 객체 중 일부이다.
  • 생성자의 접근지정자를 private
  • 클래스 내에 private인 현재 클래스의 객체를 멤버변수로 둔다
  • 해당변수의 get메서드static으로 만들어서 외부에서 이 클래스에 대한 인스턴스를 만들고 싶을 때는 오직 get메서드로만 생성할 수 있고 만약 아직 생성되지 않았다면 생성, 생성되어 있으면 그냥 반환만 받는 구조
  • static의 메서드에서는 static변수만 사용할 수 있으니 변수를 static으로!

실행결과

package common.db;

public class text {
	public static void main(String[] args) {
		for(int i=1;i<=10;i++) {
			System.out.println(i+" : "+PoolManager2.getInstance());
		}
	}
}

하나의 객체만 생성하게 되는 것을 볼 수 있다!

'프로그래밍 > Java' 카테고리의 다른 글

java - 암호화  (0) 2021.01.06
java - mail 보내기  (0) 2021.01.06
JavaFX - 개발환경 구축 및 생명주기  (0) 2020.11.23
Java - JSON & XML 파싱  (0) 2020.11.17
Java - 소켓프로그래밍 기초 Echo System  (0) 2020.11.09

지금까지 DAO를 쓸 때마다 Connection객체를 생성하고 해당 메서드가 끝나면 자원을 해제하고를 반복했다.

//접속 개체 얻기 
	public Connection getConnection(){
		Connection con=null;//return 시키기 위해..
		try{
		Class.forName(driver);
		System.out.println("드라이버 로드 성공");

		con = DriverManager.getConnection(url, user,password);
	
		}catch(ClassNotFoundException e){
			e.printStackTrace();
			System.out.println("드라이버 로드 실패");
		}catch(SQLException e){
			e.printStackTrace();	
		}
		return con;
	}

	//자원해제
	public void release(Connection con){//쿼리문 수행 안했을 때..
		if(con!=null){
			try{
				con.close();	
			}catch(SQLException e){
				e.printStackTrace();
			}
		}
	}

 

웹페이지를 만들어서 많은 사람들이 사용한다고 생각해보면 많은 사람들이 페이지에 접속하고 사용할 때마다
Connection을 받고 바로 해제하고 이러한 과정이 반복된다.
DB로부터 Connection을 얻는 행동은 엄청난 자원을 필요로 하는데 (쿼리, 유저맞어?, 권한?...)
우리는 지금까지 그런 소중한 자원을 썻다 바로 버리고 있었다....;;; 

 

이런 고충을 해결하기 위해 Connection Pool을 이용해보자

 

나는 Tomcat에서 지원하는 Connection Pool을 사용했다.

1) server.xml

    <!--톰캣서버의 server.xml 파일을 열어서 GlobalNamingResources태그 안에 넣어준다-->
    <!--myoracle은 개발자 마음대로 선언해주면 된다.-->
    <Resource name="jdbc/myoracle"
		auth="Container"
		type="javax.sql.DataSource"
        <!--driver의 위치-->
		driverClassName="oracle.jdbc.driver.OracleDriver"
        <!--사용하는 DB의 url-->
		url="jdbc:oracle:thin:@localhost:1521:XE"
        <!--유저의 id-->
		username="lastuser"
        <!--유저의 비밀번호-->
		password="lastuser"
		maxActive="20"
		maxIdle="10"
		maxWait="3000"/>

2) web.xml

	<resource-ref>
	<res-ref-name>jdbc/myoracle</res-ref-name><!--server.xml에서 썼던 이름와 동일하게!-->
	<res-type>javax.sql.DataSource</res-type>
	<res-auth>Container</res-auth>
	</resource-ref>

3) tomcat/context.xml

<ResourceLink type="javax.sql.DataSource"
                      name="jdbc/myoracle"
                      global="jdbc/myoracle" />
                      <!--여기도 이름을 동일하게!!-->

4) 사용방법 (테스트)

<html>
<head>
<%@ page
import="java.sql.*,
javax.sql.*,
java.io.*,
javax.naming.InitialContext,
javax.naming.Context" %>
</head>
<body>
<h1>JDBC JNDI Resource Test</h1>

<%
/*
JNDI란? 
JAVA Naming Directory interface : 어떤 정보를 프로그래밍 언어인 자바코드에 넣지 말고, 외부의 xml과 같은 자원으로 관리하는 방법 
(즉, 자바코드 안에 설정정보를 넣지 말고, 코드 밖으로 빼서 유지관리하자!)  server.xml
*/

InitialContext initCtx = new InitialContext(); //검색 객체
DataSource ds = (DataSource) initCtx.lookup("java:comp/env/jdbc/myoracle"); //검색객체가 안에 내용을 찾는다. server.xml의 datasource를 찾아나선다
//새로운 접속이 아니라, 이미 풀에 존재하는 접속 객체를 대여하는 것!
Connection conn = ds.getConnection();//커넥션풀로부터 하나의 커넥션을 얻는 작업!! 

Statement stmt = conn.createStatement();
ResultSet rset = stmt.executeQuery("select * from board");
while (rset.next()) {
out.println("title=="+rset.getString("title")+"<br>");
}
rset.close();
stmt.close();
conn.close();
initCtx.close();
%>
</body>
</html>

 

JNDI란?

JAVA Naming Directory Interface : 어떤 정보를 프로그래밍 언어인 자바코드에 넣지 않고 외부의 xml과 같은 자원으로 관리하는 방법  (즉, 자바코드 안에 설정정보를 넣지 말고, 코드 밖으로 빼서 유지관리하자!) 

ex) server.xml, web.xml ..?

 

DataSource?

  • Connetion Pool을 관리하기 위한 객체!!!
  • Connection 획득과 반환 등의 작업을 한다! 
<Resource name="jdbc/myoracle"
		auth="Container"
		type="javax.sql.DataSource"
        <!--driver의 위치-->
		driverClassName="oracle.jdbc.driver.OracleDriver"
        <!--사용하는 DB의 url-->
		url="jdbc:oracle:thin:@localhost:1521:XE"
        <!--유저의 id-->
		username="lastuser"
        <!--유저의 비밀번호-->
		password="lastuser"
		maxActive="20"
		maxIdle="10"
		maxWait="3000"/>
  • 위의 server.xml에서 넣어줬던 코드는 DataSource를 의미! (type="javax.sql.DataSource")

'프로그래밍 > JSP' 카테고리의 다른 글

JSP | 서블릿(Servlet) 이해  (0) 2020.12.16
JSP | session  (0) 2020.12.16
JSP | MyBatis 사용해보기  (0) 2020.12.10
JSP - 페이징 이해  (0) 2020.12.08
JSP - 이미지 업로드  (0) 2020.12.04

dependency를 사용하지 않고 jar파일을 사용해보았다.

 

1. mvnrepository로 들어가 Mybatis검색 후 원하는 버전의 jar파일을 다운받는다.

Maven Repository: org.mybatis » mybatis » 3.4.6 (mvnrepository.com)

2. 자신의 웹프로젝트의 WEB-INF의 lib폴더에 등록!

 

정리한 순서

1. 설정xml을 만들어서 DB의 정보(driver, url, user, password)를 기입하고 mapper들의 위치도 등록한다.

 

 

 

2.  Mapper(VO명Mapper.xml)XML을 만들어서 namespace(메모리상에서 이름을 가지고 구분할 수 있게)를 등록하고 
각 쿼리문을 입력 이때 id는 쿼리 구분id, parameteType은 파라미터의 자료형(int, VO객체), resultType은 결과타입(List를 반환하는 쿼리일지라도 해당 List안의 들어갈 객체들의 자료형을 적어주면됨, List처리는 Mybatis가 담당!!)

 

그리고, PreparedStatement에서 ?를 #{}로 대신하여 쓰고 #{}안에는 파라미터명을 적어주면 된다.. (이때, 파라미터명은 파라미터가 1개일 때는 아무거나 적어도 상관이 없지만 구분하기 쉽게 해당 컬럼명으로 써주는게 좋은거같구, VO로 넘어오는 매개변수면 해당 테이블의 컬럼명을 써줘야한다!!  그리고 가장 중요한 VO와 테이블의 컬럼명들을 일치시켜주는게 제일 중요!!)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 이름으로 메모리 영역을 구분하는 법 namespace 중복되면 안된다 -->
<mapper namespace="mybatis.config.Dept">
	<!--
	개발자는 Mybatis를 이용할 경우, 자바코드에서 쿼리문을 작성하지 않으며
	수많은 jdbc관련 코드 또한 작성할 필요가 없고, 오직 쿼리문에만 집중하면 된다!
	-->
	<!--모든글 가져오기 -->
	<!-- List는 자체적으로 만들어준뎨!!! -->
	<select id="selectAll" resultType="emp.model.Dept">
		select * from dept order by deptno asc
	</select>
	
	<!-- 한건 가져오기 -->
	<!-- paramertType : 파라미터자료형 -->
	<!-- ?대신 #{파라미터명} -->
	<select id="select" parameterType="int" resultType="emp.model.Dept">
		select * from dept where deptno=#{deptno}
	</select>
	
	<!-- 한건 등록 -->
	<insert id="insert" parameterType="emp.model.Dept">
		insert into deptno(dname, loc) values(#{dname}, #{loc})
	</insert>
	
	<!-- 한건 수정 -->
	<!-- 반드시 VO와 컬럼명이 일치해야함!! -->
	<update id="update" parameterType="emp.model.Dept" >
		update dept set dname=#{dname}, loc=#{locg} where deptno=#{deptno}
	</update>
	
	<!-- 삭제하기 -->
	<delete id="delete" parameterType="int">
		delete from deptno where deptno=#{deptno}
	</delete>
</mapper>

3. 지금까지 DAO를 JDBC에 따라 만들었지만 이제는 MyBatis의 코드기술을 따라만들어보았다.

Mapper를 사용하려면 SqlSession객체가 필요하다!! SqlSession객체는 SqlSessionFactory객체를 이용하여 .openSession()메서드를 이용한다. 그리고 Mapper에서 만든 쿼리문을 사용하려면 id가 필요한데 id앞에 해당 Mapper의 namespace의 이름이 필요!!

 

MybatisManager 클래스는 설정파일을 연결하여 SqlSessionFactory를 만들고 get메소드를 이용해 사용할 수 있게 해주는 클래스

/*
	DB 접속 정보 및 매퍼들에 대한 위치가 지정된 마이바티스의 설정파일을 읽어보자!!
*/
package db;

import java.io.IOException;
import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MybatisManager {
	private SqlSessionFactory sqlSessionFactory;
	
	public MybatisManager() {
		String resource = "mybatis/config/config.xml";
		InputStream inputStream;
		try {
			inputStream = Resources.getResourceAsStream(resource);
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
			System.out.println(sqlSessionFactory);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public SqlSessionFactory getSqlSessionFactory() {
		return sqlSessionFactory;
	}

	public static void main(String[] args) {
		new MybatisManager();
	}
}
/*
	지금까지는 DAO의 코드 기술을 JDBC로 이용하였기 때문에 쿼리문보다 그 외의 코드가 더 장황했었다..
	따라서 이번 DAO에서는 Mybatis 프레임웍을 도입하여, 코드를 보다 간결하게 작성해보겠다..
*/
package emp.model;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import db.MybatisManager;

public class DeptDAO {
	//DAO에서 SQL문이 들어있는 xml을 호출하자!!! 이떄, 어떤 쿼리수행을 원하는 지를 구분하기 위해서는
	// xml 태그에 부여한 id를 이용하면 된다!!!
	//xml 태그를 호출하기 위해서는 mybatic의 SqlSession이 필요하고, 현재는 MybatisManager 클래스의 멤버로
	//두었다...
	MybatisManager manager = new MybatisManager();
	SqlSessionFactory factory;
	
	public DeptDAO() {
		factory = manager.getSqlSessionFactory();
	}
	
	//모든 데이터가져오기
	public List<Dept> selectAll() {
		SqlSession session = factory.openSession();//쿼리문 수행객체 생성
		return session.selectList("mybatis.config.Dept.selectAll");
	}
}

실행결과

jsp파일을 만들어서 페이지로드 시 list들을 불러오도록 해보았다.

<%@page import="emp.model.Dept"%>
<%@page import="java.util.List"%>
<%@page import="emp.model.DeptDAO"%>
<%@ page contentType="text/html;charset=utf-8"%>
<%
	//DAO 이용하여 부서 정보 출력해보자!!!
	DeptDAO dao = new DeptDAO();
	List<Dept> list = dao.selectAll();
	
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Insert title here</title>
<style></style>
<script></script>
</head>
<body>
-----------------------------------------
	<%for(int i=0;i<list.size();i++){ %>
	<%Dept dept = list.get(i); %>
	<br>
		부서번호<%=dept.getDeptno()%><br>
		부서명<%=dept.getDname()%><br>
		부서위치<%=dept.getLoc()%><br>
		-----------------------------------------
	<%} %>
</body>
</html>

'프로그래밍 > JSP' 카테고리의 다른 글

JSP | session  (0) 2020.12.16
JSP | 커넥션풀(Connection Pool)  (0) 2020.12.11
JSP - 페이징 이해  (0) 2020.12.08
JSP - 이미지 업로드  (0) 2020.12.04
JSP - JSP(Java Server Page)란?  (0) 2020.12.01

테이블의 모든 레코드들을 가져와서 페이징 처리하기

 

필요한 값

1. totalRecord : 전체 레코드 수

2. pageSize : 한 페이지 당 보여줄 레코드 수

3. totalPage : 총 페이지 수

4. blockSize : 한 블럭(1~10페이지 이런 식으로 나누는?)당 보여질 페이지 수

5. currentPage : 현재 페이지

6. firstPage : 블럭의 시작 페이지

7. lastPage : 블럭의 끝 값 (firstPage와 lastPage를 이용하여 반복문을 사용해 블럭 나타낼 수 있다)

8. num : 페이지당 시작 번호

9. curPos : 페이지 당 List에서의 시작 index (List로 DB에서 레코드들을 받아올 경우)

 

구하는 방법

totalRecord : 총 레코드의 수 ex) list.size() = 26

pageSize : 10 (개발자 마음대로)

totalPage : 26개의 글을 각 페이지 당 10개의 글로 나오게 한다면?

=>(int)Math.ceil((float)totalRecord/pageSize) = 3

firstPage : currentPage-(currentPage-1)%blockSize 

lastPage : firstPage+(blockSize-1)

num : totalRecord-(pageSize*(currentPage-1))

curPos : pageSize*(currentPage-1)

 

예시 코드

<%@page import="board.model.QnA"%>
<%@page import="java.util.List"%>
<%@page import="board.model.QnADAO"%>
<%@ page contentType="text/html;charset=utf-8"%>
<%
	//DB연동
	QnADAO dao = new QnADAO();
	List<QnA> list = dao.selectAll();
	
	int totalRecord=list.size();//총 레코드 수, 실제 DB에 있는 데이터 수를 대입하면 된다!!
	int pageSize=10;//한 페이지당 보여줄 레코드 수
	//int totalPage=(totalRecord%pageSize)==0?(totalRecord/pageSize):(totalRecord/pageSize)+1;
	int totalPage = (int)Math.ceil(((float)totalRecord/pageSize)); //총 페이지 수
	int blockSize=10; //한 블럭 당 보여질 페이지 수
	int currentPage=1; //현재 페이지
	
	//아래의 코드는 아무때나 하는게 아니다!! 누군가 파라미터를 넘겼을 때만..
	if(request.getParameter("currentPage")!=null){//즉 페이지를 넘겼다면
		currentPage=Integer.parseInt(request.getParameter("currentPage"));
	}
	
	//int firstPage=((currentPage/blockSize)*blockSize)+1; 
	int firstPage=currentPage-(currentPage-1)%blockSize;//반복문의 시작값
	//int lastPage=((currentPage/blockSize)+1)*blockSize;
	int lastPage=firstPage+(blockSize-1);// 반복문의 끝값
	int num=totalRecord-(pageSize*(currentPage-1));//페이지당 시작 번호 ( 힌트: 위에 있는 모든 변수 조합)
	int curPos=pageSize*(currentPage-1);//페이지당 List에서의 시작 index 
%>
<%="totalRecord : "+ totalRecord+"<br>" %>
<%="pageSize : "+ pageSize+"<br>" %>
<%="totalPage : "+ totalPage +"<br>" %>
<%="blockSize : "+ blockSize+"<br>" %>
<%="currentPage : "+ currentPage +"<br>" %>
<%="firstPage : "+ firstPage+"<br>" %>
<%="lastPage : "+ lastPage +"<br>" %>
 <%="num : "+ num +"<br>" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>페이징 처리</title>
<style>
table {
  border-collapse: collapse;
  border-spacing: 0;
  width: 100%;
  border: 1px solid #ddd;
}

th, td {
  text-align: left;
  padding: 16px;
}

tr:nth-child(even) {
  background-color: #f2f2f2;
}

button {
  background-color: #4CAF50;
  color: white;
  padding: 12px 20px;
  border: none;
  border-radius: 4px;
  cursor: pointer;
}

button:hover {
  background-color: #45a049;
}

input[type=image]{
  width:100px;
 
}

img{
box-sizing: border-box;
}

a{
	text-decoration: none;
}

.pageNum{
	font-size:20pt;
	color:red;
	font-weight:bold;
}
</style>
<script></script>
</head>
<body>
<table>
  <tr>
    <th>No</th>
    <th>제목</th>
    <th>작성자</th>
	<th>등록일</th>
	<th>조회수</th>
  </tr>
	<%for(int i=1;i<=pageSize;i++){ %>
  		<%if(num<1) break; %>
  		<%
  		//break문을 만나지 않았다는 것은 레코드가 있다는 것이므로, break문 아래에서 데이터를 추출하자!! 
  			QnA qna = list.get(curPos++); //1page:0~9, 2page:10~19...
  		%>
		  <tr>
				<td><%=num-- %></td>
				<td>
					<%if(qna.getDepth()>0){ %>
						<img alt="" src="/images/reply.png" style="margin-left:<%=20*qna.getDepth()%>px">
					<%} %>
					<a href="/qna/detail.jsp?qna_id=<%=qna.getQna_id()%>"><%=qna.getTitle()%></a>
				</td>
				<td><%=qna.getWriter() %></td>
				<td><%=qna.getRegdate() %></td>
				<td><%=qna.getHit() %></td>
		  </tr>
  <%} %>
  <tr>
  	<td colspan="5" style="text-align:center">
  		<%if((firstPage-1)>0){ %>
  			<a href="/qna/list2.jsp?currentPage=<%=firstPage-1%>">◀</a>
  		<%}else{ %>
  			<a href="javascript:alert('처음 페이지입니다!');">◀</a>
  		<%} %>
  		<%for(int i=firstPage;i<=lastPage;i++){ %>
  			<%if(i>totalPage) break; //페이지 출력하는 i가 총 페이지 수에 도달하면 반복문 빠져나와라..%>
  			<a href="/qna/list2.jsp?currentPage=<%=i%>" <%if(currentPage==i){ %>class="pageNum" <%} %>>[<%=i%>]</a>
  		<%} %>
  		<%//if(totalPage<lastPage){ %>
  		<%if((lastPage+1)<lastPage){ %>
	  		<a href="/qna/list2.jsp?currentPage=<%=lastPage+1%>">▶</a>
  		<%}else{ %>
  			<a href="javascript:alert('마지막 페이지입니다!');">▶</a>
  		<%} %>
  	</td>
  </tr>
  	<tr>
	<td colspan="5">
		<button>글 등록</button>
	</td>
  </tr>
  <tr>
	<td colspan="5" style="text-align:center">
		<%@ include file="/inc/footer.jsp"%>
	</td>
  </tr>
</table>
</body>
</html>

'프로그래밍 > JSP' 카테고리의 다른 글

JSP | session  (0) 2020.12.16
JSP | 커넥션풀(Connection Pool)  (0) 2020.12.11
JSP | MyBatis 사용해보기  (0) 2020.12.10
JSP - 이미지 업로드  (0) 2020.12.04
JSP - JSP(Java Server Page)란?  (0) 2020.12.01

방법

1. oreilly에서 만든 라이브러리 사용하기

2. Apache에서 만든 라이브러리 사용하기

 

oreilly에서 만든 라이브러리 사용

Servlets.com | com.oreilly.servlet

 

Servlets.com | com.oreilly.servlet

 

www.servlets.com

위 사이트에 들어가서 MulitpartRequest 클래스를 사용하여 업로드할 수 있다.

 

페이지 아래 쪽에 jar파일을 다운로드받을 수 있게 제공해준다. jar파일을 라이브러리에 등록해준다.

<%@page import="java.io.File"%>
<%@page import="common.FileManager"%>
<%@page import="java.io.IOException"%>
<%@page import="com.oreilly.servlet.MultipartRequest"%>
<%@ page contentType="text/html;charset=UTF-8"%>
<%
	/*
클라이언트가 전송한 제목, 텍스트 및 바이너리 파일을 서버의 특정 디렉토리에 저장해보자
= 업로드라 한다!!
*/
request.setCharacterEncoding("utf-8");//파라미터 한글 깨지지 않게 인코딩
//String msg = request.getParameter("msg");//String 메시지 받기

//이미지는 글씨가 아닌 바이너리 파일이므로, request.getParameter로는 받을 수 없다!
//따라서 IO, 네트워크 등의 처리를 해야 하는데, 이 자체만으로도 하나의 개발 프로젝트일 것이다.
//해결책?? 누군가 만든 라이브러리를 이용해서 개발시간을 단축하자!!
//현재 우리가 선택한 라이브러리는 cos.jar라는 Oreilly라는 출판사에서 제작한 컴포넌트이다!!
String saveDirectory = "C:/workspace/javaee_workspace/BoardApp/WebContent/data";//하드디스크의 물리적 경로를 명시해야 한다!!
int maxSize = 1024 * 1024 * 2; //2MByte
String encoding = "utf-8";
//FileRenamePolicy policy : 업로드 시 , 동일한 파일을 업로드했을 때?? 자동으로 이름을 부여한다...
//예) p.jpg, 1p.png.. (파일명은 개발자가 주도하여 명명하므로, policy를 굳이 이용할 필요 없다.)
try {
	MultipartRequest multi = new MultipartRequest(request, saveDirectory, maxSize, encoding);
	//업로드 컴포넌트를 이용할 경우, 스트링 파라미터도 업로드 컴포넌트를 이용해야한다!!
	String msg = multi.getParameter("msg");
	//out.print("전송한 메시지는 " + msg);
	//업로드가 완료된 후, 즉 서버의 저장소에 파일이 존재하게 된 후 해야할 일!
	//파일명을 개발자가 정한 규칙으로 변경해야 한다..현재시간의 밀리세컨드까지 구해보자!
	long time = System.currentTimeMillis();
	//out.print(time);
	//구한 시간에 확장자를 붙이면 최종적으로 절대 중복되지않는 파일이 생성
	String filename = multi.getOriginalFileName("photo");
	//out.print("전송한 파일의 이름은 " + filename);
	String ext = FileManager.getExtend(filename);
	out.print("내가 조작한 파일명은 " + time + "." + ext);
	
	//조작한 이름으로 파일명을 바꾸어야함
	//결국 파일을 다루어야 하므로 javaSE의 File클래스를 이용하면 된다!
	File file = multi.getFile("photo");
	file.renameTo(new File("C:/workspace/javaee_workspace/BoardApp/WebContent/data/"+time+"."+ext));
	
	//클라이언트에게 전송할 응답정보를 가진 객체
	//클라이언트의 브라우저로 하여금 지정한 URL로 재접속을 시도하게 만듦
	response.sendRedirect("/gallery/send.html");
} catch (IOException e) {
	e.printStackTrace();//콘솔로그에 에러 출력
	out.print("업로드 용량이 너무 큽니다..");//사블릿 쓰레드 에러..
}
%>

위 코드에서 볼 수 있듯이  MultipartRequest와 request 객체를 이용해서 파일을 업로드할 수 있다.

다운받은 파일에 doc폴더 아래에 html파일들을 보면서 자세히 알 수 있다.

Apache에서 제공하는 라이브러리 사용

Maven Repository: commons-fileupload » commons-fileupload (mvnrepository.com)

 

Maven Repository: commons-fileupload » commons-fileupload

The Apache Commons FileUpload component provides a simple yet flexible means of adding support for multipart file upload functionality to servlets and web applications. VersionRepositoryUsagesDate1.4.x1.4Central226Dec, 20181.3.x1.3.3Central514Jun, 20171.3.

mvnrepository.com

위 사이트에서 jar파일을 다운받아 라이브러리에 등록한다.

<%@page import="org.apache.catalina.filters.SetCharacterEncodingFilter"%>
<%@page import="common.FileManager"%>
<%@page import="org.apache.commons.fileupload.FileItem"%>
<%@page import="java.util.List"%>
<%@page import="java.io.File"%>
<%@page import="org.apache.commons.fileupload.servlet.ServletFileUpload"%>
<%@page import="org.apache.commons.fileupload.DefaultFileItemFactory"%>
<%@ page contentType="text/html; charset=UTF-8"%>
<%
	/*
파일 업로드 컴포넌트 종류엔 여러종류가 있지만, 그 중 아파치의 공식 업로드 컴포넌트를 사용해본다.
*/
//업로드 객체를 생성해주는 팩토리 객체 : 주로 설정을 담당(서버의 저장경로, 파일의 용량제한..)
String saveDir = "C:/workspace/javaee_workspace/BoardApp/WebContent/data";
int maxSize = 1024 * 1024 * 3; // 3MB
DefaultFileItemFactory itemFactory = new DefaultFileItemFactory();
itemFactory.setRepository(new File(saveDir)); //저장될 위치!, 물리적인 저장이 아닌, 임시 디렉터리
//디렉터리도 파일의 종류 중 하나이다!!
itemFactory.setSizeThreshold(maxSize);//파일 크기 제한

//이 객체가 실제 업로드를 수행함
ServletFileUpload upload = new ServletFileUpload(itemFactory);//설정정보를 생성자의 인수로 전달!!

//FileItem은 클라이언트의 [전송 정보 하나 하나]를 의미한다!! 즉, html에서의 input, file 컴포넌트 들을..
//우리의 경우 input type="text"가 FileItem에 담기고
//우리의 경우 input type="file"도 FileItem에 담긴다.
List<FileItem> items = upload.parseRequest(request);//request를 전달하여 upload컴포넌트에게 클라이언트의 요청정보를 전달!!

for (FileItem item : items) {
	//out.print(item.getFieldName());//컴포넌트의 name추출 
	//반복문으로 처리되다보니, 파일만 따로 처리를 하려면 구분로직이 필요함..
	//out.print(item.getFieldName()+"은 텍스트 박스 여부 " + item.isFormField()+"<br>");
	
	if (!item.isFormField()) {//type이 text가 아닌 것만 업로드 처리!
		//out.print(item.getFieldName()+"의 값은 "+item.getString()+"<br>");
		//업로드 처리하자!! 메모리상의 이미지 정보를 실제 물리적 파일로 저장하자!
		//out.print( item.getName());
		String ext = FileManager.getExtend(item.getName());
		String filename = System.currentTimeMillis() + "." +ext;
		File file = new File(saveDir+"/"+filename);//비어있는 파일
		item.write(file);//저장 정보를 File클래스의 인스턴스로 전달!!
		out.print("보고서 작성<br>");
		out.print("본래 파일명 : "+item.getName()+"<br>");
		out.print("변경 파일명 : "+filename+"<br>");
		out.print("저장 위치 : "+saveDir+"<br>");
		out.print("파일 크기 : "+item.getSize()+"<br>");
	}
}
%>

아파치에서 제공하는 라이브러리는 Factory객체를 이용하여 설정을 할 수 있고 ServletFileUpload 객체를 이용하여 request내에 담긴 파라미터들을 해석하여 List로 받아 사용할 수 있다.!!

'프로그래밍 > JSP' 카테고리의 다른 글

JSP | session  (0) 2020.12.16
JSP | 커넥션풀(Connection Pool)  (0) 2020.12.11
JSP | MyBatis 사용해보기  (0) 2020.12.10
JSP - 페이징 이해  (0) 2020.12.08
JSP - JSP(Java Server Page)란?  (0) 2020.12.01

JSP란 무엇일까?

JSP는 자바가 서버에서 실행되는 형태로 문서내에 있는 자바코드를 서버에서 실행시켜주는 페이지(?) 같다.

EJS처럼 html문서 내에 자바코드가 들어가게 되는 형태이다. 

 

구조

1. 지시영역 (<%@ %>)

 지시영역는 해당 페이지의 정보를 설정한다고 보면 된다.

예를 들면 <%@ page contentType="text/html;charset=utf-8"%>이런 식으로 페이지의 파일 형태나 인코딩방식을 정의할 수 있고, <%@ page import="java.sql.Connection"%> 이런 식으로 클래스를 import할 수 있다.

 

2. 선언부 (<%! %>)

선언부는 멤버변수를 선언하는 것과 같다고 볼 수 있다. 

<%! int number=3%>와 같이 쓸 수 있으며, 이 변수는 응답에 완료하기 전까지 메모리에 남아있는 변수로 생각할 수 있다.

 

3. 스크립트릿 (<%%>)

스트립트릿(Scriptlet)는 단순히 문서내에 자바코드를 삽입할 수 있는 영역이다.

<table>
	<tr>
    	<%for(int i=0;i<10;i++){%>
    		<td><%out.print(i);%></td>
        <%}%>
    </tr>
</table>

EJS와 매우 흡사하며, 위 코드와 같이 사용할 수 있다.

 

4. 표현식 (<%= %>)

표현식은 페이지내에 선언된 메모리에 남아있는 변수들을 쉽게 사용할 수 있는 방법이다.

3번 코드블럭 내에 <%out.print(i);%>를 단순히 <%=i%>로 간편히 사용할 수 있게 된다.

 

작동원리

JSP문서는 서버에서 처리를 하게 되는데, 만약 서버로 정적인 요소(html, image..)들이 요청된다면, 서버는 단지 요청하는 요소를 클라이언트측으로 응답만 한다.

만약 .jsp 파일이 요청된다면 서버는 해당 파일내에 <%%>(스크립트릿)의 내용들을 해석하여 실행한 뒤, 이 문서를 html형태의 문서로 변환하여 클라이언트측으로 응답하게 된다! (정말 신기함)

 

<%@ page contentType="text/html;charset=utf-8"%>
<!DOCTYPE html>
<head>
<meta charset="UTF-8">
<title>Document</title>
<script>
	function getMsg(){
		return "<%="안녕"%>";
	}
	<%
		out.print(getMsg()+" 하세요");
	%>
	
</script>
</head>
<body>
</body>
</html>

예를 들어, 위와 같은 코드의 문서를 서버로 요청하게 된다면?? 과연 실행이 될까??

getMsg()는 현재 스크립트 영역 내에 존재하는 메서드이다. 그리고, 바로 아래에 <%%>내에서 getMsg()를 호출하고 있다. 

위에서 말했듯이, <%%>는 서버에서 실행되는 영역이다. 그리고 스크립트 영역의 코드는 반드시 클라이언트 측에서 실행된다. 이 개념을 이해했다면, 왜 에러가 나는 지 알 수 있다.

 

이유는, 실행순서(?)이다.  

1. 먼저, 클라이언트가 .jsp 파일을 요청하게 되면 서버는 해당 파일 내에 존재하는 <%%>를 실행하게 된다. 

2. 실행도중 getMsg()라는 메서드를 만나게 되는데, 이때 undefine 예외가 발생한다.

3. 왜냐하면, getMsg()는 스크립트 영역 내에 존재하는 메서드로 클라이언트에서 실행되기 때문에, 서버가 코드를 해석할 때는 아직 define되지 않은 상태이기 때문이다!! 

 

내장객체

jsp에서 지원하는 내장객체는 아래와 같다.

1. request : 클라이언트의 요청정보를 갖는 객체 (요청에 대한 처리 완료 시 소멸)
2. response : 클라이언트에게 보낼 응답정보를 갖는 객체 (요청에 대한 처리 완료 시 소멸)
3. out : jsp에 출력을 담당하는 객체
4. session : 정보를 세션 범위에서 유지하지 위해 지원되는 객체(로그인 정보 처리 시 사용할 예정)
5. application : 정보를 어플리케이션 범위에서 유지하기 위해 지원되는 객체
6. page : jsp를 표현한 객체
7. config : jsp 설정 정보를 보유한 객체
8. exception : jsp에서 발생한 예외정보를 보유한 객체

 

또한, 내장객체는 이미 내부적으로 인스턴스가 지원되면서, 해당 인스턴스의 변수명까지 이미 정해진 
상태이므로, 개발자는 그냥 사용하기만 하면 된다!! 

 

해당 객체들의 상세한 내용은 다음 시간에 ~ ^^

 

참고

jsp 파일 내에서 라이브러리나 외부클래스들을 사용하고 싶다면??

Sun사에서 이미 정해놓은 WEB-INF라는 보안된 디렉터리에 파일들을 위치시켜야한다!!(프로젝트 폴더 내에서)

클래스의 위치는 WEB-INF/classes, 라이브러리의 위치는 WEB-INF/lib에 두어야한다!

이런 식으로!

'프로그래밍 > JSP' 카테고리의 다른 글

JSP | session  (0) 2020.12.16
JSP | 커넥션풀(Connection Pool)  (0) 2020.12.11
JSP | MyBatis 사용해보기  (0) 2020.12.10
JSP - 페이징 이해  (0) 2020.12.08
JSP - 이미지 업로드  (0) 2020.12.04

자바FX(JavaFX)란? 

데스크톱 애플리케이션 리치 인터넷 애플리케이션(RIA)을 개발하고 배포하는 소프트웨어 플랫폼으로, 다양한 장치에서 실행 가능하다. 자바FX는 자바 SE를 위한 표준 GUI 라이브러리로서 스윙을 대체하기 위해 고안되었다.

출처 | 자바FX - 위키백과, 우리 모두의 백과사전 (wikipedia.org)

 

자바FX - 위키백과, 우리 모두의 백과사전

위키백과, 우리 모두의 백과사전.

ko.wikipedia.org

 

1) JavaFX 개발환경 구축 (Java버전 11부터는 내부에 탑재되어 있다고 한다!)

1. 구글창에 javafx download 입력 후 위 페이지로 이동!
2. 밑줄 친 페이지로 이동!
3. 자신의 컴퓨터의 OS에 맞는 설치파일 다운로드!
4. Eclipse Marketplace에서 e(fx)clipse를 입력하여 해당 플러그인 Install

해당 플러그인을 설치한 후, 이클립스를 재시작하고 나면 File-New-Other에 javafx가 생겼을 것이다! 

5. JavaFX Project 생성!

2) JavaFX 생명주기

우선, 자바FX 애플리케이션을 정의하기 위해서는 반드시 Application 추상 클래스를 상속받아야 한다!!

상속받은 후, 재정의할 메서드 중 start(), init(), stop()에 대해 알아볼 것이다.

start()는 애플리케이션이 실행할 준비가 되면 호출되는 메서드이다. 이 메서드는 반드시 재정의해야 하는 추상 메서드이다!

 

 

 

 

 

 

 

 

 

 

 

start메서드의 매개변수가 바로 애플리케이션의 윈도우이다!!!

FX에서는 윈도우의 반드시 하나의 Scene이 존재해야 한다. 

 

다음으로, init() 메서드를 살펴보자. 

init() 메서드는 인스턴스가 태어나고 초기화 작업에 사용되는 메서드이다.

 

다음, stop() 메서드는 메서드명과 같이 애플리케이션이 중지(종료)되었을 때 실행되는 메서드이다.

 

다음 예제를 보고 이해해보자!

package application;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class test extends Application{

	@Override
	public void start(Stage primaryStage) throws Exception {
		System.out.println("start() 메서드 호출 by  "+ Thread.currentThread().getName());
		//매개변수로 받은 stage 변수가 어플리케이션의 윈도우이다!!!
		
		//무대를 정의한다!!(FX에서는 윈도우에 반드시 하나의 Scene이 존재해야함)
		VBox parent = new VBox();//수직으로 컴포넌트를 배치하는 레이아웃 객체
													//FlowLayout과 비슷
		
		Scene s = new Scene(parent);//Parent란? 부모클래스를 의미하는 것이 아니라, 객체간 포함관계에서 바깥쪽
											//컨테이너를 의미
											//Swing과 비유하자면, 레이아웃 객체가 Parent이다!!
		
		Button bt = new Button("버튼");
		Button bt2 = new Button("버튼2");
		bt.setPrefWidth(200);
		bt.setPrefHeight(40);
		bt2.setPrefWidth(200);
		bt2.setPrefHeight(40);
		
		//버튼을 parent에 부착하기
		parent.getChildren().add(bt);
		parent.getChildren().add(bt2);
		
		//Scene을 윈도우에 부착
		primaryStage.setScene(s);
	
		bt.setOnAction((e)->{
			System.out.println("클릭했니?");
		});
		
		primaryStage.setMaxWidth(500);
		primaryStage.setMaxHeight(500);
		primaryStage.show();//윈도우 보이게
	}
	
	/*어플리케이션 시작 전, 초기화를 담당하는 메서드이다. 따라서 초기화할 게 없다면 재정의는 필수는 아니다
	 * 생성자 : 인스턴스가 태어날 떄 호출되는 메서드(더 시점이 빠르다)
	 * 초기화 : 인스턴스가 태어나고 초기화 작업에 사용되는 메서드*/
	
	public void init() throws Exception {
		//자바의 쓰레드의 메서드 중 현재 실행중인 쓰레드 정보를 얻기 위한 메서드 
		System.out.println("init() 메서드 호출 by "+ Thread.currentThread().getName());
	}
	
	public void stop() throws Exception {
		System.out.println("stop() 메서드 호출 by " + Thread.currentThread().getName());
	}
	
	
	public static void main(String[] args) {
		System.out.println("main() 메서드 호출 by " + Thread.currentThread().getName());
		launch(args);//애플리케이션을 실행하는 메서드!!!
	}
}

실행결과 보면 애플리케이션의 main() 메서드를 실행 후 애플리케이션의 초기화 작업인 init()를 실행한 후 애플리케이션이 실행될 준비가 완료되면 start() 메서드를 실행하며, 애플리케이션을 종료 시 stop() 메서드가 실행된다.

 

(start() 메서드를 실행시키는 쓰레드가 따로 존재하는데 JavaFX Application Thread가 이 일을 담당한다.

JavaFX Application Thread는 UI, Event을 담당하는 쓰레드이다.) - 사실, 이 부분은 아직 배우질 않아서 자세히는 적지 못하였음! 다음 수업을 듣고 보충해서 적어야 한다.

'프로그래밍 > Java' 카테고리의 다른 글

java - mail 보내기  (0) 2021.01.06
싱글톤 패턴 알아보기  (0) 2020.12.14
Java - JSON & XML 파싱  (0) 2020.11.17
Java - 소켓프로그래밍 기초 Echo System  (0) 2020.11.09
Java - JDBC(Java DataBase Connectiviy) 사용법  (0) 2020.11.05

JSON이란? 속성-값 쌍 또는 키-값 쌍으로 이루어진 데이터 오브젝트를 전달하기 위해 인간이 읽을 수 있는 텍스트를 사용하는 개방형 표준 포맷이다. 비동기 브라우저/서버 통신 을 위해, 넓게는 XML을 대체하는 주요 데이터 포맷이다.

XML이란? W3C에서 개발된, 다른 특수한 목적을 갖는 마크업 언어를 만드는데 사용하도록 권장하는 다목적 마크업 언어이다. 

 

1) JSON 파싱

mvnrepository.com/artifact/org.json/json

 

Maven Repository: org.json » json

JSON is a light-weight, language independent, data interchange format. See http://www.JSON.org/ The files in this package implement JSON encoders/decoders in Java. It also includes the capability to convert between JSON and XML, HTTP headers, Cookies, and

mvnrepository.com

 

위 MavenRepository에 들어가서 JSON을 파싱하여 사용하기 위한 라이브러리를 다운받아서 프로젝트에 등록한다.

 

 

		//StringBuffer를 쓴 이유는? String은 불변의 특징이 있으므로, 너무 많은 문자열 상수를 만들어내지 않기 위해
		StringBuffer sb = new StringBuffer();
		sb.append("{");
		sb.append("\"name\":\"hyuk\"");
		sb.append("}");
        
        //sb에 담겨진 표기는, 실제 JSON 객체는 아니므로, 파싱단계를 거쳐 JSON 객체로 전환해야 한다!!
		//JSON파서는 자바 자체적으로 지원하지 않으므로 외부 라이브러리를 이용하여 파싱업무를 시도하자!!
		//주로 무료 기반(오픈소스)의 외부 라이브러는 아파치 재단에서 운영되는 maven 사이트 이용하자!
		JSONParser jsonParser = new JSONParser();//구문을 분석하는 파서객체 생성
		
		try {
			JSONObject obj = (JSONObject)jsonParser.parse(sb.toString());//파싱시작!!
			//파싱이 완료된 이후부터는 더이상 문자열이 아닌, json 객체로 사용하면 된다!!
			//JSON은 키와 밸류의 형태!!!
			System.out.println(obj.get("name"));//get(키값)
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}

JSONParser를 이용하여 파싱을 하여 JSONObject 객체로 반환받아서 JSON데이터의 키값을 이용하여 값을 얻어올 수 있다!!

위 코드의 출력결과

2) XML 파싱

XML 파싱은 JSON과 다르게 좀 더 복잡하다..

- jAVA에서 제공하는 SAXParser라는 추상 클래스를 제공한다.

- SAXParser는 SAXParserFactory의 newSAXParser()메서드를 이용하여 인스턴스를 얻을 수 있다.

- SAXParserFactory는 추상클래스로 SAXParserFactory의 static메서드인 newInstance()를 이용하여 인스턴스를 얻을 수 있다.

- SAXParser는 DefaultHandler를 상속받는 핸들러클래스를 재정의하여 파싱할 수 있다...

- 말만 들어도 복잡하다..

<?xml version="1.0" encoding="UTF-8"?>
<pets>
	<pet>
		<type>dog</type>
		<name>뽀미</name>
		<age>9</age>
		<gender>여</gender>
	</pet>
	<pet>
		<type>cat</type>
		<name>나비</name>
		<age>3</age>
		<gender>여</gender>
	</pet>
</pets>

이러한 XML파일이 있다. 파싱을 하기 위해

/*
	XML의 모든 노드에서 이벤트가 발생할때마다 아래의 핸들러 객체의 메서드를 
	알맞게 오버라이드하면 됨.
*/
package day1113.xml;

import java.util.ArrayList;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class MyHandler extends DefaultHandler {
	ArrayList<Pet> petList;
	Pet pet;
	boolean isType;
	boolean isName;
	boolean isAge;
	boolean isGender;

	// 문서가 시작되면 호출됨
	@Override
	public void startDocument() throws SAXException {
		System.out.println("문서를 시작합니다");
	}

	// 여는 태그 만났을때 호출됨 <태그> (/가 없는 태그)
	@Override
	public void startElement(String uri, String localName, String tag, Attributes attributes) throws SAXException {
		// TODO Auto-generated method stub
		System.out.print("<" + tag + ">");

		// 여러 태그 중 pets를 만나면 ArrayList를 생성하자!!
		if (tag.equals("pets")) {
			petList = new ArrayList<Pet>();
		} else if (tag.equals("pet")) { // 하나의 pet 인스턴스 생성할 타임이다!!
			pet = new Pet();
		} else if (tag.equals("type")) { // ???
			// 시작 태그를 지금 지나가고 있음을 알려주자!!!
			isType = true;
		} else if (tag.equals("name")) { // ???
			isName = true;
		} else if (tag.equals("age")) { // ???
			isAge = true;
		} else if (tag.equals("gender")) { // ???
			isGender = true;
		}

	}

	// 태그와 태그사이의 데이터를 만났을 때 호출
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		String data = new String(ch, start, length);
		System.out.print(data);
		if(isType) {
			pet.setType(data);			
		}else if(isName) {
			pet.setName(data);
		}else if(isAge) {
			pet.setAge(Integer.parseInt(data));
		}else if(isGender) {
			pet.setGender(data);
		}
	}

	// 닫는 태그를 만났을 때
	@Override
	public void endElement(String uri, String localName, String tag) throws SAXException {
		System.out.print("</" + tag + ">");
		
		if (tag.equals("pet")) { // 이 시점에 하나의 Pet이 완성된 시점이므로, 리스트에 담아두자!!
			petList.add(pet);
		} else if (tag.equals("type")) { // ???
			// 실행부가 지나가고 있는 위치를 알려주는 모든 논리값들을 다시 초기화!!
			isType = false;
		} else if (tag.equals("name")) { // ???
			// 실행부가 지나가고 있는 위치를 알려주는 모든 논리값들을 다시 초기화
			isName = false;
		} else if (tag.equals("age")) { // ???
			// 실행부가 지나가고 있는 위치를 알려주는 모든 논리값들을 다시 초기화
			isAge = false;
		} else if (tag.equals("gender")) { // ???
			// 실행부가 지나가고 있는 위치를 알려주는 모든 논리값들을 다시 초기화
			isGender = false;
		}
	}

	// 문서가 끝날 때
	@Override
	public void endDocument() throws SAXException {
		System.out.println("문서를 종료합니다");
		System.out.println("결과 보고서 : 총 " + petList.size() + "가 존재합니다.");
		for(Pet pet : petList) {
			System.out.println("type : " + pet.getType());
			System.out.println("name : " + pet.getName());
			System.out.println("age : " + pet.getAge());
			System.out.println("gender : " + pet.getGender());
			System.out.println("-------------------------------------------");
		}
	}
}

startDocument 메서드는 문서시작 시 호출되는 메서드
startElement 메서드는 열린태그를 만났을 시 호출되는 메서드
characters 메서드는 태그안의 데이터를 만났을 시 호출되는 메서드
endElement 메서드는 닫는태그를 만났을 시 호출되는 메서드 
endDocument 메서드는 문서 종료 시 호출되는 메서드

위 코드를 보면 어떤 형식으로 진행되는지 이해할 수 있을 것이다..

 

아래는 재정의한 핸들러를 사용하여 xml을 파싱하는 코드)

/*
 * java로 xml를 파싱하는 방법은 크게 2가지 있다.
 * 1)DOM 방식 - html과 같은 원리...
 * 						즉, 모든 태그마다 1:1대응하는 DOM객체를 메모리에 생성해놓고 프로그래밍언어에서 필요한 객체를 접근하는 방식
 * 						예) javascript - DOM
 * 						무거운 DOM객체가 메모리에 부하를 일으킬 수 있다.. 특히 메모리크기가 pc에 비해 상대적으로 작은 디바이스의 경우 DOM방식은 적절치못하다!!
 * 2)SAX 방식 - xml문서를 이루는 엘리먼트, 텍스트 등의 모든 노드에 대한 이벤트를 발생시켜주는 방식
 * 					따라서 개발자는 적절한 자바의 객체를 메모리에 올려, xml을 대신하여 데이터를 사용하면 된다!!
 * 
*/
package day1113.xml;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXException;

public class XMLParseApp {
	// 실행중인 자바프로세스가 파일에 접근하기 위해서는 파일입력스트림 계열이 필요하다!
	FileInputStream fis;
	InputStreamReader reader;
	BufferedReader buffr;
	File file;
	URL url;
	URI uri;
	
	public XMLParseApp() {
		url = this.getClass().getClassLoader().getResource("res/pets.xml");
		try {
			uri = url.toURI(); // File 클래스의 생성자에서는 URL이 아닌 URI를 원하므로, 변환하자!
			fis = new FileInputStream(file = new File(uri)); //스트림얻기!! 현재 1byte씩얻는상태
			parseData(); //파싱시작!!
			
		} catch (URISyntaxException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} finally {
			if(fis!=null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	//xml파싱해보자!!
	public void parseData() {
		//SAX방식의 파서는 SAXParserFactory 객체로부터 얻는다.
		SAXParserFactory factory; 
		factory = SAXParserFactory.newInstance(); //static메서드를 이용하여 인스턴스얻음
		try {
			SAXParser saxParser=factory.newSAXParser();//Factory로부터 파서의 인스턴스를 얻을 수 있다..
			saxParser.parse(fis, new MyHandler());
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public void readTest() {
		try {
			
			//육안으로 확인할 때 한글이 깨질 수 있으므로, Reader로 업그레이드하자
			reader = new InputStreamReader(fis); //문자로 얻는 걸로 업그레이드
			buffr = new BufferedReader(reader);// 한 줄씩 얻는 걸로 업그레이드
			//한문자씩 읽어들이면 너무 시간이 오래걸리므로, 한줄씩 읽어 들이기
			
			//파싱은 나중에하고, 먼저 xml을 제대로 스트림으로 읽어들일 수 있는 지 체크
			String data = null;
			while(true) {
				data = buffr.readLine();
				if(data==null) break;
				System.out.println(data);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}

	public static void main(String[] args) {
		new XMLParseApp();
	}
}

 

Pet클래스(VO)

/*
	한마리의 반려동물을 담게 될 VO 클래스
	VO란? Value Object의 약자로서, [로직 작성이 목적이 아닌 단지 데이터만을 보관할 용도로 사용되는 객체]를 가리키는 애플리케이션 설계 용어 중 하나!
*/
package day1113.xml;

public class Pet {
	private String type;
	private String name;
	private int age;
	private String gender;

	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
}

위 코드의 출력결과

지금봐도 너무 어렵다... 여러번 봐야할 것 같다.. ㅠ

Echo System?

  • 자바의 소켓을 이용하여 채팅(멀티캐스팅)을 구현하기 위한 기초적인 학습!
  • 단순히, 내가 보낸 메시지를 내가 받아서 콘솔에 메아리치는(Echo) 프로그램 
  • 클라이언트는 Telnet을 사용

1) Telnet 기능 켜기

- 윈도우사용자의 경우, 제어판으로 들어가 Windows 기능 켜기/끄기를 눌러 Telnet 클라이언트를 체크한다음 확인을 눌러준다.

 

2) 서버 구현

  

  • 자신이 원하는 클래스명으로 클래스 생성
  • 하나의 클래스에서 실행을 하기 위해 main메서드 생성
  • ServerSocket 인스턴스를 사용하기 위해 멤버변수 생성
  • 포트번호는 1~1024번까지는 이미 시스템이 점유하므로 점유불가! 

 

 

 

 

 

 

 

 

 

 

  • ServerSocket은 서버를 열어놓고 accept()메서드를 이용하여 접속자가 들어올 때까지 Block상태로 대기한다.

 

 

 

 

 

 

  • ServerSocket으로부터 accpet()된 요청의 클라이언트와 메시지를 주고받기 위해선 Socket객체를 반환받아야한다.
  • Socket객체로부터 InputStream을 반환받아 클라이언트로부터 보낸 메시지를 콘솔창에 뿌릴 수 있다.

 

 

 

 

 

 

package day1109.echo;

import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class EchoServer2 {
	ServerSocket server;
	int port = 9999;

	public EchoServer2() {
		try {
			server = new ServerSocket(port);
			System.out.println("서버 소켓 생성완료!");
			
			Socket socket = server.accept();
			System.out.println("접속자 발견!");
			
			//반환받은 소켓을 이용하면, 현재 접속자에 대한 정보를 구할 수 있다.
			InetAddress inet = server.getInetAddress();
			String ip = inet.getHostAddress();
			System.out.println(ip);
			
			//클라이언트가 보낸 메시지 받기!! 
			//(메시지를 받는 것은 실행중인 프로그램으로 데이터가 들어오는 것이므로
			//입력 스트림으로처리해야한다!!)
			//소켓으로부터 스트림을 뽑아낼 수 있다!
			InputStream is =socket.getInputStream();//바이트기반(한글깨짐, 영문만)
			
			int data=1;
			while(data!=10) {
				System.out.print((char)data);//1byte읽어들임...
			}
			socket.close();
			server.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		new EchoServer2();
	}
}

cf. ServerSocket과 Socket의 차이는? 

ServerSocket : 말그대로 서버 프로그램에서만 사용하는 소켓이다. 서버소켓은 클라이언트로부터 연결 요청이 오기를 기다렸다가 연결 요청이 들어오면 클라이언트와 연결을 맺고 다른 소켓을 만드는 일을 한다.

Socket : 서버에 접속하기 위한 클라이언트를 구현는 사용하는 클래스

 

'프로그래밍 > Java' 카테고리의 다른 글

java - mail 보내기  (0) 2021.01.06
싱글톤 패턴 알아보기  (0) 2020.12.14
JavaFX - 개발환경 구축 및 생명주기  (0) 2020.11.23
Java - JSON & XML 파싱  (0) 2020.11.17
Java - JDBC(Java DataBase Connectiviy) 사용법  (0) 2020.11.05

JDBC란?

자바에서는 데이터베이스 연동하는 기술을 가리켜 JDBC(Java DataBase Connectiviy)라고 하며,

Java.sql 패키지에서 API가 지원된다!

연동 절차

1) DB기종에 알맞는 드라이버를 로드 (oracle용, mysql용, mssql용.. 각각 jar가 필요)
2) 접속
3) 원하는 쿼리 수행
4) 접속해제 (특히, 스트림 및 DB는 사용 후 반드시 해제하자!!!)

1) DB기종에 알맞는 드라이버를 로드 (oracle용, mysql용, mssql용.. 각각 jar가 필요)

- 오라클일 경우

오라클을 설치한 폴더로 찾아가 .jar파일을 가져온다

ex) oracle\product\11.2.0\server\jdbc\lib

 

자신의 java 버전에 따라 가져와서 사용한다! (나는 6을 사용했다)

jar파일을 사용하고 있는 프로젝트의 추가를 해준다!

 

- MySQL(MariaDB)일 경우

MavenRepository에 들어가서 jdbc를 검색하여 .jar파일로 다운받는다!

그 다음은 , 오라클과 다를게 없다~

 

이제 코드로 가서, Class.forName() 메소드를 이용하여 드라이버를 로드한다!

Class.forName("oracle.jdbc.driver.OracleDriver");//오라클의 경우
Class.forName("com.mysql.cj.jdbc.Driver");//MySQL의 경우

2) 접속

DriverManger(DBMS에 접속하여 Connection 인스턴스받아주는 클래스)를 이용하여 Conncection(접속된 데이터베이스의 정보를 가지고 있는 인터페이스) 인터페이스의 인스턴스를 반환받자!

Connection con=null;	
 			//jdbc:DBMS기종:방식:ip주소:포트번호:기기의 DBMS설치명
String url="jdbc:oracle:thin:@localhost:1521:XE"; //Oracle 경우
			//jdbc:DBMS기종:ip주소:(포트번호):database명
String url = "jdbc:mysql://localhost:/exdatabase"; //MySQL 경우
String user="";
String password="";
con=DriverManager.getConnection(url, user, password); //접속시도!!

3) 원하는 쿼리 실행

- SELECT의 경우

PreparedStatement pstmt; // 쿼리문 수행 객체, 인터페이스이므로 new로 생성하는 것이 아니라
// 접속객체인 Connection 객체로부터 인스턴스를 얻올 수 있다.
ResultSet rs;// select 쿼리문 수행결과에 의해 표가 반환되는데, 이떄 이 표를 담는 객체
String sql = "select * from emp";

pstmt = con.prepareStatement(sql); // Connection객체로부터 PerparedStatement인스턴스얻기
rs = pstmt.executeQuery();// select문의 경우엔 executeQuery() 이용해야한다..
//rs에는 표가 들어있다!! 따라서 원하는 레코드로 커서를 옮기자!!
            
while(rs.next()) { //데이터가 존재하면, 한칸 전진 후 true까지 반환
	rs.getString("컬럼명"); //테이블의 컬럼명을 통해 가져올 수 있다
    rs.getInt("컬럼명2") //반환받는 데이터의 자료형에 따라 메서드가 다르다!
}

- INSERT, UPDATE, DELETE의 경우

  • INSERT의 경우의 성공 시 1, 실패 시 0 
  • UPDATE, DELETE의 경우엔 성공 시 UPDATE, DELETE된 행들의 수만큼, 실패 시 0
PreparedStatement pstmt; // 쿼리문 수행 객체, 인터페이스이므로 new로 생성하는 것이 아니라
// 접속객체인 Connection 객체로부터 인스턴스를 얻올 수 있다.
ResultSet rs;// select 쿼리문 수행결과에 의해 표가 반환되는데, 이떄 이 표를 담는 객체
String sql = "select * from emp";

pstmt = con.prepareStatement(sql); // Connection객체로부터 PerparedStatement인스턴스얻기
int result = pstmt.executeUpdate();//DML(insert, update, delete) 쿼리 실행 시 이 메서드(executeUpdate())를 사용함
if(result!=1){
System.out.println("insert 실패");
}else{
System.out.println("insert 성공");
}

4) 접속해제 (특히, 스트림 및 DB는 사용 후 반드시 해제하자!!!) 

if(rs!=null) {
  try {
    	rs.close();
    	System.out.println("rs 연결해제");
  	} catch (SQLException e1) {
    	e1.printStackTrace();
  	}
  }
if(pstmt!=null) {
  try {
    	pstmt.close();
    	System.out.println("pstmt 연결해제");
    } catch (SQLException e1) {
    	e1.printStackTrace();
    }
  }
if(con!=null) {
	try {
  	con.close();
  	System.out.println("con 연결해제");
  } catch (SQLException e1) {
 	 e1.printStackTrace();
  }
}

원하는 쿼리 실행한 뒤에, 반드시 !!!! 접속을 해제시켜줘야한다!! 

Database Server는 동시에 연결가능한 횟수에 제한을 두고 있기 때문에 사용하지 않을 때는 닫아야 한다!!

'프로그래밍 > Java' 카테고리의 다른 글

java - mail 보내기  (0) 2021.01.06
싱글톤 패턴 알아보기  (0) 2020.12.14
JavaFX - 개발환경 구축 및 생명주기  (0) 2020.11.23
Java - JSON & XML 파싱  (0) 2020.11.17
Java - 소켓프로그래밍 기초 Echo System  (0) 2020.11.09

+ Recent posts