Notice
Recent Posts
Recent Comments
Link
| 일 | 월 | 화 | 수 | 목 | 금 | 토 |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | 5 | 6 | |
| 7 | 8 | 9 | 10 | 11 | 12 | 13 |
| 14 | 15 | 16 | 17 | 18 | 19 | 20 |
| 21 | 22 | 23 | 24 | 25 | 26 | 27 |
| 28 | 29 | 30 | 31 |
Tags
- EnhancedFor
- 생성자오버로드
- 컬렉션 타입
- abstract
- 추상메서드
- 예외미루기
- 어윈 사용법
- 환경설정
- 메소드오버로딩
- 자동차수리시스템
- 자바
- exception
- 객체 비교
- cursor문
- 오라클
- NestedFor
- 인터페이스
- oracle
- 제네릭
- 한국건설관리시스템
- 정수형타입
- 대덕인재개발원
- 사용자예외클래스생성
- 참조형변수
- Java
- 예외처리
- 컬렉션프레임워크
- 집합_SET
- GRANT VIEW
- 다형성
Archives
- Today
- Total
거니의 velog
230921_MyBatis 2 본문
[lprod-mapper.xml]
<?xml version="1.0" encoding="UTF-8"?>
<!-- 이 문서는 MyBatis에서 처리할 SQL문을 작성하는 문서입니다. -->
<!DOCTYPE mapper
PUBLIC "-//mybatis.org/DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
<mapper> 태그의 namespace 속성값은 이 문서에 작성된 SQL문을 호출할 때
같이 사용되는 이름이다.
-->
<mapper namespace="lprod">
<!--
이 <mapper>태그 영역 안에는 처리할 SQL문에 맞는 태그를 사용해서 SQL문을 작성한다.
* 사용할 수 있는 태그들...
<select> select 구문 ~~~ </select>
<insert> insert 구문 ~~~ </insert>
<update> update 구문 ~~~ </update>
<delete> delete 구문 ~~~ </delete>
등...
-->
<!--
* id속성 ==> 실행할 SQL문이 작성된 태그를 Java소스에서 호출할 때 사용되는 이름으로
위의 <mapper> 태그의 namespace 속성값과 연결해서 사용한다.
예) "lprod.insertLprod"
* parameterType 속성 ==> 작성된 SQL문에 사용될 데이터가 들어있는 객체정보를 기술한다.
(보통 VO클래스, Java의 기본 자료형 이름, Map객체 등이 사용된다.)
(VO클래스 등을 기술할 때는 해당 클래스의 패키지명을 포함한 전체 이름을 기술해야 한다.)
(이 속성에는 <typeAlias>태그에서 지정한 'alias속성값'을 사용할 수 있다.)
-->
<!-- <insert id="insertLprod" parameterType="kr.or.ddit.vo.LprodVO"> -->
<insert id="insertLprod" parameterType="lprodVo">
insert into lprod (lprod_id, lprod_gu, lprod_nm)
values (#{lprod_id}, #{lprod_gu}, #{lprod_nm})
</insert>
<update id="updateLprod" parameterType="lprodVo">
update lprod set lprod_id = #{lprod_id}, lprod_nm = #{lprod_nm}
where lprod_gu = #{lprod_gu}
</update>
</mapper>[LprodMybatisTest.java]
package kr.or.ddit.basic;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
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 kr.or.ddit.vo.LprodVO;
// MyBatis를 이용하여 DB자료를 처리하는 순서 및 방법
public class LprodMybatisTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 1. MyBatis의 환경 설정 파일(mybatis-config.xml)을 읽어와서 처리하여
// SqlSessionFactory객체를 생성한다.
InputStream in = null;
SqlSessionFactory sqlSessionFactory = null;
try {
// 1-1. 환경 설정 파일을 읽어올 스트림 객체 생성
in = Resources.getResourceAsStream("kr/or/ddit/mybatis/config/mybatis-config.xml");
// 1-2. 환경 설정 파일을 읽어와 환경 설정을 완성한 후 SqlSessionFactory객체를 생성한다.
sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
} catch (Exception e) {
System.out.println("MyBatis 초기화 실패!!!");
e.printStackTrace();
} finally {
if(in != null) try { in.close(); } catch (IOException e) {}
}
//--------------------------------------------------------------------------
// 2. Mapper에 등록된 SQL문들 중에 실행할 SQL문을 호출해서 원하는 작업을 수행한다.
/*
// 2-1. insert 연습
System.out.println("insert 작업 시작...");
System.out.print("LPROD_ID 입력 >> ");
int lprodId = scan.nextInt();
System.out.print("LPROD_GU 입력 >> ");
String lprodGu = scan.next();
System.out.print("LPROD_NM 입력 >> ");
String lprodNm = scan.next();
// 1) 저장할 데이터들을 VO객체에 저장한다.
LprodVO lprodVo = new LprodVO();
lprodVo.setLprod_id(lprodId);
lprodVo.setLprod_gu(lprodGu);
lprodVo.setLprod_nm(lprodNm);
SqlSession session = null;
try {
// 2) SqlSessionFactory객체의 openSession()메서드를 이용하여
// SQL문을 호출해서 실행할 수 있는 SqlSession객체를 생성한다.
// 형식) SqlSessionFactory객체.openSession(논리값)
// '논리값'이 true이면 AutoCommit이 활성화된 상태이고
// '논리값'이 false이거나 생략되면 AutoCommit이 비활성화된 상태이다.
session = sqlSessionFactory.openSession();
// 3) SqlSession객체를 이용하여 처리할 SQL문을 호출하여 실행한다.
// 형식) SqlSession객체.insert("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 작업에 성공한 레코드수
int insertCnt = session.insert("lprod.insertLprod", lprodVo);
if(insertCnt > 0) {
// 4) SqlSession객체를 생성할 때 AutoCommit이 비활성화된 상태일 때는
// commit을 직접 실행해야 한다.
session.commit();
System.out.println("insert 작업 성공!!!");
}else {
System.out.println("insert 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5) 작업이 끝나면 SqlSession객체를 닫아준다.
if(session != null) session.close();
}
*/
// 2-2 update 연습
System.out.println("update 연습 시작...");
System.out.print("수정할 LPROD_GU 입력 >> ");
String lprodGu2 = scan.next();
System.out.print("새로운 LPROD_ID 입력 >> ");
int newLprodId = scan.nextInt();
System.out.print("새로운 LPROD_NM 입력 >> ");
String newLprodNm = scan.next();
// 수정할 데이터를 VO 객체에 저장한다.
LprodVO lprodVo2 = new LprodVO();
lprodVo2.setLprod_gu(lprodGu2);
lprodVo2.setLprod_id(newLprodId);
lprodVo2.setLprod_nm(newLprodNm);
SqlSession session = null;
try {
// SqlSession객체 생성
session = sqlSessionFactory.openSession();
// SQL문 호출해서 실행하기
// 형식) SqlSession.update("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 실행에 성공한 레코드 수
int updateCnt = session.update("lprod.updateLprod", lprodVo2);
if(updateCnt > 0) {
session.commit();
System.out.println("update 작업 성공!!!");
}else {
System.out.println("update 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
}
}
[lprod-mapper.xml]
<?xml version="1.0" encoding="UTF-8"?>
<!-- 이 문서는 MyBatis에서 처리할 SQL문을 작성하는 문서입니다. -->
<!DOCTYPE mapper
PUBLIC "-//mybatis.org/DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
<mapper> 태그의 namespace 속성값은 이 문서에 작성된 SQL문을 호출할 때
같이 사용되는 이름이다.
-->
<mapper namespace="lprod">
<!--
이 <mapper>태그 영역 안에는 처리할 SQL문에 맞는 태그를 사용해서 SQL문을 작성한다.
* 사용할 수 있는 태그들...
<select> select 구문 ~~~ </select>
<insert> insert 구문 ~~~ </insert>
<update> update 구문 ~~~ </update>
<delete> delete 구문 ~~~ </delete>
등...
-->
<!--
* id속성 ==> 실행할 SQL문이 작성된 태그를 Java소스에서 호출할 때 사용되는 이름으로
위의 <mapper> 태그의 namespace 속성값과 연결해서 사용한다.
예) "lprod.insertLprod"
* parameterType 속성 ==> 작성된 SQL문에 사용될 데이터가 들어있는 객체정보를 기술한다.
(보통 VO클래스, Java의 기본 자료형 이름, Map객체 등이 사용된다.)
(VO클래스 등을 기술할 때는 해당 클래스의 패키지명을 포함한 전체 이름을 기술해야 한다.)
(이 속성에는 <typeAlias>태그에서 지정한 'alias속성값'을 사용할 수 있다.)
-->
<!-- <insert id="insertLprod" parameterType="kr.or.ddit.vo.LprodVO"> -->
<insert id="insertLprod" parameterType="lprodVo">
insert into lprod (lprod_id, lprod_gu, lprod_nm)
values (#{lprod_id}, #{lprod_gu}, #{lprod_nm})
</insert>
<update id="updateLprod" parameterType="lprodVo">
update lprod set lprod_id = #{lprod_id}, lprod_nm = #{lprod_nm}
where lprod_gu = #{lprod_gu}
</update>
<!--
parameterType 속성에 설정되는 값이 단일 값이면 SQL문이 이 값을 나타내는 변수는
특별히 정해지지 않는다. (즉, 사용자가 임의로 지정할 수 있다.)
-->
<delete id="deleteLprod" parameterType="String">
<!-- delete from lprod where lprod_gu = #{lprod_gu} -->
delete from lprod where lprod_gu = #{ssss}
</delete>
</mapper>[LprodMybatisTest.java]
package kr.or.ddit.basic;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
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 kr.or.ddit.vo.LprodVO;
// MyBatis를 이용하여 DB자료를 처리하는 순서 및 방법
public class LprodMybatisTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 1. MyBatis의 환경 설정 파일(mybatis-config.xml)을 읽어와서 처리하여
// SqlSessionFactory객체를 생성한다.
InputStream in = null;
SqlSessionFactory sqlSessionFactory = null;
try {
// 1-1. 환경 설정 파일을 읽어올 스트림 객체 생성
in = Resources.getResourceAsStream("kr/or/ddit/mybatis/config/mybatis-config.xml");
// 1-2. 환경 설정 파일을 읽어와 환경 설정을 완성한 후 SqlSessionFactory객체를 생성한다.
sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
} catch (Exception e) {
System.out.println("MyBatis 초기화 실패!!!");
e.printStackTrace();
} finally {
if(in != null) try { in.close(); } catch (IOException e) {}
}
//--------------------------------------------------------------------------
// 2. Mapper에 등록된 SQL문들 중에 실행할 SQL문을 호출해서 원하는 작업을 수행한다.
/*
// 2-1. insert 연습
System.out.println("insert 작업 시작...");
System.out.print("LPROD_ID 입력 >> ");
int lprodId = scan.nextInt();
System.out.print("LPROD_GU 입력 >> ");
String lprodGu = scan.next();
System.out.print("LPROD_NM 입력 >> ");
String lprodNm = scan.next();
// 1) 저장할 데이터들을 VO객체에 저장한다.
LprodVO lprodVo = new LprodVO();
lprodVo.setLprod_id(lprodId);
lprodVo.setLprod_gu(lprodGu);
lprodVo.setLprod_nm(lprodNm);
SqlSession session = null;
try {
// 2) SqlSessionFactory객체의 openSession()메서드를 이용하여
// SQL문을 호출해서 실행할 수 있는 SqlSession객체를 생성한다.
// 형식) SqlSessionFactory객체.openSession(논리값)
// '논리값'이 true이면 AutoCommit이 활성화된 상태이고
// '논리값'이 false이거나 생략되면 AutoCommit이 비활성화된 상태이다.
session = sqlSessionFactory.openSession();
// 3) SqlSession객체를 이용하여 처리할 SQL문을 호출하여 실행한다.
// 형식) SqlSession객체.insert("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 작업에 성공한 레코드수
int insertCnt = session.insert("lprod.insertLprod", lprodVo);
if(insertCnt > 0) {
// 4) SqlSession객체를 생성할 때 AutoCommit이 비활성화된 상태일 때는
// commit을 직접 실행해야 한다.
session.commit();
System.out.println("insert 작업 성공!!!");
}else {
System.out.println("insert 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5) 작업이 끝나면 SqlSession객체를 닫아준다.
if(session != null) session.close();
}
*/
/*
// 2-2 update 연습
System.out.println("update 연습 시작...");
System.out.print("수정할 LPROD_GU 입력 >> ");
String lprodGu2 = scan.next();
System.out.print("새로운 LPROD_ID 입력 >> ");
int newLprodId = scan.nextInt();
System.out.print("새로운 LPROD_NM 입력 >> ");
String newLprodNm = scan.next();
// 수정할 데이터를 VO 객체에 저장한다.
LprodVO lprodVo2 = new LprodVO();
lprodVo2.setLprod_gu(lprodGu2);
lprodVo2.setLprod_id(newLprodId);
lprodVo2.setLprod_nm(newLprodNm);
SqlSession session = null;
try {
// SqlSession객체 생성
session = sqlSessionFactory.openSession();
// SQL문 호출해서 실행하기
// 형식) SqlSession.update("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 실행에 성공한 레코드 수
int updateCnt = session.update("lprod.updateLprod", lprodVo2);
if(updateCnt > 0) {
session.commit();
System.out.println("update 작업 성공!!!");
}else {
System.out.println("update 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
*/
// 2-3 delete 연습
System.out.println("delete 연습 시작...");
System.out.print("삭제할 LPROD_GU 입력 >> ");
String lprodGu3 = scan.next();
SqlSession session = null;
try {
// SqlSession객체 생성
session = sqlSessionFactory.openSession();
// SQL문을 호출하여 실행하기
// 형식) SqlSession.delete("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 실행에 성공한 레코드 수
int deleteCnt = session.delete("lprod.deleteLprod", lprodGu3);
if(deleteCnt > 0) {
session.commit();
System.out.println("delete 작업 성공!!!");
}else {
System.out.println("delete 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
}
}
[lprod-mapper.xml]
<?xml version="1.0" encoding="UTF-8"?>
<!-- 이 문서는 MyBatis에서 처리할 SQL문을 작성하는 문서입니다. -->
<!DOCTYPE mapper
PUBLIC "-//mybatis.org/DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
<mapper> 태그의 namespace 속성값은 이 문서에 작성된 SQL문을 호출할 때
같이 사용되는 이름이다.
-->
<mapper namespace="lprod">
<!--
이 <mapper>태그 영역 안에는 처리할 SQL문에 맞는 태그를 사용해서 SQL문을 작성한다.
* 사용할 수 있는 태그들...
<select> select 구문 ~~~ </select>
<insert> insert 구문 ~~~ </insert>
<update> update 구문 ~~~ </update>
<delete> delete 구문 ~~~ </delete>
등...
-->
<!--
* id속성 ==> 실행할 SQL문이 작성된 태그를 Java소스에서 호출할 때 사용되는 이름으로
위의 <mapper> 태그의 namespace 속성값과 연결해서 사용한다.
예) "lprod.insertLprod"
* parameterType 속성 ==> 작성된 SQL문에 사용될 데이터가 들어있는 객체정보를 기술한다.
(보통 VO클래스, Java의 기본 자료형 이름, Map객체 등이 사용된다.)
(VO클래스 등을 기술할 때는 해당 클래스의 패키지명을 포함한 전체 이름을 기술해야 한다.)
(이 속성에는 <typeAlias>태그에서 지정한 'alias속성값'을 사용할 수 있다.)
-->
<!-- <insert id="insertLprod" parameterType="kr.or.ddit.vo.LprodVO"> -->
<insert id="insertLprod" parameterType="lprodVo">
insert into lprod (lprod_id, lprod_gu, lprod_nm)
values (#{lprod_id}, #{lprod_gu}, #{lprod_nm})
</insert>
<update id="updateLprod" parameterType="lprodVo">
update lprod set lprod_id = #{lprod_id}, lprod_nm = #{lprod_nm}
where lprod_gu = #{lprod_gu}
</update>
<!--
parameterType 속성에 설정되는 값이 단일 값이면 SQL문이 이 값을 나타내는 변수는
특별히 정해지지 않는다. (즉, 사용자가 임의로 지정할 수 있다.)
-->
<delete id="deleteLprod" parameterType="String">
<!-- delete from lprod where lprod_gu = #{lprod_gu} -->
delete from lprod where lprod_gu = #{ssss}
</delete>
<!--
resultType 속성 ==> select문을 처리한 결과를 저장할 VO클래스나 java의 기본자료형,
Map객체를 지정할 수 있다.
* select문을 처리한 결과가 여러개의 레코드이면 java에서 'selectList()'메서드를 이용하여
호출한다. 그러면 검색된 데이터들을 자동으로 List에 담아서 반환한다.
그래서 결과가 여러개 일 경우에도 resultType속성에는 1개의 레코드가 저장될 클래스나
자료형 이름을 지정하면 된다.
-->
<select id="getAllLprod" resultType="lprodVo">
select * from lprod
</select>
</mapper>[LprodMybatisTest.java]
package kr.or.ddit.basic;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Scanner;
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 kr.or.ddit.vo.LprodVO;
// MyBatis를 이용하여 DB자료를 처리하는 순서 및 방법
public class LprodMybatisTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 1. MyBatis의 환경 설정 파일(mybatis-config.xml)을 읽어와서 처리하여
// SqlSessionFactory객체를 생성한다.
InputStream in = null;
SqlSessionFactory sqlSessionFactory = null;
try {
// 1-1. 환경 설정 파일을 읽어올 스트림 객체 생성
in = Resources.getResourceAsStream("kr/or/ddit/mybatis/config/mybatis-config.xml");
// 1-2. 환경 설정 파일을 읽어와 환경 설정을 완성한 후 SqlSessionFactory객체를 생성한다.
sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
} catch (Exception e) {
System.out.println("MyBatis 초기화 실패!!!");
e.printStackTrace();
} finally {
if(in != null) try { in.close(); } catch (IOException e) {}
}
//--------------------------------------------------------------------------
// 2. Mapper에 등록된 SQL문들 중에 실행할 SQL문을 호출해서 원하는 작업을 수행한다.
/*
// 2-1. insert 연습
System.out.println("insert 작업 시작...");
System.out.print("LPROD_ID 입력 >> ");
int lprodId = scan.nextInt();
System.out.print("LPROD_GU 입력 >> ");
String lprodGu = scan.next();
System.out.print("LPROD_NM 입력 >> ");
String lprodNm = scan.next();
// 1) 저장할 데이터들을 VO객체에 저장한다.
LprodVO lprodVo = new LprodVO();
lprodVo.setLprod_id(lprodId);
lprodVo.setLprod_gu(lprodGu);
lprodVo.setLprod_nm(lprodNm);
SqlSession session = null;
try {
// 2) SqlSessionFactory객체의 openSession()메서드를 이용하여
// SQL문을 호출해서 실행할 수 있는 SqlSession객체를 생성한다.
// 형식) SqlSessionFactory객체.openSession(논리값)
// '논리값'이 true이면 AutoCommit이 활성화된 상태이고
// '논리값'이 false이거나 생략되면 AutoCommit이 비활성화된 상태이다.
session = sqlSessionFactory.openSession();
// 3) SqlSession객체를 이용하여 처리할 SQL문을 호출하여 실행한다.
// 형식) SqlSession객체.insert("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 작업에 성공한 레코드수
int insertCnt = session.insert("lprod.insertLprod", lprodVo);
if(insertCnt > 0) {
// 4) SqlSession객체를 생성할 때 AutoCommit이 비활성화된 상태일 때는
// commit을 직접 실행해야 한다.
session.commit();
System.out.println("insert 작업 성공!!!");
}else {
System.out.println("insert 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5) 작업이 끝나면 SqlSession객체를 닫아준다.
if(session != null) session.close();
}
*/
/*
// 2-2 update 연습
System.out.println("update 연습 시작...");
System.out.print("수정할 LPROD_GU 입력 >> ");
String lprodGu2 = scan.next();
System.out.print("새로운 LPROD_ID 입력 >> ");
int newLprodId = scan.nextInt();
System.out.print("새로운 LPROD_NM 입력 >> ");
String newLprodNm = scan.next();
// 수정할 데이터를 VO 객체에 저장한다.
LprodVO lprodVo2 = new LprodVO();
lprodVo2.setLprod_gu(lprodGu2);
lprodVo2.setLprod_id(newLprodId);
lprodVo2.setLprod_nm(newLprodNm);
SqlSession session = null;
try {
// SqlSession객체 생성
session = sqlSessionFactory.openSession();
// SQL문 호출해서 실행하기
// 형식) SqlSession.update("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 실행에 성공한 레코드 수
int updateCnt = session.update("lprod.updateLprod", lprodVo2);
if(updateCnt > 0) {
session.commit();
System.out.println("update 작업 성공!!!");
}else {
System.out.println("update 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
*/
/*
// 2-3 delete 연습
System.out.println("delete 연습 시작...");
System.out.print("삭제할 LPROD_GU 입력 >> ");
String lprodGu3 = scan.next();
SqlSession session = null;
try {
// SqlSession객체 생성
session = sqlSessionFactory.openSession();
// SQL문을 호출하여 실행하기
// 형식) SqlSession.delete("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 실행에 성공한 레코드 수
int deleteCnt = session.delete("lprod.deleteLprod", lprodGu3);
if(deleteCnt > 0) {
session.commit();
System.out.println("delete 작업 성공!!!");
}else {
System.out.println("delete 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
*/
// 2-4. select 연습
// 1) select한 결과가 여러 개의 레코드일 경우
System.out.println("select 작업 시작 -- 결과가 여러개의 레코드일 경우...");
SqlSession session = null;
try {
// SqlSession객체 생성
session = sqlSessionFactory.openSession();
// SQL문을 호출해서 실행한다.
// 실행할 select문의 검색 결과가 여러개일 경우에는 selectList()메서드를 사용하는데
// 이 메서드는 검색된 레코드 각각을 VO객체에 저장한 후 이 VO객체들을 List에 추가해
// 주는 작업을 자동으로 수행한다.
// 형식) SqlSession객체.selectList("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 검색된 데이터들이 저장된 List객체
List<LprodVO> lprodList = session.selectList("lprod.getAllLprod");
System.out.println("== 검색 결과 출력 ==");
for(LprodVO lvo : lprodList) {
System.out.println("LPROD_ID : " + lvo.getLprod_id());
System.out.println("LPROD_GU : " + lvo.getLprod_gu());
System.out.println("LPROD_NM : " + lvo.getLprod_nm());
System.out.println("-------------------------------");
}
System.out.println("출력 끝...");
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
}
}
[lprod-mapper.xml]
<?xml version="1.0" encoding="UTF-8"?>
<!-- 이 문서는 MyBatis에서 처리할 SQL문을 작성하는 문서입니다. -->
<!DOCTYPE mapper
PUBLIC "-//mybatis.org/DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
<mapper> 태그의 namespace 속성값은 이 문서에 작성된 SQL문을 호출할 때
같이 사용되는 이름이다.
-->
<mapper namespace="lprod">
<!--
이 <mapper>태그 영역 안에는 처리할 SQL문에 맞는 태그를 사용해서 SQL문을 작성한다.
* 사용할 수 있는 태그들...
<select> select 구문 ~~~ </select>
<insert> insert 구문 ~~~ </insert>
<update> update 구문 ~~~ </update>
<delete> delete 구문 ~~~ </delete>
등...
-->
<!--
* id속성 ==> 실행할 SQL문이 작성된 태그를 Java소스에서 호출할 때 사용되는 이름으로
위의 <mapper> 태그의 namespace 속성값과 연결해서 사용한다.
예) "lprod.insertLprod"
* parameterType 속성 ==> 작성된 SQL문에 사용될 데이터가 들어있는 객체정보를 기술한다.
(보통 VO클래스, Java의 기본 자료형 이름, Map객체 등이 사용된다.)
(VO클래스 등을 기술할 때는 해당 클래스의 패키지명을 포함한 전체 이름을 기술해야 한다.)
(이 속성에는 <typeAlias>태그에서 지정한 'alias속성값'을 사용할 수 있다.)
-->
<!-- <insert id="insertLprod" parameterType="kr.or.ddit.vo.LprodVO"> -->
<insert id="insertLprod" parameterType="lprodVo">
insert into lprod (lprod_id, lprod_gu, lprod_nm)
values (#{lprod_id}, #{lprod_gu}, #{lprod_nm})
</insert>
<update id="updateLprod" parameterType="lprodVo">
update lprod set lprod_id = #{lprod_id}, lprod_nm = #{lprod_nm}
where lprod_gu = #{lprod_gu}
</update>
<!--
parameterType 속성에 설정되는 값이 단일 값이면 SQL문이 이 값을 나타내는 변수는
특별히 정해지지 않는다. (즉, 사용자가 임의로 지정할 수 있다.)
-->
<delete id="deleteLprod" parameterType="String">
<!-- delete from lprod where lprod_gu = #{lprod_gu} -->
delete from lprod where lprod_gu = #{ssss}
</delete>
<!--
resultType 속성 ==> select문을 처리한 결과를 저장할 VO클래스나 java의 기본자료형,
Map객체를 지정할 수 있다.
* select문을 처리한 결과가 여러개의 레코드이면 java에서 'selectList()'메서드를 이용하여
호출한다. 그러면 검색된 데이터들을 자동으로 List에 담아서 반환한다.
그래서 결과가 여러개 일 경우에도 resultType속성에는 1개의 레코드가 저장될 클래스나
자료형 이름을 지정하면 된다.
-->
<select id="getAllLprod" resultType="lprodVo">
select * from lprod
</select>
<select id="getLprod" parameterType="String" resultType="lprodVo">
select * from lprod where lprod_gu = #{lprod_gu}
</select>
</mapper>[LprodMybatisTest.java]
package kr.or.ddit.basic;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Scanner;
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 kr.or.ddit.vo.LprodVO;
// MyBatis를 이용하여 DB자료를 처리하는 순서 및 방법
public class LprodMybatisTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 1. MyBatis의 환경 설정 파일(mybatis-config.xml)을 읽어와서 처리하여
// SqlSessionFactory객체를 생성한다.
InputStream in = null;
SqlSessionFactory sqlSessionFactory = null;
try {
// 1-1. 환경 설정 파일을 읽어올 스트림 객체 생성
in = Resources.getResourceAsStream("kr/or/ddit/mybatis/config/mybatis-config.xml");
// 1-2. 환경 설정 파일을 읽어와 환경 설정을 완성한 후 SqlSessionFactory객체를 생성한다.
sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
} catch (Exception e) {
System.out.println("MyBatis 초기화 실패!!!");
e.printStackTrace();
} finally {
if(in != null) try { in.close(); } catch (IOException e) {}
}
//--------------------------------------------------------------------------
// 2. Mapper에 등록된 SQL문들 중에 실행할 SQL문을 호출해서 원하는 작업을 수행한다.
/*
// 2-1. insert 연습
System.out.println("insert 작업 시작...");
System.out.print("LPROD_ID 입력 >> ");
int lprodId = scan.nextInt();
System.out.print("LPROD_GU 입력 >> ");
String lprodGu = scan.next();
System.out.print("LPROD_NM 입력 >> ");
String lprodNm = scan.next();
// 1) 저장할 데이터들을 VO객체에 저장한다.
LprodVO lprodVo = new LprodVO();
lprodVo.setLprod_id(lprodId);
lprodVo.setLprod_gu(lprodGu);
lprodVo.setLprod_nm(lprodNm);
SqlSession session = null;
try {
// 2) SqlSessionFactory객체의 openSession()메서드를 이용하여
// SQL문을 호출해서 실행할 수 있는 SqlSession객체를 생성한다.
// 형식) SqlSessionFactory객체.openSession(논리값)
// '논리값'이 true이면 AutoCommit이 활성화된 상태이고
// '논리값'이 false이거나 생략되면 AutoCommit이 비활성화된 상태이다.
session = sqlSessionFactory.openSession();
// 3) SqlSession객체를 이용하여 처리할 SQL문을 호출하여 실행한다.
// 형식) SqlSession객체.insert("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 작업에 성공한 레코드수
int insertCnt = session.insert("lprod.insertLprod", lprodVo);
if(insertCnt > 0) {
// 4) SqlSession객체를 생성할 때 AutoCommit이 비활성화된 상태일 때는
// commit을 직접 실행해야 한다.
session.commit();
System.out.println("insert 작업 성공!!!");
}else {
System.out.println("insert 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5) 작업이 끝나면 SqlSession객체를 닫아준다.
if(session != null) session.close();
}
*/
/*
// 2-2 update 연습
System.out.println("update 연습 시작...");
System.out.print("수정할 LPROD_GU 입력 >> ");
String lprodGu2 = scan.next();
System.out.print("새로운 LPROD_ID 입력 >> ");
int newLprodId = scan.nextInt();
System.out.print("새로운 LPROD_NM 입력 >> ");
String newLprodNm = scan.next();
// 수정할 데이터를 VO 객체에 저장한다.
LprodVO lprodVo2 = new LprodVO();
lprodVo2.setLprod_gu(lprodGu2);
lprodVo2.setLprod_id(newLprodId);
lprodVo2.setLprod_nm(newLprodNm);
SqlSession session = null;
try {
// SqlSession객체 생성
session = sqlSessionFactory.openSession();
// SQL문 호출해서 실행하기
// 형식) SqlSession.update("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 실행에 성공한 레코드 수
int updateCnt = session.update("lprod.updateLprod", lprodVo2);
if(updateCnt > 0) {
session.commit();
System.out.println("update 작업 성공!!!");
}else {
System.out.println("update 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
*/
/*
// 2-3 delete 연습
System.out.println("delete 연습 시작...");
System.out.print("삭제할 LPROD_GU 입력 >> ");
String lprodGu3 = scan.next();
SqlSession session = null;
try {
// SqlSession객체 생성
session = sqlSessionFactory.openSession();
// SQL문을 호출하여 실행하기
// 형식) SqlSession.delete("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 실행에 성공한 레코드 수
int deleteCnt = session.delete("lprod.deleteLprod", lprodGu3);
if(deleteCnt > 0) {
session.commit();
System.out.println("delete 작업 성공!!!");
}else {
System.out.println("delete 작업 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
*/
/*
// 2-4. select 연습
// 1) select한 결과가 여러 개의 레코드일 경우
System.out.println("select 작업 시작 -- 결과가 여러개의 레코드일 경우...");
SqlSession session = null;
try {
// SqlSession객체 생성
session = sqlSessionFactory.openSession();
// SQL문을 호출해서 실행한다.
// 실행할 select문의 검색 결과가 여러개일 경우에는 selectList()메서드를 사용하는데
// 이 메서드는 검색된 레코드 각각을 VO객체에 저장한 후 이 VO객체들을 List에 추가해
// 주는 작업을 자동으로 수행한다.
// 형식) SqlSession객체.selectList("namespace속성값.실행할태그의id속성값", 파라미터클래스);
// 반환값 : 검색된 데이터들이 저장된 List객체
List<LprodVO> lprodList = session.selectList("lprod.getAllLprod");
System.out.println("== 검색 결과 출력 ==");
for(LprodVO lvo : lprodList) {
System.out.println("LPROD_ID : " + lvo.getLprod_id());
System.out.println("LPROD_GU : " + lvo.getLprod_gu());
System.out.println("LPROD_NM : " + lvo.getLprod_nm());
System.out.println("-------------------------------");
}
System.out.println("출력 끝...");
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
*/
// 2) select한 결과가 한 개의 레코드일 경우
System.out.println("select 작업 시작 -- 결과가 한 개의 레코드일 경우...");
System.out.print("검색할 LPROD_GU 입력 >> ");
String lprodGu4 = scan.next();
SqlSession session = null;
try {
// SqlSession객체 생성
session = sqlSessionFactory.openSession();
// SQL문을 호출해서 실행한다.
// select한 검색 결과가 한 개의 레코드일 경우에는 'selectOne()'메서드를 사용한다.
// 'selectOne()'메서드는 검색된 결과가 없으면 'null값'을 반환한다.
// 형식) SqlSession객체.selectOne("namespace속성값.실행할태그의id속성값", 파라미터클래스);
LprodVO lprodVo3 = session.selectOne("lprod.getLprod", lprodGu4);
if(lprodVo3 == null) {
System.out.println("검색된 데이터가 하나도 없습니다...");
return;
}
System.out.println(" == 검색 결과 ==");
System.out.println("LPROD_ID : " + lprodVo3.getLprod_id());
System.out.println("LPROD_GU : " + lprodVo3.getLprod_gu());
System.out.println("LPROD_NM : " + lprodVo3.getLprod_nm());
System.out.println("-------------------------------");
System.out.println("출력 끝...");
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
}
}
[jdbc-mapper.xml]
<?xml version="1.0" encoding="UTF-8"?>
<!-- 이 문서는 MyBatis에서 처리할 SQL문을 작성하는 문서입니다. -->
<!DOCTYPE mapper
PUBLIC "-//mybatis.org/DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="jdbc">
<select id="getMaxId" resultType="int">
select nvl(max(lprod_id), 0) as maxid from lprod
</select>
<select id="getLprodguCnt" parameterType="String" resultType="int">
select count(*) as cnt from lprod where lprod_gu = #{lprod_gu}
</select>
<insert id="insertLprod" parameterType="lprodVo">
insert into lprod (lprod_id, lprod_gu, lprod_nm)
values (#{lprod_id}, #{lprod_gu}, #{lprod_nm})
</insert>
</mapper>[mybatis-config.xml]
<?xml version="1.0" encoding="UTF-8"?>
<!-- 이 문서는 MyBatis의 환경 설정을 구성하는 문서입니다. -->
<!DOCTYPE configuration
PUBLIC "-//mybatis.org/DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- DB연결 정보가 저장된 properties파일에 대한 정보를 설정한다. -->
<properties resource="kr/or/ddit/mybatis/config/dbinfo.properties" />
<!-- MyBatis 설정과 관련된 기본 setting 설정 -->
<settings>
<!-- 데이터가 null로 전달되었으면 빈칸으로 인식하지 말고 null로 인식하라 -->
<setting name="jdbcTypeForNull" value="NULL" />
</settings>
<!--
MyBatis에서 파라미터로 사용하는 객체는 패키지명을 포함한 전체 이름을 지정해야 한다.
그렇게 되면 전체 이름이 너무 길어질 수 있어서 이것을 짧은 이름으로 사용하기 위한
별칭을 설정할 수 있다.
형식) <typeAlias type="패키지명이 포함된 전체 클래스명" alias="별칭이름" />
-->
<typeAliases>
<typeAlias type="kr.or.ddit.vo.LprodVO" alias="lprodVo" />
</typeAliases>
<!-- DB연결 설정 -->
<environments default="oracleDev">
<environment id="oracleDev">
<!-- 오라클 -->
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${driver}" />
<property name="url" value="${url}" />
<property name="username" value="${user}" />
<property name="password" value="${pass}" />
</dataSource>
</environment>
<!-- <environment id="m1">
MySql
</environment> -->
</environments>
<!-- DB에서 처리될 SQL문들이 작성된 mapper파일들을 등록하는 부분 -->
<!-- 형식) <mapper resource="경로명/파일명.xml" /> -->
<mappers>
<mapper resource="kr/or/ddit/mybatis/mappers/lprod-mapper.xml" />
<!-- jdbc-mapper.xml을 새롭게 등록해 줘야 한다. -->
<mapper resource="kr/or/ddit/mybatis/mappers/jdbc-mapper.xml" />
</mappers>
</configuration>[jdbcToMyBatisTest.java]
package kr.or.ddit.basic;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
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 kr.or.ddit.vo.LprodVO;
/*
* LPROD 테이블에 새로운 데이터를 추가한다.
*
* 조건) lprod_gu값과 lprod_nm값은 직접 입력 받아서 처리하고,
* lprod_id값은 현재의 lprod_id값 중에서 제일 큰 값보다 1 크게 한다.
* 입력 받은 lprod_gu값이 이미 등록되어 있으면 다시 입력 받아 처리한다.
*
* select * from lprod order by lprod_id
* select max(lprod_id) from lprod
* select count(*) from lprod where lprod_gu = 'P101' -- 반환값 : 1이면 있고, 0이면 없다.
* INSERT INTO lprod (lprod_id, lprod_gu, lprod_nm) VALUES ( ?, ?, ? )
*/
public class jdbcToMyBatisTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
InputStream in = null;
SqlSessionFactory sqlSessionFactory = null;
try {
// 1-1. 환경 설정 파일을 읽어올 스트림 객체 생성
in = Resources.getResourceAsStream("kr/or/ddit/mybatis/config/mybatis-config.xml");
// 1-2. 환경 설정 파일을 읽어와 환경 설정을 완성한 후 SqlSessionFactory객체를 생성한다.
sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
} catch (Exception e) {
System.out.println("MyBatis 초기화 실패!!!");
e.printStackTrace();
} finally {
if(in != null) try { in.close(); } catch (IOException e) {}
}
//---------------------------------------------------------------------------
SqlSession session = null;
try {
session = sqlSessionFactory.openSession();
// lprod_id값 구하기 ==> 현재의 lprod_id값 중 제일 큰 값보다 1 큰 값으로 한다.
int maxid = session.selectOne("jdbc.getMaxId");
maxid++; // 제일 큰 값 증가하기
//------------------------------------------------------------
// 입력 받은 lprod_gu값이 이미 등록되어 있으면 다시 입력 받아 처리한다.
String gu; // 상품 분류 코드가 저장될 변수 선언
int count = 0; // 검색한 상품 분류 코드의 개수가 저장될 변수 선언
do {
System.out.print("상품 분류 코드(LPROD_GU) 입력 >> ");
gu = scan.next();
count = session.selectOne("jdbc.getLprodguCnt", gu);
if(count > 0) {
System.out.println("입력한 상품 분류 코드 [" + gu + "] 은(는) 이미 등록된 코드입니다.");
System.out.println("다른 코드로 다시 입력하세요...");
System.out.println();
}
}while(count > 0);
//------------------------------------------------------------
System.out.print("상품 분류명(LPROD_NM) 입력 >> ");
String nm = scan.next();
//------------------------------------------------------------
// 구성된 insert할 데이터를 VO객체에 저장한다.
LprodVO lVo = new LprodVO();
lVo.setLprod_id(maxid);
lVo.setLprod_gu(gu);
lVo.setLprod_nm(nm);
int cnt = session.insert("jdbc.insertLprod", lVo);
if(cnt > 0) {
session.commit();
System.out.println("insert 성공!!!");
}else {
System.out.println("insert 실패~~~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
}
}
[MyBatisUtil.java]
package kr.or.ddit.util;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
public class MyBatisUtil {
private static SqlSessionFactory sqlSessionFactory;
static {
InputStream in = null;
try {
in = Resources.getResourceAsStream("kr/or/ddit/mybatis/config/mybatis-config.xml");
sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
} catch (Exception e) {
System.out.println("MyBatis 초기화 실패!!!");
e.printStackTrace();
} finally {
if(in != null) try { in.close(); } catch (IOException e) {}
}
} // static 초기화 블럭 끝...
// SqlSession객체를 생성하여 반환하는 메서드
public static SqlSession getSqlSession() {
SqlSession session = sqlSessionFactory.openSession();
return session;
}
}[jdbcToMyBatisTest.java]
SqlSession session = null;
try {
session = MyBatisUtil.getSqlSession(); // 이 부분을 수정...
// lprod_id값 구하기 ==> 현재의 lprod_id값 중 제일 큰 값보다 1 큰 값으로 한다.
int maxid = session.selectOne("jdbc.getMaxId");
maxid++; // 제일 큰 값 증가하기
//------------------------------------------------------------
[member-mapper.xml]
<?xml version="1.0" encoding="UTF-8"?>
<!-- 이 문서는 MyBatis에서 처리할 SQL문을 작성하는 문서입니다. -->
<!DOCTYPE mapper
PUBLIC "-//mybatis.org/DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="member">
<insert id="insertMember" parameterType="memVo">
insert into mymember (mem_id, mem_pass, mem_name, mem_tel, mem_addr)
values(#{mem_id}, #{mem_pass}, #{mem_name}, #{mem_tel}, #{mem_addr})
</insert>
<delete id="deleteMember" parameterType="String">
delete from mymember where mem_id = #{mem_id}
</delete>
<update id="updateMember" parameterType="memVo">
update mymember set
mem_pass = #{mem_pass}, mem_name = #{mem_name},
mem_tel = #{mem_tel}, mem_addr = #{mem_addr}
where mem_id = #{mem_id}
</update>
<select id="getAllMember" resultType="memVo">
select * from mymember
</select>
<select id="getMemIdCount" parameterType="String" resultType="int">
select count(*) as cnt from mymember where mem_id = #{mem_id}
</select>
<!--
map을 파라미터로 받아서 SQL문에 적용할 때는 Map의 key값으로 지정한다.
그러면 해당 key와 같이 저장된 value값이 SQL문에 적용된다.
-->
<!--
파라미터로 가져온 값을 컬럼명이나 테이블명과 같은 자리에 사용할 경우에는
달러($)기호를 사용해서 나타낸다.
예) ${변수명} 또는 ${key값}
-->
<!-- key값 정보 : 회원ID(memid), 수정할컬럼명(field), 수정할데이터(data) -->
<update id="updateMember2" parameterType="map">
update mymember set ${field} = #{data}
where mem_id = #{memid}
</update>
</mapper>[mybatis-config.xml]
<?xml version="1.0" encoding="UTF-8"?>
<!-- 이 문서는 MyBatis의 환경 설정을 구성하는 문서입니다. -->
<!DOCTYPE configuration
PUBLIC "-//mybatis.org/DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- DB연결 정보가 저장된 properties파일에 대한 정보를 설정한다. -->
<properties resource="kr/or/ddit/mybatis/config/dbinfo.properties" />
<!-- MyBatis 설정과 관련된 기본 setting 설정 -->
<settings>
<!-- 데이터가 null로 전달되었으면 빈칸으로 인식하지 말고 null로 인식하라 -->
<setting name="jdbcTypeForNull" value="NULL" />
</settings>
<!--
MyBatis에서 파라미터로 사용하는 객체는 패키지명을 포함한 전체 이름을 지정해야 한다.
그렇게 되면 전체 이름이 너무 길어질 수 있어서 이것을 짧은 이름으로 사용하기 위한
별칭을 설정할 수 있다.
형식) <typeAlias type="패키지명이 포함된 전체 클래스명" alias="별칭이름" />
-->
<typeAliases>
<typeAlias type="kr.or.ddit.vo.LprodVO" alias="lprodVo" />
<typeAlias type="kr.or.ddit.vo.MemberVO" alias="memVo" />
</typeAliases>
<!-- DB연결 설정 -->
<environments default="oracleDev">
<environment id="oracleDev">
<!-- 오라클 -->
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${driver}" />
<property name="url" value="${url}" />
<property name="username" value="${user}" />
<property name="password" value="${pass}" />
</dataSource>
</environment>
<!-- <environment id="m1">
MySql
</environment> -->
</environments>
<!-- DB에서 처리될 SQL문들이 작성된 mapper파일들을 등록하는 부분 -->
<!-- 형식) <mapper resource="경로명/파일명.xml" /> -->
<mappers>
<mapper resource="kr/or/ddit/mybatis/mappers/lprod-mapper.xml" />
<!-- jdbc-mapper.xml을 새롭게 등록해 줘야 한다. -->
<mapper resource="kr/or/ddit/mybatis/mappers/jdbc-mapper.xml" />
<!-- member-mapper.xml을 새롭게 등록해 줘야 한다. -->
<mapper resource="kr/or/ddit/mybatis/mappers/member-mapper.xml" />
</mappers>
</configuration>[MemberDaoImpl.java]
package kr.or.ddit.member.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.session.SqlSession;
import kr.or.ddit.util.MyBatisUtil;
import kr.or.ddit.vo.MemberVO;
public class MemberDaoImpl implements IMemberDao {
// 1번
private static MemberDaoImpl dao;
// 2번
private MemberDaoImpl() {}
// 3번
public static MemberDaoImpl getInstance() {
if(dao == null) dao = new MemberDaoImpl();
return dao;
}
@Override
public int insertMember(MemberVO memVo) {
SqlSession session = null;
int cnt = 0; // 반환값이 저장될 변수
try {
session = MyBatisUtil.getSqlSession();
cnt = session.insert("member.insertMember", memVo);
// insert, update, delete 작업이 성공하면 commit()을 처리한다.
if(cnt > 0) session.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
return cnt;
}
@Override
public int deleteMember(String memId) {
SqlSession session = null;
int cnt = 0; // 반환값이 저장될 변수
try {
session = MyBatisUtil.getSqlSession();
cnt = session.delete("member.deleteMember", memId);
if(cnt > 0) session.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
return cnt;
}
@Override
public int updateMember(MemberVO memVo) {
SqlSession session = null;
int cnt = 0; // 반환값이 저장될 변수
try {
session = MyBatisUtil.getSqlSession();
cnt = session.update("member.updateMember", memVo);
if(cnt > 0) session.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
return cnt;
}
@Override
public List<MemberVO> getAllMember() {
SqlSession session = null;
List<MemberVO> memList = null; // 반환값이 저장될 변수
try {
session = MyBatisUtil.getSqlSession();
memList = session.selectList("member.getAllMember");
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
return memList;
}
@Override
public int getMemIdCount(String memId) {
SqlSession session = null;
int cnt = 0; // 반환값이 저장될 변수
try {
session = MyBatisUtil.getSqlSession();
cnt = session.selectOne("member.getMemIdCount", memId);
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
return cnt;
}
@Override
public int updateMember2(Map<String, String> paramMap) {
SqlSession session = null;
int cnt = 0; // 반환값이 저장될 변수
// key값 정보 ==> 회원ID(memid), 수정할컬럼명(field), 수정할데이터(data)
try {
session = MyBatisUtil.getSqlSession();
cnt = session.update("member.updateMember2", paramMap);
if(cnt > 0) session.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
if(session != null) session.close();
}
return cnt;
}
}[MemberController.java를 실행]
'대덕인재개발원_자바기반 애플리케이션' 카테고리의 다른 글
| 230922_Log4J (0) | 2023.09.22 |
|---|---|
| 230921_MyBatis 과제_myBatisBoardTest (0) | 2023.09.21 |
| 230920_MyBatis 1 (0) | 2023.09.20 |
| 230919_MVC 2 (0) | 2023.09.18 |
| 230918_MVC 1 (0) | 2023.09.15 |
'대덕인재개발원_자바기반 애플리케이션' Related Articles
more
