복습
DTO
- 자바빈의 프로퍼티명과 테이블의 컬럼명, 폼에서 넘어온 name 값을 일치시켜야 한다
DAO
- DAO 에는 싱글톤이 들어가고 나머지는 메소드로 구성됨
- 검색된 결과를 DTO 객체 생성해서 전송
DAO 클래스로 DB 연동 예제 1
1. 실습 준비 및 테이블 생성
+ DAO / DTO 클래스가 없어서 생기는 오류
- JSP 파일들은 다 있고 필요한 아래의 테이블을 먼저 생성해야함
create table member2(
id varchar2(12) primary key,
passwd varchar2(12) not null,
name varchar2(10) not null,
jumin1 varchar2(6) not null,
jumin2 varchar2(7) not null,
email varchar2(30),
blog varchar2(50),
reg_date date not null);+ 숫자더라도 값의 변화가 자주 일어나지 않는 값은 varchar2 타입으로 처리하는게 좋다
+ 주민번호는 자주 바뀌지 않으므로 숫자지만 문자형인 varchar2 로 처리
+ 값의 변화가 자주 일어나는 값은 number 타입으로 처리 ex) 조회수는 자주바뀌므로 숫자데이터로 처리
- sql/myoracle.sql 에서 테이블 생성 완료
- 이제 DAO, DTO 클래스 만들 것
- DAO / DTO 클래스 이 패키지로 만들기
2. DTO / DAO 클래스 만들기
JavaBeanMember.register - LogonDataBean.java (DTO)
JavaBeanMember.register - LogonDBBean.java (DAO)
+ Model 2 에선 DAO 클래스와 DTO 클래스가 다른 패키지에 있다
+ 지금 Model 1 에선 같은 패키지에 넣어서 import 할 필요없이 만듬
- JavaBeanMember.register 패키지 먼저 생성 후 class 자바 파일 만들기
3. DTO 클래스 만들기
- 오라클의 자료형을 자바의 자료형으로 가져온다
- 접근제어자는 private, varchar2 는 String, number 는 int 로, date 는 Date로 변경
- getter setter 메소드 추가
- DTO 클래스 완성
- LogonDataBean.java
// DTO (Data Transfer Object)
package JavaBeanMember.register;
import java.util.Date;
public class LogonDataBean {
private String id; // 프로퍼티
private String passwd;
private String name;
private String jumin1;
private String jumin2;
private String email;
private String blog;
private Date reg_date;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getJumin1() {
return jumin1;
}
public void setJumin1(String jumin1) {
this.jumin1 = jumin1;
}
public String getJumin2() {
return jumin2;
}
public void setJumin2(String jumin2) {
this.jumin2 = jumin2;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getBlog() {
return blog;
}
public void setBlog(String blog) {
this.blog = blog;
}
public Date getReg_date() {
return reg_date;
}
public void setReg_date(Date reg_date) {
this.reg_date = reg_date;
}
}
4. DAO 클래스 만들기
- DB 연동은 이제 모두 DAO 클래스에서 처리
- 메소드만으로 구성
- JSP 에서 DAO 의 메소드를 호출해서 sql 문 실행
- Singleton 사용해서 객체 생성 1번만 수행해서 공유함
- 객체를 생성하자
- static 을 붙여서 공유, 외부에서 접근 못하도록 private 설정, 정적메소드인 getInstance() 를 통해서만 접근 가능
- getInstance() 메소드 만들기
- 이제 이 아래에 메소드를 생성함
- getInstance() 메소드의 리턴자료형이 해당 클래스명임, 리턴되는 값은 위에서 만들어진 인스턴스(객체)
- public 접근제어자 이므로 다른 폴더에 있는 JSP 파일에서 호출 가능한 메소드
- 그 메소드를 JSP 에서 호출 (registerPro.jsp 부분)
- 이 DAO 클래스는 싱글톤 외 나머지는 메소드로 구성된다
DAO 클래스로 DB 연동 예제 1 (이어서)
4. DAO 클래스 만들기 (이어서)
- 이제 DAO 클래스에 나머지 메소드를 추가해보자
- 폼과 다른 코드를 먼저 보고 어떤 메소드가 필요한지 확인
- registerForm.jsp (회원가입 양식)
<%@ page contentType="text/html; charset=euc-kr" %>
<%@ include file="color.jsp" %>
<html>
<head>
<title>회원가입</title>
<link href="style.css" rel="stylesheet" type="text/css">
<script language="JavaScript" src="script.js"></script>
</head>
<body bgcolor="<%=bodyback_c%>">
<form name="regForm" method="post" action="registerPro.jsp" onsubmit="return inputCheck()">
<table width="500" border="0" cellspacing="0" cellpadding="2" align="center">
<tr height="39" align="center" bgcolor="<%=title_c%>">
<td colspan="3"><b>회원 가입</b></font></td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">아이디</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="id" size="20"> </td>
<td width="200" bgcolor="<%=value_c%>">아이디를 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">비밀번호</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="password" name="passwd" size="20"> </td>
<td width="200" bgcolor="<%=value_c%>">비밀번호를 입력하세요</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">비밀번호 확인</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="password" name="repasswd" size="20"> </td>
<td width="200" bgcolor="<%=value_c%>">비밀번호를 재입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">이름</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="name" size="20"> </td>
<td width="200" bgcolor="<%=value_c%>">이름을 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">주민번호</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="jumin1" size="6" maxlength=6>-
<input type="text" name="jumin2" size="7" maxlength=7> </td>
<td width="200" bgcolor="<%=value_c%>">주민번호를 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">이메일</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="email" size="30"> </td>
<td width="200" bgcolor="<%=value_c%>">이메일을 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">블로그</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="blog" size="20"> </td>
<td width="200" bgcolor="<%=value_c%>">블로그를 입력하세요.</td>
</tr>
<tr>
<td colspan="3" align="center" bgcolor="<%=title_c%>">
<input type="submit" value="회원가입" >
<input type="reset" value="다시작성">
</td>
</tr>
</form>
</table>
</body>
</html>- 이 양식들의 name값은 DTO 클래스의 필드값과 같다, 같아야만 값이 DTO 로 전달되도록 설정해둠
- 비밀번호 name값인 passwd 는 DTO 클래스의 필드값과 같으므로 넘어가지만 비밀번호 확인의 name값인 repasswd 는 필드값과 같지 않으므로 넘어가지 않음
- DTO 클래스의 reg_date 필드는 가입폼에서 넘어가지 않음, 나중에 insert 수행시 sysdate 로 넣어주면 된다
- 가입시 입력한 정보들은 모두 registerPro.jsp 파일로 넘어간다
+ script.js 파일에서 유효성 검사
- registerPro.jsp
<%@ page contentType="text/html; charset=euc-kr" %>
<%@ page import="JavaBeanMember.register.LogonDataBean" %>
<%@ page import="JavaBeanMember.register.LogonDBBean" %>
<%@include file="color.jsp" %>
<%
request.setCharacterEncoding("euc-kr");
LogonDataBean regBean1 = new LogonDataBean();
//regBean1.id="test";
%>
<jsp:useBean id="regBean" class="JavaBeanMember.register.LogonDataBean" />
<jsp:setProperty name="regBean" property="*" />
<%
// regBean.id="test";
%>
<%
LogonDBBean manager = LogonDBBean.getInstance();
int result=manager.insertMember(regBean);
if(result==1){
%>
<script>
alert("회원가입 성공");
location.href="list.jsp";
</script>
<% }else{%>
<script>
alert("회원가입 실패");
history.go(-1);
</script>
<% } %>
<%-- <html>
<head>
<title>회원가입 확인</title>
<link href="style.css" rel="stylesheet" type="text/css">
<script language="JavaScript" src="script.js"></script>
</head>
<body bgcolor="<%=bodyback_c%>">
<table width="500" border="0" cellspacing="0" cellpadding="2" align="center">
<tr height="39" align="center" bgcolor="<%=title_c%>">
<td colspan="2"><b>회원 가입 확인</b></td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">아이디</td>
<td width="400" bgcolor="<%=value_c%>">
<jsp:getProperty name="regBean" property="id" /></td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">비밀번호</td>
<td width="400" bgcolor="<%=value_c%>">
<jsp:getProperty name="regBean" property="passwd" /> </td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">이름</td>
<td width="400" bgcolor="<%=value_c%>">
<jsp:getProperty name="regBean" property="name" /> </td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">이메일</td>
<td width="400" bgcolor="<%=value_c%>">
<jsp:getProperty name="regBean" property="email" /> </td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">블로그</td>
<td width="400" bgcolor="<%=value_c%>">
<jsp:getProperty name="regBean" property="blog" /> </td>
</tr>
</table>
</body>
</html> --%>1. 폼을 통해 post 방식으로 한글값이 넘어가므로 인코딩
2. useBean action tag 로 폼에서 넘어온 데이터를 저장하기 위해 DTO 객체를 생성했다,
- class 속성에는 패키지부터 자바빈 클래스까지 이므로 JavaBeanMember.register.LoganDataBean 으로 설정
+ 위쪽에 자바빈 객체를 직접 생성하는 코드는 useBean action tag 와 같은 코드이다
3. setProperty action tag 로 그 DTO 객체인 regBean 의 프로퍼티에 폼에서 넘어온 name 값이 같은 모든 값을 저장함
+ repasswd 는 넘어가지 않는다, DTO 의 reg_date 가 비어있다
- 메모리상에 저장된 데이터는 안정적이지 않음, DTO 클래스만으로는 안정적이지 않다
- 안정적인 곳인 DB 에 저장하기위해 DAO 클래스의 메소드를 호출해서 메모리에 저장된 데이터를 DB 에 저장해아함
4. DAO 객체 생성 (registerPro.jsp 부분)
LogonDBBean manager = LogonDBBean.getInstance();
int result=manager.insertMember(regBean);- new 연산자로 DAO 객체를 생성하지 않고, DAO 객체를 getInstance() 정적메소드를 통해 가져온다 (싱글톤)
+ 매번 new 연산자로 힙메모리상에 공간을 만들면 메모리 소요가 심함, 그래서 싱글톤 사용
- 가져온 객체를 manager 변수에 저장
- DAO 객체를 가져오는 이유 : DAO 의 메소드를 호출해서 SQL 문 수행을 위해서
- 그리고 메소드 insertMember() 메소드를 호출함, insert 할 데이터는 id, passwd 같은 값이 아니라 이들의 주솟값을 가지고 있는 스택의 DTO 객체인 regBean 를 전달함, 즉 주솟값을 전달하는 Call By Reference 방식 사용
- insert 된 데이터의 개수를 돌려받고 그걸로 성공여부 확인할 것
- 이 메소드 insertMember 를 DAO 클래스에 만들어야한다, public int insertMember(DTO ) 로 만들어야함
+ 직접 DAO 객체를 생성할땐 import 해야함
- DAO 클래스로 돌아가서 메소드를 만들자
DAO 클래스 만들기
1. DAO 에 가입 기능 메소드 만들기
- LogonDBBean.java
// DAO (Data Access Object)
package JavaBeanMember.register;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
public class LogonDBBean {
// 싱글톤 : 객체 생성을 한번만 수행하는 것
private static LogonDBBean instance = new LogonDBBean();
public static LogonDBBean getInstance() { // 정적 메소드
return instance;
}
// 회원가입 : 주솟값 전달에 의한 메소드 호출 (Call By Reference 방식)
public int insertMember(LogonDataBean member) {
int result = 0;
Connection con = null;
PreparedStatement pstmt = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
// JDBC 방식
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "insert into member2 values(?,?,?,?,?,?,?,sysdate)";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, member.getId());
pstmt.setString(2, member.getPasswd());
pstmt.setString(3, member.getName());
pstmt.setString(4, member.getJumin1());
pstmt.setString(5, member.getJumin2());
pstmt.setString(6, member.getEmail());
pstmt.setString(7, member.getBlog());
result = pstmt.executeUpdate(); // SQL문 실행
} catch(Exception e) {
e.printStackTrace();
} finally {
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return result;
}
}<insertMember() 메소드 형식 작성>
- JSP 에서 접근할 수 있도록 메소드는 접근제어자를 모두 public 으로 만들어야한다, default 도 안됨
- 주솟값을 가진 객체인 DTO 객체가 매개변수로 오게끔 LogonDataBean 을 매개변수 자료형으로 적는다
+ 주솟값이 아니라 값을 전달한다면 10 개의 값이 있으면 10 개의 매개변수를 써야함
- insert 후에 insert 된 데이터 개수를 돌려주기 위해 리턴 자료형을 int 로 설정했다, 꼭 해야하는 것은 아님
- insert 외에도 update / delete 등도 비슷하게 작성
- select 는 검색 결과를 JSP 파일로 돌려줘야하므로 리턴 자료형을 다르게 설정한다.
<insertMember() 메소드 내용 작성>
1. Connection, PreparedStatement 객체 먼저 생성 후 Driver 위치를 driver 변수에, xe 데이터베이스 url 를 url 변수에 저장
2. try-catch 예외처리 후 오라클용 JDBC 드라이버를 로딩하기 위해 Class.forName() 사용, Connection 객체 구해오기
3. SQL문 작성시 테이블 구조를 보고 ? 몇개 할지 결정, ? 7개와 마지막은 sysdate 로 입력하면 된다
4. Connection 객체 con 을 이용해서 PreparedStatement 객체 생성
5. 자료형에 따라 값을 설정하는 메소드가 다르다, 여기선 varchar2 이므로 setString() 으로 ? 에 값 설정
6. 매개변수 member 를 통해 member.getXX() 로 메모리상에 저장된 값을 리턴받아서 setString() 으로 DB 에 넣기
- Java 에서 getProperty 는 사용 불가하므로 getXX() 로 직접 가져오기
7. insert SQL 문을 실행하기 위해 executeUpdate() 메소드 사용, 성공시 돌려주는 삽입된 데이터를 result 변수에 저장
- select 만 executeQuery(), 나머지 DML 은 executeUpdate() 사용
- insert 는 여러개 삽입이 거의 불가능하므로 return 되는 값은 주로 1
8. 각 객체가 null 이 아닌경우, try-catch 문에서 PreparedStatement 객체 pstmt 먼저 닫고 Conenction 객체 con 닫기
- null 값이 아닌 경우 = 해당 객체가 생성이 되었다면
9. 메소드의 마지막에 result 변수를 돌려주는 코드 작성
+ 이 아래에 다른 메소드도 추가할 것 (아직 DAO 미완성)
- 완성 후 회원가입 기능 되는지 확인
- 결과 캡처
- 성공시 이동하는 목록 페이지는 아직 구현되지 않았으므로 500 오류가 뜬다
- sql 파일에서 가입이 되었는지 확인해보자
- 가입이 되었음을 확인 가능하다, insert 기능 구현이 잘 되었다
DAO 클래스 만들기
2. DAO 에 전체 목록 확인 기능 메소드 만들기
- 회원 목록을 보기위해 목록을 보여주는 list.jsp 파일을 완성하자
- 이 파일에서 DAO 클래스의 select 하는 메소드를 불러옴
- list.jsp
<%@ page language="java" contentType="text/html; charset=EUC-KR"
pageEncoding="EUC-KR"%>
<%@ page import="JavaBeanMember.register.LogonDBBean" %>
<%@ page import="JavaBeanMember.register.LogonDataBean" %>
<%@ page import="java.util.*" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=EUC-KR">
<title>회원 목록</title>
</head>
<body>
<a href="registerForm.jsp">회원가입</a>
<table align=center width=1000 border=1>
<tr><td>ID</td>
<td>비밀번호</td>
<td> 이름 </td>
<td> 주민번호 </td>
<td> 이메일 </td>
<td> BLOG </td>
<td> 가입일 </td>
<td>수정</td>
<td>삭제</td>
</tr>
<%
LogonDBBean manager = LogonDBBean.getInstance();
List<LogonDataBean> li = manager.selectMember();
for(int i = 0; i < li.size(); i++) {
LogonDataBean db = (LogonDataBean)li.get(i);
%>
<tr><td><%=db.getId()%></td>
<td><%=db.getPasswd()%></td>
<td><%=db.getName()%></td>
<td><%=db.getJumin1()%> - <%=db.getJumin2()%> </td>
<td><%=db.getEmail()%></td>
<td><%=db.getBlog()%></td>
<td><%=db.getReg_date()%></td>
<td><a href="updateForm.jsp?id=<%=db.getId()%>">수정</a></td>
<td><a href="deleteForm.jsp?id=<%=db.getId()%>">삭제</a></td>
</tr>
<%
}
%>
</table>
</body>
</html>- 타이틀값 출력 후 데이터를 가져와야함
- DAO 객체를 생성한다, getInstance() 정적메소드로 DAO 객체를 구해와서 manager 에 저장
+ DAO 객체 생성 위해 DAO 클래스를 import 해야한다
- 전체 회원목록을 구해오기위한 메소드 selectMember() 메소드를 호출한다
- 목록을 구하는 메소드이므로 매개변수가 필요없다
- 10명, 20명의 검색된 데이터 (전체 데이터) 를 받아오기 위해서 리턴을 List 로 받아야한다
- 1개 데이터 검색하여 받아올때는 DTO 클래스가 와야하고, 2개 이상의 데이터를 검색할땐 List 가 와야한다
- 제네릭을 사용하므로 List 의 get() 으로 데이터를 하나씩 구해올때 다운캐스팅 할 필요 없음
+ 리스트의 메소드인 get() 은 Object 형으로 리턴
- DAO 클래스에서 selectMember() 메소드를 작성해야함
- DAO 클래스로 돌아가자
- LogonDBBean.java (추가)
// DAO (Data Access Object)
package JavaBeanMember.register;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
public class LogonDBBean {
// 싱글톤 : 객체 생성을 한번만 수행하는 것
private static LogonDBBean instance = new LogonDBBean();
public static LogonDBBean getInstance() { // 정적 메소드
return instance;
}
// 회원가입 : 주솟값 전달에 의한 메소드 호출 (Call By Reference 방식)
public int insertMember(LogonDataBean member) {
int result = 0;
Connection con = null;
PreparedStatement pstmt = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
// JDBC 방식
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "insert into member2 values(?,?,?,?,?,?,?,sysdate)";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, member.getId());
pstmt.setString(2, member.getPasswd());
pstmt.setString(3, member.getName());
pstmt.setString(4, member.getJumin1());
pstmt.setString(5, member.getJumin2());
pstmt.setString(6, member.getEmail());
pstmt.setString(7, member.getBlog());
result = pstmt.executeUpdate(); // SQL문 실행
} catch(Exception e) {
e.printStackTrace();
} finally {
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return result;
}
// 전체 회원목록 구하기
public List<LogonDataBean> selectMember() {
List<LogonDataBean> list = new ArrayList<LogonDataBean>();
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "select * from member2";
pstmt = con.prepareStatement(sql);
rs = pstmt.executeQuery();
while(rs.next()) { // 데이터를 1개씩 가져온다.
LogonDataBean member = new LogonDataBean();
// member.id = "totoro"; // 접근 안됨 (private 접근 제어자)
member.setId(rs.getString("id"));
member.setPasswd(rs.getString("passwd"));
member.setName(rs.getString("name"));
member.setJumin1(rs.getString("jumin1"));
member.setJumin2(rs.getString("jumin2"));
member.setEmail(rs.getString("email"));
member.setBlog(rs.getString("blog"));
member.setReg_date(rs.getDate("reg_date"));
list.add(member);
}
} catch(Exception e) {
} finally {
if(rs != null) try { rs.close(); } catch(Exception e) {}
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return list;
}
}<selectMember() 형식 작성>
- select sql 문을 수행하는 메소드인 경우에는 리턴 자료형이 반드시 있어야한다
- 이때 리턴 자료형으로, 한개의 데이터를 구하면 DTO 클래스가 자료형으로 오고, 2개 이상의 데이터를 구하면 List가 온다
- 메소드 내에서 List 객체 list 를 만들고 그걸 return 한다
<selectMember() 내용 작성>
1. Connection, PreparedStatement, ResultSet 객체 먼저 생성 후 Driver 위치를 driver 변수에, xe 데이터베이스 url 를 url 변수에 저장
- ResultSet 객체는 검색결과를 돌려주는 객체
2. try-catch 예외처리 후 오라클용 JDBC 드라이버를 로딩하기 위해 Class.forName() 사용, Connection 객체 구해오기
3. SQL문 작성한다, 전체 데이터를 구해오므로 select * from member2;
4. Connection 객체 con 을 이용해서 PreparedStatement 객체 생성
5. ? 가 없는 sql 이므로 바로 executeQuer() 로 sql문 실행, 결과는 ResultSet 객체인 rs 가 받는다
- select 만 executeQuery(), 나머지 DML 은 executeUpdate() 사용
6. rs 에 있는 데이터들을 next() 메소드로 데이터 하나씩 가져와야한다
- DB 에서 가져온 데이터를 바로 list 에 저장하지 않음, 컬럼 단위로 잘라서 DTO 객체를 생성해서 메모리상에 저장을 선행
7. DTO 객체 member 를 생성한다
- DTO 객체에 선행 후 그 DTO 객체를 list 에 저장한다
- Java 이므로 useBean 사용불가하므로 직접 객체 생성
+ DTO 객체는 중간 저장소의 역할도 한다
8. DTO 객체 member 에 값을 저장한다
- 프로퍼티의 접근제어자가 private 이므로 DTO 객체 프로퍼티에 직접 값 설정 불가능, setter 메소드 사용
- JSP 에서는 setProperty action tag 로 가능하지만 Java이므로 직접 setXX() 메소드를 불러온다
- varchar2 인 컬럼 이므로 getString() 메소드를 사용한다, 매개변수에는 컬럼인덱스도 올 수 있고 컬럼명도 올 수 있음
- reg_date 컬럼은 자료형이 date 이므로 getDate() 사용해야한다.
9. 첫번째 사람의 데이터를 저장한 이 DTO 객체 member 를 List 0번방(메모리)에 add()사용해서 저장해야한다.
- 그렇지 않으면 다음 사람의 데이터가 덮어버려서 마지막 사람의 데이터만 남게된다
- List 는 위에서 DTO 제네릭이 설정되었으므로 DTO 외의 자료형이 올 수 없음
- 매번 힙에 기억공간을 생성하고, 그 힙을 가리키는 member 객체를 list 에 순차적으로 저장
+ DTO 는 폼에서 넘어간 값도 저장하고, DB 에서 검색된 자료도 저장하는 중간 저장소 역할
10. 각 객체가 null 이 아닌경우, try-catch 문에서 ResultSet객체 rs 먼저 닫고, PreparedStatement 객체 pstmt 닫고 Conenction 객체 con 닫기
- null 값이 아닌 경우 = 해당 객체가 생성이 되었다면
- 닫을땐 반대로 닫는다
+ DTO 객체는 중간 저장소 역할
- 추가된 코드, 즉 회원목록 전체 검색 메소드 코드
+ 이 아래에 다른 메소드도 추가할 것 (아직 DAO 미완성)
- 데이터가 제대로 select 되는지 확인하기 위해 list.jsp 실행
- 다시 list.jsp 파일을 보면
<%@ page language="java" contentType="text/html; charset=EUC-KR"
pageEncoding="EUC-KR"%>
<%@ page import="JavaBeanMember.register.LogonDBBean" %>
<%@ page import="JavaBeanMember.register.LogonDataBean" %>
<%@ page import="java.util.*" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=EUC-KR">
<title>회원 목록</title>
</head>
<body>
<a href="registerForm.jsp">회원가입</a>
<table align=center width=1000 border=1>
<tr><td>ID</td>
<td>비밀번호</td>
<td> 이름 </td>
<td> 주민번호 </td>
<td> 이메일 </td>
<td> BLOG </td>
<td> 가입일 </td>
<td>수정</td>
<td>삭제</td>
</tr>
<%
LogonDBBean manager = LogonDBBean.getInstance();
List<LogonDataBean> li = manager.selectMember();
for(int i = 0; i < li.size(); i++) {
LogonDataBean db = (LogonDataBean)li.get(i);
%>
<tr><td><%=db.getId()%></td>
<td><%=db.getPasswd()%></td>
<td><%=db.getName()%></td>
<td><%=db.getJumin1()%> - <%=db.getJumin2()%> </td>
<td><%=db.getEmail()%></td>
<td><%=db.getBlog()%></td>
<td><%=db.getReg_date()%></td>
<td><a href="updateForm.jsp?id=<%=db.getId()%>">수정</a></td>
<td><a href="deleteForm.jsp?id=<%=db.getId()%>">삭제</a></td>
</tr>
<%
}
%>
</table>
</body>
</html>- selectMember() 의 리턴을 List 로 받는다
- for문을 통해 LIst 안의 0번 내용을 DTO 객체 db 로 받고, 바로 <tr><td> 안에서 출력한다
- 그 다음 내용을 다시 DTO 객체 db 로 받고, 출력을 더이상 데이터가 없을때까지 반복
- select 가 잘 되었음을 확인 가능
- '회원가입' 을 클릭하여 다시 한명을 회원가입 시켜보자
- 이제 가입과, 목록확인 기능 완료
DAO 클래스 만들기
3. DAO 에 수정 기능 메소드 만들기 (+ select 로 한명 데이터 가져오기 메소드도 만들기)
- '수정' 기능을 구현하자
- list.jsp 에서 '수정' 을 누르면 그 데이터의 id 를 updateForm.jsp로 get 방식으로 전달함
- '수정' 페이지는 가입한 정보를 먼저 보여주고 수정가능하다
- 가입한 정보를 보여주기위해선 또 DB 연동을 해야함
- updateForm.jsp
<%@ page contentType="text/html; charset=euc-kr" %>
<%@ page import="JavaBeanMember.register.LogonDBBean" %>
<%@ page import="JavaBeanMember.register.LogonDataBean" %>
<%@ include file="color.jsp" %>
<%
String id = request.getParameter("id");
LogonDBBean manager = LogonDBBean.getInstance();
LogonDataBean db = manager.updateForm(id);
%>
<html>
<head>
<title>회원수정</title>
<link href="style.css" rel="stylesheet" type="text/css">
<script language="JavaScript" src="script.js"></script>
</head>
<body bgcolor="<%=bodyback_c%>">
<form name="regForm" method="post" action="updatePro.jsp" onsubmit="return inputCheck()">
<input type=hidden name=id value="<%=db.getId() %>">
<table width="500" border="0" cellspacing="0" cellpadding="2" align="center">
<tr height="39" align="center" bgcolor="<%=title_c%>">
<td colspan="3"><b>회원 수정</b></font></td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">아이디</td>
<td width="200" bgcolor="<%=value_c%>">
<%=db.getId() %>
<!-- <input type="text" name="id" size="20"> --> </td>
<td width="200" bgcolor="<%=value_c%>">아이디를 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">비밀번호</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="password" name="passwd" size="20"> </td>
<td width="200" bgcolor="<%=value_c%>">비밀번호를 입력하세요</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">비밀번호 확인</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="password" name="repasswd" size="20"> </td>
<td width="200" bgcolor="<%=value_c%>">비밀번호를 재입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">이름</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="name" size="20" value="<%=db.getName()%>"> </td>
<td width="200" bgcolor="<%=value_c%>">이름을 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">주민번호</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="jumin1" size="6" maxlength=6 value="<%=db.getJumin1()%>">-
<input type="text" name="jumin2" size="7" maxlength=7 value="<%=db.getJumin2()%>"> </td>
<td width="200" bgcolor="<%=value_c%>">주민번호를 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">이메일</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="email" size="30" value="<%=db.getEmail()%>"> </td>
<td width="200" bgcolor="<%=value_c%>">이메일을 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">블로그</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="blog" size="20" value="<%=db.getBlog()%>"> </td>
<td width="200" bgcolor="<%=value_c%>">블로그를 입력하세요.</td>
</tr>
<tr>
<td colspan="3" align="center" bgcolor="<%=title_c%>">
<input type="submit" value="회원수정" >
<input type="reset" value="다시작성">
</td>
</tr>
</form>
</table>
</body>
</html>- request.getParameter() 로 넘어온 id 값을 받는다
- id 값으로 한명에 대한 상세정보를 구해와야하므로 DB 연동을 준비함
- DAO 객체를 getInstance() 로 구하고, updateForm() 메소드를 호출하며 매개변수로 id 값을 전달
- 결과 돌려받을때는 1명에 대한 정보를 돌려받으므로 DTO 클래스를 자료형으로 사용
- DAO 클래스에서 updateForm() 메소드를 추가하자
- LogonDBBean.java (추가)
// DAO (Data Access Object)
package JavaBeanMember.register;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
public class LogonDBBean {
// 싱글톤 : 객체 생성을 한번만 수행하는 것
private static LogonDBBean instance = new LogonDBBean();
public static LogonDBBean getInstance() { // 정적 메소드
return instance;
}
// 회원가입 : 주솟값 전달에 의한 메소드 호출 (Call By Reference 방식)
public int insertMember(LogonDataBean member) {
int result = 0;
Connection con = null;
PreparedStatement pstmt = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
// JDBC 방식
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "insert into member2 values(?,?,?,?,?,?,?,sysdate)";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, member.getId());
pstmt.setString(2, member.getPasswd());
pstmt.setString(3, member.getName());
pstmt.setString(4, member.getJumin1());
pstmt.setString(5, member.getJumin2());
pstmt.setString(6, member.getEmail());
pstmt.setString(7, member.getBlog());
result = pstmt.executeUpdate(); // SQL문 실행
} catch(Exception e) {
e.printStackTrace();
} finally {
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return result;
}
// 전체 회원목록 구하기
public List<LogonDataBean> selectMember() {
List<LogonDataBean> list = new ArrayList<LogonDataBean>();
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "select * from member2";
pstmt = con.prepareStatement(sql);
rs = pstmt.executeQuery();
while(rs.next()) { // 데이터를 1개씩 가져온다.
LogonDataBean member = new LogonDataBean();
// member.id = "totoro"; // 접근 안됨 (private 접근 제어자)
member.setId(rs.getString("id"));
member.setPasswd(rs.getString("passwd"));
member.setName(rs.getString("name"));
member.setJumin1(rs.getString("jumin1"));
member.setJumin2(rs.getString("jumin2"));
member.setEmail(rs.getString("email"));
member.setBlog(rs.getString("blog"));
member.setReg_date(rs.getDate("reg_date"));
list.add(member);
}
} catch(Exception e) {
} finally {
if(rs != null) try { rs.close(); } catch(Exception e) {}
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return list;
}
// 회원 수정 폼 : 회원 1명 정보 구하기
public LogonDataBean updateForm(String id) {
LogonDataBean member = new LogonDataBean();
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "select * from member2 where id=?";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, id);
rs = pstmt.executeQuery(); // SQL문 실행
if(rs.next()) {
member.setId(rs.getString("id"));
member.setPasswd(rs.getString("passwd"));
member.setName(rs.getString("name"));
member.setJumin1(rs.getString("jumin1"));
member.setJumin2(rs.getString("jumin2"));
member.setEmail(rs.getString("email"));
member.setBlog(rs.getString("blog"));
member.setReg_date(rs.getDate("reg_date"));
}
} catch(Exception e) {
e.printStackTrace();
} finally {
if(rs != null) try { rs.close(); } catch(Exception e) {}
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return member;
}
}<updateForm() 메소드 형식 작성>
- select sql 문을 수행하는 메소드인 경우에는 리턴 자료형이 반드시 있어야한다
- 이때 리턴 자료형으로, 한개의 데이터를 구하면 DTO 클래스가 자료형으로 오고, 2개 이상의 데이터를 구하면 List가 온다
- updateForm()의 매개변수는 id 를 저장하므로 String, 리턴자료형은 한명의 상세정보를 돌려줘야하므로 DTO로 만들기
- 결과 줄때는 1명에 대한 정보를 돌려주므로 DTO 클래스를 리턴자료형으로 사용
<updateform() 메소드 내용 작성>
1. DTO 객체인 member 를 위쪽에 먼저 생성하고 아래에 return member; 로 리턴
2. Connection, PreparedStatement, ResultSet 객체 먼저 생성 후 Driver 위치를 driver 변수에, xe 데이터베이스 url 를 url 변수에 저장
- 이건 select 이므로, 검색 결과 돌려받을 ResultSet 객체를 생성해야한다
3. try-catch 예외처리 후 오라클용 JDBC 드라이버를 로딩하기 위해 Class.forName() 사용, Connection 객체 구해오기
4. SQL문 작성시 한명에 대한 상세정보(모든 속성)를 구하기때문에 where 조건절에 매개변수로 넘어온 id 사용
5. Connection 객체 con 을 이용해서 PreparedStatement 객체 생성
6. id 컬럼이 varchar2 이므로 setString() 으로 ? 에 매개변수로 넘어온 id 값 설정
7. select SQL 문을 실행하기 위해 executeQuery() 메소드 사용, 성공시 돌려주는 수정된 데이터를 result 변수에 저장
- select 만 executeQuery(), 나머지 DML 은 executeUpdate() 사용
8. 검색한 데이터인 rs 에 있는 데이터는 1개이므로 next() 메소드로 데이터 하나씩 가져오되 if 문을 사용한다
9.검색한 결과를 DTO 객체 member 에 setString() 으로 저장한다
10. 각 객체가 null 이 아닌경우, try-catch 문에서 ResultSet객체 rs 먼저 닫고, PreparedStatement 객체 pstmt 닫고 Conenction 객체 con 닫기
- null 값이 아닌 경우 = 해당 객체가 생성이 되었다면
11. 데이터는 1개이므로 메소드의 마지막에 List가 아닌 DTO 객체를 돌려주는 코드 작성
- 추가된 코드만 캡처
+ 이 아래에 다른 메소드도 추가할 것 (아직 DAO 미완성)
- 회원 수정 기능이 잘 구현되었는지 실행해보자
- list.jsp 실행 후 '수정' 누르기
- 회원 수정 폼이 완성되었음을 알 수 있다
- 아이디는 수정하지 못하게 출력만 하고 있다
- 나머지 정보를 수정하기위해서 updatePro.jsp 가 필요함
- updatePro.jsp 를 보기 전에 updateForm.jsp 파일을 먼저 보자
- updateForm.jsp
<%@ page contentType="text/html; charset=euc-kr" %>
<%@ page import="JavaBeanMember.register.LogonDBBean" %>
<%@ page import="JavaBeanMember.register.LogonDataBean" %>
<%@ include file="color.jsp" %>
<%
String id = request.getParameter("id");
LogonDBBean manager = LogonDBBean.getInstance();
LogonDataBean db = manager.updateForm(id);
%>
<html>
<head>
<title>회원수정</title>
<link href="style.css" rel="stylesheet" type="text/css">
<script language="JavaScript" src="script.js"></script>
</head>
<body bgcolor="<%=bodyback_c%>">
<form name="regForm" method="post" action="updatePro.jsp" onsubmit="return inputCheck()">
<input type=hidden name=id value="<%=db.getId() %>">
<table width="500" border="0" cellspacing="0" cellpadding="2" align="center">
<tr height="39" align="center" bgcolor="<%=title_c%>">
<td colspan="3"><b>회원 수정</b></font></td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">아이디</td>
<td width="200" bgcolor="<%=value_c%>">
<%=db.getId() %>
<!-- <input type="text" name="id" size="20"> --> </td>
<td width="200" bgcolor="<%=value_c%>">아이디를 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">비밀번호</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="password" name="passwd" size="20"> </td>
<td width="200" bgcolor="<%=value_c%>">비밀번호를 입력하세요</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">비밀번호 확인</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="password" name="repasswd" size="20"> </td>
<td width="200" bgcolor="<%=value_c%>">비밀번호를 재입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">이름</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="name" size="20" value="<%=db.getName()%>"> </td>
<td width="200" bgcolor="<%=value_c%>">이름을 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">주민번호</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="jumin1" size="6" maxlength=6 value="<%=db.getJumin1()%>">-
<input type="text" name="jumin2" size="7" maxlength=7 value="<%=db.getJumin2()%>"> </td>
<td width="200" bgcolor="<%=value_c%>">주민번호를 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">이메일</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="email" size="30" value="<%=db.getEmail()%>"> </td>
<td width="200" bgcolor="<%=value_c%>">이메일을 입력하세요.</td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">블로그</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="text" name="blog" size="20" value="<%=db.getBlog()%>"> </td>
<td width="200" bgcolor="<%=value_c%>">블로그를 입력하세요.</td>
</tr>
<tr>
<td colspan="3" align="center" bgcolor="<%=title_c%>">
<input type="submit" value="회원수정" >
<input type="reset" value="다시작성">
</td>
</tr>
</form>
</table>
</body>
</html>- 수정폼에 입력한 값을 name 값을 통해서 전달하고 있다
- id 값은 수정하지 못하게 출력만 시키고 있다
- id 값은 화면에 노출시키지 않고 hidden 객체로 updatePro.jsp 로 값 전달
- 비밀번호는 value 를 설정하지 않아서 사용자가 처음부터 입력해야한다
- 이름은 value 속성을 사용해서 DAO의 updateForm() 메소드로부터 받아온 DTO 객체의 값을 출력, 다른 정보도 마찬가지
ex) <%=db.getName()%>
- 다음으로 updatePro.jsp 를 보자
- select 하는 DAO 의 메소드를 호출하는 파일, 비밀번호가 DB의 비밀번호와 일치하는지 확인함
- registerPro.jsp 와 비슷한 구조이다
- updatePro.jsp
<%@ page contentType="text/html; charset=euc-kr" %>
<%@ page import="JavaBeanMember.register.LogonDataBean" %>
<%@ page import="JavaBeanMember.register.LogonDBBean" %>
<%@include file="color.jsp" %>
<%
request.setCharacterEncoding("euc-kr");
LogonDataBean regBean1 = new LogonDataBean();
// regBean1.id="test";
%>
<jsp:useBean id="regBean" class="JavaBeanMember.register.LogonDataBean" />
<jsp:setProperty name="regBean" property="*" />
<%
LogonDBBean manager = LogonDBBean.getInstance();
LogonDataBean old = manager.updateForm(regBean.getId());
if(old.getPasswd().equals(regBean.getPasswd())){ // 비번 일치시
manager.update(regBean); // update SQL문 실행
%>
<script>
alert("회원수정 성공");
location.href="list.jsp";
</script>
<% }else{ // 비번 불일치 %>
<script>
alert("비밀번호가 일치하지 않습니다.");
history.go(-1);
</script>
<% } %>- 수정폼에서 한글값이 post 로 넘어오므로 한글 인코딩
- useBean action tag 로 DTO 객체 regBean 을 생성하고 폼에서 넘어온 name 값을 DTO 프로퍼티명과 일치하는 곳으로 저장
- DB 를 update 하기 위해 DAO 객체를 getInstance() 로 생성
- updateForm() 이 여기서도 사용되어서 사용자의 id 값을 받아서 그 사용자의 상세 정보를 가져와서 변수 old 에 저장
- 그 상세정보 중에서 사용할 것은 사용자의 비번
<비번과 비번확인 일치 확인>
- DB 에 저장된 비번만 필요하므로 DB 에서 id 값으로 검색수행하여 받은 비번이 old.getPasswd() 이다
- 사용자가 입력하여 메모리에 잠시 저장되었다가 가져온 값이 regBean.getPasswd() 이다
- 두 값이 같은 경우, 즉 비밀번호와 비밀번호 확인 값이 같은 경우에만 회원 수정 시키는 메소드 update() 를 호출
- update()를 호출하며 사용자가 수정폼에서 입력한 정보를 담은 DTO 객체인 regBean 을 매개변수로 넘김
- DAO 클래스에서 update() 메소드를 추가하자
- LogonDBBean.java (추가)
// DAO (Data Access Object)
package JavaBeanMember.register;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
public class LogonDBBean {
// 싱글톤 : 객체 생성을 한번만 수행하는 것
private static LogonDBBean instance = new LogonDBBean();
public static LogonDBBean getInstance() { // 정적 메소드
return instance;
}
// 회원가입 : 주솟값 전달에 의한 메소드 호출 (Call By Reference 방식)
public int insertMember(LogonDataBean member) {
int result = 0;
Connection con = null;
PreparedStatement pstmt = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
// JDBC 방식
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "insert into member2 values(?,?,?,?,?,?,?,sysdate)";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, member.getId());
pstmt.setString(2, member.getPasswd());
pstmt.setString(3, member.getName());
pstmt.setString(4, member.getJumin1());
pstmt.setString(5, member.getJumin2());
pstmt.setString(6, member.getEmail());
pstmt.setString(7, member.getBlog());
result = pstmt.executeUpdate(); // SQL문 실행
} catch(Exception e) {
e.printStackTrace();
} finally {
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return result;
}
// 전체 회원목록 구하기
public List<LogonDataBean> selectMember() {
List<LogonDataBean> list = new ArrayList<LogonDataBean>();
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "select * from member2";
pstmt = con.prepareStatement(sql);
rs = pstmt.executeQuery();
while(rs.next()) { // 데이터를 1개씩 가져온다.
LogonDataBean member = new LogonDataBean();
// member.id = "totoro"; // 접근 안됨 (private 접근 제어자)
member.setId(rs.getString("id"));
member.setPasswd(rs.getString("passwd"));
member.setName(rs.getString("name"));
member.setJumin1(rs.getString("jumin1"));
member.setJumin2(rs.getString("jumin2"));
member.setEmail(rs.getString("email"));
member.setBlog(rs.getString("blog"));
member.setReg_date(rs.getDate("reg_date"));
list.add(member);
}
} catch(Exception e) {
} finally {
if(rs != null) try { rs.close(); } catch(Exception e) {}
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return list;
}
// 회원 수정 폼 : 회원 1명 정보 구하기
public LogonDataBean updateForm(String id) {
LogonDataBean member = new LogonDataBean();
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "select * from member2 where id=?";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, id);
rs = pstmt.executeQuery(); // SQL문 실행
if(rs.next()) {
member.setId(rs.getString("id"));
member.setPasswd(rs.getString("passwd"));
member.setName(rs.getString("name"));
member.setJumin1(rs.getString("jumin1"));
member.setJumin2(rs.getString("jumin2"));
member.setEmail(rs.getString("email"));
member.setBlog(rs.getString("blog"));
member.setReg_date(rs.getDate("reg_date"));
}
} catch(Exception e) {
e.printStackTrace();
} finally {
if(rs != null) try { rs.close(); } catch(Exception e) {}
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return member;
}
// 회원 정보 수정
public void update(LogonDataBean member) {
Connection con = null;
PreparedStatement pstmt = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "update member2 set name=?, jumin1=?, jumin2=?,";
sql += "email=?, blog=? reg_date=sysdsate where id=?";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, member.getName());
pstmt.setString(2, member.getJumin1());
pstmt.setString(3, member.getJumin2());
pstmt.setString(4, member.getEmail());
pstmt.setString(5, member.getBlog());
pstmt.setString(6, member.getId());
pstmt.executeUpdate(); // SQL문 실행
} catch(Exception e) {
e.printStackTrace();
} finally {
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
}
}<update() 메소드 형식 작성>
- 업데이트한 결과를 돌려줄 수도 있지만 지금은 돌려주지 않음, 리턴자료형을 void로 설정
- update()의 매개변수로는 DTO 객체를 받아야하므로 DTO
<update() 메소드 내용 작성>
1. Connection, PreparedStatement 객체 먼저 생성 후 Driver 위치를 driver 변수에, xe 데이터베이스 url 를 url 변수에 저장
2. try-catch 예외처리 후 오라클용 JDBC 드라이버를 로딩하기 위해 Class.forName() 사용, Connection 객체 구해오기
3. SQL문 작성시 각 컬럼들을 ? 를 사용해서 쓰고, reg_date 는 수정 날짜로 바꾸기 위해 sysdate 작성, 특정 1명을 수정하는 것이므로 where 절에 id 사용
4. Connection 객체 con 을 이용해서 PreparedStatement 객체 생성
5. 매개변수 member 를 통해 member.getXX() 로 메모리상에 저장된 값을 리턴받아서 setString() 으로 DB 에 넣기
- Java 에서 getProperty 는 사용 불가하므로 getXX() 로 직접 가져오기
6. update SQL 문을 실행하기 위해 executeUpdate() 메소드 사용
- select 만 executeQuery(), 나머지 DML 은 executeUpdate() 사용
7. 업데이트한 값을 돌려주는 경우도 있지만 지금은 돌려주지 않는 경우임
8. 각 객체가 null 이 아닌경우, try-catch 문에서 ResultSet객체 rs 먼저 닫고, PreparedStatement 객체 pstmt 닫고 Conenction 객체 con 닫기
- null 값이 아닌 경우 = 해당 객체가 생성이 되었다면
+ 추가된 코드 부분만
- list.jsp 실행해서 수정폼으로 가서 수정을 시도해보자
- 수정이 잘 되었음을 확인할 수 있다, update 기능이 잘 구현되었음
+ 틀린 비밀번호를 입력했을때
DAO 클래스 만들기
4. DAO 에 삭제 기능 메소드 만들기
- '삭제' 기능을 구현하자
- list.jsp 에서 '삭제' 를 누르면 해당 데이터(사람)의 id 를 get 방식으로 가져간다
- '사람' 페이지는 가입한 정보를 보여주지 않으므로 수정처럼 중간에도 DB 연동을 할 필요는 없다
- deleteForm.jsp 를 보자
<%@ page contentType="text/html; charset=euc-kr" %>
<%@ page import="JavaBeanMember.register.LogonDBBean" %>
<%@ page import="JavaBeanMember.register.LogonDataBean" %>
<%@ include file="color.jsp" %>
<%
String id = request.getParameter("id");
%>
<html>
<head>
<title>회원삭제</title>
<link href="style.css" rel="stylesheet" type="text/css">
<script language="JavaScript" src="script.js"></script>
</head>
<body bgcolor="<%=bodyback_c%>">
<form name="regForm" method="post" action="deletePro.jsp" onsubmit="return inputCheck()">
<input type=hidden name=id value="<%=id %>">
<table width="500" border="0" cellspacing="0" cellpadding="2" align="center">
<tr height="39" align="center" bgcolor="<%=title_c%>">
<td colspan="3"><b>회원 삭제</b></font></td>
</tr>
<tr>
<td width="100" bgcolor="<%=title_c%>">비밀번호</td>
<td width="200" bgcolor="<%=value_c%>">
<input type="password" name="passwd" size="20"> </td>
<td width="200" bgcolor="<%=value_c%>">비밀번호를 입력하세요</td>
</tr>
<tr>
<td colspan="3" align="center" bgcolor="<%=title_c%>">
<input type="submit" value="회원삭제" >
<input type="reset" value="다시작성">
</td>
</tr>
</form>
</table>
</body>
</html>- 앞에서 get 방식으로 넘어온 id 를 getParameter()로 받아서 id 변수에 저장함
- id 값을 화면에 출력시키지 않고 hidden 객체로 deletePro.jsp 로 넘김
- id 와 사용자가 삭제폼에서 입력한 passwd 를 넘김
- deletePro.jsp
<%@ page contentType="text/html; charset=euc-kr" %>
<%@ page import="JavaBeanMember.register.LogonDataBean" %>
<%@ page import="JavaBeanMember.register.LogonDBBean" %>
<%@include file="color.jsp" %>
<%
request.setCharacterEncoding("euc-kr");
LogonDataBean regBean1 = new LogonDataBean();
// regBean1.id="test";
%>
<jsp:useBean id="regBean" class="JavaBeanMember.register.LogonDataBean" />
<jsp:setProperty name="regBean" property="*" />
<%
LogonDBBean manager = LogonDBBean.getInstance();
LogonDataBean old = manager.updateForm(regBean.getId());
if(old.getPasswd().equals(regBean.getPasswd())){ // 비번 일치시
manager.delete(regBean); // delete SQL문 실행
%>
<script>
alert("회원삭제 성공");
location.href="list.jsp";
</script>
<% }else{ // 비번 불일치시 %>
<script>
alert("비밀번호가 일치하지 않습니다.");
history.go(-1);
</script>
<% } %>- 전달되는 값이 많지 않으므로 setProperty action tag 를 쓸 필요 없지만 여기선 쓰고 있다
- updateForm() 을 세번째 사용하고 있다, DB 에서 비번을 끄집어내서 사용자가 삭제폼에 입력한 비번과 일치하는지 확인
- old.getPasswd() 는 DB에서 가져온 비번이고 regBean.getPasswd() 는 사용자가 삭제폼에서 입력한 비번이다
- 두 비번이 일치하면 DAO 의 delete() 메소드를 호출함
- 삭제할때는 id 값이 들어가야한다, id 값만매개변수로 전달해도 되지만 지금은 regBean 객체 전체를 넘기고 있음
- DAO 클래스에서 delete() 메소드를 추가하자
- LogonDBBean.java (최종 DAO 클래스)
// DAO (Data Access Object)
package JavaBeanMember.register;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
public class LogonDBBean {
// 싱글톤 : 객체 생성을 한번만 수행하는 것
private static LogonDBBean instance = new LogonDBBean();
public static LogonDBBean getInstance() { // 정적 메소드
return instance;
}
// 회원가입 : 주솟값 전달에 의한 메소드 호출 (Call By Reference 방식)
public int insertMember(LogonDataBean member) {
int result = 0;
Connection con = null;
PreparedStatement pstmt = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
// JDBC 방식
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "insert into member2 values(?,?,?,?,?,?,?,sysdate)";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, member.getId());
pstmt.setString(2, member.getPasswd());
pstmt.setString(3, member.getName());
pstmt.setString(4, member.getJumin1());
pstmt.setString(5, member.getJumin2());
pstmt.setString(6, member.getEmail());
pstmt.setString(7, member.getBlog());
result = pstmt.executeUpdate(); // SQL문 실행
} catch(Exception e) {
e.printStackTrace();
} finally {
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return result;
}
// 전체 회원목록 구하기
public List<LogonDataBean> selectMember() {
List<LogonDataBean> list = new ArrayList<LogonDataBean>();
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "select * from member2";
pstmt = con.prepareStatement(sql);
rs = pstmt.executeQuery();
while(rs.next()) { // 데이터를 1개씩 가져온다.
LogonDataBean member = new LogonDataBean();
// member.id = "totoro"; // 접근 안됨 (private 접근 제어자)
member.setId(rs.getString("id"));
member.setPasswd(rs.getString("passwd"));
member.setName(rs.getString("name"));
member.setJumin1(rs.getString("jumin1"));
member.setJumin2(rs.getString("jumin2"));
member.setEmail(rs.getString("email"));
member.setBlog(rs.getString("blog"));
member.setReg_date(rs.getDate("reg_date"));
list.add(member);
}
} catch(Exception e) {
} finally {
if(rs != null) try { rs.close(); } catch(Exception e) {}
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return list;
}
// 회원 수정 폼 : 회원 1명 정보 구하기
public LogonDataBean updateForm(String id) {
LogonDataBean member = new LogonDataBean();
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "select * from member2 where id=?";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, id);
rs = pstmt.executeQuery(); // SQL문 실행
if(rs.next()) {
member.setId(rs.getString("id"));
member.setPasswd(rs.getString("passwd"));
member.setName(rs.getString("name"));
member.setJumin1(rs.getString("jumin1"));
member.setJumin2(rs.getString("jumin2"));
member.setEmail(rs.getString("email"));
member.setBlog(rs.getString("blog"));
member.setReg_date(rs.getDate("reg_date"));
}
} catch(Exception e) {
e.printStackTrace();
} finally {
if(rs != null) try { rs.close(); } catch(Exception e) {}
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
return member;
}
// 회원 정보 수정
public void update(LogonDataBean member) {
Connection con = null;
PreparedStatement pstmt = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "update member2 set name=?, jumin1=?, jumin2=?,";
sql += "email=?, blog=?,reg_date=sysdate where id=?";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, member.getName());
pstmt.setString(2, member.getJumin1());
pstmt.setString(3, member.getJumin2());
pstmt.setString(4, member.getEmail());
pstmt.setString(5, member.getBlog());
pstmt.setString(6, member.getId());
pstmt.executeUpdate(); // SQL문 실행
} catch(Exception e) {
e.printStackTrace();
} finally {
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
}
// 회원 정보 삭제
public void delete(LogonDataBean member) {
Connection con = null;
PreparedStatement pstmt = null;
String driver = "oracle.jdbc.driver.OracleDriver";
String url = "jdbc:oracle:thin:@localhost:1521:xe";
try {
Class.forName(driver);
con = DriverManager.getConnection(url, "scott", "tiger");
String sql = "delete from member2 where id=?";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, member.getId());
pstmt.executeUpdate(); // SQL문 실행
} catch(Exception e) {
e.printStackTrace();
} finally {
if(pstmt != null) try { pstmt.close(); } catch(Exception e) {}
if(con != null) try { con.close(); } catch(Exception e) {}
}
}
}- update() 메소드와 거의 유사함, 이름만 delete() 로 바꿈
- sql 문을 delete sql문으로 수정한다, 한명의 데이터를 삭제하므로 where 절에 id 를 넣음
- deletePro.jsp 에서 객체 전체가 매개변수로 넘어왔으므로 member.getId() 로 아이디를 객체에서 가져와서 ? 에 설정
- 값을 돌려주는 부분은 없다
- 최종 DAO 클래스 이다
- 실행 확인
- list.jsp 에서 '삭제' 를 누르면
- 잘 삭제된다, delete 기능이 잘 구현되었음을 알 수 있다
+ 틀린 비번 입력시
+ 추가된 코드 부분만
- DAO 클래스 완료
+ 유효성검사 메세지 박스 한글값이 깨진다
- script.js 가 유효성 검사를 하는데 한글값이 꺠지므로 모든 파일의 인코딩을 EUC-KR 에서UTF-8 로 바꾸자
- 이후 script.js 를 바탕화면에 저장하고, 메모장으로 열기
- 파일-다른이름으로 저장
- 인코딩을 UTF-8 로 변경해준다
- 이후 이 파일을 다시 이클립스로 넣으면 한글 인코딩이 완료됨
DBCP 방식으로 DB 연동
- 여태까지 JDBC 방식으로 DB 와 연동했다
- 메소드 호출마다 매번 Driver 를 로딩했다, 시간소요, 서버측 메모리 자원 사용
- 이제 두번째 방법인 DBCP 방식으로 DB 연동 해볼것
- 완성된 프로그램은 모두 DBCP 방식으로 DB 연동할 것
DBCP 방식
- WAS 실행 시 미리 일정량의 DB Connection 객체를 생성하고 Pool 이라는 공간에 저장
- 그리고 DB 연결 요청이 있으면, 이 Pool 이라는 공간에서 Connection 객체를 가져다 쓰고 반환
- 데이터베이스와 연결된 커넥션을 미리 만들어서 풀 속에 저장하고 있다가 필요할 때에 커넥션을 풀에서 가져다 쓰고 다시 풀에 반환하는 기법
DBCP 특징
- 커넥션을 생성하는데 드는연결시간이 소비되지 않음
- 커넥션 풀이 저장된 커넥션을 재사용할 수 있다
- 접속이 빈번한 경우에 많이 쓴다
- 환경설정파일에서 몇개의 커넥션을 미리 만들어둘지 설정 가능
- 설정하지 않으면 기본적으로 8개의 커넥션 만듬
- 풀에서 커넥션을 가져오고 커넥션을 사용하고 커넥션을 close() 하면 풀에 반환됨
커넥션 풀 환경설정
- 커넥션 풀 환경설정 파일인 context.xml 파일은 META-INF 폴더 안에 저장해야함
- 오라클과 연동위해 lib 폴더 하위에 ojdbc6.jar 가 필요하다
context.xml 파일에 들어갈 내용
- 루트 엘리먼트 context, 부모 엘리먼트 Resource
- Resource 엘리먼트에 name 값을 jdbc/OracleDB 로 임의로 정함
- 나중에 이 name 값을 찾아오는 것
- driverClassName 속성값으로 오라클 드라이버 위치
- factory 속성값은 org.apache.tomcat.dbcp.dbcp2 까지가 패키지고, BasicDataSourceFactory 가 클래스 명이다
- maxActive 는 커넥션 풀이 관리하는 커넥션의 최대 개수, 500으로 설정시 500개를 미리 만들어둠
Connection Pool 에서 커넥션 구해오기
- 네임값인 jdbc/OracleDB 으로 찾아가야한다
- InitialContext 객체를 생성하고 lookup() 으로 Resource name 값을 찾아가서 커넥션을 구해옴
- DataSource 객체로 커넥션을 받아옴
Connection Pool 설정 실습
- 이 war 파일을 다운받아 이클립스로 import
- import 시 dbcpTest 라는 프로젝트가 생성됨
- 구조 확인, context.xml 은 META-INF 안에 있어야한다
- context.xml
- name 속성값은 임의로 설정한 이름이다
- 나중에 커넥션 풀에서 커넥션을 구할때는 Resource name값으로 구해옴
- factory 는 Apache Tomcat 안의 패키지안의 클래스명임
Connection Pool 에서 커넥션 구해오기
- 커넥션을 잘 구해오는지 Test
- 테스트 하기위한 파일인 dbcpAPITest.jsp
<%@ page language="java" contentType="text/html; charset=EUC-KR"%>
<%@ page import="java.sql.*"%>
<%@ page import="javax.sql.*" %>
<%@ page import="javax.naming.*" %>
<%
Connection conn = null;
try {
Context init = new InitialContext();
DataSource ds = (DataSource) init.lookup("java:comp/env/jdbc/OracleDB");
conn = ds.getConnection();
out.println("<h3>연결되었습니다.</h3>");
}catch(Exception e){
out.println("<h3>연결에 실패하였습니다.</h3>");
e.printStackTrace();
}
%>1. 가장먼저 InitlaContext 객체 생성, 업캐스팅 방식으로 Context 객체 init 생성
2. 그 init.lookup() 으로 커넥션 풀 이름인 jdbc/OracleDB 로 그 커넥션을 요청하고 소스를 DataSource 객체 ds 에 저장
3. 그 ds 로 커넥션 객체를 구하기
- 테스트파일이라 JSP 로 만들었지만 나중에 완성된 프로그램에선 이 3줄이 DAO 클래스에 들어간다
- 커넥션 풀에서 커넥션 하나를 구해왔으면 "연결되었습니다" 가 출력된다
- 커넥션을 잘 구해왔음을 확인 가능
- 앞으로 완성된 프로그램은 모두 DBCP 방식으로 처리
- Model 1 으로 완성된 프로그램을 만들자
- 회원관리 기능부터 시작, 양식과 유효성 검사는 이전에 HTML, JS 에서 했던걸 가져오기
Model 1 DBCP 방식으로 회원관리 프로그램 만들기
회원관리 프로그램 : 주요 기능 소개
1. Connection Pool
2. 액션 태그
- useBean action tag
- setProperty action tag
3. DTO, DAO 클래스
4. 세션(session)
- 로그인 성공시 session 공유 시작, 로그아웃시 session 강제로 삭제
회원관리 프로그램 : 오라클 계정 생성
- 복잡하므로 새로운 계정 생성해서 작업
- system 계정으로 접속 후 오라클에 새로운 계정을 생성
- 롤을 사용해서 권한 부여
create user totoro identified by totoro123;
grant connect, resource to totoro;
- 콘솔창에서 계정 생성과 권한 부여
회원관리 프로그램 : 프로젝트 생성
- 이렇게 구조를 만들기 위해
- 이클립스에서 Dynamic Web Project 인 member 생성
- 초기에 보여줄 파일인 index.jsp 를 WebContent 폴더 안에 생성
회원관리 프로그램 : HTML, Javascript 파일 가져오기
- 폼과 유효성 검사 파일을 가져오기
- 이 기본 파일을 바탕으로 프로그램 구현
회원관리 프로그램 : 몇가지 환경 구축
1) member 폴더 안의 context.xml 파일을 META-INF 폴더로 옮기기
- 커넥션 풀의 환경설정 파일이다
2) lib 폴더 안에 오라클용 JDBC Driver 인 ojdbc.jar 가져오기, 다른 프로젝트에서 가져오면 된다
회원관리 프로그램 : Connection Pool 테스트
- dbcpAPITest.jsp 파일을 실행해서 커넥션 풀에서 커넥션 가져오기 테스트
- 커넥션 풀에서 커넥션 가져오기 테스트 성공
+ 추후 DAO 클래스 만들때 커넥션풀에서 커넥션 구하기 3줄 코드를 DAO 클래스에 넣을 것
Context init = new InitialContext();
DataSource ds = (DataSource) init.lookup("java:comp/env/jdbc/orcl");
conn = ds.getConnection();
회원관리 프로그램 : 오라클 totoro 계정 커넥션 추가
- Data Source Management 에서 totoro 계정에 대한 Connection 추가
- scott계정 외 totoro 계정 커넥션도 추가
- Oracle 선택
- totoro 계정에 대한 커넥션임을 나타내기 위해 (totoro) 추가
- username, passwd 를 다르게 설정
- 이후 Finish 버튼 누르기
- totoro 계정으로 연결
회원관리 프로그램 : member 테이블 생성
- totoro 오라클 계정에 member 테이블을 생성
- HTML 시간의 양식에 맞는 테이블을 그대로 생성해야한다 (아래)
create table member(
id varchar2(20) primary key,
passwd varchar2(20) not null,
name varchar2(20) not null,
jumin1 varchar2(6) not null,
jumin2 varchar2(7) not null,
mailid varchar2(30),
domain varchar2(30),
tel1 varchar2(5),
tel2 varchar2(5),
tel3 varchar2(5),
phone1 varchar2(5),
phone2 varchar2(5),
phone3 varchar2(5),
post varchar2(10),
address varchar2(200),
gender varchar2(20),
hobby varchar2(50),
intro varchar2(2000),
register timestamp );
- WebContent 하위에 sql 폴더를 만들고 안에 member.sql 파일 생성
- 커넥션 프로파일을 Oracle_11, New Oracle(totoro), xe 로 해준다
- member 테이블을 생성
- member 테이블 생성 확인
회원관리 프로그램 : DAO 와 DTO 클래스 만들기
- 프로그램 구조도 대로 src 의 member 패키지에 DAO, DTO 클래스를 만든다
회원관리 프로그램 : DTO 클래스 작성
- 이걸 가져와서 DTO 클래스에 복붙
- varchar2 는 String 으로, number 는 Int 로, timestamp 는 Timestamp로 바꿔서 자바 변수(프로퍼티) 만들기
+ 프로퍼티의 접근제어자는 private
+ java.sql 의 Timestamp import
- getter / setter 메소드 추가
- DTO 클래스 완성 코드
// DTO (Data Transfer Object)
package member;
import java.sql.Timestamp;
public class MemberDTO {
private String id;
private String passwd;
private String name;
private String jumin1;
private String jumin2;
private String mailid;
private String domain;
private String tel1;
private String tel2;
private String tel3;
private String phone1;
private String phone2;
private String phone3;
private String post;
private String address;
private String gender;
private String hobby;
private String intro;
private Timestamp register;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getJumin1() {
return jumin1;
}
public void setJumin1(String jumin1) {
this.jumin1 = jumin1;
}
public String getJumin2() {
return jumin2;
}
public void setJumin2(String jumin2) {
this.jumin2 = jumin2;
}
public String getMailid() {
return mailid;
}
public void setMailid(String mailid) {
this.mailid = mailid;
}
public String getDomain() {
return domain;
}
public void setDomain(String domain) {
this.domain = domain;
}
public String getTel1() {
return tel1;
}
public void setTel1(String tel1) {
this.tel1 = tel1;
}
public String getTel2() {
return tel2;
}
public void setTel2(String tel2) {
this.tel2 = tel2;
}
public String getTel3() {
return tel3;
}
public void setTel3(String tel3) {
this.tel3 = tel3;
}
public String getPhone1() {
return phone1;
}
public void setPhone1(String phone1) {
this.phone1 = phone1;
}
public String getPhone2() {
return phone2;
}
public void setPhone2(String phone2) {
this.phone2 = phone2;
}
public String getPhone3() {
return phone3;
}
public void setPhone3(String phone3) {
this.phone3 = phone3;
}
public String getPost() {
return post;
}
public void setPost(String post) {
this.post = post;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
public String getIntro() {
return intro;
}
public void setIntro(String intro) {
this.intro = intro;
}
public Timestamp getRegister() {
return register;
}
public void setRegister(Timestamp register) {
this.register = register;
}
}
회원관리 프로그램 : DAO 클래스 작성
DAO 에 들어갈 내용
1. 싱글톤
2. 정적메소드 getInstance() 생성
3. Connection Pool 에서 커넥션 구해오는 메소드
4. 그 이후 회원가입, 중복검사, 탈퇴 등의 메소드
1. 싱글톤
- 자기자신의 클래스로 객체 생성을 한번만 하고 static 을 붙여 공유 , private 설정
2. 정적메소드 getInstance() 생성
3. Connection Pool 에서 커넥션 구해오는 메소드
- 메소드 호출시 Connection Pool 에서 커넥션을 구해주도록 함
- 커넥션 구할때 예외처리를 해야한다, 여기선 throws 로 Exception 던지기
+ Connection 클래스 import
- 테스트할때 사용했던 이 3줄을 복사해서 넣는다
- 단축키 Ctrl + Shift + O 로 import 시키기
- javax.naming.Context 를 선택후 Next, 다음은 javax.sql.DataSource 선택후 Finish
- 가져온 커넥션을 리턴하는 코드로 바꿈
4. 그 이후 회원가입, 중복검사, 탈퇴 등의 메소드
- 그 이후 회원가입, 중복검사, 탈퇴 등의 메소드가 오면 된다
회원관리 프로그램 : 파일별 기능 및 구조 설명
회원관리 프로그램 : 추후 구현할 파일
- memberform.html 등의 폼들은 이전에 만들었던 파일을 그대로 가져왔다
+ 유효성 검사는 이미 되어있다
- member.jsp을 포함한 나머지 파일은 우리가 만들어야한다
- 팝업창으로 ID중복검사도 해보고 Ajax를 써서 비동기로 팝업창을 띄우지 않고 ID 중복검사도 할 것