[MyBatis] Console program(MVC) Exercise 🔥

🧩 MVC구조로 콘솔 프로그램 제작하기

💁‍ 브런치 카페를 운영중인 당신, 매일 새로운 재료를 여러 업체에서 공급받아 음식을 조리합니다. 각각의 업체에서 재료를 주문하고 관리하는 프로그램을 만들어 더욱 손쉽게 재료를 오더해요! :)

---

📌 초기 Setting

◼ connection-info.properties

driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@localhost:1521:xe
username=C##FOOD_PRODUCTS
password=FOOD_PRODUCTS

◼ mybatis-config.xml

<?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>

  <!--connection-info.properties를 읽어올 것 
(아래 value에 직접 입력하지않고 ${}를 이용하여 작성(보안을 위해 분리하여 사용))-->
  <properties resource="connection-info.properties"/>
  
  <!-- 별칭 설정 -->
  <typeAliases>
    <typeAlias type="com.joyhyonie.common.SearchCriteria" alias="SerchCriteria"/> 
    <!-- type="클래스경로" alias="별칭"-->
  </typeAliases>

  <environments default="dev">
    <environment id="dev">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
  
  <mappers>
  	<!-- package의 명칭을 작성하여 해당 패키지 하위에 있는 모든 파일을 mapper로 사용 -->
	  <package name="com.joyhyonie.foodProducts.mapper"/> 
	  
  </mappers>
</configuration>

◼ SearchCriteria Class

public class SearchCriteria { // 검색 기준

	private String condition; 	// 검색 조건
	private String value; 		// 검색하려는 단어
	
	public SearchCriteria() {}
	
	public SearchCriteria(String value) {
		super();
		this.value = value;
	}

	public SearchCriteria(String condition, String value) {
		super();
		this.condition = condition;
		this.value = value;
	}

	public String getCondition() {
		return condition;
	}

	public void setCondition(String condition) {
		this.condition = condition;
	}

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}

	@Override
	public String toString() {
		return "SearchCriteria [condition=" + condition + ", value=" + value + "]";
	}
}

◼ Template Class

public class Template {

	private static SqlSessionFactory sqlSessionFactory; 
	
	public static SqlSession getSqlSession() {
		
		if(sqlSessionFactory == null) { 
			String resource = "mybatis-config.xml";
			
			try {
				InputStream inputStream = Resources.getResourceAsStream(resource);
				sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
				
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		return sqlSessionFactory.openSession(false);
	}
}

---

👉 DB Script

◼ FoodProducts.sql

-- 테이블 생성
--[ TBL_FOOD_CATEGORY ]
CREATE TABLE TBL_FOOD_CATEGORY(
    CATEGORY_CODE NUMBER CONSTRAINT PK_CATEGORY_CODE PRIMARY KEY
,   CATEGORY VARCHAR2(30) NOT NULL
);

COMMENT ON COLUMN TBL_FOOD_CATEGORY.CATEGORY_CODE IS '식품 종류 코드';
COMMENT ON COLUMN TBL_FOOD_CATEGORY.CATEGORY IS '종류명';

--[ TBL_SUPPLIER ]
CREATE TABLE TBL_SUPPLIER(
    CATEGORY_CODE NUMBER
,   SUPPLIER_CODE VARCHAR2(10) 
,   SUPPLIER_NAME VARCHAR2(30) UNIQUE
,   ADDRESS VARCHAR2(80)
,   CONTACT_NUMBER VARCHAR2(20) NOT NULL
,   ORDER_YN VARCHAR2(10) DEFAULT 'Y' CHECK (ORDER_YN IN('Y', 'N')) 
,   CONSTRAINT FK_CATEGORY_CODE FOREIGN KEY(CATEGORY_CODE) REFERENCES TBL_FOOD_CATEGORY(CATEGORY_CODE)
,   CONSTRAINT PK_SUPPLIER_CODE PRIMARY KEY(SUPPLIER_CODE)
);

COMMENT ON COLUMN TBL_SUPPLIER.CATEGORY_CODE IS '식품 종류 코드';
COMMENT ON COLUMN TBL_SUPPLIER.SUPPLIER_CODE IS '업체 코드';
COMMENT ON COLUMN TBL_SUPPLIER.SUPPLIER_NAME IS '업체명';
COMMENT ON COLUMN TBL_SUPPLIER.ADDRESS IS '주소';
COMMENT ON COLUMN TBL_SUPPLIER.CONTACT_NUMBER IS '연락처';
COMMENT ON COLUMN TBL_SUPPLIER.ORDER_YN IS '거래 가능 여부';

--[ TBL_PRODUCTS ]
CREATE TABLE TBL_PRODUCTS(
    PROD_CODE NUMBER
,   PROD_NAME VARCHAR2(30) NOT NULL
,   PRICE NUMBER
,   SUPPLIER_NAME VARCHAR2(30) NOT NULL
,   CONSTRAINT PK_PROD_CODE PRIMARY KEY(PROD_CODE)
);

COMMENT ON COLUMN TBL_PRODUCTS.PROD_CODE IS '재료 코드';
COMMENT ON COLUMN TBL_PRODUCTS.PROD_NAME IS '재료명';
COMMENT ON COLUMN TBL_PRODUCTS.PRICE IS '재료가격';
COMMENT ON COLUMN TBL_PRODUCTS.SUPPLIER_NAME IS '업체명';

--[ TBL_STORAGE ]
CREATE TABLE TBL_STORAGE(
    PROD_CODE NUMBER NOT NULL
,   PROD_NAME VARCHAR2(30) NOT NULL
,   INCOMING_DATE VARCHAR2(10) NOT NULL
);

COMMENT ON COLUMN TBL_STORAGE.PROD_CODE IS '재료 코드';
COMMENT ON COLUMN TBL_STORAGE.PROD_NAME IS '재료명';
COMMENT ON COLUMN TBL_STORAGE.INCOMING_DATE IS '입고날짜';

--[ TBL_ORDER_HISTORY ]
CREATE TABLE TBL_ORDER_HISTORY(
    ORDER_CODE NUMBER
,   ORDER_DATE VARCHAR2(10) NOT NULL
,   ORDER_TIME VARCHAR2(10)
,   TOTAL_PRICE NUMBER NOT NULL
,   CONSTRAINT PK_ORDER_CODE PRIMARY KEY(ORDER_CODE)
);

COMMENT ON COLUMN TBL_ORDER_HISTORY.ORDER_CODE IS '주문코드';
COMMENT ON COLUMN TBL_ORDER_HISTORY.ORDER_DATE IS '주문일자';
COMMENT ON COLUMN TBL_ORDER_HISTORY.ORDER_TIME IS '주문시각';
COMMENT ON COLUMN TBL_ORDER_HISTORY.TOTAL_PRICE IS '주문총액';

--시퀀스 생성
--[ CATEGORY_CODE ]
CREATE SEQUENCE SEQ_CATEGORY_CODE
START WITH 1
INCREMENT BY 1
MAXVALUE 10
NOCYCLE
NOCACHE;
--[ PROD_CODE ]
CREATE SEQUENCE SEQ_PROD_CODE
START WITH 100
INCREMENT BY 1
MAXVALUE 999
NOCYCLE
NOCACHE;
--[ ORDER_CODE ]
CREATE SEQUENCE SEQ_ORDER_CODE
START WITH 1000
INCREMENT BY 1
MAXVALUE 9999
NOCYCLE
NOCACHE;

--컬럼 값 삽입
--[ TBL_FOOD_CATEGORY ]
INSERT INTO TBL_FOOD_CATEGORY VALUES(SEQ_CATEGORY_CODE.NEXTVAL, '육류');
INSERT INTO TBL_FOOD_CATEGORY VALUES(SEQ_CATEGORY_CODE.NEXTVAL, '어류');
INSERT INTO TBL_FOOD_CATEGORY VALUES(SEQ_CATEGORY_CODE.NEXTVAL, '과일,채소류');
INSERT INTO TBL_FOOD_CATEGORY VALUES(SEQ_CATEGORY_CODE.NEXTVAL, '유제품');
INSERT INTO TBL_FOOD_CATEGORY VALUES(SEQ_CATEGORY_CODE.NEXTVAL, '냉동식품');
INSERT INTO TBL_FOOD_CATEGORY VALUES(SEQ_CATEGORY_CODE.NEXTVAL, '건조식품');
INSERT INTO TBL_FOOD_CATEGORY VALUES(SEQ_CATEGORY_CODE.NEXTVAL, '기타');

--[ TBL_SUPPLIER ]
INSERT INTO TBL_SUPPLIER VALUES(1, '1A', '굽네정육', '서울시 성동구 마장동 고깃길 79',	'02-6549-2341', DEFAULT);
INSERT INTO TBL_SUPPLIER VALUES(2, '2A', '바다회사랑', '서울시 동작구 노량진수산물도매시장 7-A', '02-4061-0605', DEFAULT);
INSERT INTO TBL_SUPPLIER VALUES(3, '3A', 'SING싱채소'	, '서울시 동대문구 제기동 청량리청과물시장 185호', '070-3059-4953', DEFAULT);
INSERT INTO TBL_SUPPLIER VALUES(3, '3B', '베지상회', '경기도 남양주시 야채로2길 71', '031-3421-5800', DEFAULT);
INSERT INTO TBL_SUPPLIER VALUES(4, '4A', '치즈FARM', '경기도 파주시 우유리 921-12', '031-9372-0221', DEFAULT);
INSERT INTO TBL_SUPPLIER VALUES(5, '5A', '얼음땡푸드', '서울시 종로구 꽁꽁3가 2-38', '02-5068-4480', DEFAULT);
INSERT INTO TBL_SUPPLIER VALUES(6, '6A', '짱구는말려', '경기도 하남시 흰둥로 600', '070-3242-1666', DEFAULT);
INSERT INTO TBL_SUPPLIER VALUES(7, '7A', '꼬순내방앗간', '경기도 이천시 무촌리 52-7', '031-2221-5838', DEFAULT);
INSERT INTO TBL_SUPPLIER VALUES(7, '7B', 'EGG머니나',	 '서울시 도봉구 병아리길 92', '02-7483-8812', DEFAULT);

--[ TBL_PRODUCTS ]
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '소 등심', 20000,	'굽네정육');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '소 안심', 23000,	'굽네정육');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '소 다짐육', 15000, '굽네정육');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '돼지 등심', 10000, '굽네정육');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '돼지 안심', 15000, '굽네정육');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '돼지 다짐육',	8000, '굽네정육');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '닭 안심',	 7000, '굽네정육');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '연어', 20000, '바다회사랑');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '새우', 11000, '바다회사랑');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '오징어',	5000, '바다회사랑');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '가자미',	10000, '바다회사랑');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '바지락',	5000, '바다회사랑');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '모시조개', 6000, '바다회사랑');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '당근', 3000,	'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '양파', 4000,	'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '샐러리',	3000, 'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '양배추',	6000, 'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '비트', 3000,	'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '감자', 4000,	'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '고구마',	4000, 'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '호박', 8000,	'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '딸기', 7000,	'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '바나나',	4000, 'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '키위', 8000,	'SING싱채소');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '로즈마리', 7000, '베지상회');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '쪽파', 4000,	'베지상회');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '깻잎', 2000,	'베지상회');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '무순', 4000,	'베지상회');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '양송이버섯', 5000, '베지상회');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '딜',	 7000, '베지상회');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '우유', 4000, '치즈FARM');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '생크림',	7000, '치즈FARM');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '체다치즈', 5000, '치즈FARM');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '크림치즈', 7000, '치즈FARM');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '리코타치즈', 9000, '치즈FARM');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '냉동감자튀김',	 10000,	'얼음땡푸드');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '냉동고구마튀김', 12000, '얼음땡푸드');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '냉동만두', 7000, '얼음땡푸드');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '냉동블루베리', 15000, '얼음땡푸드');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '호박씨',	5000, '짱구는말려');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '해바라기씨', 4000, '짱구는말려');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '건포도',	4000, '짱구는말려');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '건크랜베리', 6000, '짱구는말려');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '곰표밀가루', 6000, '꼬순내방앗간');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '쌀가루',	8000, '꼬순내방앗간');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '빵가루',	4000, '꼬순내방앗간');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '콩가루',	3000, '꼬순내방앗간');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '유기농 달걀',	10000, 'EGG머니나');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '하얀 달걀', 8000,	'EGG머니나');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '특대 달걀', 7000,	'EGG머니나');
INSERT INTO TBL_PRODUCTS VALUES(SEQ_PROD_CODE.NEXTVAL, '일반 달걀', 5000,	'EGG머니나');

--[ TBL_STORAGE ]
INSERT INTO TBL_STORAGE VALUES(101, '소 안심', SYSDATE);
INSERT INTO TBL_STORAGE VALUES(105, '돼지 다짐육', SYSDATE);
INSERT INTO TBL_STORAGE VALUES(108, '새우', SYSDATE);
INSERT INTO TBL_STORAGE VALUES(112, '모시조개', SYSDATE);
INSERT INTO TBL_STORAGE VALUES(116, '양배추', SYSDATE);
INSERT INTO TBL_STORAGE VALUES(122, '바나나', SYSDATE);
INSERT INTO TBL_STORAGE VALUES(131, '생크림', SYSDATE);
INSERT INTO TBL_STORAGE VALUES(138, '냉동블루베리', SYSDATE);
INSERT INTO TBL_STORAGE VALUES(143, '밀가루', SYSDATE);
INSERT INTO TBL_STORAGE VALUES(147, '유기농 달걀', SYSDATE);

COMMIT;

👉 DTO

◼ FoodCategoryDTO Class

public class FoodCategoryDTO {

	private int categoryCode;
	private String category;
    
    /* 기본 생성자, 모든 매개변수가 있는 생성자 */
    /* getter & setter */
    /* toStirng */
}

◼ FoodProductsDTO Class

public class FoodProductsDTO {
	
	private int prodCode;
	private String prodName;
	private int price;
	private String supplierName;
    
    /* 기본 생성자, 모든 매개변수가 있는 생성자 */
    /* getter & setter */
    
    @Override
	public String toString() {
		return "-----------------------\n" + "|" + prodCode + "| " + prodName + " | " + price
				+ "원 | [" + supplierName + "]";
	}
}

◼ StorageDTO Class

public class StorageDTO {
	
	private int prodCode;
	private String prodName;
	private String incomingDate;
    
    /* 기본 생성자, 모든 매개변수가 있는 생성자 */
    /* getter & setter */
    
    @Override
	public String toString() {
		return "[" + incomingDate + "입고] " + "|" + prodCode + "| " + prodName;
	}
}

◼ SupplierDTO Class

public class SupplierDTO {
	
	private int categoryCode;
	private String supplierCode;
	private String supplierName;
	private String address;
	private String contactNumber;
	private String orderYn;
	private FoodCategoryDTO foodCategory; // TBL_FOOD_CATEGORY의 category를 함께 출력하기 위해 추가 <association>
    
    /* 기본 생성자, 모든 매개변수가 있는 생성자 */
    /* getter & setter */
    
    @Override
	public String toString() {
		return "[" + supplierName + "]-----------------------\n* " + foodCategory + "업체(" + categoryCode + ")\n* 업체코드 : " + supplierCode + "\n* 주소 : " + address +
				"\n* 연락처 : " + contactNumber + "\n* 거래가능여부 : " + orderYn + "\n";
	}
    
}

◼ OrderHistoryDTO Class

public class OrderHistoryDTO {
	
	private int orderCode;
	private String orderDate;
	private String orderTime;
	private int totalPrice;
	private List<StorageDTO> storageDTO; 
    // 주문내역과 주문한 재료를 하나의 트랜잭션 안에서 INSERT하기 위해 List<StorageDTO> 필드 생성
    
    /* 기본 생성자, 모든 매개변수가 있는 생성자 */
    /* getter & setter */
    
    @Override
	public String toString() {
		return "|" + orderCode + "|주문일자 " + orderDate + "|주문시각 " + orderTime
				+ "|총액 " + totalPrice + "원";
	}
}

◼ OrderProductsDTO Class

/* 테이블에 의한 DTO가 아닌 오더한 목록을 출력 및 담기 위한 DTO */
public class OrderProductsDTO {

	private int prodCode;
	private String prodName;
	private int price;
	private String supplierName;
    
    /* 기본 생성자, 모든 매개변수가 있는 생성자 */
    /* getter & setter */
    
    @Override
	public String toString() {
		return "-----------------------\n" + "|" + prodCode + "| " + prodName + " | " + price
				+ "원 | [" + supplierName + "]";
	}
}

👉 View

◼ MainView Class

public class MainView {
	
	private static Scanner sc = new Scanner(System.in);
	private static FoodProductsController fpController = new FoodProductsController();

	public void displayView() {

		do {
			System.out.println("");
			System.out.println("=====[ 재료 주문 및 관리 프로그램 ]=====");
			System.out.println("[A] 재료 주문하기");
			System.out.println("[B] 재료 관리하기");
			System.out.println("[C] 원하는 재료 판매 제안하기");
			System.out.println("[D] 업체 관리하기");
			System.out.println("[E] 주문내역 조회하기");
			System.out.println("[Z] 프로그램 종료하기");
			System.out.print("메뉴 선택 : ");
			char ch = sc.nextLine().toUpperCase().charAt(0);
			
			switch(ch) {
			case 'A': orderNewProduct(); break;
			case 'B': manageStorage(); break; 
			case 'C': suggestNewProduct(); break;
			case 'D': manageSupplier(); break;
			case 'E': fpController.selectOrderHistory(manageOrderHistory()); break;
			case 'Z': System.out.println("프로그램이 종료되었습니다 :D"); return;
			default : System.out.println("잘못 된 번호입니다! 다시 입력해주세요 :(");
			}
			
		} while(true);	
	}

	/* [1] 재료 주문하기 */
	private static void orderNewProduct() {
		
		do {
			System.out.println("");
			System.out.println("=====[ 재료 주문하기 ]=====");
			System.out.println("[A] 오늘의 재료 먼저 추천받기");
			System.out.println("[B] 각 업체마다의 재료 조회하기");
			System.out.println("[C] 주문 시작하기");
			System.out.println("[Z] ◀ 돌아가기");
			System.out.print("메뉴 선택 : ");
			char ch = sc.nextLine().toUpperCase().charAt(0);
			System.out.println("잠시만 기다려주세요 :)");
			
			switch(ch) {
			case 'A' : fpController.selectRandomProducts(pickRandomProducts()); break;
			case 'B' : fpController.selectProductsBySupplier(pickSupplier()); break;
			case 'C' : fpController.insertOrderedProducts(OrderedProducts()); break;
			case 'Z' : return;
			}
			
		} while(true);
	}

	/* [1-1] 오늘의 재료 추천받기 */
	private static List<Integer> pickRandomProducts() {
		
		Set<Integer> set = new HashSet<>();
		while(set.size() < 3) {
			int temp = ((int) (Math.random() * 50)) + 100;
			set.add(temp);
		}
		
		List<Integer> list = new ArrayList<>(set); 
		
		return list;
	}

	/* [1-2] 각 업체마다의 재료 조회하기 */
	private static SearchCriteria pickSupplier() {
		
		System.out.println("");
		System.out.println("=====[ 업체 선택하기 ]=====");
		System.out.println("[A] 굽네정육");
		System.out.println("[B] 바다회사랑");
		System.out.println("[C] SING싱채소");
		System.out.println("[D] 베지상회");
		System.out.println("[E] 치즈FARM");
		System.out.println("[F] 얼음땡푸드");
		System.out.println("[G] 짱구는말려");
		System.out.println("[H] 꼬순내방앗간");
		System.out.println("[I] EGG머니나");
		System.out.print("메뉴 선택 : ");
		String value = sc.nextLine().toUpperCase();

		return new SearchCriteria(value);
	}

	/* [1-3] 주문 시작하기 */
	private static OrderHistoryDTO OrderedProducts() {
		
		/* [1-3A] 전체 재료 조회하여 리스트에 담기 */
		List<FoodProductsDTO> allProductsList = fpController.selectAllProducts();
		
		/* 주문들을 담기 위한 리스트 */
		List<OrderProductsDTO> orderProductsList = new ArrayList<>(); 
		int totalPrice = 0; 
		
		/* 주문한 재료들 담기용 */
		List<StorageDTO> productsToStorageList = new ArrayList<>();
		
		do {
			System.out.println("");
			System.out.println("=====[ 주문중... ]=====");
			System.out.print("주문할 재료명 입력 : ");
			
			String prodName = sc.nextLine();
			
			int prodCode = 0;
			int prodPrice = 0;
			String suppName = null;
			for(FoodProductsDTO prod : allProductsList) {
				if(prod.getProdName().equals(prodName)) {
					prodCode = prod.getProdCode();
					prodPrice = prod.getPrice();
					suppName = prod.getSupplierName();
				} 
			}

			/* 주문한 재료(들) 저장 */
			OrderProductsDTO orderProducts = new OrderProductsDTO();
			orderProducts.setProdName(prodName);
			orderProducts.setProdCode(prodCode);
			orderProducts.setPrice(prodPrice);
			orderProducts.setSupplierName(suppName);
			
			orderProductsList.add(orderProducts); // orderProductsList에 주문한 것들 추가
			totalPrice += prodPrice; // 총액 계산
			
			System.out.print("계속 주문하시겠어요? :)\n(Y/N) : ");
			boolean isContinue = sc.nextLine().toUpperCase().equals("Y");
			
			/* [1-3C] 주문한 재료 저장고에 추가하기 */
			java.util.Date orderDate = new java.util.Date();
			SimpleDateFormat dateFormat = new SimpleDateFormat("yy/MM/dd");
			String incomingDate = dateFormat.format(orderDate);
			
			StorageDTO storage = new StorageDTO();
			storage.setProdCode(prodCode);
			storage.setProdName(prodName);
			storage.setIncomingDate(incomingDate);
			productsToStorageList.add(storage);
			
			if(!isContinue) break;
			
		} while(true);
		
//		fpController.insertProductsToStorage(productsToStorageList);
//		재료를 추가하는 것은 주문내역과 함께 INSERT 되어야함
		
		for(OrderProductsDTO orderMenu : orderProductsList) {
			System.out.println(orderMenu);
			
		}
		System.out.println("-----------------------\n총액 : " + totalPrice + "원");
		
		/* [1-3B] 주문한 내역 저장하기 */
		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);
		
		OrderHistoryDTO order = new OrderHistoryDTO();
		order.setOrderDate(date);
		order.setOrderTime(time);
		order.setTotalPrice(totalPrice);
		order.setStorageDTO(productsToStorageList); 
		/* 주문내역과 주문한 재료를 하나의 트랜잭션 안에서 INSERT하기 위해 
        	(둘 중에 하나라도 문제가 있다면, 나머지 하나도 작동되어선 안됨)
		 * StorageDTO를 OrderHistoryDTO의 필드에 선언한 뒤,
		 * productsToStorageList를 StorageDTO에 set하여 함께 인자로 전달 */
		
		return order;
	}

	/* [2] 재료 관리하기 */
	private static void manageStorage() {
		
		do {
			System.out.println("");
			System.out.println("=====[ 재료 관리하기 ]=====");
			System.out.println("[A] 재료 파악하기");
			System.out.println("[B] 재료 사용하기");
			System.out.println("[C] 상한 재료 교환받기");
			System.out.println("[D] 오래된 재료 모두 폐기하기");			
			System.out.println("[Z] ◀ 돌아가기");
			System.out.print("메뉴 선택 : ");
			char ch = sc.nextLine().toUpperCase().charAt(0);
			System.out.println("잠시만 기다려주세요 :)");
			
			switch(ch) {
			case 'A' : fpController.selectProductsBySomething(inputSearchCriteria()); break;
			case 'B' : fpController.deletePickedProduct(useProduct()); break;
			case 'C' : fpController.updatePickedProduct(changeProduct()); break;
			case 'D' : fpController.deleteOldProducts(throwAwayOldProducts()); break;
			case 'Z' : return;
			}
			
		} while(true);
	}

	/* [2-1] 재료 파악하기 */
	private static SearchCriteria inputSearchCriteria() {
		
		System.out.println("");
		System.out.println("=====[ 재료 파악하기 ]=====");
		System.out.println("|   전체   |   재료명별   |");
		System.out.print("재료 목록 기준 선택 : ");
		String condition = sc.nextLine();
		
		String value = null;
		if(condition.equals("재료명별")) {
			System.out.print("재료명 입력 : ");
			value = sc.nextLine();
		}
		
		System.out.println("잠시만 기다려주세요 :)");
		
		return new SearchCriteria(condition, value);
	}

	/* [2-2] 재료 사용하기 */
	private static Map<String, String> useProduct() {
		
		System.out.println("");
		System.out.println("=====[ 재료 사용하기 ]====="); 
		System.out.print("사용할 재료명 입력 : ");
		String prodName = sc.nextLine();
		System.out.println("잠시만 기다려주세요 :)");
		
		Map<String, String> param = new HashMap<>();
		param.put("prodName", prodName);
		
		return param;
	}

	/* [2-3] 상한 재료 교환받기 */
	private static Map<String, String> changeProduct() {
		
		System.out.println("");
		System.out.println("=====[ 상한 재료 교환받기 ]====="); 
		System.out.print("상한 재료명 입력 : ");
		String prodName = sc.nextLine();
		System.out.println("잠시만 기다려주세요 :)");
		
		Map<String, String> param = new HashMap<>();
		param.put("prodName", prodName);
		
		return param;
	}

	/* [2-4] 오래된 재료 모두 폐기하기 */
	private static Map<String, String> throwAwayOldProducts() {
		
		System.out.println("");
		System.out.println("=====[ 오래된 재료 모두 폐기하기 ]====="); 
		System.out.println("며칠 이상 지난 재료를 폐기하시겠습니까?");
		System.out.print("일수 입력 : ");
		String days = sc.nextLine();
		System.out.println("잠시만 기다려주세요 :)");
		
		Map<String, String> param = new HashMap<>();
		param.put("days", days);
		
		return param;
	}

	/* [3] 원하는 재료 판매 제안하기 */
	private static void suggestNewProduct() {
		
		System.out.println("");
		System.out.println("=====[ 원하는 재료 판매 제안하기 ]=====");
		System.out.print("판매를 제안할 업체명을 입력해주세요 :)\n : ");
		String supplier = sc.nextLine();
		System.out.print("원하는 재료를 입력해주세요 :)\n : ");
		String product = sc.nextLine();
		System.out.print("원하는 가격을 제시해주세요 :)\n : ");
		String price = sc.nextLine();
		System.out.println("잠시만 기다려주세요 :)");
			
		int intPrice = Integer.parseInt(price);
		if(intPrice > 5000) {
			Map<String, String> param = new HashMap<>();
			param.put("supplier", supplier);
			param.put("product", product);
			param.put("price", price);
				
			fpController.insertNewProduct(param);
				
		} else {
			System.out.println("제시하신 금액이 너무 적어 업체가 거절했습니다 :(");
		}
	}

	/* [4] 업체 관리하기 */
	private static void manageSupplier() {

		do {
			System.out.println("");
			System.out.println("=====[ 업체 관리하기 ]=====");
			System.out.println("[A] 모든 업체 조회하기");
			System.out.println("[B] 정보 변경하기"); 
			System.out.println("[C] 계약 해지하기");		
			System.out.println("[Z] ◀ 돌아가기");
			System.out.print("메뉴 선택 : ");
			char ch = sc.nextLine().toUpperCase().charAt(0);
			System.out.println("잠시만 기다려주세요 :)");
			
			switch(ch) {
			case 'A' : fpController.selectAllSupplier(); break;
			case 'B' : fpController.updateSupplierInfo(modifySupplier()); break;
			case 'C' : System.out.println("------------[WARNING]------------\n계약을 해지할 시, 재계약은 불가능합니다. 계속 진행하시겠습니까?\n(해당 업체의 재료 또한 주문불가)");
					   System.out.print("(Y/N) : ");
					   char yn = sc.nextLine().toUpperCase().charAt(0);
					   if(yn == 'N') {
						   return;
					   } else
					   System.out.println("안전한 계약 해지를 위해 아래의 문자를 알맞은 순서로 입력해주세요 :)");
					   System.out.print("[ ofdo ]\n : ");
					   String word = sc.nextLine();
					   if(word.equals("food")) {
						   fpController.deleteSupplier(cancelSupplier()); break;
					   } else {
						   System.out.println("문자의 순서가 올바르지 않아요 :( 메인 페이지로 이동합니다 !"); return;
					   }
			case 'Z' : return;
			}
			
		} while(true);
		
	}

	/* [4-2] 정보 변경하기 */
	private static Map<String, String> modifySupplier() {
		
		System.out.println("");
		System.out.println("=====[ 정보 변경하기 ]====="); 
		System.out.print("변경할 업체명 입력 : ");
		String suppName = sc.nextLine();
		System.out.println("*변경하고자 하는 정보만 입력하셔도 됩니다 !* ▶ ENTER");
		sc.nextLine();
		System.out.print("새로운 주소 입력 : ");
		String newAddress = sc.nextLine();
		System.out.print("새로운 연락처 입력 : ");
		String newContactNumber = sc.nextLine();
		System.out.print("거래가능여부 입력 : ");
		String newOrderYn = sc.nextLine();
		System.out.println("잠시만 기다려주세요 :)");
		
		Map<String, String> param = new HashMap<>();
		param.put("suppName", suppName);
		param.put("newAddress", newAddress);
		param.put("newContactNumber", newContactNumber);
		param.put("newOrderYn", newOrderYn);
		
		return param;
	}

	/* [4-3] 계약 해지하기 */
	private static Map<String, String> cancelSupplier() {
		
		System.out.println("");
		System.out.println("=====[ 계약 해지하기 ]====="); 
		System.out.print("업체명 입력 : ");
		String suppName = sc.nextLine();
		System.out.println("잠시만 기다려주세요 :)");
		
		Map<String, String> param = new HashMap<>();
		param.put("suppName", suppName);
		
		return param;
	}

	/* [5] 주문내역 조회하기 */
	private static Map<String, String> manageOrderHistory() {

			System.out.println("");
			System.out.println("=====[ 주문내역 조회하기 ]=====");
			System.out.println("|    최신순    |    과거순    |");
			System.out.print(" : ");
			String range = sc.nextLine();
			System.out.println("잠시만 기다려주세요 :)");
			
			Map<String, String> param = new HashMap<>();
			param.put("range", range);
			
			return param;
	}
}

◼ ResultView Class

public class ResultView {

	/* 재료 리스트 출력 */
	public void printProductsList(List<FoodProductsDTO> ProductsList) {
		
		for(FoodProductsDTO o : ProductsList) {
			System.out.println(o);
		}	
	}
	
	/* 업체 리스트 출력 */
	public void printSupplierList(List<SupplierDTO> allSupplierList) {
		
		for(SupplierDTO o : allSupplierList) {
			System.out.println(o);
		}	
	}
	
	/* 주문내역 리스트 출력 */
	public void printOrderHistoryList(List<OrderHistoryDTO> orderHistoryList) {
		
		for(OrderHistoryDTO o : orderHistoryList) {
			System.out.println(o);
		}	
	}

	/* CompleteMessage */
	public void printCompleteMessage(String completeCode) {
		
		String completeMessage = "";
		switch(completeCode) {
		case "successInsertOrderedProducts" : completeMessage = "성공적으로 주문이 완료되어 재료가 즉시 입고되었어요 :D"; break;
		case "successDeletePickedProduct" : completeMessage = "재료를 사용하였습니다 :D"; break;
		case "successUpdatePickedProduct" : completeMessage ="싱싱한 재료로 교환 완료되었습니다 :D"; break;
		case "successDeleteOldProducts" : completeMessage = "오래된 재료를 모두 폐기 완료하였습니다 :D"; break;
		case "successInsertNewProduct" : completeMessage = "업체가 판매 제안을 받아들여 이제부터 주문이 가능합니다 :D"; break;
		case "successUpdateSupplierInfo" : completeMessage = "업체 정보가 정상적으로 변경되었습니다 :D"; break;
		case "successDeleteSupplier" : completeMessage = "계약이 정상적으로 해지되었습니다 :D"; break;
		}
		
		System.out.println(completeMessage);
	}

	/* ErrorMessages */
	public void printErrorMessage(String errorCode) {
		
		String errorMessage = "";
		switch(errorCode) {
		case "failSelectRandomProducts" : errorMessage = "오늘의 재료를 찾지 못 했어요 :("; break;
		case "failSelectProductsBySupplier" : errorMessage = "재료들을 불러오지 못 했어요 :("; break;
		case "failInsetOrderedProducts" : errorMessage = "주문하신 내역이 전달되지 못 했어요 :("; break;
		case "failInsertProductsToStorage" : errorMessage = "입고 또한 실패했습니다 :( "; break;
		case "failSelectProductsBySomething" : errorMessage = "재료 파악에 실패했습니다 :("; break;
		case "failDeletePickedProduct" : errorMessage = "재료를 사용하지 못 했습니다 :("; break;
		case "failUpdatePickedProduct" : errorMessage = "재료를 교환받지 못 했습니다 :("; break;
		case "failDeleteOldProducts" : errorMessage = "해당 일수가 지난 재료가 없습니다 :("; break;
		case "failInsertNewProduct" : errorMessage = "끝내 제안이 거절 당했습니다 :("; break;
		case "failSelectAllSupplier" : errorMessage = "업체 정보를 불러오지 못 했습니다 :("; break;
		case "failUpdateSupplierInfo" : errorMessage = "업체명이 올바르지 않아 정보 변경에 실패했습니다 :("; break;
		case "failDeleteSupplier" : errorMessage = "업체명이 올바르지 않아 계약 해지에 실패했습니다 :("; break;
		case "failSelectOrderHistory" : errorMessage = "주문내역을 불러오지 못 했습니다 :("; break;
		}
		
		System.out.println(errorMessage);
	}
}

👉 Controller

◼ FoodProductsController Class

public class FoodProductsController {

	private final FoodProductsService fpService;
	private final ResultView rView;
	
	// 위의 필드들을 생성자에서 초기화
	public FoodProductsController() {
		fpService = new FoodProductsService();
		rView = new ResultView();
	}

	/* [1-1] 오늘의 재료 추천받기 */
	public void selectRandomProducts(List<Integer> list) {

		List<FoodProductsDTO> RandomProductsList = fpService.selectRandomProducts(list);
		
		/* 사용자에게 보여줄 Result View */
		if(RandomProductsList != null) {
			rView.printProductsList(RandomProductsList);
		} else {
			rView.printErrorMessage("failSelectRandomProducts");
		}
	}

	/* [1-2] 유통업체 선택하기 */
	public void selectProductsBySupplier(SearchCriteria searchCriteria) {
		
		List<FoodProductsDTO> ProductsListBySupplier = fpService.selectProductsBySupplier(searchCriteria);
		
		if(ProductsListBySupplier != null) {
			rView.printProductsList(ProductsListBySupplier);
		} else {
			rView.printErrorMessage("failSelectProductsBySupplier");
		}
	}

	/* [1-3A] 전체 재료 조회하여 리스트에 담기 */
	public List<FoodProductsDTO> selectAllProducts() {
		
		List<FoodProductsDTO> allProductsList = fpService.selectAllProducts();
		
		return allProductsList;
	}

	/* [1-3B] 주문한 내역 저장하기 / [1-3C] 주문한 재료 저장고에 추가하기 */
	public void insertOrderedProducts(OrderHistoryDTO order) {
		
		if(fpService.insertOrderedProducts(order)) {
			rView.printCompleteMessage("successInsertOrderedProducts");
		} else {
			rView.printErrorMessage("failInsetOrderedProducts");
		}
	}

	/* [1-3C] 주문한 재료 저장고에 추가하기 */
//	public void insertProductsToStorage(List<StorageDTO> productsToStorageList) {
//	
//		if(!fpService.insertProductsToStorage(productsToStorageList))
//			rView.printErrorMessage("failInsertProductsToStorage");
//	}

	/* [2-1] 재료 파악하기 */
	public void selectProductsBySomething(SearchCriteria searchCriteria) {
		
		List<StorageDTO> myProductsList = fpService.selectProductsBySomething(searchCriteria);
		
		if(myProductsList != null && !myProductsList.isEmpty()) {
			for(StorageDTO products : myProductsList) {
				System.out.println(products);
			}
		} else {
			rView.printErrorMessage("failSelectProductsBySomething");
		}
		
	}

	/* [2-2] 재료 사용하기 */
	public void deletePickedProduct(Map<String, String> param) {
		
		String prodName = param.get("prodName");
		
		if(fpService.deletePickedProduct(prodName)) {
			rView.printCompleteMessage("successDeletePickedProduct");
		} else {
			rView.printErrorMessage("failDeletePickedProduct");
		}
		
	}

	/* [2-3] 상한 재료 교환받기 */
	public void updatePickedProduct(Map<String, String> param) {

		String prodName = param.get("prodName");
		
		if(fpService.updatePickedProduct(prodName)) {
			rView.printCompleteMessage("successUpdatePickedProduct");
		} else {
			rView.printErrorMessage("failUpdatePickedProduct");
		}
		
	}

	/* [2-4] 오래된 재료 모두 폐기하기 */
	public void deleteOldProducts(Map<String, String> param) {
		
		int days = Integer.parseInt(param.get("days"));
		
		if(fpService.deleteOldProducts(days)) {
			rView.printCompleteMessage("successDeleteOldProducts");
		} else {
			rView.printErrorMessage("failDeleteOldProducts");
		}
		
	}

	/* [3] 원하는 재료 판매 제안하기 */
	public void insertNewProduct(Map<String, String> param) {
		
		FoodProductsDTO foodProducts = new FoodProductsDTO();
		foodProducts.setProdName(param.get("product"));
		foodProducts.setPrice(Integer.parseInt(param.get("price")));
		foodProducts.setSupplierName(param.get("supplier"));
		
		if(fpService.insertNewProduct(foodProducts)) { 
			rView.printCompleteMessage("successInsertNewProduct");
		} else {
			rView.printErrorMessage("failInsertNewProduct");
		}
	}

	/* [4-1] 모든 업체 조회하기 */
	public void selectAllSupplier() {
	
		List<SupplierDTO> allSupplierList = fpService.selectAllSupplier();
		
		if(allSupplierList != null) {
			rView.printSupplierList(allSupplierList);
		} else {
			rView.printErrorMessage("failSelectAllSupplier");
		}
	}

	/* [4-2] 정보 변경하기 */
	public void updateSupplierInfo(Map<String, String> param) {
		
		SupplierDTO supplier = new SupplierDTO();
		supplier.setSupplierName(param.get("suppName"));
		supplier.setAddress(param.get("newAddress"));
		supplier.setContactNumber(param.get("newContactNumber"));
		supplier.setOrderYn(param.get("newOrderYn"));
		
		if(fpService.updateSupplierInfo(supplier)) {
			rView.printCompleteMessage("successUpdateSupplierInfo");
		} else {
			rView.printErrorMessage("failUpdateSupplierInfo");
		}
	}

	/* [4-3] 계약 해지하기 */
	public void deleteSupplier(Map<String, String> param) {
		
		String suppName = param.get("suppName");
		
		if(fpService.deleteSupplier(suppName)) {
			rView.printCompleteMessage("successDeleteSupplier");
		} else {
			rView.printErrorMessage("failDeleteSupplier");
		}
		
	}

	/* [5] 주문내역 조회하기 */
	public void selectOrderHistory(Map<String, String> param) {
		
		String range = param.get("range");
		
		List<OrderHistoryDTO> orderHistoryList = fpService.selectOrderHistory(range);
		
		if(orderHistoryList != null) {
			rView.printOrderHistoryList(orderHistoryList);
		} else {
			rView.printErrorMessage("failSelectOrderHistory");
		}
	}
}

👉 Service

◼ FoodProductsService Class

public class FoodProductsService {
	
	private FoodProductsMapper mapper;

	/* [1-1] 오늘의 재료 추천받기 */
	public List<FoodProductsDTO> selectRandomProducts(List<Integer> randomProductsList) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		
		/* Map에 집어넣기 */
		Map<String, List<Integer>> criteria = new HashMap<>();
		criteria.put("randomProductsList", randomProductsList);
		
		List<FoodProductsDTO> productsList = mapper.selectRandomProducts(criteria);
		
		sqls.close();
		
		return productsList;
	}

	/* [1-2] 유통업체 선택하기 */
	public List<FoodProductsDTO> selectProductsBySupplier(SearchCriteria searchCriteria) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		List<FoodProductsDTO> productsList = mapper.selectProductsBySupplier(searchCriteria);
		
		sqls.close();
		
		return productsList;
	}

	/* [1-3A] 전체 판매 재료 조회하여 리스트에 담기 */
	public List<FoodProductsDTO> selectAllProducts() {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		List<FoodProductsDTO> allproductsList = mapper.selectAllProducts();

		sqls.close();
		
		return allproductsList;
	}

	/* [1-3B] 주문한 내역 저장하기 / [1-3C] 주문한 재료 저장고에 추가하기 */
	public boolean insertOrderedProducts(OrderHistoryDTO order) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		
		/* 주문한 내역 저장하기 */
		int result1 = mapper.insertOrderedProducts(order);
		
		/* 주문한 재료 저장고에 추가하기 */
		int result2 = 0;
		for(StorageDTO storage : order.getStorageDTO()) {
			result2 += mapper.insertProductsToStorage(storage);			
		}
		
		if(result1 > 0 && result2 > 0) { 
        // 주문 내역과 재료들이 모두 정상적으로 INSERT되었을 때, commit (하나의 트랜잭션 안에서 수행)
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result1 > 0 && result2 > 0 ? true : false;
	}

	/* [1-3C] 주문한 재료 저장고에 추가하기 */
	public boolean insertProductsToStorage(List<StorageDTO> productsToStorageList) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		
		/* INSERT이므로 int로 반환받기 */
		int result = 0;
		for(StorageDTO storage : productsToStorageList) {
			result += mapper.insertProductsToStorage(storage);
		}
		
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}

	/* [2-1] 재료 파악하기 */
	public List<StorageDTO> selectProductsBySomething(SearchCriteria searchCriteria) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		List<StorageDTO> myProductsList = mapper.selectProductsBySomething(searchCriteria);

		sqls.close();
		
		return myProductsList;
	}

	/* [2-2] 재료 사용하기 */
	public boolean deletePickedProduct(String prodName) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		
		/* DELETE이므로 int로 반환받기 */
		int result = mapper.deletePickedProduct(prodName);
		
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}

	/* [2-3] 상한 재료 교환받기 */
	public boolean updatePickedProduct(String prodName) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		
		/* UPDATE이므로 int로 반환받기 */
		int result = mapper.updatePickedProduct(prodName);
		
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}

	/* [2-4] 오래된 재료 모두 폐기하기 */
	public boolean deleteOldProducts(int days) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		
		/* DELETE이므로 int로 반환받기 */
		int result = mapper.deleteOldProducts(days);
		
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	
	}

	/* [3] 원하는 재료 판매 제안하기 */
	public boolean insertNewProduct(FoodProductsDTO foodProducts) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		
		/* INSERT이므로 int로 반환받기 */
		int result = mapper.insertNewProduct(foodProducts);
		
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}

	/* [4-1] 모든 업체 조회하기 */
	public List<SupplierDTO> selectAllSupplier() {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		List<SupplierDTO> allSupplierList = mapper.selectAllSupplier();
		
		sqls.close();
		
		return allSupplierList;
	}

	/* [4-2] 정보 변경하기 */
	public boolean updateSupplierInfo(SupplierDTO supplier) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		
		/* UPDATE이므로 int로 반환받기 */
		int result = mapper.updateSupplierInfo(supplier);
		
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}

	/* [4-3] 계약 해지하기 */
	public boolean deleteSupplier(String suppName) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		
		/* DELETE이므로 int로 반환받기 */
		int result = mapper.deleteSupplier(suppName);
		
		if(result > 0) {
			sqls.commit();
		} else {
			sqls.rollback();
		}
		
		sqls.close();
		
		return result > 0 ? true : false;
	}

	/* [5] 주문내역 조회하기 */
	public List<OrderHistoryDTO> selectOrderHistory(String range) {
		
		SqlSession sqls = getSqlSession();
		mapper = sqls.getMapper(FoodProductsMapper.class);
		List<OrderHistoryDTO> orderHistoryList = mapper.selectOrderHistory(range);
		
		sqls.close();
		
		return orderHistoryList;
	}
}

👉 Mapper

◼ FoodProductsMapper Interface

public interface FoodProductsMapper {

	/* [1-1] 오늘의 재료 추천받기 */
	List<FoodProductsDTO> selectRandomProducts(Map<String, List<Integer>> criteria);

	/* [1-2] 유통업체 선택하기 */
	List<FoodProductsDTO> selectProductsBySupplier(SearchCriteria searchCriteria);

	/* [1-3A] 전체 메뉴 조회하여 리스트에 담기 */
	List<FoodProductsDTO> selectAllProducts();

	/* [1-3B] 주문한 내역 저장하기 */
	int insertOrderedProducts(OrderHistoryDTO order);

	/* [1-3C] 주문한 재료 저장고에 추가하기 */
	int insertProductsToStorage(StorageDTO storageDTO);

	/* [2-1] 재료 파악하기 */
	List<StorageDTO> selectProductsBySomething(SearchCriteria searchCriteria);

	/* [2-2] 재료 사용하기 */
	int deletePickedProduct(String prodName);

	/* [2-3] 상한 재료 교환받기 */
	int updatePickedProduct(String prodName);

	/* [2-4] 오래된 재료 모두 폐기하기 */
	int deleteOldProducts(int days);

	/* [3] 원하는 재료 판매 제안하기 */
	int insertNewProduct(FoodProductsDTO foodProducts);

	/* [4-1] 모든 업체 조회하기 */
	List<SupplierDTO> selectAllSupplier();

	/* [4-2] 정보 변경하기 */
	int updateSupplierInfo(SupplierDTO supplier);

	/* [4-3] 계약 해지하기 */
	int deleteSupplier(String suppName);

	/* [5] 주문내역 조회하기 */
	List<OrderHistoryDTO> selectOrderHistory(String range);
}

◼ FoodProductsMapper.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="com.joyhyonie.foodProducts.mapper.FoodProductsMapper">

	<resultMap type="com.joyhyonie.foodProducts.model.dto.FoodProductsDTO" id="foodProductsResultMap">
		<id property="prodCode" column="PROD_CODE"/>
		<result property="prodName" column="PROD_NAME"/>
		<result property="price" column="PRICE"/>
		<result property="supplierName" column="SUPPLIER_NAME"/>
	</resultMap>
	
	<resultMap type="com.joyhyonie.foodProducts.model.dto.OrderHistoryDTO" id="orderHistoryResultMap">
		<id property="orderCode" column="ORDER_CODE"/>
		<result property="orderDate" column="ORDER_DATE"/>
		<result property="orderTime" column="ORDER_TIME"/>
		<result property="totalPrice" column="TOTAL_PRICE"/>
	</resultMap>
	
	<resultMap type="com.joyhyonie.foodProducts.model.dto.StorageDTO" id="storageResultMap">
		<id property="prodCode" column="PROD_CODE"/>
		<result property="prodName" column="PROD_NAME"/>
		<result property="incomingDate" column="INCOMING_DATE"/>
	</resultMap>
	
	<resultMap type="com.joyhyonie.foodProducts.model.dto.SupplierDTO" id="supplierResultMap">
		<id property="supplierCode" column="SUPPLIER_CODE"/>
		<result property="categoryCode" column="CATEGORY_CODE"/>
		<result property="supplierName" column="SUPPLIER_NAME"/>
		<result property="address" column="ADDRESS"/>
		<result property="contactNumber" column="CONTACT_NUMBER"/>
		<result property="orderYn" column="ORDER_YN"/>
      	<!-- JOIN 하기 위해 <association> 사용 -->
		<association property="foodCategory" javaType="com.joyhyonie.foodProducts.model.dto.FoodCategoryDTO">
			<id property="categoryCode" column="CATEGORY_CODE"/>
			<result property="category" column="CATEGORY"/>
		</association>
	</resultMap>

  <select id="selectRandomProducts" parameterType="hashmap" resultMap="foodProductsResultMap">
  SELECT
    		PROD_CODE
    	,	PROD_NAME
    	,	PRICE
    	,	SUPPLIER_NAME
    	FROM TBL_PRODUCTS
    	JOIN TBL_SUPPLIER USING(SUPPLIER_NAME)
    	WHERE ORDER_YN = 'Y'
    	AND PROD_CODE IN
    	<foreach collection="randomProductsList" item="prodCode" open="(" separator="," close=")"> 
    		#{ prodCode }
    	</foreach>
    	ORDER BY PROD_CODE
  </select>

  <select id="selectProductsBySupplier" parameterType="SerchCriteria" resultMap="foodProductsResultMap"> 
  SELECT
    		PROD_CODE
    	,	PROD_NAME
    	,	PRICE
    	,	SUPPLIER_NAME
  		FROM TBL_PRODUCTS
  		JOIN TBL_SUPPLIER USING(SUPPLIER_NAME)
  		WHERE ORDER_YN = 'Y'
  		<choose>
  			<when test='value == "A"'>
  			AND SUPPLIER_NAME = '굽네정육'</when>
  			<when test='value == "B"'>
  			AND SUPPLIER_NAME = '바다회사랑'</when>
  			<when test='value == "C"'>
  			AND SUPPLIER_NAME = 'SING싱채소'</when>
  			<when test='value == "D"'>
  			AND SUPPLIER_NAME = '베지상회'</when>
  			<when test='value == "E"'>
  			AND SUPPLIER_NAME = '치즈FARM'</when>
  			<when test='value == "F"'>
  			AND SUPPLIER_NAME = '얼음땡푸드'</when>
  			<when test='value == "G"'>
  			AND SUPPLIER_NAME = '짱구는말려'</when>
  			<when test='value == "H"'>
  			AND SUPPLIER_NAME = '꼬순내방앗간'</when>
  			<when test='value == "I"'>
  			AND SUPPLIER_NAME = 'EGG머니나'</when>
  		</choose>
  		ORDER BY PROD_CODE
  </select>

  <select id="selectAllProducts" resultMap="foodProductsResultMap">
  	SELECT
    		PROD_CODE
    	,	PROD_NAME
    	,	PRICE
    	,	SUPPLIER_NAME
  		FROM TBL_PRODUCTS
  </select>

  <insert id="insertOrderedProducts" parameterType="com.joyhyonie.foodProducts.model.dto.OrderHistoryDTO">
  	INSERT
  		INTO TBL_ORDER_HISTORY
  	(
  		ORDER_CODE
	,	ORDER_DATE
	,	ORDER_TIME
	,	TOTAL_PRICE
	)
	VALUES
	(
		SEQ_ORDER_CODE.NEXTVAL
	,	#{ orderDate }
	,	#{ orderTime }
	,	#{ totalPrice }
  	)
  </insert>

  <insert id="insertProductsToStorage" parameterType="com.joyhyonie.foodProducts.model.dto.StorageDTO">
  	INSERT
  		INTO TBL_STORAGE
  	(
  		PROD_CODE
  	,	PROD_NAME
  	,	INCOMING_DATE
  	)
  	VALUES
  	(
  		#{ prodCode }
  	,	#{ prodName }
  	,	#{ incomingDate	}
  	)
  </insert>

  <select id="selectProductsBySomething" parameterType="SerchCriteria" resultMap="storageResultMap">
  	SELECT
  			PROD_CODE
  		,	PROD_NAME
  		,	INCOMING_DATE
  		FROM TBL_STORAGE
  		<if test="condition == '재료명별'">
  		WHERE PROD_NAME LIKE '%' || #{ value } || '%'
  		</if>
  		ORDER BY INCOMING_DATE
  </select>

  <delete id="deletePickedProduct" parameterType="string">
  	DELETE
  		FROM TBL_STORAGE
  		WHERE PROD_NAME = #{ prodName }
  </delete>
  
  <update id="updatePickedProduct" parameterType="string">
  	UPDATE
  			TBL_STORAGE
  		SET INCOMING_DATE = SYSDATE
  		WHERE PROD_NAME = #{ prodName }
  </update>

  <delete id="deleteOldProducts" parameterType="_int">
  	DELETE
  		FROM TBL_STORAGE
  	 WHERE ROUND(MONTHS_BETWEEN(SYSDATE, INCOMING_DATE) * 24) >= #{ days } 
  </delete>

  <insert id="insertNewProduct" parameterType="com.joyhyonie.foodProducts.model.dto.FoodProductsDTO">
  	INSERT
  		INTO TBL_PRODUCTS
  	(
  		PROD_CODE
  	,	PROD_NAME
  	,	PRICE
  	,	SUPPLIER_NAME	
  	)
  	VALUES
  	(
  		SEQ_PROD_CODE.NEXTVAL
  	,	#{ prodName }
  	,	#{ price }
 	,	#{ supplierName }
 	)
  </insert>

  <select id="selectAllSupplier" resultMap="supplierResultMap"> <!-- <association> 사용 -->
  	SELECT
  			A.CATEGORY_CODE
  		,	A.SUPPLIER_CODE
  		,	A.SUPPLIER_NAME
  		,	A.ADDRESS
  		,	A.CONTACT_NUMBER
  		,	A.ORDER_YN
  		,	B.CATEGORY
  		FROM TBL_SUPPLIER A
  		JOIN TBL_FOOD_CATEGORY B ON (A.CATEGORY_CODE = B.CATEGORY_CODE)
  		ORDER BY CATEGORY_CODE
  </select>

  <update id="updateSupplierInfo" parameterType="com.joyhyonie.foodProducts.model.dto.SupplierDTO">
  	UPDATE
  		TBL_SUPPLIER
  	<trim prefix="SET" prefixOverrides=",">
  		<if test="address != null and address !=''">
  		ADDRESS = #{ address } </if>
  		<if test="contactNumber != null and contactNumber !=''">
  	,	CONTACT_NUMBER = #{ contactNumber } </if>
  		<if test="orderYn != null and orderYn !=''">
  	,	ORDER_YN = #{ orderYn } </if>
  	</trim>
  	WHERE SUPPLIER_NAME = #{ supplierName }
  </update>

  <delete id="deleteSupplier" parameterType="string">
  	DELETE
  		FROM TBL_SUPPLIER
  		WHERE SUPPLIER_NAME = #{ supplierName }
  </delete>

  <select id="selectOrderHistory" resultMap="orderHistoryResultMap">
  	SELECT
  		ORDER_CODE
	,	ORDER_DATE
	,	ORDER_TIME
	,	TOTAL_PRICE
	FROM TBL_ORDER_HISTORY
	ORDER BY ORDER_DATE <if test="range == '최신순'">DESC</if>, ORDER_TIME <if test="range == '최신순'">DESC</if>
  </select>

</mapper>

👉 Run

◼ Application Class

public class Application {

	public static void main(String[] args) {
		
		new MainView().displayView();
	}
}

---

💬 Overall Comment

처음으로 Mybatis를 활용해서 MVC 구조로 콘솔 프로그램을 만들어보았다. 내가 원하는 주제를 선택하여 제작할 수 있었기 때문에 첫 제작과정부터 설레고 정말 재미있었다. DB부터 어떻게 구성하면 효율적일지 고민을 굉장히 많이 했고 엑셀에 직접 완성된 테이블이 어떻게 보이는지 만들어 보기도 했다. 결과적으로 약간 수정되고 삭제되는 부분이 있었으나, DB모델링을 배우기 전이었기 때문에 엑셀을 활용한 DB구조 작업은 확실히 큰 도움이 되었다.

몇 시간동안 구성을 하고 테이블을 완성하고나니, 이제 이클립스에서 코드를 작성해야했다. 차근차근 폴더를 상세히 나누고 오타는 없는지 정말 수없이 확인을 했던 것 같다. 이제 내가 원하는 기능을 하나하나 넣어가면 되었는데, 이미 한번 MVC구조를 연습해본 경험이 있었으나 새로운 기능을 시도해보고자 하는 욕심덕에 초반부터 꽤 애를 먹었다.

완전한 첫 기능이었던 '오늘의 재료 추천받기'를 만들고 다행스럽게도 정상적으로 작동은 되었으나, 이게 왠걸 재료 3개가 고정적으로 출력되는 것이 아닌 0개, 1개, 2개, 3개 등등 갯수 또한 랜덤으로 출력되어 적잖이 당황했다. 원인이 도무지 뭔지 도통 모르겠어서 선생님께 자문을 구했는데, 정말 여쭤보기도 민망할만큼 사소했다. 100번부터 150번의 재료를 랜덤으로 3개 뽑으려면, (int) (Math.random() * 50)) + 100으로 코드를 작성해야했는데, (int) (Math.random() * 150)) + 100으로 작성하니 당연히 범위를 벗어난 재료들은 출력되지 않은 것이었다. 정신차리고 코드를 작성해야겠다고 다짐한 한 부분이었다..!

그리고 여러가지 동적쿼리와 엘리먼트를 최대한 활용하고자, <association>, <foreach>, <choose>&<when>, <if>, <trim>등을 사용하여 쿼리문을 작성했고 특히 '오래된 재료 폐기하기'기능을 위해 사용했던 MONTHS_BETWEEN이 기억에 남는다! 쿼리문을 요리조리 작성해보는게 너무 재미있어서 꼭 프로그램을 제작할 때 여러가지를 사용해보고 싶었는데, 생각처럼 잘 구현되어 기분이 좋았다 :)
수업에서 그냥 배운 것과 한번이라도 내 것으로 사용해보는 것은 정말 천지차이라고 생각하기 때문에 앞으로도 계속 꾸준히 활용할 예정이다.

또한, 가장 마지막까지 애를 먹었던 부분인 '주문 시작하기'... 정말 정말 까다로웠으나 내가 구현한 기능 중 정말 자신있게 먼저 선보이고 싶은 기능이었다. 훗날 이 모습을 내가 보게 된다면 겨우 이거 가지고 쩔쩔 매었던게 귀여워 보일 듯 하지만 구현하고나서 너무 뿌듯했다. 내가 원했던 부분은 사용자가 여러 재료를 계속 입력할 수 있게 한 뒤, 주문이 끝나면 총액 및 주문한 재료들을 출력해주고 그에 따라 Storage, OrderHistory 데이터베이스에 자동으로 저장되게 만들도록 하고싶었다. 생각만큼 수월한 과정은 아니었고 여러 재료를 Insert하기 위해 List를 사용해야한다는 점이 풀어내야할 숙제였다. 하지만 정말 말처럼 쉽지 않았고 계속 한 가지 재료만 삽입되었다... :(
계속 붙잡고 있다가 안될 것 같아서 선생님께 자문을 구했고 Service에서 for문을 이용하여 값을 하나하나 뽑아내어 넘기면 된다는 결정적인 힌트를 얻게 되었다. 드디어 구현이 되었고 뛸 듯이 기뻤다.

하지만, 내가 질문했을 때 전체적인 코드를 선생님이 봐주시다가 Storage와 OrderHistory에 insert될 때 각기 다른 트랜잭션에서 수행되고 있다는 것을 확인해 주셨고 이 둘을 하나의 트랜잭션에서 수행하도록 코드를 다시 고쳐야만했다. (절망) 이 또한 어떤 방식으로 고쳐야하는지 그 시점에 배우게 되었고 끝내 완성할 수 있게 되어 정말 많이 뿌듯했다.

한 가지 더, 시간이 더 있었다면 추가하고 싶은 욕심 나는 기능이 있는데 Storage에 이미 있는 재료들은 주문하지 못 하도록 하는 기능을 구현하고싶다. 이건 아마도 Storage를 전체 조회한 뒤, !@@.equals()를 이용하여 이 때만 주문이 가능하도록 하게 만들면 좋을 것 같다.

결과적으로 내가 원했던 작지만 나름 알찬 콘솔 프로그램이 완성되어 감회가 새롭고 기분이 좋다 :)
더 유용한 프로그램을 계속 해서 만들어 나가고 싶다!