DAO(Data Access Object)

Joy🌱·2023년 1월 23일

🐘 JDBC

목록 보기

3/3

💁‍♀️ DAO(Data Access Object)란,
데이터베이스 접근용 객체. CRUD 연산을 담당하는 메소드들의 집합으로 이루어진 클래스

어떠한 기능이 필요할 때마다 간단히 호출만하여 사용할 수 있게끔 메소드를 분리하여 DAO에 담아 사용

👀 DAO의 사용

📌 초기 Setting

◼ Setting

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<!-- '1. 카테고리 전체 조회'를 위한 쿼리 -->
	<entry key="selectAllCategory">
		SELECT
				CATEGORY_CODE
			,	CATEGORY_NAME
			,	REF_CATEGORY_CODE
			FROM TBL_CATEGORY
	</entry>

	<!-- '2. 신규 메뉴 등록'을 위한 쿼리 -->
	<entry key="insertMenu">
		INSERT
			INTO TBL_MENU
		(
			MENU_CODE
		,	MENU_NAME
		, 	MENU_PRICE
		,	CATEGORY_CODE
		,	ORDERABLE_STATUS
		)
		VALUES
		(
			SEQ_MENU_CODE.NEXTVAL <!-- 시퀀스로 MENU_CODE 컬럼 값 계속 생성 -->
		,	?
		,	?
		,	?
		,	?		
		)
	</entry>
</properties>

◼ JDBCTemplate

public class JDBCTemplate { 
	
	/*  Connection을 return시킬 메소드 */ 
	public static Connection getConnection() {
		
		Connection conn = null;
		Properties prop = new Properties();
		
		try {
			prop.load(new FileReader("config/jdbc-config.properties")); // config부터 작성
			
			String driver = prop.getProperty("driver");
			String url = prop.getProperty("url");
			
			Class.forName(driver);
			
			conn = DriverManager.getConnection(url, prop);
			
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} 
		
		return conn;
	}
	/* Connection을 close할 메소드 */
	public static void close(Connection conn) {
		try {
			if(conn != null && !conn.isClosed()) {
				conn.close(); 
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	/* Statement를 close할 메소드 */
	public static void close(Statement stmt) {
		try {
			if(stmt != null && !stmt.isClosed()) {
				stmt.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	/* ResultSet을 close할 메소드 */
	public static void close(ResultSet rset) {
		try {
			if(rset != null && !rset.isClosed()) {
				rset.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

👉 DTO

◼ CategoryDTO Class

public class CategoryDTO {

	/*
	CATEGORY_CODE	NUMBER
	CATEGORY_NAME	VARCHAR2(30 BYTE)
	REF_CATEGORY_CODE	NUMBER
	*/

	/* 필드 */
	private int categoryCode;
	private String categoryName;
	private int refCategoryCode;
	
	/* 생성자 */
	public CategoryDTO() {}
	
	public CategoryDTO(int categoryCode, String categoryName, int refCategoryCode) {
		super();
		this.categoryCode = categoryCode;
		this.categoryName = categoryName;
		this.refCategoryCode = refCategoryCode;
	}

	/* getter & setter */
	public int getCategoryCode() {
		return categoryCode;
	}

	public void setCategoryCode(int categoryCode) {
		this.categoryCode = categoryCode;
	}

	public String getCategoryName() {
		return categoryName;
	}

	public void setCategoryName(String categoryName) {
		this.categoryName = categoryName;
	}

	public int getRefCategoryCode() {
		return refCategoryCode;
	}

	public void setRefCategoryCode(int refCategoryCode) {
		this.refCategoryCode = refCategoryCode;
	}

	/* toString */
	@Override
	public String toString() {
		return "CategoryDTO [categoryCode=" + categoryCode + ", categoryName=" + categoryName + ", refCategoryCode="
				+ refCategoryCode + "]";
	}
}

◼ MenuDTO Class

public class MenuDTO {

	/* 
	MENU_CODE	NUMBER
	MENU_NAME	VARCHAR2(30 BYTE)
	MENU_PRICE	NUMBER
	CATEGORY_CODE	NUMBER
	ORDERABLE_STATUS	CHAR(1 BYTE)
	*/
	
	private int menuCode;
	private String menuName;
	private int menuPrice;
	private int categoryCode;
	private String orderableStatus;
	
	/* 생성자 */
	public MenuDTO() {}
	
	public MenuDTO(int menuCode, String menuName, int menuPrice, int categoryCode, String orderableStatus) {
		super();
		this.menuCode = menuCode;
		this.menuName = menuName;
		this.menuPrice = menuPrice;
		this.categoryCode = categoryCode;
		this.orderableStatus = orderableStatus;
	}

	
	/* getter & setter */

	public int getMenuCode() {
		return menuCode;
	}

	public void setMenuCode(int menuCode) {
		this.menuCode = menuCode;
	}

	public String getMenuName() {
		return menuName;
	}

	public void setMenuName(String menuName) {
		this.menuName = menuName;
	}

	public int getMenuPrice() {
		return menuPrice;
	}

	public void setMenuPrice(int menuPrice) {
		this.menuPrice = menuPrice;
	}

	public int getCategoryCode() {
		return categoryCode;
	}

	public void setCategoryCode(int categoryCode) {
		this.categoryCode = categoryCode;
	}

	public String getOrderableStatus() {
		return orderableStatus;
	}

	public void setOrderableStatus(String orderableStatus) {
		this.orderableStatus = orderableStatus;
	}
	
	@Override
	public String toString() {
		return "MenuDTO [menuCode=" + menuCode + ", menuName=" + menuName + ", menuPrice=" + menuPrice
				+ ", categoryCode=" + categoryCode + ", orderableStatus=" + orderableStatus + "]";
	}
}

👉 DAO

◼ MenuDAO Class

public class MenuDAO {

	>>> 메소드 안이 아닌, 필드에 Properties 선언 
    >>> (모든 메소드에서 xml 파일을 불러올 것이기 때문)
    /* 필드 */
	private Properties prop; 
	
	/* 기본 생성자 */ >>> 필드에 대해 객체 생성 및 객체쪽으로 xml 파일을 로드해오겠다는 구문 작성
	public MenuDAO() { 
		try {
			prop = new Properties();
			prop.loadFromXML(new FileInputStream("mapper/menu-query.xml"));
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

✅ '1. 카테고리 전체 조회'를 위한 메소드

	public List<CategoryDTO> selectAllcategory(Connection conn) {
		
		PreparedStatement pstmt = null;
		ResultSet rset = null;
		
		List<CategoryDTO> categoryList = null; // 최종 반환할 리스트
		
		String query = prop.getProperty("selectAllCategory");
		
		try {
			pstmt = conn.prepareStatement(query);
			rset = pstmt.executeQuery();
			
            // while문 전에 ArrayList 객체 생성
			categoryList = new ArrayList<>(); 
			
			while(rset.next()) {
				CategoryDTO category = new CategoryDTO();
				category.setCategoryCode(rset.getInt("CATEGORY_CODE"));
				category.setCategoryName(rset.getString("CATEGORY_NAME"));
				category.setRefCategoryCode(rset.getInt("REF_CATEGORY_CODE"));
			
				categoryList.add(category); 
			}
	
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(rset);
			close(pstmt);
			>>> Connection은 Applicaiton 클래스에서 호출하고 다 사용한 후 반납할 예정
		}	
		return categoryList;
	}

✅ '2. 신규 메뉴 등록'을 위한 메소드

	public int insertNewMenu(Connection conn, MenuDTO newMenu) { 
    >>> 연결 객체(conn)와 삽입하고자 하는 메뉴 값이 무엇인지에 대한 메뉴 객체(newMenu)
		
		PreparedStatement pstmt = null;
		int result = 0;
		String query = prop.getProperty("insertMenu");
		
		try {
			pstmt = conn.prepareStatement(query);
            // 전달 받은 인자(newMenu)로 DTO와 연결
			pstmt.setString(1, newMenu.getMenuName()); 
			pstmt.setInt(2, newMenu.getMenuPrice());
			pstmt.setInt(3, newMenu.getCategoryCode());
			pstmt.setString(4, newMenu.getOrderableStatus());
			
			result = pstmt.executeUpdate(); // 실행
			
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(pstmt);
		}
		
		return result;
	}
}

👉 RUN

◼ Application Class

>>> 신규 메뉴 등록 전 카테고리 목록을 조회해서 보여주고 신규 메뉴 등록을 진행하는 흐름
		
MenuDAO menuDAO = new MenuDAO();
		
>>> 메소드가 아닌 Application에서 Connection 객체 생성
Connection conn = getConnection();

✅ 1. 카테고리 목록 조회

>>> 이 수행이 끝나고 나서 받아야하는 값이 List이기 때문에 List 사용
List<CategoryDTO> categoryList = menuDAO.selectAllcategory(conn); 
   // 반환 타입                                            // 인자
		
for(CategoryDTO category : categoryList) {
	System.out.println(category);
}

✅ 2. 신규 메뉴 등록

Scanner sc = new Scanner(System.in);
System.out.print("메뉴 이름 : ");
String menuName = sc.nextLine();
System.out.print("메뉴 가격 : ");
int menuPrice = sc.nextInt();
System.out.print("카테고리 코드 : ");
int categoryCode = sc.nextInt();
sc.nextLine();
System.out.print("판매 여부(Y/N) : ");
String orderableStatus = sc.nextLine().toUpperCase();
		
MenuDTO newMenu = new MenuDTO();
newMenu.setMenuName(menuName);
newMenu.setMenuPrice(menuPrice);
newMenu.setCategoryCode(categoryCode);
newMenu.setOrderableStatus(orderableStatus);

// MenuDAO의 insertNewMenu 메소드로 conn, newMenu인자 전달
int result = menuDAO.insertNewMenu(conn, newMenu); 
		
if(result > 0) {
	System.out.println("신규 메뉴 등록이 완료 되었습니다 :) ");
} else {
	System.out.println("신규 메뉴 등록에 실패 하였습니다 :( ");
}
		
close(conn); 
>>> Connection은 여기서 닫아주기

👀 DAO를 활용한 Service < 신규 메뉴 등록 프로그램 >

📌 초기 Setting

◼ Setting

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<!-- '1. 신규 카테고리 등록'을 위한 쿼리 -->
	<entry key="insertCategory">
		INSERT
			INTO TBL_CATEGORY
		(
			CATEGORY_CODE
		,	CATEGORY_NAME
		, 	REF_CATEGORY_CODE
		)
		VALUES
		(
			SEQ_CATEGORY_CODE.NEXTVAL <!-- 시퀀스로 CATEGORY_CODE 컬럼 값 계속 생성 -->
		,	?
		,	?	
		)
	</entry>
	
	<!-- '2. 마지막 카테고리 코드 조회'를 위한 쿼리 -->
	<entry key="getCurrentSequence">
		SELECT
				SEQ_CATEGORY_CODE.CURRVAL
			FROM DUAL
	</entry>
    
    <!-- '3. 신규 메뉴 등록'을 위한 쿼리 -->
	<entry key="insertMenu">
		INSERT
			INTO TBL_MENU
		(
			MENU_CODE
		,	MENU_NAME
		, 	MENU_PRICE
		,	CATEGORY_CODE
		,	ORDERABLE_STATUS
		)
		VALUES
		(
			SEQ_MENU_CODE.NEXTVAL <!-- 시퀀스로 MENU_CODE 컬럼 값 계속 생성 -->
		,	?
		,	?
		,	?
		,	?		
		)
	</entry>
</properties>

◼ JDBCTemplate (transaction 구문 추가)

public class JDBCTemplate { 
	
	/* Connection을 return하는 메소드 */
	public static Connection getConnection() {
		
		Connection conn = null;
		Properties prop = new Properties();
		
		try {
			prop.load(new FileReader("config/jdbc-config.properties"));
			
			String driver = prop.getProperty("driver");
			String url = prop.getProperty("url");
			
			Class.forName(driver);
			
			conn = DriverManager.getConnection(url, prop);
			
			>>> auto commit이 기본값으로 설정되어 있으나,
			>>> 프로그램 내에서 작업 단위별로 commit과 rollback을 판단하여 수행하고자하므로
			>>> auto commit을 false로 수동 설정
			conn.setAutoCommit(false);
			
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} 
		
		return conn;
		
	}
	
	/* Connection을 close할 메소드 */
	public static void close(Connection conn) {
		try {
			if(conn != null && !conn.isClosed()) {
				conn.close();
				
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	/* Statement를 close할 메소드 */
	public static void close(Statement stmt) {
		try {
			if(stmt != null && !stmt.isClosed()) {
				stmt.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	/* ResultSet을 close할 메소드 */
	public static void close(ResultSet rset) {
		try {
			if(rset != null && !rset.isClosed()) {
				rset.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	/* ---------자동 commit을 수동 commit으로 변경--------- */
	
	/* 모두 올바르게 실행이 완료되면, commit할 메소드 */
	public static void commit(Connection conn) {
		try {
			if(conn != null && !conn.isClosed()) { // :conn 객체가 존재한다면, commmit
				conn.commit();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	/* 하나라도 실행되지 않는다면, rollback할 메소드 */
	public static void rollback(Connection conn) {
		try {
			if(conn != null && !conn.isClosed()) { // :conn 객체가 존재한다면, rollback
				conn.rollback();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

👉 DTO

◼ CategoryDTO Class

public class CategoryDTO {

	/*
	CATEGORY_CODE	NUMBER
	CATEGORY_NAME	VARCHAR2(30 BYTE)
	REF_CATEGORY_CODE	NUMBER
	*/

	/* 필드 */
	private int categoryCode;
	private String categoryName;
	private Integer refCategoryCode;
    >>> refCategoryCode에 null값을 담기 위해 int가 아닌 Integer로 설정 !!
	
	/* 생성자 */
	public CategoryDTO() {}
	
	public CategoryDTO(int categoryCode, String categoryName, Integer refCategoryCode) {
		super();
		this.categoryCode = categoryCode;
		this.categoryName = categoryName;
		this.refCategoryCode = refCategoryCode;
	}

	/* getter & setter */
	public int getCategoryCode() {
		return categoryCode;
	}

	public void setCategoryCode(int categoryCode) {
		this.categoryCode = categoryCode;
	}

	public String getCategoryName() {
		return categoryName;
	}

	public void setCategoryName(String categoryName) {
		this.categoryName = categoryName;
	}

	public Integer getRefCategoryCode() {
		return refCategoryCode;
	}

	public void setRefCategoryCode(Integer refCategoryCode) {
		this.refCategoryCode = refCategoryCode;
	}

	/* toString */
	@Override
	public String toString() {
		return "CategoryDTO [categoryCode=" + categoryCode + ", categoryName=" + categoryName + ", refCategoryCode="
				+ refCategoryCode + "]";
	}
}

◼ MenuDTO Class

* 'DAO의 사용'의 MenuDTO Class와 동일 *

👉 DAO

◼ MenuDAO Class

public class MenuDAO {

	>>> 메소드 안이 아닌, 필드에 Properties 선언 
    >>> (모든 메소드에서 xml 파일을 불러올 것이기 때문)
    /* 필드 */
	private Properties prop; 
	
	/* 기본 생성자 */ >>> 필드에 대해 객체 생성 및 객체쪽으로 xml 파일을 로드해오겠다는 구문 작성
	public MenuDAO() { 
		try {
			prop = new Properties();
			prop.loadFromXML(new FileInputStream("mapper/menu-query.xml"));
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

✅ '1. 신규 카테고리 등록'을 위한 메소드

	public int insertNewCategory(Connection conn, CategoryDTO newCategory) {
		
		PreparedStatement pstmt = null;
		int result = 0;
		String query = prop.getProperty("insertCategory");
		
		try {
			pstmt = conn.prepareStatement(query);
			pstmt.setString(1, newCategory.getCategoryName()); // CATEGORY_NAME
			pstmt.setObject(2, newCategory.getRefCategoryCode()); // REF_CATEGORY_CODE 
			>>> RefCategoryCode는 int가 아닌 Integer니 setObject 사용 !!

			result = pstmt.executeUpdate(); // 실행
			
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(pstmt);
		}
		
		return result;
	}

✅ '2. 마지막 카테고리 코드 조회'를 위한 메소드

	public int selectLastCategoryCode(Connection conn) {

		PreparedStatement pstmt = null;
		ResultSet rset = null;
		int newCategoryCode = 0;
		String query = prop.getProperty("getCurrentSequence");
		
		try {
			pstmt = conn.prepareStatement(query);
			rset = pstmt.executeQuery();
			
			if(rset.next()) {
				newCategoryCode = rset.getInt("CURRVAL"); 
                >>> CURRVAL을 int값으로 뽑아 새로운 카테고리 값이 뭔지 전달
			}
			
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(rset);
			close(pstmt);
		}
	
		return newCategoryCode;	>>> 그리고 리턴
	}

✅ '3. 신규 메뉴 등록'을 위한 메소드

	public int insertNewMenu(Connection conn, MenuDTO newMen u) { 
    >>> 연결 객체(conn)와 삽입하고자 하는 메뉴 값이 무엇인지에 대한 메뉴 객체(newMenu)
		
		PreparedStatement pstmt = null;
		int result = 0;
		String query = prop.getProperty("insertMenu");
		
		try {
			pstmt = conn.prepareStatement(query);
            // 전달 받은 인자(newMenu)로 DTO와 연결
			pstmt.setString(1, newMenu.getMenuName());
			pstmt.setInt(2, newMenu.getMenuPrice());
			pstmt.setInt(3, newMenu.getCategoryCode());
			pstmt.setString(4, newMenu.getOrderableStatus());
			
			result = pstmt.executeUpdate(); // 실행
			
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(pstmt);
		}
		return result;
	}
}

👉 Transaction

◼ Application Class

Connection conn = getConnection();
		
/* COMMIT 상태 확인 */
try {
	System.out.println("AutoCommit의 현재 설정 값 : " + conn.getAutoCommit()); 
    // true 출력 (Insert할 때마다, 자동으로 Commit되는 중이라는 의미)
	// JDBCTemplate에서 자동커밋 해제 구문 작성한 뒤, 다시 실행하면 출력문이 false로 바뀜
			
} catch (SQLException e1) {
	e1.printStackTrace();
}
		
PreparedStatement pstmt1 = null;
PreparedStatement pstmt2 = null;
		
int result1 = 0;
int result2 = 0;

Properties prop = new Properties();

try {
	prop.loadFromXML(new FileInputStream("mapper/menu-query.xml"));
	String query1 = prop.getProperty("insertCategory");
	String query2 = prop.getProperty("insertMenu");
			
	/* TBL_CATEGORY 테이블에 1행 삽입 */
	pstmt1 = conn.prepareStatement(query1);
	pstmt1.setString(1, "테스트카테고리");
	pstmt1.setInt(2, 1);
			
	result1= pstmt1.executeUpdate();
			
	/* TBL_MENU 테이블에 1행 삽입 */
	pstmt2 = conn.prepareStatement(query2);
	pstmt2.setString(1, "테스트메뉴");
	pstmt2.setInt(2, 10000);
    
	>>> TBL_CATEGORY에 존재하지 않은 CATEGORY_CODE를 삽입하려고 하면
	>>> 부모키를 찾지 못 하는 외래키 제약조건 위반 오류 발생
	pstmt2.setInt(3, 15); // 일부러 오류 발생시킴 
    					  >>> 위의 카테고리는 삽입되고 오류있는 메뉴만 삽입이 안됨 
                          >>> (원래는 하나라도 오류가 발생 시, 아예 실행이 되면 안됨)
	pstmt2.setString(4, "Y");
			
	result2 = pstmt2.executeUpdate();
			
	System.out.println("result1 : " + result1); // 1 출력 (정상 삽입되었다는 의미)
	System.out.println("result2 : " + result2); // 1 출력
			
} catch (IOException e) {
	e.printStackTrace();
} catch (SQLException e) {
	e.printStackTrace();
} finally {
	close(pstmt1);
	close(pstmt2);

✅ Transaction 수행 🔥중요🔥

>>> 트랜잭션(논리적인 기능 수행 단위) 관리를 위해 2개의 insert가 모두 잘 동작했는지 판단하여 
>>> 잘 동작했을경우 commit, 둘 중 하나라도 잘 동작하지 않았을 경우 rollback을 수행
			
>>> 이곳에 직접 conn.commit과 conn.rollback을 입력해도 되지만 
>>> 둘 다 try-catch 블럭을 사용하여 Exception을 처리해줘야하므로,
>>> 코드가 길어지기 때문에 이것 또한 따로 JDBCTemplate에 메소드를 작성하여 호출하는 방식으로 사용

	if(result1 > 0 && result2 > 0) { // : 둘 다 모두 잘 작동했다면,
		commit(conn); // commit
	} else { // 하나라도 실행되지 않는다면,
		rollback(conn); // rollback하여 아무것도 삽입 X
	}
			
	close(conn);
}

👉 Service

📌 Ref. Service의 역할

1. Connection 생성
2. DAO의 메소드 호출 (논리적인 기능 단위로 묶인 메소드들을 모두 호출하므로 여러 번 호출 할 수도 있음) 
3. 트랜잭션 제어(commit, rollback)
4. Connection 종료

◼ MenuService Class

public class MenuService {

	public void registNewMenu() {
		
		/* 1. Connection 생성 */
		Connection conn = getConnection();
		
		/* 2. DAO 메소드 호출 */
		MenuDAO menuDAO = new MenuDAO();
		
		/* 2-1. 신규 카테고리 등록 */
		CategoryDTO newCategory = new CategoryDTO();
		newCategory.setCategoryName("기타");
		newCategory.setRefCategoryCode(null); 
        >>> 테이블에 null값을 넣고 싶다고해서 null을 넣으면 오류 
		>>> 필드에 선언했던 int형을 값으로 담아야하기 때문에 오류가 발생하므로, 
        >>> 따라서 Integer로 자료형 바꿔주기
		
		int result1 = menuDAO.insertNewCategory(conn, newCategory); 
        // 정상 수행되었을 때, 한 개의 행이 잘 삽입되었다는 출력
		
		/* 2-2. 신규 카테고리 등록 시 발생한 카테고리 코드 번호 조회 */
		int newCategoryCode = menuDAO.selectLastCategoryCode(conn);
		
		/* 2-3. 등록 된 신규 카테고리로 메뉴 등록 */
		MenuDTO newMenu = new MenuDTO();
		newMenu.setMenuName("메롱메롱스튜");
		newMenu.setMenuPrice(40000);
		newMenu.setCategoryCode(newCategoryCode);
		newMenu.setOrderableStatus("Y");
		
		int result2 = menuDAO.insertNewMenu(conn, newMenu);
		
		/* 3. 트랜잭션 제어 */
		if(result1 > 0 && result2 > 0) {
			System.out.println("신규 카테고리와 해당 카테고리의 신규 메뉴가 추가되었습니다 :) ");
			commit(conn);
		} else {
			System.out.println("신규 카테고리와 해당 카테고리의 신규 메뉴가 추가에 실패하였습니다 :( ");
			rollback(conn);
		}
		
		/* 4. Connection 종료 */
		close(conn);
	}
}

👉 Run

◼ Application Class

public class Application {

	public static void main(String[] args) {
		
		new MenuService().registNewMenu();
	}
}

👀 DAO를 활용한 View < 음식 주문 프로그램 >

📌 초기 Setting

◼ Setting

◼ order-query.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<!-- '1. 카테고리 전체 조회'를 위한 쿼리 -->
	<entry key="selectAllCategory">
		SELECT
				CATEGORY_CODE
			,	CATEGORY_NAME
			,	REF_CATEGORY_CODE
			FROM TBL_CATEGORY
	</entry>

	<!-- '2. 카테고리 목록에서 메뉴 고르기'를 위한 쿼리 -->
	<entry key="selectMenuByCategory">
		SELECT
				MENU_CODE
			,	MENU_NAME
			,	MENU_PRICE
			,	CATEGORY_CODE
			,	ORDERABLE_STATUS
			FROM TBL_MENU
			WHERE ORDERABLE_STATUS = 'Y'
			AND CATEGORY_CODE = ? <!-- 입력된 특정 카테고리 코드의 메뉴들만 조회하는 조건 -->
	</entry>
	
	<!-- '3. 주문 정보 넣기'를 위한 쿼리 -->
	<entry key="insertOrder">
		INSERT
			INTO TBL_ORDER
		(
			ORDER_CODE
		,	ORDER_DATE
		,	ORDER_TIME
		,	TOTAL_ORDER_PRICE
		)
		VALUES
		(
			SEQ_ORDER_CODE.NEXTVAL
		,	?
		,	?
		,	?
		)
	</entry>

	<!-- '4. 고른 메뉴의 정보 넣기'를 위한 쿼리 -->
	<entry key="insertOrderMenu">
		INSERT
			INTO TBL_ORDER_MENU
		(
			ORDER_CODE
		,	MENU_CODE
		,	ORDER_AMOUNT
		)
		VALUES
		(
			SEQ_ORDER_CODE.CURRVAL <!-- 발생시켰던 넥스트밸류를 가져오기 -->
		,	?
		,	?
		)
	</entry>
</properties>

◼ JDBCTemplate (transaction 구문 추가)

* DAO를 활용한 Service의 JDBCTemplate과 동일 *

👉 DTO

◼ CategoryDTO Class

* 'DAO를 활용한 Service'의 CategoryDTO Class와 동일 *

◼ MenuDTO Class

* 'DAO의 사용'의 MenuDTO Class와 동일 *

◼ OrderDTO Class

public class OrderDTO {

	/*
	ORDER_CODE	NUMBER
	ORDER_DATE	VARCHAR2(8 BYTE)
	ORDER_TIME	VARCHAR2(8 BYTE)
	TOTAL_ORDER_PRICE	NUMBER
	*/
	
	private int orderCode;
	private String orderDate;
	private String orderTime;
	private int totalOrderPrice;
	private List<OrderMenuDTO> orderMenuList; 
    >>> 오더 메뉴들로 이루어진 List를 orderDTO에서도 다룰 수 있게 필드에 작성

	public OrderDTO() {}

	public OrderDTO(int orderCode, String orderDate, String orderTime, int totalOrderPrice,
			List<OrderMenuDTO> orderMenuList) {
		super();
		this.orderCode = orderCode;
		this.orderDate = orderDate;
		this.orderTime = orderTime;
		this.totalOrderPrice = totalOrderPrice;
		this.orderMenuList = orderMenuList;
	}

	public int getOrderCode() {
		return orderCode;
	}

	public void setOrderCode(int orderCode) {
		this.orderCode = orderCode;
	}

	public String getOrderDate() {
		return orderDate;
	}

	public void setOrderDate(String orderDate) {
		this.orderDate = orderDate;
	}

	public String getOrderTime() {
		return orderTime;
	}

	public void setOrderTime(String orderTime) {
		this.orderTime = orderTime;
	}

	public int getTotalOrderPrice() {
		return totalOrderPrice;
	}

	public void setTotalOrderPrice(int totalOrderPrice) {
		this.totalOrderPrice = totalOrderPrice;
	}

	public List<OrderMenuDTO> getOrderMenuList() {
		return orderMenuList;
	}

	public void setOrderMenuList(List<OrderMenuDTO> orderMenuList) {
		this.orderMenuList = orderMenuList;
	}

	@Override
	public String toString() {
		return "OrderDTO [orderCode=" + orderCode + ", orderDate=" + orderDate + ", orderTime=" + orderTime
				+ ", totalOrderPrice=" + totalOrderPrice + ", orderMenuList=" + orderMenuList + "]";
	}
}

◼ OrderMenuDTO Class

public class OrderMenuDTO {

	private int orderCode;
	private int menuCode;
	private int orderAmount;
	
	public OrderMenuDTO() {}
	
	public OrderMenuDTO(int orderCode, int menuCode, int orderAmount) {
		super();
		this.orderCode = orderCode;
		this.menuCode = menuCode;
		this.orderAmount = orderAmount;
	}

	public int getOrderCode() {
		return orderCode;
	}

	public void setOrderCode(int orderCode) {
		this.orderCode = orderCode;
	}

	public int getMenuCode() {
		return menuCode;
	}

	public void setMenuCode(int menuCode) {
		this.menuCode = menuCode;
	}

	public int getOrderAmount() {
		return orderAmount;
	}

	public void setOrderAmount(int orderAmount) {
		this.orderAmount = orderAmount;
	}

	@Override
	public String toString() {
		return "OrderMenuDTO [orderCode=" + orderCode + ", menuCode=" + menuCode + ", orderAmount=" + orderAmount + "]";
	}
}

👉 DAO

◼ OrderDAO Class

public class OrderDAO {

		>>> 메소드 안이 아닌, 필드에 Properties 선언 
   		>>> (모든 메소드에서 xml 파일을 불러올 것이기 때문)
    	/* 필드 */
		private Properties prop; 
		
		/* 기본 생성자 */ >>> 필드에 대해 객체 생성 및 객체쪽으로 xml 파일을 로드해오겠다는 구문 작성
		public OrderDAO() { 
			try {
				prop = new Properties();
				prop.loadFromXML(new FileInputStream("mapper/order-query.xml"));
				
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

✅ '1. 카테고리 전체 조회'를 위한 메소드

public List<CategoryDTO> selectAllCategory(Connection conn) {
			
	PreparedStatement pstmt = null;
	ResultSet rset = null;
			
	List<CategoryDTO> categoryList = null; // 최종 반환할 리스트
			
	String query = prop.getProperty("selectAllCategory");
			
	try {
		pstmt = conn.prepareStatement(query);
		rset = pstmt.executeQuery();
				
        // while문 전에 ArrayList 객체 생성
		categoryList = new ArrayList<>();
				
		while(rset.next()) {
			CategoryDTO category = new CategoryDTO();
			category.setCategoryCode(rset.getInt("CATEGORY_CODE"));
			category.setCategoryName(rset.getString("CATEGORY_NAME"));
			category.setRefCategoryCode(rset.getInt("REF_CATEGORY_CODE"));
				
			categoryList.add(category); 
		}
		
	} catch (SQLException e) {
		e.printStackTrace();
	} finally {
		close(rset);
		close(pstmt);
		>>> Connection은 Applicaiton 클래스에서 호출하고 다 사용한 후 반납할 예정
	}	
	return categoryList; 
    >>> 반환값 누락하지않게 조심 !
}

✅ '2. 카테고리 목록에서 메뉴 고르기'를 위한 메소드

public List<MenuDTO> selectMenuByCategory(Connection conn, int categoryCode) {

	PreparedStatement pstmt = null;
	ResultSet rset = null;
	List<MenuDTO> menuList = null; // 리스트를 반환할 것
	String query = prop.getProperty("selectMenuByCategory"); // 키값 넣기
			
	try {
		pstmt = conn.prepareStatement(query); // 쿼리문 준비
		pstmt.setInt(1, categoryCode);
				
		rset = pstmt.executeQuery();
				
		menuList = new ArrayList<>();
				
		while(rset.next()) {
					
			MenuDTO menu = new MenuDTO();
			menu.setMenuCode(rset.getInt("MENU_CODE"));
			menu.setMenuName(rset.getString("MENU_NAME"));
			menu.setMenuPrice(rset.getInt("MENU_PRICE"));
			menu.setCategoryCode(rset.getInt("CATEGORY_CODE"));
			menu.setOrderableStatus(rset.getString("ORDERABLE_STATUS"));
					
			menuList.add(menu);
		}
				
	} catch (SQLException e) {
		e.printStackTrace();
	} finally {
		close(rset);
		close(pstmt);
	}
			
	return menuList;
    >>> 반환값 누락하지않게 조심 !
}

✅ '3. 주문 정보 넣기'를 위한 메소드

public int insertOrder(Connection conn, OrderDTO order) {
			
	PreparedStatement pstmt = null;
	int result = 0;
	String query = prop.getProperty("insertOrder");
			
	try {
		pstmt = conn.prepareStatement(query);
		pstmt.setString(1, order.getOrderDate());
		pstmt.setString(2, order.getOrderTime());
		pstmt.setInt(3, order.getTotalOrderPrice());
				
		result = pstmt.executeUpdate();
						
	} catch (SQLException e) {
		e.printStackTrace();
	} finally {
		close(pstmt);
	}
			
	return result;
}

✅ '4. 고른 메뉴의 정보 넣기'를 위한 메소드

public int insertOrderMenu(Connection conn, OrderMenuDTO orderMenu) {
			
	PreparedStatement pstmt = null;
	int result = 0;
	String query = prop.getProperty("insertOrderMenu");
			
	try {
		pstmt = conn.prepareStatement(query);
		pstmt.setInt(1, orderMenu.getMenuCode());
		pstmt.setInt(2, orderMenu.getOrderAmount());
				
		result = pstmt.executeUpdate();
						
	} catch (SQLException e) {
		e.printStackTrace();
	} finally {
		close(pstmt);
	}
			
	return result;
}

👉 Service

◼ OrderService Class

public class OrderService {
	
    // OrderDAO 객체 생성
	private OrderDAO orderDAO = new OrderDAO();

✅ 1. 카테고리 전체 조회

	public List<CategoryDTO> selectAllcategory() {
		
		/* 1. Connection 생성 */
		Connection conn = getConnection();
		
		/* 2. DAO의 메소드 호출하여 결과 리턴 받기 */
		List<CategoryDTO> categoryList = orderDAO.selectAllCategory(conn);
		
		/* 3. 트랜잭션 관리 (select의 경우 commit, rollback이 필요없으므로 생략) */
		/* 4. Connection 반납 */
		close(conn);
		
		return categoryList; // 최종 반환
	}

✅ 2. 카테고리 목록에서 메뉴 고르기

	public List<MenuDTO> selectMenuByCategory(int categoryCode) {
		
		/* 1. Connection 생성 */
		Connection conn = getConnection();
		
		/* 2. DAO의 메소드 호출하여 결과 리턴 받기 */
		List<MenuDTO> menuList = orderDAO.selectMenuByCategory(conn, categoryCode);
		
		/* 3. 트랜잭션 관리 (select의 경우 commit, rollback이 필요없으므로 생략) */
		/* 4. Connection 반납 */
		close(conn);
		
		return menuList;
	}

✅ 3. 주문 정보 넣기 / 4. 고른 메뉴의 정보 넣기

	public int registOrder(OrderDTO order) {
		
		/* 1. Connection 생성 */
		Connection conn = getConnection();
		
		/* 2. DAO의 메소드 호출하여 결과 리턴 받기 */
		/* 2-1. ORDER TABLE INSERT */
		int orderResult = orderDAO.insertOrder(conn, order);
		
		/* 2-2. ORDER MENU TABLE INSERT */
		List<OrderMenuDTO> orderMenuList = order.getOrderMenuList();
		int orderMenuResult = 0;
		for(OrderMenuDTO orderMenu : orderMenuList) {
			orderMenuResult += orderDAO.insertOrderMenu(conn, orderMenu);
		}
		
		int result = 0;
        >>> 전체 프로세스 성공, 실패를 나타내는 변수
		
		/* 3. 트랜잭션 관리 */
		if(orderResult > 0 && orderMenuResult == orderMenuList.size()) { // : 주문 갯수와 같니?
			commit(conn);
			result = 1; // : 같으면 result는 1이 되어 반환 (성공)
		} else {
			rollback(conn);
		}
		/* 4. Connection 반납 */
		close(conn);
		
		return result; 
		>>> orderResult 와 orderMenuResult 둘 중에 하나를 쓰기엔 
        >>> 다른 하나가 잘못된 상태로 반환이 되면 안되기 때문에 
        >>> 새로운 result라는 변수를 생성하여 넣어줌
		// 성공시에는 1, 실패시에는 0 반환
	}
}

👉 View

◼ OrderMenu Class

public class OrderMenu {
	
    // OrderService 클래스를 필드쪽에 선언하고 객체까지 생성
	private OrderService orderService = new OrderService(); 
   
	public void displayMenu() {
		
		/* 반복---------------------------
		 * 1. 카테고리 목록 조회 -> 선택
		 * 2. 해당 카테고리의 메뉴 조회 -> 선택
		 * 3. 메뉴 선택 후 주문 수량 입력 
		 * -------------------------------
		 * 4. 주문
		 * */
         
		Scanner sc = new Scanner(System.in);
		
		List<OrderMenuDTO> orderMenuList = new ArrayList<>(); 
        >>>  주문을 여러 개 담을 수 있는 리스트
        
		int totalOrderPrice = 0; 
		
		do {
			/* 1. 카테고리 목록 조회 -> 선택 */
			System.out.println("====================== 음식 주문 프로그램 ======================");
			List<CategoryDTO> categoryList = orderService.selectAllcategory(); // '이런 메소드가 필요하겠다' 라고 예상해서 작성한 것
			for(CategoryDTO category : categoryList) {
				System.out.println(category.getCategoryName());
			}
			
			System.out.println("===========================================================");
			System.out.print("주문하실 카테고리를 선택해주세요 : ");
			String inputCategoryName = sc.nextLine();
			
			// 카테코리 코드를 알아오는 반복문
			int categoryCode = 0;
            
            >>> 카테고리명을 하나씩 가져와서 사용자가 입력한 문자열과 같은지 확인 
			for(CategoryDTO category : categoryList) {
				if(category.getCategoryName().equals(inputCategoryName)) { 
                
					categoryCode = category.getCategoryCode();
				}
			}
            
            >>> 카테고리명을 입력했을 때, 카테고리가 잘 출력되는지 확인
//			System.out.println(categoryCode); 

			/* 2. 해당 카테고리의 메뉴 조회 -> 선택 */
			System.out.println("===================== " + inputCategoryName + " 주문 가능 메뉴 =====================");
			List<MenuDTO> menuList = orderService.selectMenuByCategory(categoryCode); 
            >>> 여기서 selectMenuByCategory 메소드 생성
			
			for(MenuDTO menu : menuList) { // menuList 값 뽑아오기
				System.out.println(menu);
			}
			
			/* 3. 메뉴 선택 후 주문 수량 입력 및 4. 주문하기 */
			System.out.print("주문하실 메뉴를 선택해주세요 : ");
			String inputMenu = sc.nextLine();
			System.out.print("주문하실 수량을 입력해주세요 : ");
			int orderAmount = sc.nextInt();
			sc.nextLine();
			
			int menuCode = 0;
			int menuPrice = 0;
			for(MenuDTO menu : menuList) {
				if(menu.getMenuName().equals(inputMenu)) {	// : 메뉴 이름이 입력받은 것과 동일하다면,
					menuCode = menu.getMenuCode();			// menuCode 변수에 저장 
					menuPrice = menu.getMenuPrice();		// menuPrice 변수에 저장
				}
			}
			
			OrderMenuDTO orderMenu = new OrderMenuDTO();
			orderMenu.setMenuCode(menuCode);
			orderMenu.setOrderAmount(orderAmount);
//			orderMenu.setOrderCode();
			>>> OrderCode는 시퀀스라 아직 입력 할 수 없음
			
			orderMenuList.add(orderMenu); // orderMenuList에 주문한거 추가됨
			totalOrderPrice += (menuPrice * orderAmount); // 총 액수 계산됨
			
			System.out.print("계속 주문하시겠습니까? (예/아니오) : ");
			boolean isContinue = sc.nextLine().equals("예");
			
			if(!isContinue) break;
			
		} while(true);
		
		for(OrderMenuDTO orderMenu : orderMenuList) {
			System.out.println("주문 메뉴 : " + orderMenu);
			
		}
		System.out.println("주문 총액 : " + totalOrderPrice);
		
		/* 영수증 */
		java.util.Date orderTime = new java.util.Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat("yy/MM/dd"); 
		SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");
		String date = dateFormat.format(orderTime);
		String time = timeFormat.format(orderTime);
        >>> SimpleDateFormat : 생성자쪽으로 전달된 인자처럼 문자열 포맷으로 만들어줌
        
		OrderDTO order = new OrderDTO();
		order.setOrderDate(date);
		order.setOrderTime(time);
		order.setTotalOrderPrice(totalOrderPrice);
		order.setOrderMenuList(orderMenuList); // 리스트도 넘겨줌
		
		int result = orderService.registOrder(order);
		
		if(result > 0) {
			System.out.println("주문 완료 ! :)");
		} else {
			System.out.println("주문 실패 :(");
		}
	}
}

👉 Run

◼ Application Class

public class Application {

	public static void main(String[] args) {
		
		new OrderMenu().displayMenu();
	}
}

👀 DAO를 활용한 Controller < 음식 주문 프로그램 >

💁‍♀️ Controller의 역할 🔥중요🔥

View에서 사용자가 입력한 정보를 파라미터 형태로 전달 받음

전달 받은 값들을 검증하고, 추가적인 정보가 필요한 경우 가공

Service쪽으로 전달하기 위한 인스턴스에 담고 Service에서 비즈니스 로직을 담당하는 메소드를 호출

호출한 수행 결과를 반환 받아 어떤 (Result)View를 다시 사용자에게 보여줄 것인지를 결정

🙋‍ 위의 'DAO를 활용한 View'가 일부 변경/추가된 것 이므로 동일한 코드는 생략

👉 Controller

◼ OrderController Class

public class OrderController {
	
	private OrderService orderService = new OrderService();

	/* 모든 카테고리 조회하기 */
	public List<CategoryDTO> selectAllCategory() {
		
		List<CategoryDTO> categoryList = orderService.selectAllCategory();
		
		return categoryList;
	}
	
	/* 카테고리 목록에서 메뉴 고르기 */
	public List<MenuDTO> selectMenuByCategory(int categoryCode) {
		return orderService.selectMenuByCategory(categoryCode);
	}

	/* 주문 정보 넣기 */
	public void registOrder(Map<String, Object> requestMap) {
		
		/* 1. 뷰에서 전달 받은 파라미터 꺼내서 변수에 담기 */
		int totalOrderPrice = (Integer)requestMap.get("totalOrderPrice");
		List<OrderMenuDTO> orderMenuList = (List<OrderMenuDTO>)requestMap.get("orderMenuList");
		
		/* 2. 추가적으로 필요한 값이 있는 경우 생성하기 */
		java.util.Date orderTime = new java.util.Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat("yy/MM/dd");
		SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");
		String date = dateFormat.format(orderTime);
		String time = timeFormat.format(orderTime);
		
		/* 3. 서비스쪽으로 전달하기 위해 DTO 인스턴스에 담기 */
		OrderDTO order = new OrderDTO();
		order.setDate(date);
		order.setTime(time);
		order.setTotalOrderPrice(totalOrderPrice);
		order.setOrderMenuList(orderMenuList);
		
		/* 4. 서비스(비즈니스 로직)를 호출하고 결과를 리턴 받음 */
		int result = orderService.registOrder(order);
		
		/* 5. 서비스 처리 결과를 이용해 성공 실패 여부를 판단하여 사용자에게 보여줄 뷰를 결정함 */
		ResultView resultView = new ResultView();
		if(result > 0) {
			resultView.success();
		} else {
			resultView.failed();
		}
 	}
}

👉 View

◼ OrderMenu Class

public class OrderMenu {
	
	private OrderController orderController = new OrderController();

	public void displayMenu() {
		
		/* 반복
		 * ------------------------
		 * 1. 카테고리 조회
		 * 2. 해당 카테고리의 메뉴 조회
		 * 3. 사용자에게 어떤 메뉴를 주문 받을 것인지 입력
		 * 4. 주문할 수량 입력
		 * ------------------------
		 * 5. 주문 
		 * */
		
		Scanner sc = new Scanner(System.in);
		
		List<OrderMenuDTO> orderMenuList = new ArrayList<>();
		int totalOrderPrice = 0;
		
		do {
			System.out.println("=============== 음식 주문 프로그램 ==================");
			
			List<CategoryDTO> categoryList = orderController.selectAllCategory();
			for(CategoryDTO category : categoryList) {
				System.out.println(category.getName());
			}
			
			System.out.println("=================================================");
			System.out.print("주문하실 카테고리를 선택해주세요 : ");
			String inputCategory = sc.nextLine();
			
			int categoryCode = 0;
			for(CategoryDTO category : categoryList) {
				if(category.getName().equals(inputCategory)) {
					categoryCode = category.getCode();
				}
			}
			
			System.out.println("================ 주문 가능 메뉴 ====================");
			List<MenuDTO> menuList = orderController.selectMenuByCategory(categoryCode);
			for(MenuDTO menu : menuList) {
				System.out.println(menu);
			}
			
			System.out.print("주문하실 메뉴를 선택해주세요 : ");
			String inputMenu = sc.nextLine();
			
			int menuCode = 0;
			int menuPrice = 0;
			
			for(int i = 0; i < menuList.size();  i++) {
				MenuDTO menu = menuList.get(i);
				if(menu.getName().equals(inputMenu)) {
					menuCode = menu.getCode();
					menuPrice = menu.getPrice();
				}
			}
			
			System.out.print("주문하실 수량을 입력하세요 : ");
			int orderAmount = sc.nextInt();
			
			OrderMenuDTO orderMenu = new OrderMenuDTO();
			orderMenu.setMenuCode(menuCode);
			orderMenu.setOrderAmount(orderAmount);
			
			orderMenuList.add(orderMenu);
			totalOrderPrice += (menuPrice * orderAmount);
			
			System.out.print("계속 주문하시겠습니까?(예/아니오) : ");
			sc.nextLine();
			boolean isContinue = sc.nextLine().equals("예") ? true : false;
			
			if(!isContinue) break;
			
		} while(true);
		
		for(OrderMenuDTO orderMenu : orderMenuList) {
			System.out.println(orderMenu);
		}

		Map<String, Object> requestMap = new HashMap<>();
		requestMap.put("totalOrderPrice", totalOrderPrice);
		requestMap.put("orderMenuList", orderMenuList);
		
		orderController.registOrder(requestMap);
	}
}

◼ ResultView Class

public class ResultView {
	
	public void success() {
		System.out.println("주문에 성공하셨습니다.");
	}

	public void failed() {
		System.out.println("주문에 실패하셨습니다.");
	}
}

Joy🌱

Tiny little habits make me

이전 포스트

DAO(Data Access Object)

🐘 JDBC

👀 DAO의 사용

📌 초기 Setting

◼ Setting

◼ menu-query.xml

◼ JDBCTemplate

👉 DTO

◼ CategoryDTO Class

◼ MenuDTO Class

👉 DAO

◼ MenuDAO Class

✅ '1. 카테고리 전체 조회'를 위한 메소드

✅ '2. 신규 메뉴 등록'을 위한 메소드

👉 RUN

◼ Application Class

✅ 1. 카테고리 목록 조회

✅ 2. 신규 메뉴 등록

👀 DAO를 활용한 Service < 신규 메뉴 등록 프로그램 >

📌 초기 Setting

◼ Setting

◼ menu-query.xml

◼ JDBCTemplate (transaction 구문 추가)

👉 DTO

◼ CategoryDTO Class

◼ MenuDTO Class

👉 DAO

◼ MenuDAO Class

✅ '1. 신규 카테고리 등록'을 위한 메소드

✅ '2. 마지막 카테고리 코드 조회'를 위한 메소드

✅ '3. 신규 메뉴 등록'을 위한 메소드

👉 Transaction

◼ Application Class

✅ Transaction 수행 🔥중요🔥

👉 Service

◼ MenuService Class

👉 Run

◼ Application Class

👀 DAO를 활용한 View < 음식 주문 프로그램 >

📌 초기 Setting

◼ Setting

◼ order-query.xml

◼ JDBCTemplate (transaction 구문 추가)

👉 DTO

◼ CategoryDTO Class

◼ MenuDTO Class

◼ OrderDTO Class

◼ OrderMenuDTO Class

👉 DAO

◼ OrderDAO Class

✅ '1. 카테고리 전체 조회'를 위한 메소드

✅ '2. 카테고리 목록에서 메뉴 고르기'를 위한 메소드

✅ '3. 주문 정보 넣기'를 위한 메소드

✅ '4. 고른 메뉴의 정보 넣기'를 위한 메소드

👉 Service

◼ OrderService Class

✅ 1. 카테고리 전체 조회

✅ 2. 카테고리 목록에서 메뉴 고르기

✅ 3. 주문 정보 넣기 / 4. 고른 메뉴의 정보 넣기

👉 View

◼ OrderMenu Class

👉 Run

◼ Application Class

👀 DAO를 활용한 Controller < 음식 주문 프로그램 >

👉 Controller

◼ OrderController Class

👉 View

◼ OrderMenu Class

◼ ResultView Class

CRUD (Create, Read, Update, Delete)

0개의 댓글