본문 바로가기
카테고리 없음

24. 08. 28 개발자교육 10주차 User 프로그램 만들기

by 융기융 2024. 8. 28.
반응형

 

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;

}

}

 

 

반응형