200528 MVC2 / context.xml / Repository / historyback

 

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 파일 생성

 

 

 

파일 다운받아서 복붙

README.md

0.00MB

 

 

시퀀스 생성

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);
		}
			
	}
}

 

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

 

 

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