Mybatis를 활용한 CRUD (CRUD with Mybatis)

💁‍♀️ CRUD란,
대부분의 컴퓨터 소프트웨어가 가지는 기본적인 데이터 처리 기능인 Create(생성), Read(읽기), Update(갱신), Delete(삭제)를 묶어서 일컫는 말

---

📌 초기 Setting

• lib 폴더에 ojdbc8.jar / mybatis-3.5.11.jar 파일 삽입
• Classpath에 ojdbc8.jar / mybatis-3.5.11.jar 파일 추가

📌 Ref. mybatis.jar 파일 다운로드
mybatis-3.5.11.jar

---

👀 XMLconfig 방식

💁‍ 나열된 클래스 및 파일 순서가 곧 작성 순서이므로, 흐름 잘 파악하기 🔥중요🔥
(자세한 작성 순서는 [ ] 안에 있는 설명을 참고할 것)

👉 mybatis-config.xml

Mybatis에서 '시작하기' > 'XML에서 SqlSessionFactory 빌드하기' 탭 아래의 템플릿을 복사하여 값 채워넣기

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <environments default="dev">
    <environment id="dev">
    
      <transactionManager type="JDBC"/>	<!-- JDBC와 MANAGED 선택 가능
    										JDBC : 수동 커밋, MANEGED : 자동 커밋 -->
     
      <dataSource type="POOLED">  <!-- POOLED와 UNPOOLED 선택 가능
      								POOLED : 커넥션 풀 사용, UNPOOLED : 커넥션풀 미사용 -->
                                    
        <property name="driver" value="oracle.jdbc.driver.OracleDriver"/>
        <property name="url" value="jdbc:oracle:thin:@localhost:1521:xe"/>
        <property name="username" value="C##GREEDY"/>
        <property name="password" value="GREEDY"/>
        
      </dataSource>
    </environment>
  </environments>
  <mappers> <!-- 매핑을 위해 mapper 등록 -->
  <mapper resource="com/greedy/section01/xmlconfig/menu-mapper.xml"/>
  </mappers>
  
</configuration>

👉 Template

public class Template {
	
	>>> 'SqlSessionFactory'는 애플리케이션을 실행하는 동안 존재해야함
	>>> 애플리케이션이 실행 되는 동안 여러 차례 SqlSessionFactory를 다시 빌드하지 않는 것이 가장 좋은 형태
	>>> 애플리케이션 스코프로 관리하기 위한 가장 간단한 방법은 '싱글톤 패턴'을 이용하는 것
    
    // '싱글톤패턴'을 위해 필드(공간) 생성
	private static SqlSessionFactory sqlSessionFactory;

	public static SqlSession getSqlSession() {
		
		if(sqlSessionFactory == null) { // 단 하나만 생성될 수 있도록 보장하기 위해 
										// try-catch문을 이 조건의 if문으로 감싸기 
										// 한번 생성된 이후로는 null이 아니므로 다시 build를 수행 X
                                        >>> '싱글톤패턴'
			try {
				String resource = "com/greedy/section01/xmlconfig/mybatis-config.xml";
				InputStream inputStream = Resources.getResourceAsStream(resource);
		
				>>> 'SqlSessionFacoryBuilder는 생성 후 유지할 필요 X
				>>> 따라서 '메소드 스코프'로 생성
                
				sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	>>> 'SqlSession'은 요청 시마다 생성해야함
	>>> SqlSession은 스레드에 안전하지 않기 때문에 공유되지 않아야함
	>>> 요청 시 생성하고 요청이 완료되면 close하는 HTTP요청과 유사한 스코프에 두는 것이 가장 올바른 방법
    >>> (따라서 Service에서 getSqlSession()메소드로 SqlSession를 호출하고 사용한 뒤, 그 스코프에서 반납)
    
	SqlSession sqlSession = sqlSessionFactory.openSession(false);
	
    // sqlSession 사용한 후 반납
 	return sqlSession; 
	}
}

📌 Ref.

* singleton(싱글톤)
  : 오로지 하나의 객체만 만들어지는 것을 보장

👉 MenuDTO

private int menuCode;
private String menuName;
private int menuPrice;
private int categoryCode;
private String orderableStatus;

/* 기본 생성자, 모든 매개변수가 존재하는 생성자 */
...

/* getter & setter */
...

/* toString */
...

👉 Application

Scanner sc = new Scanner(System.in);
MenuController menucontroller = new MenuController();
		
do {
	System.out.println("===== 메뉴 관리 =====");
	System.out.println("1. 메뉴 전체 조회");
	System.out.println("2. 메뉴 코드로 메뉴 조회");
	System.out.println("3. 신규 메뉴 추가");
	System.out.println("4. 메뉴 수정");
	System.out.println("5. 메뉴 삭제");
	System.out.print("메뉴 관리 번호를 입력 : ");
	int no = sc.nextInt();
			
	switch(no) {
	case 1: menucontroller.selectAllMenu(); break; // [MenuController 클래스 생성 및 selectAllMenu()메소드 생성]
	case 2: menucontroller.selectMenuByCode(inputMenuCode()); break; 
    		// 아래의 inputMenuCode() 메소드의 반환값이 selectMenuByCode()의 인자로 넘어감 
	case 3: menucontroller.registMenu(inputMenu()); break;
	case 4: menucontroller.updateMenu(inputModifyMenu()); break;
	case 5: menucontroller.deleteMenu(inputMenuCode()); break;
	default : System.out.println("잘못 된 메뉴를 선택하셨습니다.");
	}
} while(true);	
}

◼ 메뉴 코드를 입력받아 Map으로 값을 설정하여 MenuController로 넘기는 메소드

	private static Map<String, String> inputMenuCode(){
		
		Scanner sc = new Scanner(System.in);
		System.out.print("메뉴 코드 입력 : ");
		String code = sc.nextLine();
		
		Map<String, String> parameter = new HashMap<>();
		parameter.put("code", code);
		
		return parameter;
	}

◼ 메뉴 이름, 가격, 카테고리 코드를 입력받아 Map으로 값을 설정하여 MenuController로 넘기는 메소드

	private static Map<String, String> inputMenu() {
		
		Scanner sc = new Scanner(System.in);
		System.out.print("메뉴 이름 : ");
		String name = sc.nextLine();
		System.out.print("메뉴 가격 : ");
		String price = sc.nextLine();
		System.out.print("카테고리 코드 : ");
		String CategoryCode = sc.nextLine();
		
		Map<String, String> parameter = new HashMap<>();
		parameter.put("name", name);
		parameter.put("price", price);
		parameter.put("categoryCode", CategoryCode);
		
		return parameter;
	}

◼ 수정하고자 하는 메뉴의 메뉴 코드 및 이름, 가격, 카테고리 코드를 입력받아 Map으로 값을 설정하여 MenuController로 넘기는 메소드

	private static Map<String, String> inputModifyMenu() {
		
		Scanner sc = new Scanner(System.in);
		System.out.print("수정할 메뉴의 메뉴 코드 : ");
		String code = sc.nextLine();
		System.out.print("수정할 메뉴 이름 : ");
		String name = sc.nextLine();
		System.out.print("수정할 메뉴 가격 : ");
		String price = sc.nextLine();
		System.out.print("수정할 카테고리 코드 : ");
		String CategoryCode = sc.nextLine();
		
		Map<String, String> parameter = new HashMap<>();
		parameter.put("code", code);
		parameter.put("name", name);
		parameter.put("price", price);
		parameter.put("categoryCode", CategoryCode);
		
		return parameter;
	}

👉 MenuController

💁‍ Controller의 역할

• View에서 사용자가 입력한 정보를 매개변수로 전달 받으면 전달 받은 값들을 검증 / 추가적인 정보가 필요한 경우 가공
• Service로 전달하기 위한 인스턴스에 담고 메소드 호출
• 호출한 수행 결과를 반환 받아 어떠한 View를 다시 사용자에게 보여줄 것인지를 결정

public class MenuController {

	/* final로 선언 후 생성자에서 초기화할 것 */
	private final MenuService menuService;	// [MenuService 필드 선언 후 클래스 만들기]
	private final PrintResult printResult;	// [PrintResult 필드 선언 후 클래스 만들기]
	
    /* 작성된 필드 초기화 */
	public MenuController() {
		menuService = new MenuService();
		printResult = new PrintResult();
	}

◼ '1. 메뉴 전체 조회'를 위한 메소드

	public void selectAllMenu() {
		
		List<MenuDTO> menuList = menuService.selectAllMenu(); 
        // [menuService 클래스 생성하여 selectAllMenu()메소드 생성]
		
		/* 사용자에게 보여줄 Result View */
		if(menuList != null) {
			printResult.printMenuList(menuList);
		} else {
			printResult.printErrorMessage("selectList");
		}
		
	}

◼ '2. 메뉴 코드로 메뉴 조회'를 위한 메소드

	public void selectMenuByCode(Map<String, String> parameter) {
		
		/* 전달되는 parameter는 String으로 받아오기 때문에 int로 parsing */
		int code = Integer.parseInt(parameter.get("code"));
		
		MenuDTO menu = menuService.selectMenuByCode(code); 
        // [menuService에 selectMenuByCode() 메소드 만들면서 인자전달]
		
		if(menu != null) {
			printResult.printMenu(menu);
		} else {
			printResult.printErrorMessage("selectOne");
		}
	}

◼ '3. 신규 메뉴 추가'를 위한 메소드

	public void registMenu(Map<String, String> parameter) {
		
		/* 전달되는 parameter는 String으로 받아오기 때문에 int로 parsing */
		/* 값이 여러 개이므로 MenuDTO를 이용하는 것이 편리 */
		MenuDTO menu = new MenuDTO();
		menu.setMenuName(parameter.get("name"));
		menu.setMenuPrice(Integer.parseInt(parameter.get("price")));
		menu.setCategoryCode(Integer.parseInt(parameter.get("categoryCode")));
		
		if(menuService.registMenu(menu)) { // [menuService에 registMenu()메소드 생성하면서 인자전달]
			printResult.printSuccessMessage("insert"); // [printResult에 printSuccessMessage() 메소드 생성]
		} else {
			printResult.printErrorMessage("insert");
		}
		
	}

◼ '4. 메뉴 수정'을 위한 메소드

	public void updateMenu(Map<String, String> parameter) {
		
		/* 전달되는 parameter는 String으로 받아오기 때문에 int로 parsing */
		/* 값이 여러 개이므로 MenuDTO를 이용하는 것이 편리 */
		MenuDTO menu = new MenuDTO();
		menu.setMenuCode(Integer.parseInt(parameter.get("code")));
		menu.setMenuName(parameter.get("name"));
		menu.setMenuPrice(Integer.parseInt(parameter.get("price")));
		menu.setCategoryCode(Integer.parseInt(parameter.get("categoryCode")));
		
		if(menuService.modifyMenu(menu)) {
			printResult.printSuccessMessage("update"); 
		} else {
			printResult.printErrorMessage("update");
		}
		
	}

◼ '5. 메뉴 삭제'를 위한 메소드

	public void deleteMenu(Map<String, String> parameter) {
		
        /* 전달되는 parameter는 String으로 받아오기 때문에 int로 parsing */
		int code = Integer.parseInt(parameter.get("code"));
        
        /* DELETE는 DTO를 사용할 필요 X */
		
		if(menuService.deleteMenu(code)) {
			printResult.printSuccessMessage("delete"); 
		} else {
			printResult.printErrorMessage("delete");
		}
	}
}

👉 MenuService

💁‍ Service의 역할

• SqlSession(Connection) 생성
• DAO의 메소드 호출
  : 논리적인 기능 단위로 묶인 메소드들을 모두 호출하므로 여러번 호출 할 수도 있음
• 트랜잭션 제어 (commit, rollback)
• SqlSession(Connection) 반납

public class MenuService {
	
	private final MenuDAO menuDAO; // [MenuDAO 클래스 생성]
	
	public MenuService() {
		menuDAO = new MenuDAO();
	}

◼ '1. 메뉴 전체 조회'를 위한 메소드

	public List<MenuDTO> selectAllMenu() {
		
		/* SqlSession 호출 (getConnection()과 같음) */
		SqlSession sqls = getSqlSession();
	
		List<MenuDTO> menuList = menuDAO.selectAllMenu(sqls); 
        // [menuDAO에 selectAllMenu()메소드 생성 및 인자 전달]
        >>> Service는 항상 DAO의 메소드를 호출하며 SqlSession(Connection) 전달
		
		/* SELECT이므로 트랜잭션(commit, rollback) 필요 X */
		
		/* 반납 */
		sqls.close();
		
		/* 반환(전달) */
		return menuList;
	}

◼ '2. 메뉴 코드로 메뉴 조회'를 위한 메소드

	public MenuDTO selectMenuByCode(int code) {
		
		SqlSession sqls = getSqlSession();
		
		MenuDTO menu = menuDAO.selectMenuByCode(sqls, code);
		
		sqls.close();
		
		return menu;
	}

◼ '3. 신규 메뉴 추가'를 위한 메소드

	public boolean registMenu(MenuDTO menu) { >>> 반환값이 true or false이므로 boolean타입
		
		SqlSession sqls = getSqlSession();
		
		/* INSERT 이므로 int로 결과값 반환 */
		int result = menuDAO.insertMenu(sqls, menu); 
        // [menuDAO에 insertMenu()메소드 생성 및 인자들 전달]
		
		/* 트랜잭션 관리 */ 
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		} 
         >>> 따로 템플릿에 commit, rollback코드를 작성하지 않아도 Mybatis의 메소드 사용 가능 !
		
		sqls.close();
		
		return result > 0 ? true : false;
	}

◼ '4. 메뉴 수정'을 위한 메소드

	public boolean modifyMenu(MenuDTO menu) {
		
		SqlSession sqls = getSqlSession();
		
		/* UPDATE 이므로 int로 결과값 반환 */
		int result = menuDAO.updateMenu(sqls, menu);
		
		/* 트랜잭션 관리 */
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}

◼ '5. 메뉴 삭제'를 위한 메소드

	public boolean deleteMenu(int code) {
		
		SqlSession sqls = getSqlSession();
		
		/* DELETE 이므로 int로 결과값 반환 */
		int result = menuDAO.deleteMenu(sqls, code);
		
		/* 트랜잭션 관리 */
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}
}

👉 MenuDAO

💁‍ DAO의 역할

• 메소드가 호출되면 그에 상응하는 Mybatis의 메소드를 이용하여 mapper.xml파일 호출한 뒤, 그것을 반환

Mybatis의 자체 메소드로 인해 DAO에서 메소드를 비효율적으로 여러 번 적을 일이 현저히 줄어들었음 (프레임워크 사용의 장점)

public class MenuDAO { 

	public List<MenuDTO> selectAllMenu(SqlSession sqls) {

	 /* return sqls.selectList("namespace.id"); */ >>> 접근 방식
		return sqls.selectList("MenuMapper.selectAllMenu"); 
        // 조회하고 싶은 것이 MenuDTO의 리스트이므로 selectList()메소드 활용
		// 괄호 안에는 어떤 쿼리문을 전달할 것인지 작성 ("namespace.id") *menu-mapper.xml 참고
	}

	public MenuDTO selectMenuByCode(SqlSession sqls, int code) {
		
		return sqls.selectOne("MenuMapper.selectMenuByCode", code); 
        // "MenuMapper.selectMenuByCode" : 조회하고자하는 쿼리문
		// code : 수행 시, 사용될만한 추가적인 값
	}

	public int insertMenu(SqlSession sqls, MenuDTO menu) {

		return sqls.insert("MenuMapper.insertMenu", menu); 
	}

	public int updateMenu(SqlSession sqls, MenuDTO menu) {

		return sqls.update("MenuMapper.updateMenu", menu);
	}

	public int deleteMenu(SqlSession sqls, int code) {

		return sqls.delete("MenuMapper.deleteMenu", code);
	}
}

👉 menu-mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="MenuMapper">

	<!-- 조회한 컬럼과 DTO를 매핑(연결)시키기 위한 설정으로 resultMap을 선언 -->
	<resultMap type="com.greedy.section01.xmlconfig.MenuDTO" id="menuResultMap">
		<id property="menuCode" column="MENU_CODE"/> <!-- property="DTO의 필드 명칭" -->
		<result property="menuName" column="MENU_NAME"/> <!-- result에는 id에 입력하지않은 나머지 모두 입력 -->
		<result property="menuPrice" column="MENU_PRICE"/>
		<result property="categoryCode" column="CATEGORY_CODE"/>
		<result property="orderableStatus" column="ORDERABLE_STATUS"/>
	</resultMap>

  <select id="selectAllMenu" resultMap="menuResultMap"> <!-- 결과값을 "menuResultMap"를 이용해서 매핑시킬 것-->
    SELECT
    		MENU_CODE
    	,	MENU_NAME
    	,	MENU_PRICE
    	,	CATEGORY_CODE
    	,	ORDERABLE_STATUS
    	FROM TBL_MENU
    	WHERE ORDERABLE_STATUS = 'Y'
    	ORDER BY MENU_CODE
  </select>
  
  <select id="selectMenuByCode" parameterType= "_int" resultMap="menuResultMap"> 
  <!-- 위와 마찬가지로 DTO에서 참조해오기 때문에 resultMap으로 동일하게 작성 -->
  <!-- parameterType= "_int" : 마이바티스에서 제공하는 별칭으로 표기. int는 '_int' (명시하지 않아도 동작에 문제 X) -->
  <!-- 파라미터가 한 개인 경우 바인딩 되는 이름(ex:code)은 무엇을 작성해도 상관 X. parameterType 또한 지정하지않아도 됨.
  		resultMap : 위에서 정의한 resultMap을 리턴 타입으로 이용하는 경우
  		resultType : 이미 정의되어있는 타입을 리턴 타입으로 이용하는 경우 
  -->
  	SELECT
    		MENU_CODE
    	,	MENU_NAME
    	,	MENU_PRICE
    	,	CATEGORY_CODE
    	,	ORDERABLE_STATUS
    	FROM TBL_MENU
    	WHERE ORDERABLE_STATUS = 'Y'
    	AND MENU_CODE = #{ code } <!-- code 대신 다른 문자 가능 -->
    	<!-- ?(위치홀더)가 아닌 #{ code }처럼 어떤 값을 넣을지 확실히 명시해야함
			(위치홀더에 값을 넣는 코드를 MyBatis가 대신 실행하므로 따로 값을 넣을 기회 X) -->
  </select>
  

  <!-- insert, update, delete의 경우 resultType 작성 X. 
		기본 _int로 수행 결과 행의 갯수를 리턴. parameterType은 생략 가능
  		파라미터로 전달 된 DTO의 필드명으로 값을 바인딩 해줘야한다. getter를 이용하며 gertter가 없는 경우 에러 발생-->
  <insert id="insertMenu" parameterType="com.greedy.section01.xmlconfig.MenuDTO"> 
  <!-- parameterType에 MenuDTO의 클래스를 기입(명시 필수X)-->
  	INSERT
  		INTO TBL_MENU
  	(
  		MENU_CODE
  	,	MENU_NAME
  	,	MENU_PRICE
  	,	CATEGORY_CODE
  	,	ORDERABLE_STATUS
  	)
  	VALUES
  	(
  		SEQ_MENU_CODE.NEXTVAL
    <!-- Mybatis에서 제공하는 기능이므로, 필드명과 정확히 일치하게 작성 및 DTO에 getter 메소드 존재해야함 --> 
  	, #{ menuName } 
  	, #{ menuPrice }
  	, #{ categoryCode }
  	, 'Y' <!-- 이미 'Y'로 fix된 값임 -->
  	)
  </insert>
  
  <update id="updateMenu" parameterType="com.greedy.section01.xmlconfig.MenuDTO">
  	UPDATE
  			TBL_MENU
  		SET MENU_NAME = #{ menuName }
  		,	MENU_PRICE = #{ menuPrice }
  		,	CATEGORY_CODE = #{ categoryCode }
  		WHERE MENU_CODE = #{ menuCode }
  </update>
  
  <delete id="deleteMenu" parameterType="_int">
  	DELETE
  		FROM TBL_MENU
  		WHERE MENU_CODE = #{ menuCode } 
    	<!-- 값이 하나이므로, 여기서는 아무 단어가 들어가도 상관 X -->
  </delete>
  
</mapper>

👉 PrintResult

public class PrintResult {

	/* 전달 된 리스트 출력용으로 사용하는 메소드 */
	public void printMenuList(List<MenuDTO> menuList) {
		for(MenuDTO menu : menuList) {
			System.out.println(menu);
		}
		
	}
	
	/* 전달 된 문자열 출력용으로 사용하는 메소드 */
	public void printMenu(MenuDTO menu) {
		System.out.println(menu);
	}

	/* 에러 메세지 호출용으로 사용하는 메소드 */
	public void printErrorMessage(String errorCode) { >>> 매개변수로 errorCode 올 예정
		
		String errorMessage = "";
		switch(errorCode) {
		case "selectList" : errorMessage = "메뉴 목록 조회에 실패하였습니다."; break;
		case "selectOne" : errorMessage = "메뉴 조회에 실패하였습니다."; break;
		case "insert" : errorMessage = "메뉴 등록에 실패하였습니다."; break;
		case "update" : errorMessage = "메뉴 수정에 실패하였습니다."; break;
		case "delete" : errorMessage = "메뉴 삭제에 실패하였습니다."; break;
		
		}
		
		System.out.println(errorMessage);
		
	}

	/* 성공 메세지 호출용으로 사용하는 메소드 */
	public void printSuccessMessage(String successCode) {
		
		String successMessage = "";
		switch(successCode) {
		case "insert" : successMessage = "메뉴 등록에 성공하였습니다."; break;
		case "update" : successMessage = "메뉴 수정에 성공하였습니다."; break;		
		case "delete" : successMessage = "메뉴 삭제에 성공하였습니다."; break;		
		}
		
		System.out.println(successMessage);
	}
}

---

👀 JAVAconfig 방식

💁‍♀️ JAVAconfig 방식은 XMLconfig 방식과 기능적으로는 완전히 동일하나, 코드 작성 부분에서 약간의 차이 존재

• MenuDTO, Application, MenuController, PrintResult 클래스는 XMLconfig 방식과 완벽히 동일
• MenuService에서 MenuDAO가 아닌 MenuMapper 인터페이스를 직접 호출하여 MenuDAO 클래스 존재 X
• 마찬가지로 menu-mapper.xml파일이 아닌 MenuMapper 인터페이스를 활용하므로 mybatis-config.xml파일 존재 X

👉 Template

public class Template {
	
    /* 연결할 데이터베이스의 정보를 필드로 작성 */
	private static String DRIVER = "oracle.jdbc.driver.OracleDriver";
	private static String URL = "jdbc:oracle:thin:@localhost:1521:xe";
	private static String USER = "C##GREEDY";
	private static String PASSWORD = "GREEDY";

	private static SqlSessionFactory sqlSessionFactory; 

	public static SqlSession getSqlSession() {
		
		if(sqlSessionFactory == null) {
				
			/* 환경 객체 생성 */
			Environment environment = new Environment("dev"
													, new JdbcTransactionFactory()
													, new PooledDataSource(DRIVER, URL, USER, PASSWORD)
                                                    );
				
			Configuration configuration = new Configuration(environment);
			
			configuration.addMapper(MenuMapper.class); 
            // [ MenuMapper 인터페이스 생성 ]
			
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
			
	}
	
    // sqlSession 사용한 후 반납 (.xmlconfig 보다 간단하게 작성 가능)
	return sqlSessionFactory.openSession(false); 
	}
}

👉 MenuDTO

* XMLconfig 방식의 MenuDTO와 동일 *

👉 Application

* XMLconfig 방식의 Application와 동일 *

👉 MenuController

* XMLconfig 방식의 MenuController와 동일 *

👉 MenuService

public class MenuService { 
/* MenuController로 부터 인자를 전달받으며 메소드들을 생성 */

	/* 생성해둔 MenuMapper 인터페이스를 필드에 먼저 선언 */
	private MenuMapper menuMapper; 

◼ '1. 메뉴 전체 조회'를 위한 메소드

	public List<MenuDTO> selectAllMenu() {
		
		/* SqlSession 호출 */
		SqlSession sqls = getSqlSession();
		
		/* MenuMapper의 메소드 호출 및 값 반환받기 */
		menuMapper = sqls.getMapper(MenuMapper.class);
		List<MenuDTO> menuList = menuMapper.selectAllMenu(); 
        // [ menuMapper 인터페이스에 selectAllMenu() 생성 ]
		
		sqls.close();
		
		return menuList;
	}

◼ '2. 메뉴 코드로 메뉴 조회'를 위한 메소드

	public MenuDTO selectMenuByCode(int code) {
		
		/* SqlSession 및 menuMapper 호출 */
		SqlSession sqls = getSqlSession();
		menuMapper = sqls.getMapper(MenuMapper.class);
		
		MenuDTO menu = menuMapper.selectMenuByCode(code);
        // [ MenuMapper 인터페이스에 selectMenuByCode() 생성 ]
		
		sqls.close();
		
		return menu;
	}

◼ '3. 신규 메뉴 추가'를 위한 메소드

	public boolean registMenu(MenuDTO menu) {
		
		/* SqlSession 및 menuMapper 호출 */
		SqlSession sqls = getSqlSession();
		menuMapper = sqls.getMapper(MenuMapper.class);
		
		/* INSERT이므로 int로 반환받기 */
		int result = menuMapper.insertMenu(menu);
		
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}

◼ '4. 메뉴 수정'을 위한 메소드

	public boolean modifyMenu(MenuDTO menu) {
		
		/* SqlSession 및 menuMapper 호출 */
		SqlSession sqls = getSqlSession();
		menuMapper = sqls.getMapper(MenuMapper.class);
		
		/* UPDATE이므로 int로 반환받기 */
		int result = menuMapper.modifyMenu(menu);
		
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}

◼ '5. 메뉴 삭제'를 위한 메소드

	public boolean deleteMenu(int code) {
		
		/* SqlSession 및 menuMapper 호출 */
		SqlSession sqls = getSqlSession();
		menuMapper = sqls.getMapper(MenuMapper.class);
		
		/* DELETE이므로 int로 반환받기 */
		int result = menuMapper.deleteMenu(code);
		
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}
}

👉 MenuMapper

💁‍ MenuMapper의 역할
menu-mapper.xml파일에 입력했던 resultMap 및 쿼리문을 java형식으로 작성

public interface MenuMapper {

	/* @Results : 이곳에 정의된 대로 매핑 (어떤 컬럼에 어떤 값(필드명)을 넣을지 작성) */
	@Results(id = "menuResultMap", value= { 
			@Result(id = true, property = "menuCode", column = "MENU_CODE"),
			@Result(property = "menuName", column = "MENU_NAME"),
			@Result(property = "menuPrice", column = "MENU_PRICE"),
			@Result(property = "categoryCode", column = "CATEGORY_CODE"),
			@Result(property = "orderableStatus", column = "ORDERABLE_STATUS")
	}) 
	
	/* 1. 메뉴 전체 조회 */
	@Select("SELECT \n" +
			"		MENU_CODE\n" +
			"	,	MENU_NAME\n" +
			"	,	MENU_PRICE\n" +
			"	,	CATEGORY_CODE\n" +
			"	,	ORDERABLE_STATUS\n" +
			"	FROM TBL_MENU\n" +
			"	WHERE ORDERABLE_STATUS = 'Y'\n" +
			"	ORDER BY MENU_CODE") // SELECT 구문을 작성
	List<MenuDTO> selectAllMenu();
	
	/* 2. 메뉴 코드로 메뉴 조회 */
	@ResultMap("menuResultMap") // 위에서 작성한 resultMap을 다시 사용 가능 // @ResultMap(id)
	@Select("SELECT \n" +
			"		MENU_CODE\n" +
			"	,	MENU_NAME\n" +
			"	,	MENU_PRICE\n" +
			"	,	CATEGORY_CODE\n" +
			"	,	ORDERABLE_STATUS\n" +
			"	FROM TBL_MENU\n" +
			"	WHERE ORDERABLE_STATUS = 'Y'\n" +
			"	AND MENU_CODE = #{ code }") 
	MenuDTO selectMenuByCode(int code);

	/* 3. 신규 메뉴 추가 */
	@Insert("INSERT\n" + 
			"  INTO TBL_MENU\n" +
			"(\n" +
			"  MENU_CODE\n" +
			", MENU_NAME\n" +
			", MENU_PRICE\n" +
			", CATEGORY_CODE\n" +
			", ORDERABLE_STATUS\n" +
			")\n" +
			"VALUES\n" +
			"(\n" +
			"  SEQ_MENU_CODE.NEXTVAL\n" +
			", #{ menuName }\n" +
			", #{ menuPrice }\n" +
			", #{ categoryCode }\n" +
			", 'Y'\n" +
			")")
	int insertMenu(MenuDTO menu);

	/* 4. 메뉴 수정 */
	@Update("UPDATE\n" +
			"		TBL_MENU\n" +
			"	SET MENU_NAME = #{ menuName }\n" + // #{ } 값은 필드명과 정확히 일치하도록 작성
			"	,	MENU_PRICE = #{ menuPrice }\n" +
			"	,	CATEGORY_CODE = #{ categoryCode }\n" +
			"	WHERE MENU_CODE = #{ menuCode }") 
	int modifyMenu(MenuDTO menu);

	
	/* 5. 메뉴 삭제 */
	@Delete("DELETE\n" +
			"	FROM TBL_MENU\n" +
			"	WHERE MENU_CODE = #{ code }")
	int deleteMenu(int code);

}

👉 PrintResult

* XMLconfig 방식의 PrintResult와 동일 *

---

👀 XMLconfig + JAVAconfig 방식 (Remix)

💁‍♀️ XMLconfig + JAVAconfig 방식이란,
JAVAconfig는 XMLconfig보다 적은 클래스로 더 효율적인 방식으로 데이터베이스와 연결. 하지만 MenuMapper 인터페이스와 작성한 것과 같이 굉장히 번거롭게 쿼리문을 개행하며 작성해야한다는 단점 존재.
따라서, AVAconfig 방식에 XMLconfig의 menu-mapper.xml파일을 연동시켜 두 방식의 장점만을 사용한 방식을 일컫음

---

🙋‍ 잠깐 ! 어떻게 연동을 시키나요 ? 🔥중요🔥
[1] 해당 프로젝트에 mappers 라는 소스폴더를 생성하고 하위에 com.greedy.section03.remix 패키지 생성
[2] .xmlconfig의 menu-mapper.xml를 패키지 안에 복사
[3] MenuMapper 인터페이스와 연동시키기 위해 menu-mapper.xml파일의 이름을 MenuMapper.xml로 변경
[4] MenuMapper.xml의 namespace를 "com.greedy.section03.remix.MenuMapper"로 설정 (같은 경로)
[5] .xmlconfig에서 복사해온 파일이므로 모든 부분을 section03.remix로 수정 (ex : "com.greedy.section03.remix.MenuDTO")
👉 위 과정을 모두 실행해주면 MenuMapper에 힘들게 쿼리문을 개행해가며 작성할 필요없이 .xml 파일을 참조하여 사용 가능

---

👉 Template

* JAVAconfig 방식의 Template와 동일 *

👉 MenuDTO

* XMLconfig 방식 및 JAVAconfig 방식의 MenuDTO와 동일 *

👉 Application

* XMLconfig 방식 및 JAVAconfig 방식의 Application와 동일 *

👉 MenuController

* XMLconfig 방식 및 JAVAconfig 방식의 MenuController와 동일 *

👉 MenuService

* JAVAconfig 방식의 MenuService와 동일 *

👉 MenuMapper

public interface MenuMapper { 
	/* 원래 구구절절 쿼리문을 어렵게 작성해야했으나, 메소드만 작성 */

	/* 1. 메뉴 전체 조회 */
	List<MenuDTO> selectAllMenu();
	
	/* 2. 메뉴 코드로 메뉴 조회 */
	MenuDTO selectMenuByCode(int code);

	/* 3. 신규 메뉴 추가 */
	int insertMenu(MenuDTO menu);

	/* 4. 메뉴 수정 */
	int updateMenu(MenuDTO menu);

	/* 5. 메뉴 삭제 */
	int deleteMenu(int code);
}

👉 MenuMapper.xml 🔥중요🔥

💁‍♀️ 반드시 경로가 MenuMapper 인터페이스와 일치하도록 변경
(com.greedy.section03.remix.@@@)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <!-- 
  		mapper를 DAO 인터페이스와 동일한 패키지에 두고 DAO 인터페이스의 풀네임을 namespace로 지정한다.
  		또한 매퍼 인터페이스와 XML의 이름이 동일해야함
  		작성한 메소드의 이름과 id가 일치하며 리턴 타입이 일치하는 쿼리문을 모두 작성해야함
  -->
<mapper namespace="com.greedy.section03.remix.MenuMapper">

	<!-- 조회한 컬럼과 DTO를 매핑(연결)시키기 위한 설정으로 resultMap을 선언 -->
	<resultMap type="com.greedy.section03.remix.MenuDTO" id="menuResultMap">
		<id property="menuCode" column="MENU_CODE"/>
		<result property="menuName" column="MENU_NAME"/>
		<result property="menuPrice" column="MENU_PRICE"/>
		<result property="categoryCode" column="CATEGORY_CODE"/>
		<result property="orderableStatus" column="ORDERABLE_STATUS"/>
	</resultMap>

  <select id="selectAllMenu" resultMap="menuResultMap">
    SELECT
    		MENU_CODE
    	,	MENU_NAME
    	,	MENU_PRICE
    	,	CATEGORY_CODE
    	,	ORDERABLE_STATUS
    	FROM TBL_MENU
    	WHERE ORDERABLE_STATUS = 'Y'
    	ORDER BY MENU_CODE
  </select>
  
  <select id="selectMenuByCode" parameterType= "_int" resultMap="menuResultMap"> 
  	SELECT
    		MENU_CODE
    	,	MENU_NAME
    	,	MENU_PRICE
    	,	CATEGORY_CODE
    	,	ORDERABLE_STATUS
    	FROM TBL_MENU
    	WHERE ORDERABLE_STATUS = 'Y'
    	AND MENU_CODE = #{code}
  </select>

  <insert id="insertMenu" parameterType="com.greedy.section03.remix.MenuDTO">
  	INSERT
  		INTO TBL_MENU
  	(
  		MENU_CODE
  	,	MENU_NAME
  	,	MENU_PRICE
  	,	CATEGORY_CODE
  	,	ORDERABLE_STATUS
  	)
  	VALUES
  	(
  		SEQ_MENU_CODE.NEXTVAL
  	, #{ menuName } 
  	, #{ menuPrice }
  	, #{ categoryCode }
  	, 'Y'
  	)
  </insert>
  
  <update id="updateMenu" parameterType="com.greedy.section03.remix.MenuDTO">
  	UPDATE
  			TBL_MENU
  		SET MENU_NAME = #{ menuName }
  		,	MENU_PRICE = #{ menuPrice }
  		,	CATEGORY_CODE = #{ categoryCode }
  		WHERE MENU_CODE = #{ menuCode }
  </update>
  
  <delete id="deleteMenu" parameterType="_int">
  	DELETE
  		FROM TBL_MENU
  		WHERE MENU_CODE = #{ menuCode }
  </delete>

</mapper>

👉 PrintResult

* XMLconfig 방식 및 JAVAconfig 방식의 PrintResult와 동일 *

😈 Warning

---