Userview
package edu.kh.jdbc.view;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Scanner;
import javax.swing.tree.ExpandVetoException;
import edu.kh.jdbc.dto.User;
import edu.kh.jdbc.service.UserService;
public class UserView {
// 필드
private UserService service = new UserService();
private Scanner sc = new Scanner(System.in);
/**
* JDBCTemplate 사용 테스트
*/
public void test() {
// 입력된 ID와 일치하는 USER 정보 조회
System.out.print("ID 입력 : ");
String input = sc.nextLine();
// 서비스 호출 후 결과 반환받기
User user = service.selectId(input);
// 결과출력
System.out.println(user);
}
/** User 관리 프로그램 메인메뉴
*/
public void mainMenu() {
int input = 0;
do {
try {
System.out.println("\n===== User 관리프로그램 =====\n");
System.out.println("1. User 등록(INSERT)");
System.out.println("2. User 전체조회(SELECT)");
System.out.println("3. User 중 이름에 검색어가 포함된 회원조회 (SELECT)");
System.out.println("4. USER_NO를 입력받아 일치하는 User 조회(SELECT)");
System.out.println("5. USER_NO를 입력받아 일치하는 User 삭제(DELETE)");
System.out.println("6. ID, PW가 일치하는 회원이 있을경우 이름수정(UPDATE)");
System.out.println("7. User 등록(아이디 중복검사)");
System.out.println("8. 여러 User 등록하기");
System.out.println("0. 프로그램 종료");
System.out.print("메뉴선택 : ");
input = sc.nextInt();
sc.nextLine(); // 버퍼에 남은 개행문자 제거
switch(input) {
case 1 : insertUser(); break;
case 2 : selectAll(); break;
case 3 : selectName(); break;
case 4 : selectUser(); break;
case 5 : deleteUser(); break;
case 6 : updateName(); break;
case 7 : insertUser2(); break;
case 8 : multiInsertUser(); break;
case 0 : System.out.println("\n[프로그램 종료]\n");break;
default: System.out.println("\n[메뉴 번호만 입력하세요]\n");
}
System.out.println("\n------------------------------------\n");
}catch(InputMismatchException e) {
// Scanner를 이용한 입력 시 자료형이 잘못된 경우
System.out.println("\n***잘못 입력 하셨습니다 ***\n");
input = -1; // 잘못 입력해서 while문 멈추는거 방지
sc.nextLine();
}catch(Exception e){
// 발생되는 예외를 모두해당 catch 구문으로 모아서 처리
e.printStackTrace();
}
}while(input != 0);
} // mainMenu() 종료
/**
* 1. User 등록
* @throws Exception
*/
private void insertUser() throws Exception {
System.out.println("\n=== 1. User 등록 ===\n");
System.out.print("ID : ");
String userId = sc.next();
System.out.print("PW : ");
String userPw = sc.next();
System.out.print("Name : ");
String userName = sc.next();
// 입력받은 값 3개를 한번에 묶어서 전달할 수 있도록
// User DTO 객체를 생성한 후 필드에 값을 세팅
User user = new User();
// lombok을 이용해 자동생성된 setter 이용
user.setUserId(userId);
user.setUserPw(userPw);
user.setUserName(userName);
// 서비스 호출 후
// 결과(삽입된 행의개수, int) 반환받기
int result = service.insertUser(user);
// 반환된 결과에 따라 출력할 내용 선택
if(result >0) {
System.out.println("\n" + userId + "사용자가 등록 되었습니다.\n");
}else {
System.out.println("\n*** 등록 실패 ***\n");
}
}
/**
* 2. User 전체조회(SELECT)
*/
private void selectAll() throws Exception {
System.out.println("\n=== 2. User 전체 조회(SELECT) ===\n");
// 서비스 메서드(SELECT) 호출 후
// 결과() 반환 받기
List<User> userList = service.selectAll();
// 조회결과가 없을경우
if(userList.isEmpty()) {
System.out.println("\n***조회 결과가 없습니다***\n");
return;
}
// 향상된 for문
for(User user : userList) {
System.out.println(user);
// 자동으로 user.toString() 호출
}
}
/**
* 3. User 중 이름에 검색어가 포함된 회원조회
* @throws Exception
*/
private void selectName() throws Exception {
System.out.println("\n=== 3. User 중 이름에 검색어가 포함된 회원조회 (SELECT) ===\n");
System.out.print("검색어 입력 : ");
String keyword = sc.nextLine();
// 서비스(SELECT) 호출 후
// 결과(List<User>) 반환받기
List<User> searchList = service.selectName(keyword);
if(searchList.isEmpty()) {
System.out.println("검색 결과 없음");
return;
}
for(User user : searchList) {
System.out.println(user);
}
}
/**
* 4. USER_NO를 입력받아 일치하는 User 조회
*/
private void selectUser() throws Exception {
System.out.println("\n=== 4. USER_NO를 입력받아 일치하는 User 조회 ===\n");
System.out.print("사용자 번호 입력 : ");
int input = sc.nextInt();
// 사용자번호 == PK == 중복이 있을 수 없다
// == 일치하는 사용자가 있다면 1행만 조회된다!!
// -> 1행의 조회결과를 담기위해 사용하는 객체 == User DTO
User user = service.selectUser(input);
// 조회결과가 없으면 null, 있으면 null 아님
if(user == null) {
System.out.println("USER_NO가 일치하는 회원이 없습니다");
return;
}
System.out.println(user);
}
/**
* 5. USER_NO를 입력 받아 일치하는 User 삭제
*/
private void deleteUser() throws Exception {
System.out.println("\n=== 5. USER_NO를 입력 받아 일치하는 User 삭제 ===\n");
System.out.print("삭제할 사용자 번호 입력 : ");
int input = sc.nextInt();
// 서비스(DELETE)호출 후 결과 반환받기
// 결과(삭제된 행의 개수, int) 반환받기
int result = service.deleteUser(input);
if(result > 0) System.out.println("삭제 성공");
else System.out.println("사용자번호가 일치하는 User가 존재하지 않습니다");
}
/**
* 6. ID, PW가 일치하는 회원이 있을 경우 이름 수정(UPDATE)
* @throws Exception
*/
private void updateName() throws Exception {
System.out.println("\n=== 6. ID, PW가 일치하는 회원이 있을 경우 이름 수정(UPDATE) ===\n");
System.out.print("ID : ");
String userId = sc.nextLine();
System.out.print("PW : ");
String userPw = sc.nextLine();
/* 입력받은 ID, PW가 일치하는 회원이 있는지 조회(SELECT) */
// -> USER_NO 조회
int userNo = service.selectUserNo(userId, userPw);
if(userNo == 0) { // 조회 결과 없음
System.out.println(
"아이디, 비밀번호가 틀려!!");
return;
}
// 조회된 사용자 번호가 있을 경우
System.out.print("수정할 이름 입력 : ");
String userName = sc.nextLine();
// 이름 수정서비스(UPDATE) 호출 후 결과 반환받기
// 결과(수정된 행의 개수, int) 반환받기
int result = service.updateName(userName, userNo);
if(result >0 )System.out.println("수정 성공하면 혁명이야!!");
else System.out.println("수정 실패하면 쿠테타야!!");
}
/** 7. User 등록(아이디 중복검사)
* @throws Exception
*/
private void insertUser2()throws Exception {
System.out.println("\n=== 7. User 등록(아이디 중복 검사) ===\n");
String userId = null; // 입력된 아이디를 저장할 변수
while(true) {
System.out.print("ID : ");
userId = sc.nextLine();
// 입력받은 userId가 중복인지 검사하는
// 서비스(SELECT) 호출 후
// 검사(int, 중복 == 1, 아니면 == 0) 반환받기
int count = service.idCheck(userId);
if(count == 0) { // 중복이 아닌경우
System.out.println("사용 가능한 아이디입니다");
break;
}
System.out.println("이미 사용중인 아이디입니다. 다시 입력해주세요");
}
// 아이디가 중복이 아닌 경우 while 종료 후 pw, name 입력 받기
System.out.print("PW : ");
String userPw = sc.next();
System.out.print("Name : ");
String userName = sc.next();
// 입력받은 ID, PW, NAME을 User 객체로 묶어서 서비스 호출
User user = new User();
user.setUserId(userId);
user.setUserPw(userPw);
user.setUserName(userName);
// 1번에 만든 service 메서드 재활용
int result = service.insertUser(user);
// 반환된 결과에 따라 출력할 내용 선택
if(result > 0) {
System.out.println("\n" + userId + "사용자가 등록 되었습니다.\n");
}else {
System.out.println("\n*** 등록 실패 ***\n");
}
}
/** 8. 여러 User 등록하기
* @throws Exception
*/
private void multiInsertUser()throws Exception {
// 등록할 유저 수 : 2
// 1번째 userId : user100
// -> 사용가능한 ID 입니다
// 1번째 userPw : pass100
// 1번째 userName : 유저백
// -----------------------
// 2번째 userId : user200
// -> 사용가능한 ID 입니다
// 2번째 userPw : pass200
// 2번째 userName : 유저이백
// -- 전체 삽입 성공 / 삽입 실패
System.out.println("\n=== 8. 여러 User 등록하기 ===\n");
System.out.println("등록할 User 수 : ");
int input = sc.nextInt();
sc.nextLine(); // 버퍼 개행문자 제거
// 입력받은 회원정보를 저장할 List 객체 생성
List<User> userList = new ArrayList<User>();
for(int i = 0; i < input; i++ ) {
String userId = null; // 입력된 아이디를 저장할 변수
while(true) {
System.out.print((i+1) + "번째 userId : ");
userId = sc.nextLine();
// 입력받은 userId가 중복인지 검사하는
// 서비스(SELECT) 호출 후
// 검사(int, 중복 == 1, 아니면 == 0) 반환받기
int count = service.idCheck(userId);
if(count == 0) { // 중복이 아닌경우
System.out.println("사용 가능한 아이디입니다");
break;
}
System.out.println("이미 사용중인 아이디입니다. 다시 입력해주세요");
}
// 아이디가 중복이 아닌 경우 while 종료 후 pw, name 입력 받기
System.out.print((i+1) + "번째 userPw : ");
String userPw = sc.nextLine();
System.out.print((i+1) + "번째 userName : ");
String userName = sc.nextLine();
System.out.println("-------------------------------------------");
// 입력받은 ID, PW, NAME을 User 객체로 묶어서 서비스 호출
User user = new User();
user.setUserId(userId);
user.setUserPw(userPw);
user.setUserName(userName);
// userList에 user 추가
userList.add(user);
} // for문 종료
// 입력받은 모든 사용자 insert 하는 서비스 호출
// -> 결과로 삽입된 행의 개수 반환
int result = service.multiInsertUser(userList);
// 전체 삽입 성공시
if(result == userList.size()) {
System.out.println("전체 삽입 성공");
}else {
System.err.println("삽입 실패");
}
}
}
Userdao
package edu.kh.jdbc.dao;
import static edu.kh.jdbc.common.JDBCTemplate.*;
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import edu.kh.jdbc.common.JDBCTemplate;
import edu.kh.jdbc.dto.User;
// DAO(Data Access Object) : 데이터가 저장된 곳에 접근하는 용도의 객체
// -> DB에 접근하여 Java 에서 원하는 결과를 얻기위해
// SQL을 수행하고 결과 반환받는 역할
public class UserDao {
// 필드
// - DB 접근관련한 JDBC 객체 참조형 변수를 미리선언
private Statement stmt = null;
private PreparedStatement pstmt = null;
private ResultSet rs = null;
/** 전달받은 Connection을 이용해 DB에 접근하여
* 전달받은 아이디와 일치하는 User 정보 조회하기
* @param conn : Service에서 생성한 Connection 객체
* @param input : View에서 입력받은 아이디
* @return
*/
public User selectId(Connection conn, String input) {
User user = null; // 결과 저장용 변수
try {
// SQL 작성
String sql = "SELECT * FROM TB_USER WHERE USER_ID = ?";
// PreparedStatement 객체 생성
pstmt = conn.prepareStatement(sql);
// ?(placeholder)에 알맞은 값 대입
pstmt.setString(1, input);
// SQL 수행 후 결과 반환받기
rs = pstmt.executeQuery();
// 조회결과가 있을경우
// -> 중복되는 아이디가 없을경우
// 1행만 조회되기 때문에 while보단 if를 사용하는게 효과적
if(rs.next()) {
// 각 컬럼의 값 얻어오기
int userNo = rs.getInt("USER_NO");
String userId = rs.getString("USER_ID");
String userPw = rs.getString("USER_PW");
String userName = rs.getString("USER_NAME");
// java.sql.Date 활용
Date enrollDate = rs.getDate("ENROLL_DATE");
// 조회된 컬럼값을 이용해 User 객체생성
user = new User(userNo,
userId,
userPw,
userName,
enrollDate.toString());
}
}catch(Exception e) {
e.printStackTrace();
}finally {
// 사용한 JDBC 객체 자원반환(close)
JDBCTemplate.close(rs);
JDBCTemplate.close(pstmt);
// Connection 객체는 Service에서 close!!!!!!
}
return user; // 결과 반환(생성된 User 또는 null)
}
/**
* User 등록 DAO 메서드
* @param conn : DB 연결정보가 담겨있는 객체
* @param user : 입력받은 id, pw, name
* @return result : INSERT 결과 행의 개수
* @throws Exception : 발생하는 예외 모두던짐
*/
public int insertUser(Connection conn, User user) throws Exception{
// SQL 수행중 발생하는 예외를
// catch로 처리하지 않고, throws를 이용해서 호출부로 던져 처리
// -> catch문이 필요없다!!
// 1. 결과 저장용 변수 선언
int result = 0;
try {
// 2. SQL 작성
String sql = """
INSERT INTO TB_USER
VALUES(SEQ_USER_NO.NEXTVAL, ?, ?, ?, DEFAULT) """;
// 3. PreparedStatement 생성
pstmt = conn.prepareStatement(sql);
// 4. ?(placeholder)에 알맞은 값 대입
pstmt.setString(1, user.getUserId());
pstmt.setString(2, user.getUserPw());
pstmt.setString(3, user.getUserName());
// 5. SQL(INSERT) 수행(executeUpdate()) 후
// 결과(삽입된 행의 개수, int) 반환받기
result = pstmt.executeUpdate();
}finally {
// 6. 사용한 JDBC 객체 자원 반환(Close)
close(pstmt);
}
// 결과 저장용 변수에 저장된 값을 반환
return result;
}
/** User 전체조회 DAO 메서드
* @param conn
* @return userList
* @throws Exception
*/
public List<User> selectAll(Connection conn)throws Exception {
// 1. 결과 저장용 변수선언
// -> List 같은 컬렉션을 반환하는 경우에는
// 변수 선언시 객체도 같이 생성해두자!!!
List<User> userList = new ArrayList<User>();
try {
// 2. SQL 작성
String sql = """
SELECT
USER_NO,
USER_ID,
USER_PW,
USER_NAME,
TO_CHAR(ENROLL_DATE, 'YYYY"년" MM "월" DD"일"')ENROLL_DATE
FROM TB_USER
ORDER BY USER_NO ASC
""";
// 3. PreparedStatement 생성
pstmt = conn.prepareStatement(sql);
// 4. ?에 알맞는 값 대입 (없으면 패스~)
// 5. SQL(SELECT) 수행(executeQuery()) 후
// 결과(ResultSet) 반환받기
rs = pstmt.executeQuery();
// 6. 조회결과(ResultSet)를
// 커서를 이용해서 1행씩 접근하여 컬럼값 얻어오기
/* 몇 행이 조회될지 모른다 -> while
* 무조건 1행이 조회된다 -> if
*/
// rs.next() : 커서를 1행 이동
// 이동된 행의 데이터가 있으면 true, 없으면 false
while(rs.next()) {
int userNo = rs.getInt("USER_NO");
String userId = rs.getString("USER_ID");
String userPw = rs.getString("USER_PW");
String userName = rs.getString("USER_NAME");
String enrollDate = rs.getString("ENROLL_DATE");
// - java.sql.Date 타입으로 값을 저장하지 않는 이유!
// -> TO_CHAR()를 이용해서 문자열로 변환했기 때문!
// ** 조회된 값을 userList에 추가 **
// -> User 객체를 생성해 조회된 값을 담고
// userList에 추가하기
User user = new User(userNo, userId,
userPw, userName, enrollDate);
userList.add(user);
// ResultSet을 이용해 List에 옮겨담는이유
// 1. List가 사용이 편해서
// -> 호환되는 곳도 많음(jsp, thymeleaf 등)
// 2. 사용된 ResultSet은 DAO에 close 되기때문
}
}finally {
close(rs);
close(pstmt);
}
// 조회결과가 담긴 List 반환
return userList;
}
/** 이름에 검색어가 포함되는 회원 모두조회 Service메서드
* USER
* @param keyword
* @return searchList
* @throws Exception
*/
public List<User> selectName(Connection conn, String keyword) throws Exception {
List<User> searchList = new ArrayList<User>();
try {
String sql = """
SELECT
USER_NO,
USER_ID,
USER_PW,
USER_NAME,
TO_CHAR(ENROLL_DATE, 'YYYY"년" MM "월" DD"일"')ENROLL_DATE
FROM TB_USER
WHERE USER_NAME LIKE '%' || ? || '%'
ORDER BY USER_NO ASC
""";
// PreparedStatement 생성
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, keyword);
// SQL(SELECT) 수행(executeQuery()) 후
// 결과(ResultSet) 반환받기
rs = pstmt.executeQuery();
// rs.next() : 커서를 1행 이동
// 이동된 행의 데이터가 있으면 true, 없으면 false
while(rs.next()) {
int userNo = rs.getInt("USER_NO");
String userId = rs.getString("USER_ID");
String userPw = rs.getString("USER_PW");
String userName = rs.getString("USER_NAME");
String enrollDate = rs.getString("ENROLL_DATE");
// ** 조회된 값을 userList에 추가 **
// -> User 객체를 생성해 조회된 값을 담고
// userList에 추가하기
User user = new User(userNo, userId,
userPw, userName, enrollDate);
searchList.add(user);
}
}finally {
close(rs);
close(pstmt);
}
return searchList;
}
/** USER_NO를 입력받아 일치하는 User 조회
* @param conn
* @param input
* @return
* @throws Exception
*/
public User selectUser(Connection conn, int input) throws Exception {
User user = null;
try {
String sql = """
SELECT
USER_NO,
USER_ID,
USER_PW,
USER_NAME,
TO_CHAR(ENROLL_DATE, 'YYYY"년" MM "월" DD"일"')ENROLL_DATE
FROM TB_USER
WHERE USER_NO = ?
""";
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, input);
rs = pstmt.executeQuery();
if(rs.next()) {
// 각 컬럼의 값 얻어오기
int userNo = rs.getInt("USER_NO");
String userId = rs.getString("USER_ID");
String userPw = rs.getString("USER_PW");
String userName = rs.getString("USER_NAME");
String enrollDate = rs.getString("ENROLL_DATE");
// 조회된 컬럼값을 이용해 User 객체생성
user = new User(userNo,
userId,
userPw,
userName,
enrollDate);
}
}finally {
close(rs);
close(pstmt);
}
return user;
}
public int deleteUser(Connection conn, int input) throws Exception{
// 1. 결과 저장용 변수 선언
int result = 0;
try {
// 2. SQL 작성
String sql = """
DELETE
FROM TB_USER
WHERE USER_NO = ?
""";
// 3. PreparedStatement 생성(placeholder(?)가 있으면 무조건 써야함)
pstmt = conn.prepareStatement(sql); // preparedStatement가 만들어지자마자(괄호안에)
/* -> (sql) """
DELETE
FROM TB_USER
WHERE USER_NO = ?
"""; 가 들어감!!!!!! */
// 4. ?에 알맞은 값 대입
pstmt.setInt(1, input);
// 5. SQL(DELETE) 수행(executeUpdate) 후
// 결과(int) 반환 받기 DELETE는 update
result = pstmt.executeUpdate();
}finally {
// 6. 사용한 JDBC 객체 자원 반환
close(pstmt);
}
return result;
}
/** 아이디, 비밀번호가 일치하는 User의 USER_NO 조회
* @param userId
* @param userPw
* @return userNo
* @throws Exception
*/
public int selectUser(Connection conn, String userId, String userPw)
throws Exception{
int userNo = 0; // 결과 저장용 변수선언
try {
String sql = """
SELECT USER_NO
FROM TB_USER
WHERE USER_ID = ?
AND USER_PW = ?
""";
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, userId);
pstmt.setString(2, userPw);
// SQL(SELECT) 수행(executeQuery()) 후
// 결과(resultSet) 반환받기 ★☆★☆ select = resultset
rs = pstmt.executeQuery();
// 조회된 1행이 있을경우
if(rs.next()) {
userNo = rs.getInt("USER_NO");
}
}finally {
close(rs);
close(pstmt);
}
return userNo; // 조회성공 USER_NO, 실패 0 반환
}
/** userNo가 일치하는 User의 이름수정
* @param userName
* @param userNo
* @return
* @throws Exception
*/
public int updateName(Connection conn, String userName, int userNo) throws SQLException {
int result = 0;
try {String sql = """
UPDATE TB_USER
SET USER_NAME = ?
WHERE USER_NO = ?
""";
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, userName);
pstmt.setInt(2, userNo);
result = pstmt.executeUpdate();
}finally {
close(pstmt);
}
return result;
}
/** 아이디 중복확인
* @param userId
* @return
* @throws Exception
*/
public int idCheck(Connection conn, String userId) throws Exception{
int count = 0; // 결과 저장용 변수
try {
String sql = """
SELECT COUNT(*)
FROM TB_USER
WHERE USER_ID = ?
""";
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, userId);
rs = pstmt.executeQuery();
if(rs.next()) { // COUNT(*) 그룹함수 결과 1행만 조회
count = rs.getInt(1); // 조회된 컬럼순서를 이용해
// 컬럼 값 얻어오기
}
}finally {
close(rs);
close(pstmt);
}
return count;
}
}
UserService
package edu.kh.jdbc.service;
// import static : 지정된 경로에 존재하는 static 구문을 모두 얻어와
// 클래스명.메서드명()이 아닌 메서드명()만 작성해도 호출 가능하게 함
import static edu.kh.jdbc.common.JDBCTemplate.*;
import java.sql.Connection;
import java.util.List;
import edu.kh.jdbc.common.JDBCTemplate;
import edu.kh.jdbc.dao.UserDao;
import edu.kh.jdbc.dto.User;
// Service : 비즈니스 로직 처리
// - DB에 CRUD 후 결과반환받기
// + DML 성공여부에 따른 트랜잭션 제어처리(commit/rollback)
// --> connection 객체를 Service에서 생성 후
// Dao에 전달하는 형식의 코드를 작성하게됨
public class UserService {
// 필드
private UserDao dao = new UserDao();
// 메서드
/*
* 전달받은 아이디와 일치하는 User 정보반환
* @param 입력된 아이디
* @return 아이디가 일치하는 회원정보, 없으면 null
*/
public User selectId(String input) {
// 커넥션 생성
Connection conn = JDBCTemplate.getConnection();
// Dao 메서드 호출 후 결과 반환받기
// (조금 이따 작성)
User user = dao.selectId(conn, input);
// 다쓴 커넥션 닫기
JDBCTemplate.close(conn);
return user; // DB조회 결과 반환
}
/**
* User 등록 서비스
* @param user : 입력받은 id, pw, name
* @return 삽입 성공한 결과 행의개수
* @throws Exception
*/
public int insertUser(User user) throws Exception {
// 1. Conection 생성
Connection conn = getConnection();
// 2. 데이터 가공(할게 없으면 넘어감)
// 3. DAO 메서드(INSERT 수행) 호출 후
// 결과(삽입 성공한 행의 개수, int) 반환받기
int result = dao.insertUser(conn, user);
// 4. INSERT 수행 결과에 따라 트랜잭션 제어처리
if(result > 0) { // INSERT 성공
commit(conn);
} else { // INSERT 실패
rollback(conn);
}
// 5. Connection 반환하기
close(conn);
// 6. 결과 반환
return result;
}
/** User 전체조회
* @return userList : 조회된 User가 담긴 List
* @return Exception
*/
public List<User> selectAll() throws Exception{
// 1. Connection 생성
Connection conn = getConnection();
// 2. 데이터 가공(없으면 넘어감)
// 3. DAO 메서드(SELECT) 호출 후 결과 반환 받기
// 결과 반환 받기(List<User>) 반환받기
List<User> userList = dao.selectAll(conn);
// 4. DML인 경우 트랜잭션 처리
// SELECT는 안해도된다!!
// 5. Connection 반환
close(conn);
// 6. 결과반환
return userList;
}
/** 이름에 검색어가 포함되는 회원 모두조회 Service메서드
* USER
* @param keyword
* @return searchList
* @throws Exception
*/
public List<User> selectName(String keyword) throws Exception {
// 커넥션 생성
Connection conn = getConnection();
List<User> searchList = dao.selectName(conn, keyword);
close(conn);
return searchList;
}
/**
* 4. USER_NO를 입력받아 일치하는 User 조회
*/
public User selectUser(int input) throws Exception{
Connection conn = getConnection();
User user = dao.selectUser(conn, input);
close(conn);
return user;
}
/**
* 5. USER_NO를 입력 받아 일치하는 User 삭제
* @param input
* @return result
* @throws Exception
*/
public int deleteUser(int input)throws Exception {
// 1. Connection 생성하기
Connection conn = getConnection();
// 2. 데이터 가공
// 3. DAO 메서드(DELETE) 호출 후
// 결과 ( 삭제된 행의 개수, int ) 반환받기
int result = dao.deleteUser(conn, input);
// 4. 결과에 따라 트랜잭션 제어처리
if(result > 0 ) {
commit(conn);
}else {
rollback(conn);
}
// 5. Connection 반환
close(conn);
return result; // 결과 반환
}
/** 아이디, 비밀번호가 일치하는 User의 USER_NO 조회
* @param userId
* @param userPw
* @return userNo
* @throws Exception
*/
public int selectUserNo(String userId, String userPw) throws Exception {
Connection conn = getConnection(); // 커넥션 생성
// DAO 호출 후 결과 반환받기
int userNo = dao.selectUser(conn, userId, userPw);
close(conn); // 커넥션 반환
return userNo;
}
/** userNo가 일치하는 User의 이름수정
* @param userName
* @param userNo
* @return
* @throws Exception
*/
public int updateName(String userName, int userNo) throws Exception{
Connection conn = getConnection();
int result = dao.updateName(conn, userName, userNo);
if(result > 0) commit(conn);
else rollback(conn);
close(conn);
return result;
}
/** 아이디 중복확인
* @param userId
* @return
* @throws Exception
*/
public int idCheck(String userId) throws Exception {
Connection conn = getConnection();
int count = dao.idCheck(conn, userId);
close(conn);
return count;
}
/**userList에 있는 모든 user INSERT하기
* @param userList
* @return result : 삽인된 행의개수
* @throws Exception
*/
public int multiInsertUser(List<User> userList) throws Exception {
Connection conn = getConnection();
// 다중 insert 방법
// 1) SQL을 이용한 다중 INSERT
// 2) Java 반복문을 이용한 다중 INSERT (이거 사용!!)
int count = 0; // 삽입 성공한 행의 개수 count
//count--; // 강제로 실패
// 1행씩 삽입
for(User user : userList) {
int result = dao.insertUser(conn, user);
count += result; // 삽입 성공한 행의 개수를 count로 누적
}
// 전체 삽입 성공시 commit / 아니면 rollback
if(count == userList.size()) {
commit(conn);
}else {
rollback(conn);
}
close(conn);
return count;
}
}