5월 ~ 7월) 웹/mybatis
72 ~ 73Day)
첼로그
2023. 7. 18. 12:42
72 ~ 73Day
mymember 테이블(오라클) 만들어줌
create table mymember(id varchar2(50) primary key, name varchar2(50),phone varchar2(20), email varchar2(100));
src/main/java>xyz.itwill.dto)
MyMember .java
package xyz.itwill.dto;
//create table mymember(id varchar2(50) primary key, name varchar2(50),phone varchar2(20), email varchar2(100));
public class MyMember {
private String id;
private String name;
private String phone;
private String email;
public MyMember() {
// TODO Auto-generated constructor stub
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
- mapper먼저 만들어줘야함.
src/main/java>xyz.itwill.dao)
MyMemberXMLDAO .java
package xyz.itwill.dao;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import xyz.itwill.dto.MyMember;
public class MyMemberXMLDAO {
private static MyMemberXMLDAO _dao;
private MyMemberXMLDAO() {
// TODO Auto-generated constructor stub
}
static {
_dao=new MyMemberXMLDAO();
}
public static MyMemberXMLDAO getDAO() {
return _dao;
}
//SqlSessionFactory 객체를 생성하여 반환하는 메소드
private SqlSessionFactory getSqlSessionFactory() {
String resource="mybatis-config.xml";
InputStream inputStream=null;
try {
inputStream=Resources.getResourceAsStream(resource);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
return new SqlSessionFactoryBuilder().build(inputStream);
}
//회원정보를 전달받아 MYMEMBER 테이블의 회원정보로 삽입하고 삽입행의 갯수를 반환하는 메소드
public int insertMember(MyMember member) {
SqlSession sqlSession=getSqlSessionFactory().openSession();
try {
//SqlSession.insert(String elementId[, Object parameterValue]) : 매퍼에 등록된
//insert 엘리먼트의 SQL 명령(INSERT)을 제공받아 DBMS 서버에 전달하여 실행하고
//삽입행의 갯수를 제공받아 반환하는 메소드
// => elementId : SQL 명령이 등록된 매퍼와 엘리먼트의 식별자를 문자열로 표현하여 전달
// => parameterValue : SQL 명령 작성에 필요한 값(객체)를 전달 - parameterType 속성값으로 사용
// => SQL 명령 작성에 필요한 값(객체)이 없는 경우 parameterValue 매개변수에 값 미전달
int rows=sqlSession.insert("MyMemberXMLMapper.insertMember", member);
//mybatis 프레임워크는 기본적으로 AutoCommit 기능을 비활성화 처리하고 SQL 명령을
//DBMS 서버에 전달하여 실행
// => DML 명령을 DBMS 서버에 전달하여 실행한 경우 반드시 커밋 또는 롤백 처리
if(rows > 0) {
//SqlSession.commit() : 트렌젝션 적용 명령(COMMIT)을 DBMS 서버에 전달하여 실행 - 커밋 처리
sqlSession.commit();
} else {
//SqlSession.rollback() : 트렌젝션 취소 명령(ROLLBACK)을 DBMS 서버에 전달하여 실행 - 롤백 처리
sqlSession.rollback();
}
return rows;
} finally {
sqlSession.close();
}
}
//회원정보를 전달받아 MYMEMBER 테이블에 저장된 회원정보를 변경하고 변경행의 갯수를 반환하는 메소드
public int updateMember(MyMember member) {
//SqlSessionFactory.openSession(boolean autoCommit) : SqlSession 객체를 생성하여 반환하는 메소드
// => false : AutoCommit 기능 비활성화(기본), true : AutoCommit 기능 활성화
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
//SqlSession.update(String elementId[, Object parameterValue]) : 매퍼에 등록된
//update 엘리먼트의 SQL 명령(UPDATE)을 제공받아 DBMS 서버에 전달하여 실행하고
//변경행의 갯수를 제공받아 반환하는 메소드
return sqlSession.update("MyMemberXMLMapper.updateMember", member);
} finally {
sqlSession.close();
}
}
//아이디를 전달받아 MYMEMBER 테이블에 저장된 회원정보를 삭제하고 삭제행의 갯수를 반환하는 메소드
public int deleteMember(String id) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
//SqlSession.delete(String elementId[, Object parameterValue]) : 매퍼에 등록된
//delete 엘리먼트의 SQL 명령(DELETE)을 제공받아 DBMS 서버에 전달하여 실행하고
//삭제행의 갯수를 제공받아 반환하는 메소드
return sqlSession.delete("MyMemberXMLMapper.deleteMember", id);
} finally {
sqlSession.close();
}
}
//아이디를 전달받아 MYMEMBER 테이블에 저장된 회원정보를 검색하여 DTO 객체로 반환하는 메소드
public MyMember selectMember(String id) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
//SqlSession.selectOne(String elementId[, Object parameterValue]) : 매퍼에 등록된
//select 엘리먼트의 SQL 명령(SELECT)을 제공받아 DBMS 서버에 전달하여 실행하고
//검색결과가 저장된 객체(값)를 제공받아 반환하는 메소드
// => 하나의 행만 검색하는 SELECT 명령을 DBMS 서버에 전달하여 실행할 경우 호출하는 메소드
return sqlSession.selectOne("MyMemberXMLMapper.selectMember", id);
} finally {
sqlSession.close();
}
}
//MYMEMBER 테이블에 저장된 모든 회원정보를 검색하여 List 객체로 반환하는 메소드
public List<MyMember> selectMemberList() {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
//SqlSession.selectOne(String elementId[, Object parameterValue]) : 매퍼에 등록된
//select 엘리먼트의 SQL 명령(SELECT)을 제공받아 DBMS 서버에 전달하여 실행하고
//검색결과가 저장된 List 객체를 제공받아 반환하는 메소드
// => 여러개의 행을 검색하는 SELECT 명령을 DBMS 서버에 전달하여 실행할 경우 호출하는 메소드
return sqlSession.selectList("MyMemberXMLMapper.selectMemberList");
} finally {
sqlSession.close();
}
}
}
src/main/java>xyz.itwill.mapper)
MyMemberXMLMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="MyMemberXMLMapper">
<!-- insert : INSERT 명령을 등록하기 위한 엘리먼트 -->
<!-- id 속성 : SQL 명령이 등록된 엘리먼트를 구분하기 위한 식별자를 속성값으로 설정 -->
<!-- parameterType 속성 : SQL 명령 작성에 필요한 값을 제공하기 위한 Java 객체의 자료형을 속성값으로 설정 -->
<!-- => Java 자료형 대신 typeAlias 엘리먼트의 별칭 사용 가능 -->
<!-- => SQL 명령 작성에 필요한 값이 없는 경우 parameterType 속성 생략 -->
<!-- DML 명령(INSERT, UPDATE, DELETE) 관련 엘리먼트는 등록된 SQL 명령을 DBMS 서버에 전달하여
실행한 후 조작행의 갯수(int)를 무조건 정수값으로 매핑하여 제공하므로 resultType 속성 생략 -->
<insert id="insertMember" parameterType="MyMember">
<!-- parameterType 속성값으로 전달된 값은 SQL 명령에서 #{변수명|필드명|맵키} 형식으로
표현하여 전달값을 제공받아 사용 -->
<!-- => parameterType 속성값으로 전달된 값이 Java 객체(DTO)인 경우 #{필드명} 형식으로
객체의 필드값을 제공받아 사용 - Getter 메소드 자동 호출 -->
<!-- => ibatis 프레임워크에서는 전달값을 #변수명|필드명|맵키# 형식 표현하여 사용 -->
insert into mymember values(#{id}, #{name} , #{phone} , #{email})
</insert>
<!-- update : UPDATE 명령을 등록하기 위한 엘리먼트 -->
<update id="updateMember" parameterType="MyMember">
update mymember set name=#{name}, phone=#{phone}, email=#{email} where id=#{id}
</update>
<!-- delete : DELETE 명령을 등록하기 위한 엘리먼트 -->
<delete id="deleteMember" parameterType="string">
<!-- parameterType 속성값으로 값 하나만 전달받은 경우 #{변수명} 형식으로 표현하여
전달값을 제공받아 사용 - 변수명은 어떤 이름으로 표현해도 사용 가능 -->
delete from mymember where id=#{id}
</delete>
<!-- select : SELECT 명령을 등록하기 위한 엘리먼트 -->
<!-- => 반드시 resultType 속성 또는 resultMap 속성을 설정하여 매핑정보를 제공받아 사용 -->
<!-- resultType 속성 : 검색행을 객체로 제공하기 위한 Java 자료형을 속성값으로 설정 -->
<!-- => Java 자료형 대신 typeAlias 엘리먼트의 별칭 사용 가능 -->
<!-- resultType 속성값으로 클래스를 설정한 경우 속성값으로 설정된 클래스의 객체를 생성하여
검색행의 컬럼값을 컬럼과 같은 이름의 객체 필드에 저장하여 제공 - 자동 매핑 -->
<select id="selectMember" parameterType="string" resultType="MyMember">
select id, name, phone, email from mymember where id=#{id}
</select>
<!-- SELECT 명령으로 다수행을 검색해도 resultType 속성에는 하나의 검색행을 객체로 매핑하기
위한 Java 자료형을 속성값으로 설정 -->
<select id="selectMemberList" resultType="MyMember">
select * from mymember order by id
</select>
</mapper>
main/webapp>member) ++선생님컴에서 4개 받아오기
memberDisplay.jsp - (73Day와 합침 / 실행)
<%@page import="xyz.itwill.dao.MyMemberDAO"%>
<%@page import="xyz.itwill.dao.MyMemberInterfaceDAO"%>
<%@page import="xyz.itwill.dao.MyMemberXMLDAO"%>
<%@page import="xyz.itwill.dto.MyMember"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
//List<MyMember> memberList=MyMemberXMLDAO.getDAO().selectMemberList();
//List<MyMember> memberList=MyMemberInterfaceDAO.getDAO().selectMemberList();
List<MyMember> memberList=MyMemberDAO.getDAO().selectMemberList();
%>
<!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=UTF-8">
<title>MYBATIS</title>
</head>
<body>
<h1 align="center">회원목록</h1>
<hr>
<table align="center" border="1" cellspacing="0" width="300">
<tr>
<th width="140">아이디</th>
<th width="160">이름</th>
</tr>
<%-- 회원목록 출력 => 반복문 시작 --%>
<% for(MyMember member : memberList) { %>
<tr align="center">
<td width="140"><%=member.getId() %></td>
<td width="160">
<a href="memberView.jsp?id=<%=member.getId() %>"><%=member.getName() %></a></td>
</tr>
<% } %>
<%-- 반복문 종료 --%>
<tr align="right">
<td colspan="2">
<button type="button"
onclick="location.href='memberInputForm.jsp';">회원등록</button>
</td>
</tr>
</table>
</body>
</html>
main/webapp>member)
memberinputAction .jsp
<%@page import="xyz.itwill.dao.MyMemberXMLDAO"%>
<%@page import="xyz.itwill.dto.MyMember"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
request.setCharacterEncoding("utf-8");
String id=request.getParameter("id");
String name=request.getParameter("name");
String phone=request.getParameter("phone");
String email=request.getParameter("email");
MyMember member=new MyMember();
member.setId(id);
member.setName(name);
member.setPhone(phone);
member.setEmail(email);
try {
//SqlSession 객체를 이용하여 매퍼에 등록된 SQL 명령을 DBMS 서버에 전달하여 실행할 때
//문제가 발생되면 PersistenceException 발생 - 예외처리
MyMemberXMLDAO.getDAO().insertMember(member);
response.sendRedirect("memberDisplay.jsp");
} catch(Exception e) {
//SQL 명령(INSERT) 명령이 정상인 경우 PK 제약조건을 위반하면 예외 발생
//response.sendRedirect("memberInputForm.jsp");
out.println("<script type='text/javascript'>");
out.println("alert('이미 사용중인 아이디를 입력하여 회원등록이 실패 하였습니다.');");
out.println("history.go(-1);");
out.println("</script>");
}
%>
main/webapp>member)
memberView .jsp (실행하면 오류)
<%@page import="xyz.itwill.dao.MyMemberXMLDAO"%>
<%@page import="xyz.itwill.dto.MyMember"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
String id=request.getParameter("id");
MyMember member=MyMemberXMLDAO.getDAO().selectMember(id);
%>
<!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=UTF-8">
<title>MYBATIS</title>
</head>
<body>
<h1 align="center">회원정보</h1>
<hr>
<table align="center" border="1" cellspacing="0" width="300">
<tr>
<th width="100">아이디</th>
<td align="center" width="200"><%=member.getId() %></td>
</tr>
<tr>
<th width="100">이름</th>
<td align="center" width="200"><%=member.getName() %></td>
</tr>
<tr>
<th width="100">전화번호</th>
<td align="center" width="200"><%=member.getPhone() %></td>
</tr>
<tr>
<th width="100">이메일</th>
<td align="center" width="200"><%=member.getEmail() %></td>
</tr>
<tr align="right">
<td colspan="2">
<button type="button" onclick="location.href='memberUpdateForm.jsp?id=<%=member.getId() %>';">회원변경</button>
<button type="button" onclick="location.href='memberDeleteAction.jsp?id=<%=member.getId() %>';">회원삭제</button>
<button type="button" onclick="location.href='memberDisplay.jsp';">회원목록</button>
</td>
</tr>
</table>
</body>
</html>
main/webapp>member)
memberUpdateForm .jsp (실행하면 오류남)
<%@page import="xyz.itwill.dao.MyMemberXMLDAO"%>
<%@page import="xyz.itwill.dto.MyMember"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
String id=request.getParameter("id");
MyMember member=MyMemberXMLDAO.getDAO().selectMember(id);
%>
<!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=UTF-8">
<title>MYBATIS</title>
<script type="text/javascript" src="http://code.jquery.com/jquery-1.12.4.min.js"></script>
<script type="text/javascript">
$(document).ready(function() {
$("#id").focus();
$("#submitBtn").click(function() {
if($("#name").val()=="") {
alert("이름을 입력해 주세요");
$("#name").focus();
return;
}
if($("#phone").val()=="") {
alert("전화번호를 입력해 주세요");
$("#phone").focus();
return;
}
if($("#email").val()=="") {
alert("이메일을 입력해 주세요");
$("#email").focus();
return;
}
$("#input").attr("method","POST").attr("action"
,"memberUpdateAction.jsp").submit();
});
$("#resetBtn").click(function() {
$("#input").each(function() {
this.reset();
});
$("#id").focus();
});
$("#displayBtn").click(function() {
location.href="memberDisplay.jsp";
});
});
</script>
</head>
<body>
<h1 align="center">회원변경</h1>
<form id="input">
<input type="hidden" name="id" value="<%=member.getId()%>">
<table align="center" border="1" cellspacing="0" width="300">
<tr>
<th width="100">아이디</th>
<td align="center" width="200">
<%=member.getId()%>
</td>
</tr>
<tr>
<th width="100">이름</th>
<td align="center" width="200">
<input type="text" name="name" id="name" value="<%=member.getName()%>">
</td>
</tr>
<tr>
<th width="100">전화번호</th>
<td align="center" width="200">
<input type="text" name="phone" id="phone" value="<%=member.getPhone()%>">
</td>
</tr>
<tr>
<th width="100">이메일</th>
<td align="center" width="200">
<input type="text" name="email" id="email" value="<%=member.getEmail()%>">
</td>
</tr>
<tr>
<th colspan="2">
<button type="button" id="submitBtn">변경전송</button>
<button type="button" id="resetBtn">다시입력</button>
<button type="button" id="displayBtn">회원정보</button>
</th>
</tr>
</table>
</form>
</body>
</html>
main/webapp>member)
memberUpdateAction .jsp (실행하면 오류남)
<%@page import="xyz.itwill.dao.MyMemberXMLDAO"%>
<%@page import="xyz.itwill.dto.MyMember"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
request.setCharacterEncoding("utf-8");
String id=request.getParameter("id");
String name=request.getParameter("name");
String phone=request.getParameter("phone");
String email=request.getParameter("email");
MyMember member=new MyMember();
member.setId(id);
member.setName(name);
member.setPhone(phone);
member.setEmail(email);
MyMemberXMLDAO.getDAO().updateMember(member);
response.sendRedirect("memberView.jsp?id="+id);
%>
main/webapp>member)
memberDeleteAction .jsp (당근 실행하면 오류남)
<%@page import="xyz.itwill.dao.MyMemberXMLDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
String id=request.getParameter("id");
MyMemberXMLDAO.getDAO().deleteMember(id);
response.sendRedirect("memberDisplay.jsp");
%>
mybatis_config.xml에 매핑 class 등록
업데이트및 검색/삭제 하려는 것
src/main/java>xyz.itwill.mapper)
MyMemberInterfaceMapper .java - (인터페이스)
package xyz.itwill.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import xyz.itwill.dto.MyMember;
//mybatis 프레임워크에서는 인터페이스를 이용하여 매퍼 파일을 작성 가능
// => 추상메소드에 매퍼 어노테이션(Mapper Annotation)을 사용하여 SQL 명령을 작성하여 등록
public interface MyMemberInterfaceMapper {
//@Insert : 추상메소드에 INSERT 명령을 등록하기 위한 어노테이션
//value 속성 : 추상메소드에 등록될 SQL 명령을 속성값으로 설정
// => value 속성외에 다른 속성이 없는 경우 속성값만 설정 가능
@Insert(value = "insert into mymember values(#{id}, #{name} , #{phone} , #{email})")
//추상메소드의 매개변수에서 SQL 명령 작성에 필요한 객체(값)을 전달받기 위해 선언하며
//추상메소드 반환형은 실행결과를 객체(값)로 제공받기 위한 Java 자료형을 선언
int insertMember(MyMember member);
//@Update : 추상메소드에 UPDATE 명령을 등록하기 위한 어노테이션
@Update("update mymember set name=#{name}, phone=#{phone}, email=#{email} where id=#{id}")
int updateMember(MyMember member);
//@Delete : 추상메소드에 DELETE 명령을 등록하기 위한 어노테이션
@Delete("delete from mymember where id=#{id}")
int deleteMember(String id);
//@Select : 추상메소드에 SELECT 명령을 등록하기 위한 어노테이션
@Select("select id, name, phone, email from mymember where id=#{id}")
MyMember selectMember(String id);
@Select("select id, name, phone, email from mymember order by id")
List<MyMember> selectMemberList();
}
src/main/java>xyz.itwill.dao)
MyMemberInterfaceDAO .java
package xyz.itwill.dao;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import xyz.itwill.dto.MyMember;
import xyz.itwill.mapper.MyMemberInterfaceMapper;
public class MyMemberInterfaceDAO {
private static MyMemberInterfaceDAO _dao;
private MyMemberInterfaceDAO() {
// TODO Auto-generated constructor stub
}
static {
_dao=new MyMemberInterfaceDAO();
}
public static MyMemberInterfaceDAO getDAO() {
return _dao;
}
//SqlSessionFactory 객체를 생성하여 반환하는 메소드
private SqlSessionFactory getSqlSessionFactory() {
String resource="mybatis-config.xml";
InputStream inputStream=null;
try {
inputStream=Resources.getResourceAsStream(resource);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
return new SqlSessionFactoryBuilder().build(inputStream);
}
//회원정보를 전달받아 MYMEMBER 테이블의 회원정보로 삽입하고 삽입행의 갯수를 반환하는 메소드
public int insertMember(MyMember member) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
//SqlSession.getMapper(Class<T> clazz) : 매개변수에 Class 객체(Clazz - 메모리에 저장된
//인터페이스 매퍼)를 전달받아 Mapper 객체로 생성하여 반환하는 메소드
// => 매개변수에 [XXX.class] 형식으로 인터페이스를 Class 객체로 직접 표현하여 전달
//Mapper 객체 : 인터페이스 기반의 매퍼 파일을 제공받아 Mapper 객체로 생성되며
//추상메소드를 호출하여 추상메소드에 등록된 SQL 명령을 DBMS 서버에 전달하여
//실행하고 실행결과를 Java 객체로 매핑하여 반환하는 기능을 제공하는 객체
return sqlSession.getMapper(MyMemberInterfaceMapper.class).insertMember(member);
} finally {
sqlSession.close();
}
}
//회원정보를 전달받아 MYMEMBER 테이블에 저장된 회원정보를 변경하고 변경행의 갯수를 반환하는 메소드
public int updateMember(MyMember member) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyMemberInterfaceMapper.class).updateMember(member);
} finally {
sqlSession.close();
}
}
//아이디를 전달받아 MYMEMBER 테이블에 저장된 회원정보를 삭제하고 삭제행의 갯수를 반환하는 메소드
public int deleteMember(String id) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyMemberInterfaceMapper.class).deleteMember(id);
} finally {
sqlSession.close();
}
}
//아이디를 전달받아 MYMEMBER 테이블에 저장된 회원정보를 검색하여 DTO 객체로 반환하는 메소드
public MyMember selectMember(String id) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyMemberInterfaceMapper.class).selectMember(id);
} finally {
sqlSession.close();
}
}
//MYMEMBER 테이블에 저장된 모든 회원정보를 검색하여 List 객체로 반환하는 메소드
public List<MyMember> selectMemberList() {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyMemberInterfaceMapper.class).selectMemberList();
} finally {
sqlSession.close();
}
}
}
73Day
회원 등록창 / 회원 목록
**내포 바인딩 - 중요!!
**리절트맵 & 자동매핑 & 수동매핑 - 중
main/java>xyz.itwill.mapper)
MyMemberMapper .java
package xyz.itwill.mapper;
import java.util.List;
import xyz.itwill.dto.MyMember;
public interface MyMemberMapper {
int insertMember(MyMember member);
int updateMember(MyMember member);
int deleteMember(String id);
MyMember selectMember(String id);
List<MyMember> selectMemberList();
}
main/java>xyz.itwill.mapper)
MyMemberMapper .xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="xyz.itwill.mapper.MyReplyMapper">
<insert id="insertReply" parameterType="MyReply">
<selectKey resultType="int" keyProperty="replyNo" order="BEFORE">
select myreply_seq.nextval from dual
</selectKey>
insert into myreply values(#{replyNo}, #{replyId}, #{replyContent}, sysdate, #{replyCommentNo})
</insert>
<select id="selectReplyList" resultType="MyReply">
select reply_no, reply_id, reply_content, reply_date, reply_comment_no
from myreply order by reply_no desc
</select>
<!-- MYREPLY 테이블에 저장된 댓글 중 가장 최근에 작성된 5개 댓글만 검색하는 SELECT 명령 등록 -->
<!-- 문제점 : XML 기반의 매퍼 파일에서는 SQL 명령이 등록된 엘리먼트에서 비교 연산자 중
> 또는 < 연산자를 사용할 경우 엘리먼트를 표현하는 기호로 인식되어 에러 발생 -->
<!-- 해결법-1 : > 또는 < 비교 연산자를 엔티티 레퍼런스(회피문자)로 표현하여 SQL 명령 작성 -->
<!--
<select id="selectCountReplyList" resultType="MyReply">
select rownum, reply.* from (select reply_no, reply_id, reply_content, reply_date
, reply_comment_no from myreply order by reply_no desc) reply where rownum <= 5
</select>
-->
<!-- 해결법-2 : CDATA 세션을 사용하여 SQL 명령 작성 -->
<select id="selectCountReplyList" resultType="MyReply">
<![CDATA[
select rownum, reply.* from (select reply_no, reply_id, reply_content, reply_date
, reply_comment_no from myreply order by reply_no desc) reply where rownum <= 5
]]>
</select>
<resultMap type="MyReplyUser" id="myReplyUserResultMap1">
<association property="reply" javaType="MyReply">
<id column="reply_no" property="replyNo"/>
<result column="reply_id" property="replyId"/>
<result column="reply_content" property="replyContent"/>
<result column="reply_date" property="replyDate"/>
<result column="reply_comment_no" property="replyCommentNo"/>
</association>
<association property="user" javaType="MyUser">
<id column="user_id" property="userId"/>
<result column="user_name" property="userName"/>
</association>
</resultMap>
<select id="selectReplyUserList1" resultMap="myReplyUserResultMap1">
select reply_no, reply_id, reply_content, reply_date, reply_comment_no, user_id
, user_name from myreply join myuser on reply_id=user_id order by reply_no desc
</select>
<!-- 검색행의 컬럼값이 필드값으로 저장된 객체를 생성하여 제공하는 resultMap 엘리먼트 -->
<resultMap type="MyReply" id="myReplyResultMap">
<id column="reply_no" property="replyNo"/>
<result column="reply_id" property="replyId"/>
<result column="reply_content" property="replyContent"/>
<result column="reply_date" property="replyDate"/>
<result column="reply_comment_no" property="replyCommentNo"/>
</resultMap>
<resultMap type="MyReplyUser" id="myReplyUserResultMap2">
<!-- resultMap 속성 : resultMap 엘리먼트의 식별자를 속성값으로 설정 -->
<!-- => 다른 resultMap 엘리먼트의 매핑정보를 이용하여 검색행의 컬럼값이 저장된 객체를
제공받아 필드에 저장 - resultMap 엘리먼트의 매핑 정보 재사용 -->
<association property="reply" resultMap="myReplyResultMap"/>
<!-- select 속성 : select 엘리먼트의 식별자를 속성값을 설정 -->
<!-- => select 엘리먼트로 검색행의 컬럼값이 저장된 객체를 제공받아 필드에 저장 -->
<!-- column 속성 : SELECT 명령에 전달될 값이 저장된 검색행의 컬럼명을 속성값으로 설정 -->
<!-- => 검색행의 컬럼값을 select 속성값으로 설정된 select 엘리먼트의 parameterType
속성값으로 전달하여 SELECT 명령에서 사용 가능 -->
<association property="user" select="selectMyUser" column="reply_id"/>
</resultMap>
<!-- DAO 클래스의 메소드에서 사용하지 않고 association 엘리먼트에서만 사용하기 위한 SELECT 명령 -->
<!-- => Interface 기반의 매퍼 파일에서 추상메소드로 미선언 -->
<!-- => parameterType 속성값으로 전달받은 값을 사용하여 단일행이 검색되도록 SELECT 명령 작성 -->
<select id="selectMyUser" resultType="MyUser" parameterType="string">
select user_id, user_name from myuser where user_id=#{userId}
</select>
<!-- 테이블 조인 명령을 사용하지 않고 resultMap 엘리먼트의 매핑정보를 이용하여 2개
이상의 테이블에 대한 검색결과를 객체로 제공받아 사용 가능 -->
<select id="selectReplyUserList2" resultMap="myReplyUserResultMap2">
select reply_no, reply_id, reply_content, reply_date, reply_comment_no from myreply order by reply_no desc
</select>
</mapper>
main/java>xyz.itwill.mapper)
MyUserMapper .java
package xyz.itwill.mapper;
import java.util.List;
import xyz.itwill.dto.MyUser;
public interface MyUserMapper {
int insertUser(MyUser user);
List<MyUser> selectUserList();
}
main/java>xyz.itwill.mapper)
MyUserMapper .xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="xyz.itwill.mapper.MyUserMapper">
<insert id="insertUser" parameterType="MyUser">
insert into myuser values(#{userId}, #{userName})
</insert>
<!-- resultType 속성을 사용하면 resultType 속성값으로 설정된 클래스로 객체를 생성하여
검색행의 컬럼값을 같은 이름의 객체 필드값으로 자동 저장하여 제공 - 자동 매핑 -->
<!-- 문제점 : 검색행의 컬럼명과 resultType 속성값으로 설정된 클래스의 필드명이 모두
다른 경우 resultType 속성값으로 설정된 클래스의 객체를 제공하지 않고 NULL 제공 -->
<!--
<select id="selectUserList" resultType="MyUser">
select user_id, user_name from myuser order by user_id
</select>
-->
<!-- 해결법-1 : 검색행의 컬럼명을 resultType 속성값으로 설정된 클래스의 필드명과 같도록 검색 -->
<!-- => SELECT 명령에서 Column Alias 기능을 이용하여 검색대상의 별칭을 필드명과 같도록 작성하여 검색 -->
<!--
<select id="selectUserList" resultType="MyUser">
select user_id userId, user_name userName from myuser order by user_id
</select>
-->
<!-- sql : SQL 명령을 구성하는 일부분의 문장을 등록하기 위한 엘리먼트 -->
<!-- id 속성 : sql 엘리먼트를 구분하는 식별자를 속성값으로 설정 -->
<sql id="myUserColumnAlias">
user_id userId, user_name userName
</sql>
<!-- include : sql 엘리먼트에 등록된 문장을 제공받아 SQL 명령에 포함하는 엘리먼트 -->
<!-- refid 속성 : sql 엘리먼트의 식별자(id 속성값)을 속성값으로 설정 -->
<!--
<select id="selectUserList" resultType="MyUser">
select <include refid="myUserColumnAlias"/> from myuser order by user_id
</select>
-->
<!-- 해결법-2 : mybatis 환경설정파일(mybatis-config.xml)의 setting 엘리먼트를 사용하여
스네이크 표기법의 식별자를 카멜 표기법의 식별자로 자동 변환하는 기능 사용 -->
<!--
<select id="selectUserList" resultType="MyUser">
select user_id, user_name from myuser order by user_id
</select>
-->
<!-- 해결법-3 : resultMap 엘리먼트를 사용하여 검색행의 컬럼값이 객체의 필드에 저장되도록
설정 - 수동 매핑 -->
<!-- resultMap : 검색행을 Java 객체로 생성하여 제공하기 위한 엘리먼트 - 매핑 정보를 제공하는 엘리먼트 -->
<!-- => 검색행의 컬럼값이 객체 필드에 저장되도록 처리하기 위해 하위 엘리먼트 사용 -->
<!-- => 하위 엘리먼트 : constructor, id, result, association, collection, discriminator -->
<!-- type 속성 : resultMap 엘리먼트로 제공될 객체의 Java 자료형(클래스)을 속성값으로 설정 -->
<!-- => Java 자료형 대신 typeAlias 엘리먼트로 설정된 별칭 사용 가능 -->
<!-- id 속성 : resultMap 엘리먼트를 구분하기 위한 식별자를 속성값으로 설정 -->
<resultMap type="MyUser" id="myUserResultMap">
<!-- id : 검색행의 컬럼값을 필드에 저장하기 위한 엘리먼트 - Setter 메소드 호출 -->
<!-- => PK 제약조건이 설정된 컬럼의 값을 제공받아 필드에 저장하기 위해 사용 -->
<!-- column 속성 : 검색행의 컬럼명을 속성값으로 설정 -->
<!-- property 속성 : 클래스의 필드명을 속성값으로 설정 -->
<id column="user_id" property="userId"/>
<!-- result : 검색행의 컬럼값을 필드에 저장하기 위한 엘리먼트 - Setter 메소드 호출 -->
<result column="user_name" property="userName"/>
</resultMap>
<!-- resultMap 속성 : resultMap 엘리먼트의 식별자를 속성값으로 설정 -->
<!-- => resultMap 엘리먼트의 매핑정보를 제공받아 검색행을 Java 객체로 생성하여 제공 - 수동 매핑 -->
<select id="selectUserList" resultMap="myUserResultMap">
select user_id, user_name from myuser order by user_id
</select>
</mapper>
src/main/java/xyz.itwill.dao)
MyMemberDAO .java
package xyz.itwill.dao;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import xyz.itwill.dto.MyMember;
import xyz.itwill.mapper.MyMemberMapper;
public class MyMemberDAO {
private static MyMemberDAO _dao;
private MyMemberDAO() {
// TODO Auto-generated constructor stub
}
static {
_dao=new MyMemberDAO();
}
public static MyMemberDAO getDAO() {
return _dao;
}
//SqlSessionFactory 객체를 생성하여 반환하는 메소드
private SqlSessionFactory getSqlSessionFactory() {
String resource="mybatis-config.xml";
InputStream inputStream=null;
try {
inputStream=Resources.getResourceAsStream(resource);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
return new SqlSessionFactoryBuilder().build(inputStream);
}
//회원정보를 전달받아 MYMEMBER 테이블의 회원정보로 삽입하고 삽입행의 갯수를 반환하는 메소드
public int insertMember(MyMember member) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyMemberMapper.class).insertMember(member);
} finally {
sqlSession.close();
}
}
//회원정보를 전달받아 MYMEMBER 테이블에 저장된 회원정보를 변경하고 변경행의 갯수를 반환하는 메소드
public int updateMember(MyMember member) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyMemberMapper.class).updateMember(member);
} finally {
sqlSession.close();
}
}
//아이디를 전달받아 MYMEMBER 테이블에 저장된 회원정보를 삭제하고 삭제행의 갯수를 반환하는 메소드
public int deleteMember(String id) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyMemberMapper.class).deleteMember(id);
} finally {
sqlSession.close();
}
}
//아이디를 전달받아 MYMEMBER 테이블에 저장된 회원정보를 검색하여 DTO 객체로 반환하는 메소드
public MyMember selectMember(String id) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyMemberMapper.class).selectMember(id);
} finally {
sqlSession.close();
}
}
//MYMEMBER 테이블에 저장된 모든 회원정보를 검색하여 List 객체로 반환하는 메소드
public List<MyMember> selectMemberList() {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyMemberMapper.class).selectMemberList();
} finally {
sqlSession.close();
}
}
}
src/main/java/xyz.itwill.dao)
MyUserDAO.java
package xyz.itwill.dao;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import xyz.itwill.dto.MyUser;
import xyz.itwill.mapper.MyUserMapper;
public class MyUserDAO extends AbstractSession {
private static MyUserDAO _dao;
private MyUserDAO() {
// TODO Auto-generated constructor stub
}
static {
_dao=new MyUserDAO();
}
public static MyUserDAO getDAO() {
return _dao;
}
public int insertUser(MyUser user) {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyUserMapper.class).insertUser(user);
} finally {
sqlSession.close();
}
}
public List<MyUser> selectUserList() {
SqlSession sqlSession=getSqlSessionFactory().openSession(true);
try {
return sqlSession.getMapper(MyUserMapper.class).selectUserList();
} finally {
sqlSession.close();
}
}
}
src/main/java/xyz.itwill.dao)
AbstractSession.java
package xyz.itwill.dao;
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;
//SqlSessionFactory 객체를 생성하여 반환하는 기능을 제공하는 클래스
// => 매퍼를 사용하는 모든 DAO 클래스가 상속받기 위한 부모클래스
// => 상속을 목적으로 작성된 클래스이므로 추상클래스로 선언하는 것을 권장
public abstract class AbstractSession {
private static SqlSessionFactory sqlSessionFactory;
static {
String resource="mybatis-config.xml";
InputStream inputStream=null;
try {
inputStream=Resources.getResourceAsStream(resource);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
}
protected SqlSessionFactory getSqlSessionFactory() {
return sqlSessionFactory;
}
}
src/main>webapp>member)
memberDisplay .jsp
<%@page import="xyz.itwill.dao.MyMemberDAO"%>
<%@page import="xyz.itwill.dao.MyMemberInterfaceDAO"%>
<%@page import="xyz.itwill.dao.MyMemberXMLDAO"%>
<%@page import="xyz.itwill.dto.MyMember"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
//List<MyMember> memberList=MyMemberXMLDAO.getDAO().selectMemberList();
//List<MyMember> memberList=MyMemberInterfaceDAO.getDAO().selectMemberList();
List<MyMember> memberList=MyMemberDAO.getDAO().selectMemberList();
%>
<!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=UTF-8">
<title>MYBATIS</title>
</head>
<body>
<h1 align="center">회원목록</h1>
<hr>
<table align="center" border="1" cellspacing="0" width="300">
<tr>
<th width="140">아이디</th>
<th width="160">이름</th>
</tr>
<%-- 회원목록 출력 => 반복문 시작 --%>
<% for(MyMember member : memberList) { %>
<tr align="center">
<td width="140"><%=member.getId() %></td>
<td width="160">
<a href="memberView.jsp?id=<%=member.getId() %>"><%=member.getName() %></a></td>
</tr>
<% } %>
<%-- 반복문 종료 --%>
<tr align="right">
<td colspan="2">
<button type="button"
onclick="location.href='memberInputForm.jsp';">회원등록</button>
</td>
</tr>
</table>
</body>
</html>
글입력
myuser 테이블생성 ▼ (회원정보를 저장하기위한 테이블)
create table myuser(user_id varchar2(50) primary key, user_name varchar2(50));
src/main/java>xyz.itwill.dto)
MyUser.java
package xyz.itwill.dto;
/*
MYUSER 테이블 : 회원정보를 저장하기 위한 테이블
=> SQL 명령은 대소문자를 구분하기 않기 때문에 식별자를 선언할 때 스네이크 표기법 사용
=> 스네이크 표기법(SnakeCase) : 단어와 단어를 구분하기 위해 _ 기호를 사용하여 식별자를 선언하는 방법
create table myuser(user_id varchar2(50) primary key, user_name varchar2(50));
이름 널? 유형
--------- -------- ------------
USER_ID NOT NULL VARCHAR2(50) - 아이디
USER_NAME VARCHAR2(50) - 이름
*/
//Java 자료형(Class, Interface, Enum)을 선언할 경우에는 파스칼 표기법 사용
// => 파스칼 표기법(PascalCase) : 모든 단어의 첫문자를 대문자로 표현하여 식별자를 선언하는 방법
public class MyUser {
//Java 자료형을 제외한 식별자는 카멜 표기법 사용
// => 카멜 표기법(CamelCase) : 첫단어를 제외한 나머지 단어의 첫문자를 대문자로 표현하여 식별자를 선언하는 방법
private String userId;
private String userName;
public MyUser() {
// TODO Auto-generated constructor stub
}
public MyUser(String userId, String userName) {
super();
this.userId = userId;
this.userName = userName;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
}
src/main/webapp>user)
userInsert .jsp
<%@page import="xyz.itwill.dto.MyUser"%>
<%@page import="xyz.itwill.dao.MyUserDAO"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
MyUserDAO.getDAO().insertUser(new MyUser("abc","홍길동"));
MyUserDAO.getDAO().insertUser(new MyUser("xyz","임꺽정"));
MyUserDAO.getDAO().insertUser(new MyUser("opq","전우치"));
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
</head>
<body>
<h1>회원등록</h1>
<hr>
<h3>회원정보가 성공적으로 삽입 되었습니다.</h3>
</body>
</html>
src/main/webapp>user)
userListSelect .jsp
<%@page import="xyz.itwill.dao.MyUserDAO"%>
<%@page import="xyz.itwill.dto.MyUser"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
List<MyUser> userList=MyUserDAO.getDAO().selectUserList();
//System.out.println("userList.size() = "+userList.size());
//System.out.println("userList.get(0) = "+userList.get(0));
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MYBATIS</title>
</head>
<body>
<h1>회원목록</h1>
<hr>
<ul>
<% for(MyUser user : userList) { %>
<li>아이디 = <%=user.getUserId() %>, 이름 = <%=user.getUserName() %></li>
<% } %>
</ul>
</body>
</html>
src/main/java)
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- mybatis 환경설정파일 : SqlSessionFactory 객체를 생성하기 위해 필요한 정보를 제공하는 파일 -->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- properties : property 엘리먼트를 등록하기 위한 상위 엘리먼트 -->
<!-- resource 속성 : Properties 파일의 경로를 속성값으로 설정 - 생략 가능 -->
<!-- => property 엘리먼트 대신 Properties 파일의 등록된 정보를 이용하여 이름으로 값을 제공받아 사용 -->
<properties resource="oracle_url.properties">
<!-- property : mybatis 환경설정파일에 필요한 값을 제공하기 위한 엘리먼트 -->
<!-- => 다른 엘리먼트에서 ${이름} 형식으로 property 엘리먼트로 제공되는 값을 사용 -->
<!-- => 다수의 엘리먼트에서 공통적으로 사용되는 값을 제공하기 위해 설정 - 유지보수의 효율성 증가 -->
<property name="oracleDriver" value="oracle.jdbc.driver.OracleDriver"/>
</properties>
<!-- settings : setting 엘리먼트를 등록하기 위한 상위 엘리먼트 -->
<settings>
<!-- setting : mybatis 실행시 필요한 정보를 제공하기 위한 엘리먼트 -->
<!-- => setting 엘리먼트를 사용하지 않아도 실행에 필요한 값은 기본값으로 제공받아 사용 -->
<!-- => mybatis 실행을 기본값을 제외한 값으로 제공받아 사용할 경우에만 setting 엘리먼트 설정 -->
<!-- callSettersOnNulls 옵션을 [true]로 설정하면 UPDATE 명령 실행시 컬럼값을 [NULL]로
변경하는 기능을 허용 -->
<setting name="callSettersOnNulls" value="true"/>
<!-- mapUnderscoreToCamelCase 옵션을 [true]로 설정하면 SELECT 명령 실행시 스네이크 표기법으로
작성된 컬럼명을 자동으로 카멜 표기법의 컬럼명으로 변환하여 검색하는 기능을 제공받아 사용 -->
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<!-- typeAliases : typeAlias 엘리먼트를 등록하기 위한 상위 엘리먼트 -->
<typeAliases>
<!-- typeAlias : XML 기반의 매퍼 파일에서 Java 자료형에 대신 사용할 수 있는 별칭
(AliasName)을 설정하기 위한 엘리먼트 -->
<!-- => mybatis 프레임워크는 내부적으로 Java 자료형에 대신 사용할 별칭 제공 -->
<!-- type 속성 : Java 자료형을 속성값으로 설정 -->
<!-- alias 속성 : Java 자료형 대신 사용될 별칭을 속성값으로 설정 -->
<!-- <typeAlias type="xyz.itwill.dto.Student" alias="Student"/> -->
<!-- <typeAlias type="xyz.itwill.dto.MyMember" alias="MyMember"/> -->
<!-- package : 특정 패키지에 작성된 모든 클래스에 별칭을 자동 등록하는 엘리먼트 -->
<!-- => 패키지에 작성된 클래스는 패키지를 제외한 클래스 이름을 별칭으로 자동 등록 -->
<package name="xyz.itwill.dto"/>
</typeAliases>
<!-- environments : environment 엘리먼트를 등록하기 위한 상위 엘리먼트 -->
<!-- default 속성 : environment 엘리먼트의 식별자(id 속성값)을 속성값으로 설정 -->
<!-- => mybatis 프레임워크가 기본적으로 사용하기 위한 DBMS 서버 지정 -->
<environments default="development">
<!-- environment : DBMS 서버 접속에 필요한 정보를 설정하기 위한 엘리먼트 -->
<!-- => Connection 객체를 생성하기 위한 정보를 제공 -->
<!-- id 속성 : environment 엘리먼트를 구분하기 위한 식별자를 속성값으로 설정 -->
<environment id="development">
<!-- transactionManager : 트렌젝션 관리자(커밋 또는 롤백 처리)를 설정하기 위한 엘리먼트 -->
<!-- type 속성 : [JDBC] 또는 [MANAGED] 중 하나를 속성값으로 설정 -->
<!-- => JDBC 속성값 : JDBC 기능을 사용하여 직접 트렌젝션 관리 - Connection 객체의 메소드 호출 -->
<!-- => MANAGED 속성값 : 트렌젝션 관리 프로그램을 사용하여 트렌젝션 관리 -->
<transactionManager type="JDBC"/>
<!-- dataSource : Connection 객체를 생성하기 위한 정보를 제공하는 엘리먼트 -->
<!-- type 속성 : [UNPOOLED], [POOLED], [JNDI] 중 하나를 속성값으로 설정 -->
<!-- => type 속성값에 따라 하위 엘리먼트 설정 변경 -->
<!-- => UNPOOLED 속성값 : Connection 객체를 미리 생성하지 않고 실행시 생성하여 제공 -->
<!-- => POOLED 속성값 : Connection 객체를 미리 생성하여 실행시 제공 - DBCP -->
<!-- => JNDI 속성값 : WAS 프로그램에 등록된 자원을 이용하여 Connection 객체를 실행시 제공 -->
<dataSource type="POOLED">
<!-- property : Connection 객체 생성에 필요한 값을 제공하는 엘리먼트 -->
<!-- name 속성 : Connection 객체 생성에 필요한 값이 저장될 이름을 속성값으로 설정 -->
<!-- value 속성 : Connection 객체 생성에 필요한 값을 속성값으로 설정 -->
<!-- <property name="driver" value="oracle.jdbc.driver.OracleDriver"/> -->
<property name="driver" value="${oracleDriver}"/>
<!-- <property name="url" value="jdbc:oracle:thin:@localhost:1521:xe"/> -->
<property name="url" value="${local}"/>
<property name="username" value="scott"/>
<property name="password" value="tiger"/>
</dataSource>
</environment>
</environments>
<!-- mappers : mapper 엘리먼트를 등록하기 위한 상위 엘리먼트 -->
<mappers>
<!-- mapper : 매퍼 파일(Mapper File)을 매퍼(Mapper)로 등록하기 위한 엘리먼트 -->
<!-- 매퍼(Mapper) : SQL 명령에 필요한 값을 전달받아 SQL 명령을 등록하고 실행결과를
Java 객체(원시형)으로 매핑하기 위한 정보를 제공 -->
<!-- => mybatis 프레임워크에서는 XML 기반의 매퍼 파일과 Interface 기반의 매퍼 파일을
이용하여 매퍼 등록 가능 -->
<!-- => ibatis 프레임워크에서는 XML 기반의 매퍼 파일로만 매퍼 등록 가능 -->
<!-- resource 속성 : XML 기반의 매퍼 파일 경로를 속성값으로 설정 -->
<!-- => XML 기반의 매퍼 파일 경로는 파일 시스템 경로로 표현하여 작성 -->
<!-- XML 기반의 매퍼 파일의 장점 : 수동 매핑 설정과 동적 SQL 설정에 대한 기능 구현 편리 -->
<!-- XML 기반의 매퍼 파일의 단점 : SqlSession 객체로 SQL 명령을 제공받아 사용하기 불편 -->
<mapper resource="xyz/itwill/mapper/StudentMapper.xml"/>
<mapper resource="xyz/itwill/mapper/MyMemberXMLMapper.xml"/>
<!-- class 속성 : Interface 기반의 매퍼 파일의 경로를 속성값으로 설정 -->
<!-- => Interface 기반의 매퍼 파일의 경로는 Java 자료형(인터페이스)으로 표현하여 작성 -->
<!-- Interface 기반의 매퍼 파일의 장점 : SqlSession 객체로 SQL 명령을 제공받아 사용하기 편리 -->
<!-- Interface 기반의 매퍼 파일의 단점 : 수동 매핑 설정과 동적 SQL 설정에 대한 기능 구현 불편 -->
<!-- <mapper class="xyz.itwill.mapper.MyMemberInterfaceMapper"/> -->
<!-- 매퍼 바인딩 기능을 사용하여 XML 기반의 매퍼 파일과 Interface 기반의 매퍼 파일을
하나의 매퍼로 등록되어 동작되도록 설정 가능 -->
<!-- 매퍼 바인딩(Mapper Binding) : SQL 명령은 XML 기반의 매퍼 파일에 등록하고
DAO 클래스는 Interface 기반의 매퍼 파일을 이용하여 작성 -->
<!-- => mapper 엘리먼트에는 XML 기반의 매퍼 파일만 등록하여 사용하는 것을 권장 -->
<!-- <mapper resource="xyz/itwill/mapper/MyMemberMapper.xml"/> -->
<!-- package : 특정 패키지에 작성된 모든 Interface 기반의 매퍼 파일을 매퍼로 자동
등록하기 위한 엘리먼트 -->
<!-- name 속성 : Interface 기반의 매퍼 파일이 작성된 패키지를 속성값으로 설정 -->
<package name="xyz.itwill.mapper"/>
</mappers>
</configuration>
main/webapp>member)
memberinputForm .jsp ( 실행문)
<%@page import="xyz.itwill.dao.MyMemberXMLDAO"%>
<%@page import="xyz.itwill.dto.MyMember"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
String id=request.getParameter("id");
MyMember member=MyMemberXMLDAO.getDAO().selectMember(id);
%>
<!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=UTF-8">
<title>MYBATIS</title>
<script type="text/javascript" src="http://code.jquery.com/jquery-1.12.4.min.js"></script>
<script type="text/javascript">
$(document).ready(function() {
$("#id").focus();
$("#submitBtn").click(function() {
if($("#name").val()=="") {
alert("이름을 입력해 주세요");
$("#name").focus();
return;
}
if($("#phone").val()=="") {
alert("전화번호를 입력해 주세요");
$("#phone").focus();
return;
}
if($("#email").val()=="") {
alert("이메일을 입력해 주세요");
$("#email").focus();
return;
}
$("#input").attr("method","POST").attr("action"
,"memberUpdateAction.jsp").submit();
});
$("#resetBtn").click(function() {
$("#input").each(function() {
this.reset();
});
$("#id").focus();
});
$("#displayBtn").click(function() {
location.href="memberDisplay.jsp";
});
});
</script>
</head>
<body>
<h1 align="center">회원변경</h1>
<form id="input">
<input type="hidden" name="id" value="<%=member.getId()%>">
<table align="center" border="1" cellspacing="0" width="300">
<tr>
<th width="100">아이디</th>
<td align="center" width="200">
<%=member.getId()%>
</td>
</tr>
<tr>
<th width="100">이름</th>
<td align="center" width="200">
<input type="text" name="name" id="name" value="<%=member.getName()%>">
</td>
</tr>
<tr>
<th width="100">전화번호</th>
<td align="center" width="200">
<input type="text" name="phone" id="phone" value="<%=member.getPhone()%>">
</td>
</tr>
<tr>
<th width="100">이메일</th>
<td align="center" width="200">
<input type="text" name="email" id="email" value="<%=member.getEmail()%>">
</td>
</tr>
<tr>
<th colspan="2">
<button type="button" id="submitBtn">변경전송</button>
<button type="button" id="resetBtn">다시입력</button>
<button type="button" id="displayBtn">회원정보</button>
</th>
</tr>
</table>
</form>
</body>
</html>
