Jaybon 의 지식창고

데이터 커넥션 풀링 기법

DBCP

ex) 10개의 튜브를 만들어 놨다가 손님이 10명이하면 정상으로 진행하고, 10명이상 몰릴경우 10명까지만 사용하고 나머지는 줄을 세워놓고 대기를 시킨다. 대기시간이 길어지면 대기자를 튕겨내고 재요청하도록 한다.

--------------------------------------

1 톰캣스타트

- 카타리나(catalina.properties) : 웹서버위치
- server.xml, 포트, SSL, 컨텍스트

- context.xml -> web.xml 읽기
- web.xml 배포서술자

서블릿들은 사용자 요청시에 new 된다 + (req, resp 가 주입됨)
blog/user?cmd=joinProc

blog2 프로젝트

love(DB유저)

context.xml

서버가 켜질 때 띄우고 싶은 객체가 있을 경우 xml로 불러온다.

server에 있는 root-context는 서버 전반에 적용할 내용을 입력한다

프로젝트에 있는 servlet-context는 해당 프로젝트에 적용할 내용을 입력한다.

-------------------------------------

Repository - DB, 공공데이터, 다른 데이터 등 어떠한 데이터들을 저장하는 것을 Repository라고 한다.

--------------------------------------

클라이언트가 DB정보를 들고 있을 수 없으므로 서버에 연결하여 DB에 접근하여 다시 데이터를 받게 된다.

------------------------------------

자바스크립트에는 히스토리백이 있다 (자바에는 리다이렉트 밖에 없다)

회원가입 내용을 입력하고 가입을 눌렀는데 내용이 틀려서 다시 회원가입페이지로 돌아올경우

사용자가 입력한 내용들을 유지시키는 것

-------------------------------------

프로젝트 하나 생성하고 패키지를 만들자

이렇게 만들면 된다

테이블세팅

CREATE TABLE users(
	id number primary key,
    username varchar2(100) not null unique,
    password varchar2(100) not null,
    email varchar2(100) not null,
    address varchar2(100) not null,
    userProfile varchar2(200),
    userRole VARCHAR2(20),
    createDate timestamp
) ;

CREATE TABLE board(
	id number primary key,
    userId number,
    title varchar2(100) not null,
    content clob,
    readCount number default 0,
    createDate timestamp,
    foreign key (userId) references users (id)
);

CREATE TABLE reply(
	id number primary key,
    userId number,
    boardId number,
    content varchar2(300) not null,
    createDate timestamp,
    foreign key (userId) references users (id) on delete set null,
    foreign key (boardId) references board (id) on delete cascade
);

readme.md 파일 생성

파일 다운받아서 복붙

시퀀스 생성

CREATE SEQUENCE USERS_SEQ
    START WITH 1
    INCREMENT BY 1;

CREATE SEQUENCE BOARD_SEQ
    START WITH 1
    INCREMENT BY 1;

CREATE SEQUENCE REPLY_SEQ
    START WITH 1
    INCREMENT BY 1;

이걸 복사해서 context.xml에 붙여넣기

<Resource name="jdbc/myoracle" auth="Container"
              type="javax.sql.DataSource" driverClassName="oracle.jdbc.OracleDriver"
              url="jdbc:oracle:thin:@127.0.0.1:1521:mysid"
              username="scott" password="tiger" maxTotal="20" maxIdle="10"
              maxWaitMillis="-1"/>

*서버의 context.xml

내 프로젝트 안의 META-INF 에 context.xml 을 만들어두면 프로젝트를 다른 곳으로 옮겨도 설정이 유지된다.

*내 프로젝트의 context.xml

DB커넥션을 메모리에 미리 띄워주기 위한 코드

내 프로젝트에 web.xml을 복사하여 붙여넣기한다. 

톰캣사이트의 내용을 복사하여 붙여넣는다

<resource-ref>
 <description>Oracle Datasource example</description>
 <res-ref-name>jdbc/myoracle</res-ref-name>
 <res-type>javax.sql.DataSource</res-type>
 <res-auth>Container</res-auth>
</resource-ref>

web-app 안에 넣어준다

db패키지에 DBConn 클래스를 만들어주자

톰캣 사이트에서 예제를 복사하자

클래스안에 getConnection 만들어주고 위의 내용을 넣는다

톰캣이 들고있는 라이브러리이다 (javax)

리턴을 넣어주자

WebContent에 dbConnTest.jsp를 만들자

아래와 같이 작성하고 테스트

연결 성공 확인

--

테스트를 위해 JUnit을 라이브러리에 추가하자

테스트를 위한 테스트 패키지와 파일을 만들자

JUnit으로 테스트 해본다

서버가 켜지지 않아서 context.xml이 실행되지 않아서 DB 객체가 불러와 지지 않아서 오류가 난다.

DBConn.java

package com.cos.blog.db;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

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

public class DBConn {
	public static Connection getConnection() {
		try {
			
			Context initContext = new InitialContext();
			Context envContext  = (Context)initContext.lookup("java:/comp/env");
			DataSource ds = (DataSource)envContext.lookup("jdbc/myoracle");
			Connection conn = ds.getConnection();
			
			return conn;
			
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("DBConn : 데이터베이스 연결 실패");
			System.out.println("DBConn : Message" + e.getMessage());
		}
		return null;
	}
	
	public static void close(Connection conn, PreparedStatement pstmt) {
		try {
			if(conn != null) {
				conn.close();				
			}
			if(pstmt != null) {			
				pstmt.close();
			}
		} catch (Exception e) {
			System.out.println("DB종료시 오류가 발생 : " +e.getMessage());
		}
	}
	
	public static void close(Connection conn, PreparedStatement pstmt, ResultSet rs) {
		try {
			if(conn != null) {
				conn.close();				
			}
			if(pstmt != null) {			
				pstmt.close();
			}
			if(rs != null) {			
				rs.close();
			}
		} catch (Exception e) {
			System.out.println("DB종료시 오류가 발생 : " +e.getMessage());
		}
	}
}

UsersRepository.java

package com.cos.blog.repository;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import com.cos.blog.db.DBConn;
import com.cos.blog.model.Users;

public class UsersRepository {

	private static final String TAG = "UsersRepository : ";

	// 싱글톤
	private static UsersRepository instance = new UsersRepository();

	private UsersRepository() {
	}

	public static UsersRepository getInstance() {
		return instance;
	}

	private Connection conn = null;
	private PreparedStatement pstmt = null;
	private ResultSet rs = null;

	public int join(Users user) {

		final String SQL = "";

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			// 여기에 물음표 완성하기

			return pstmt.executeUpdate();

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "join : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt);
		}

		return -1;
	}

	public int update(Users user) {

		final String SQL = "";

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			// 여기에 물음표 완성하기

			return pstmt.executeUpdate();

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "update : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt);
		}

		return -1;
	}

	public int deleteById(int id) {

		final String SQL = "";

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			// 여기에 물음표 완성하기

			return pstmt.executeUpdate();

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "deleteById : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt);
		}

		return -1;
	}
	
	public List<Users> findAll() {

		final String SQL = "";
		List<Users> users = new ArrayList<>();

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			
			// 여기에 물음표 완성하기
			// while 돌려서 rs -> java 오브젝트에 집어넣기

			return users;

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "findAll : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt, rs);
		}

		return null;
	}
	
	public Users findById(int id) {

		final String SQL = "";
		Users user = new Users();

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			
			// 여기에 물음표 완성하기
			// if 해서 rs -> java 오브젝트에 집어넣기

			return user;

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "findById : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt, rs);
		}

		return null;
	}

}

BoardRepository.java

package com.cos.blog.repository;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import com.cos.blog.db.DBConn;
import com.cos.blog.model.Board;
import com.cos.blog.model.Users;

public class BoardRepository {

	private static final String TAG = "BoardRepository : ";

	// 싱글톤
	private static BoardRepository instance = new BoardRepository();

	private BoardRepository() {
	}

	public static BoardRepository getInstance() {
		return instance;
	}

	private Connection conn = null;
	private PreparedStatement pstmt = null;
	private ResultSet rs = null;

	public int save(Board board) {

		final String SQL = "";

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			// 여기에 물음표 완성하기

			return pstmt.executeUpdate();

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "save : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt);
		}

		return -1;
	}

	public int update(Board board) {

		final String SQL = "";

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			// 여기에 물음표 완성하기

			return pstmt.executeUpdate();

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "update : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt);
		}

		return -1;
	}

	public int deleteById(int id) {

		final String SQL = "";

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			// 여기에 물음표 완성하기

			return pstmt.executeUpdate();

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "deleteById : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt);
		}

		return -1;
	}
	
	public List<Board> findAll() {

		final String SQL = "";
		List<Board> boards = new ArrayList<>();

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			
			// 여기에 물음표 완성하기
			// while 돌려서 rs -> java 오브젝트에 집어넣기

			return boards;

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "findAll : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt, rs);
		}

		return null;
	}
	
	public Board findById(int id) {

		final String SQL = "";
		Board board = new Board();

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			
			// 여기에 물음표 완성하기
			// if 해서 rs -> java 오브젝트에 집어넣기

			return board;

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "findById : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt, rs);
		}

		return null;
	}

}

ReplyRepository.java

package com.cos.blog.repository;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import com.cos.blog.db.DBConn;
import com.cos.blog.model.Board;
import com.cos.blog.model.Reply;
import com.cos.blog.model.Users;

public class ReplyRepository {

	private static final String TAG = "BoardRepository : ";

	// 싱글톤
	private static ReplyRepository instance = new ReplyRepository();

	private ReplyRepository() {
	}

	public static ReplyRepository getInstance() {
		return instance;
	}

	private Connection conn = null;
	private PreparedStatement pstmt = null;
	private ResultSet rs = null;

	public int save(Reply reply) {

		final String SQL = "";

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			// 여기에 물음표 완성하기

			return pstmt.executeUpdate();

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "save : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt);
		}

		return -1;
	}

	public int update(Reply reply) {

		final String SQL = "";

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			// 여기에 물음표 완성하기

			return pstmt.executeUpdate();

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "update : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt);
		}

		return -1;
	}

	public int deleteById(int id) {

		final String SQL = "";

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			// 여기에 물음표 완성하기

			return pstmt.executeUpdate();

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "deleteById : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt);
		}

		return -1;
	}
	
	public List<Reply> findAll() {

		final String SQL = "";
		List<Reply> replies = new ArrayList<>();

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			
			// 여기에 물음표 완성하기
			// while 돌려서 rs -> java 오브젝트에 집어넣기

			return replies;

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "findAll : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt, rs);
		}

		return null;
	}
	
	public Reply findById(int id) {

		final String SQL = "";
		Reply reply = new Reply();

		try {

			conn = DBConn.getConnection();
			pstmt = conn.prepareStatement(SQL);
			
			// 여기에 물음표 완성하기
			// if 해서 rs -> java 오브젝트에 집어넣기

			return reply;

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(TAG + "findById : " + e.getMessage());
		} finally {
			DBConn.close(conn, pstmt, rs);
		}

		return null;
	}

}

UsersController.java

package com.cos.blog.controller;

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


@WebServlet("/user")
public class UsersController extends HttpServlet {
	
	private static final String TAG = "UsersController : ";
	
	private static final long serialVersionUID = 1L;
       

    public UsersController() {
        super();
    }


	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		router(request, response);
	}

	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		router(request, response);
	}
	
	// 어떠한 형식의 요청이 오든 여기서 처리
	protected void router(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		
		// http://localhost:8000/blog/user?cmd=join
		
		String cmd = request.getParameter("cmd");
		
		System.out.println(TAG + "router : " + cmd);
		
		if(cmd.equals("join")) {
			// 회원가입 페이지로 이동
		} else if(cmd.equals("joinProc")) {
			// 회원가입을 진행 한 후 -> index.jsp로 이동
		} else if(cmd.equals("update")) {
			// 회원 수정 페이지로 이동 (세션에 User 오브젝트를 가지고 있을 예정)
		} else if(cmd.equals("updateProc")) {
			// 회원 수정을 진행 한 후 -> index.jsp로 이동
		} else if(cmd.equals("delete")) {
			// 회원 수정페이지에서 삭제할 예정 - 회원 삭제를 진행 한 후 -> 로그아웃을 하고 -> index.jsp로 이동
		} else if(cmd.equals("login")) {
			// 회원 로그인 페이지로 이동
		} else if(cmd.equals("loginProc")) {
			// 회원 로그인을 수행한 후 -> 세션에 등록을 하고 -> index.jsp로 이동
		} 	
	}
}

주소창에 쳐보고 잘 작동되는지 테스트

---

UserController 파일에서 다른파일로 위임

package com.cos.blog.action.user;

import java.io.IOException;

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

public class UsersJoinAction  {
	
	// 컨트롤러가 해야될 일들을 위임해서 다른 클래스가 일을 하게 하는 것을 팩토리패턴이라고 한다
	public void execute(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		RequestDispatcher dis = request.getRequestDispatcher("user/join.jsp");
		dis.forward(request, response);
	}
	
}

user와 관련된 뷰를 넣을 폴더

--

유효성 체크는 모든 action에서 다해줘야 한다 (중요)

router를 doProcess로 변경하고 router를 하나 새로만든다

package com.cos.blog.action.user;

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

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

import com.cos.blog.action.Action;
import com.cos.blog.model.RoleType;
import com.cos.blog.model.Users;
import com.cos.blog.repository.UsersRepository;
import com.cos.blog.util.Script;

public class UsersJoinProcAction implements Action  {
	
	// 컨트롤러가 해야될 일들을 위임해서 다른 클래스가 일을 하게 하는 것을 팩토리패턴이라고 한다
	@Override
	public void execute(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		
		// 0. // 페이지 오류를 막기위해(공격 등) 유효성 검사부터 해야한다
		if(request.getParameter("username").equals("") ||
				request.getParameter("username") == null ||
				request.getParameter("password").equals("") ||
				request.getParameter("password") == null ||
				request.getParameter("email").equals("") ||
				request.getParameter("email") == null ||
				request.getParameter("address").equals("") ||
				request.getParameter("address") == null) {
			
			// 로그하나 남겨야함
			return;
			
		}
		
		// 1. 파라메터 받기 (x-www-form-urlencoded)라는 MIME타입 key=value
		String username = request.getParameter("username");
		String password = request.getParameter("password");
		String email = request.getParameter("email"); // postman등으로 공격하면 형식에 맞지않게 보낼수 있기 때문에 유효성체크 해줘야한다(지금은 안함)
		String address = request.getParameter("address");
		String userRole = RoleType.USER.toString();
		
		
		// 2. User 오브젝트 변환
		Users user = Users.builder()
				.username(username)
				.password(password)
				.email(email)
				.address(address)
				.userRole(userRole)
				.build();
		
		
		// 3. DB 연결 - UserRepository의 save() 호출
		UsersRepository usersRepository = UsersRepository.getInstance();
		int result = usersRepository.save(user);
		
		// 4. index.jsp 페이지로 이동
		if(result == 1) {
			RequestDispatcher dis = request.getRequestDispatcher("index.jsp");
			dis.forward(request, response);
		} else {
			Script.back("회원가입에 실패하였습니다.", response);
		}
			
	}
}

포스트맨으로 테스트해본다

----------------------------------

https://swdevelopment.tistory.com/130

https://hyoje420.tistory.com/36

리눅스 에디터

vi HelloWorld.java

nano helloWorld.java

나노 설치법 sudo apt-get install nano

리눅스에 vi가 기본 내장되어 있기 때문에 vi쓰는 법을 알면 좋다.

-----------------------------------------

JSP 주석 <%-- 주석내용 %-->

JSP 페이지 지시자 <%@ %>

JSP <%! %>
-전역공간 (함수 만들 수 있음)

JSP 스크립트 릿 <% %>
-스택공간

JSP 표현식 <%= %>

---------------------------------------------

윈도우에서 작업하여 리눅스에 자바 프로젝트 올리기(5~8번)

sudo!

1. jdk 설치

2. nano 에서 HelloWorld.java 만들기

3. 컴파일 -> 실행

4. Github 저장소 생성

5. 윈도우에서 자바프로젝트 하나 생성

6. 메인클래스가 있는 앱 생성

7. Github에 배포

8. 리눅스에서 Git clone으로 복사

--------------------------------------------

자바 버전확인

나노를 이용해서 java 파일 만들기

컴파일 하고 출력해보기

리포지토리 새로 만들고 github에 프로젝트 올리기

git clone으로 프로젝트 받기

폴더 확인

--

서버 부하 관리

기본적으로 페이지가 요청될 때마다 request, response 객체가 생성되고 사람이 많이 몰릴 경우 컴퓨터에 부하가 걸려 뻗어버릴 수가 있다.

그래서 미리 20~100개의 request, response 객체를 만들어 두고 해당객체들을 쓰고 비우고 하면서 부하 관리를 하게 된다.

--------------------------------------