[Team/붕어빵원정대(최프)] 중프(JSP기반)에서 Spring 이관 작업 1차

 

 

[DBMS] Oracle에서 MySQL로 데이터 이관 (CSV/DBeaver)

 

지난 번 Oracle에서 MySQL로 데이터 이관 작업을 하며 데이터를 옮기는 작업과 DAO의 쿼리문을 수정하는 작업을 팀원끼리 2개의 DAO씩 분배해 작업 했다.

 

파트 분배

이번에는 Spring 기초 구조 진도를 나갔기 때문에 기존 JSP기반 Controller 코드를 Spring으로 변경해 옮기는 작업을 진행했다. 마찬가지로 담당한 파트 구분없이 페이지 기준 2개로 Controller 코드를 변경하며 공부하기로 했다. 남은 Controller 파일은 Controller 파트를 맡은 팀원들이 진행하기로 했다. (취소)

 

최종 프로젝트에서는 Controller 파트장을 맡았으므로 먼저 할당된 Controller 두 개를 이관 작업 한 뒤 남은 이관 작업을 진행할 예정이다.

 

 

보완할 점

그런데 자세히 살펴보니 너무,,, 충격적인 부분이 많아서 로직은 유지한 상태로 어떻게 좀.. 해보려고 했는데 너무 오랜 시간이 소요 돼 update 부분부터는 일단 이관 작업부터 마치고 로직 및 코드 수정을 진행하기로 했다.

 

팀 적으로 코드리뷰가 잘 이뤄지지 않았고, model파트에서도 로직만 서로 리뷰하는 선에서 진행했는데 그 부분이 큰 문제였음을 다시 깨달았다.. 최종 프로젝트에서는 코드리뷰를 좀 더 세세하게 진행할 필요가 있을 것 같다. 아직 배우는 단계이고 다행히 최종프로젝트가 많이 진행되기 전에 문제를 찾을 수 있었으니 보완할 수 있어 정말 다행이다...!

 

 

진행

작업을 맡은 부분은 가게 insert, 가게 update 부분과 해당 페이지로 이동하는 기능이다. 네 기능 모두 가게 기능으로 묶을 수 있으므로 StoreController로 묶어 두 기능을 넣었다.

 

로직 등은 이관 마치며 바로 수정 들어갈 예정이다. (개인 개발 계획 수정)

 

[코드]

package com.bungeabbang.app.view.controller;

import com.bungeabbang.app.biz.model.dao.StoreDAO;
import com.bungeabbang.app.biz.model.dao.StoreMenuDAO;
import com.bungeabbang.app.biz.model.dao.StorePaymentDAO;
import com.bungeabbang.app.biz.model.dao.StoreWorkDAO;
import com.bungeabbang.app.biz.model.dto.StoreDTO;
import com.bungeabbang.app.biz.model.dto.StoreMenuDTO;
import com.bungeabbang.app.biz.model.dto.StorePaymentDTO;
import com.bungeabbang.app.biz.model.dto.StoreWorkDTO;
import com.bungeabbang.app.view.util.StoreMethods;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.ArrayList;

@Controller("store")
public class StoreController {
    //가게 추가
    @RequestMapping("/storeRegister.do")
    public String addStore(Model model,
                           StoreDAO storeDAO, StoreDTO storeDTO, StoreDTO storePKDTO,
                           StoreWorkDAO storeWorkDAO, StoreMenuDAO storeMenuDAO, StoreMenuDTO storeMenuDTO, StorePaymentDAO storePaymentDAO, StorePaymentDTO storePaymentDTO,
                           ArrayList<String> storeMenuDatas,
                           // 이름 차이로 자동 주입을 사용할 수 없어 수동으로 주입 할 데이터
                           String storeName, String storeAddress, String storeAddressDetail, String storePhone,
                           String[] businessDays, String startTime, String endTime,
                           String[] businessMenus, String[] businessPayments
                           ) {

        System.out.println("log: /storeRegister.do - addStore start");

        String failPath = "failInfo"; //실패 시 이동할 경로
        String successPath = "main"; //성공 시 이동할 경로

        // 이름 차이로 자동 주입을 사용할 수 없어 수동으로 주입
        storeDTO.setStoreName(storeName);
        storeDTO.setStoreDefaultAddress(storeAddress);
        storeDTO.setStoreDetailAddress(storeAddressDetail);
        storeDTO.setStorePhoneNum(storePhone);
        storeDTO.setStoreClosed("N");

        //값 확인
        System.out.println("log: addStore - store before insert - storeDTO [" + storeDTO + "]");

        // insert에 실패하면
        if(!storeDAO.insert(storeDTO)) {
            System.err.println("log: addStore - store insert fail");
            //실패 시 실패문구
            model.addAttribute("msg", "가게 등록에 실패했습니다.");
            //실패 안내 요청
            return failPath;
        }

        System.out.println("log: addStore - store insert success");
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //영업일시 insert 시작
        System.out.println("log: addStore - work start");

        // 추가 정보를 등록하기 위해 PK값을 정보 요청
        storePKDTO.setCondition("STORE_NEW_SELECTONE");
        storePKDTO = storeDAO.selectOne(storePKDTO);

        // int storeNum에 반환값(PK) 저장
        int storeNum = storePKDTO.getStoreMaxNum();
        System.out.println("log: addStore PK - storeNum [" + storeNum + "]");


        // 가게 영업
        // String[] 변수명(요일) : storeWorkWeek
        //FIXME 정리 필요
        String[] storeWorkWeek = businessDays;
        // String 변수명(영업시작 시간) : storeStartTime
        String storeStartTime = startTime;
        // String 변수명(영업종료 시간) : storeEndTime
        String storeEndTime = endTime;

        // storeWorkDTO.set으로 가게번호(PK), 요일, 영업시작 시간, 영업 종료 시간 넣기
        // storeWorkWeek만큼 반복
        boolean flag = false;
        for(String data : storeWorkWeek) {
            StoreWorkDTO storeWorkDTO = new StoreWorkDTO();
            storeWorkDTO.setStoreNum(storeNum);
            storeWorkDTO.setStoreWorkWeek(data);
            storeWorkDTO.setStoreWorkOpen(storeStartTime);
            storeWorkDTO.setStoreWorkClose(storeEndTime);

            System.out.println("log: addStore - work before insert : storeWorkDTO [" + storeWorkDTO + "]");
            // 가게 영업 시간 추가 insert 실패 시
            if(!storeWorkDAO.insert(storeWorkDTO)) {
                flag = true;
                break;
            }
        }
        if(flag){
            //가게 영업 시간 insert 실패 시
            System.out.println("log: addStore - work insert fail");
            model.addAttribute("msg", "가게 영업 등록에 실패했습니다.");
            // 실패 이동 경로
            return failPath;
        }
        //가게 영업 시간 insert 성공 시
        System.out.println("log: addStore - work insert success");
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //가게 메뉴 분류 insert 시작
        System.out.println("log: addStore - menu start");

        // 가게 메뉴
        // 가게 메뉴 받기 (팥/슈크림, 야채/김치/만두, 미니, 고구마, 아이스크림/초코, 치즈, 패스츄리, 기타)
        //String[] 변수명 : storeMenu
        //FIXME 정리 필요
        String[] storeMenu = businessMenus;

        // 가게 메뉴 체크박스 데이터 전달을 위한 배열리스트 생성
        // ArrayList<String> 변수명 : storeMenuDatas
        String[] menu = {"팥/슈크림", "야채/김치/만두", "미니", "고구마", "아이스크림/초코", "치즈", "패스츄리", "기타"};
        for(String data : storeMenu) {
            for(int i = 0; i < menu.length; i++) {
                if(data.equals(menu[i])) {
                    //요청이 있을 경우 Y
                    storeMenuDatas.set(i, "Y");
                    System.out.println("log: addStore - menu set storeMenuDatas ["+i+"]num set Y");
                }
                else{
                    //요청이 없을 경우 N
                    storeMenuDatas.set(i, "N");
                    System.out.println("log: addStore - menu set storeMenuDatas ["+i+"]num set N");
                }
            }
        }
        // storeMenuDTO.set가게번호 하기
        storeMenuDTO.setStoreNum(storeNum);
        // storeMenuSet 메서드로 storeMenuDTO.set 완료

        //FIXME 정말 반드시 수정할 것
        int index = 0;
        System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ index);
        storeMenuDTO.setStoreMenuNomal(storeMenuDatas.get(index++));      // 0.팥/슈크림
        System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ index);
        storeMenuDTO.setStoreMenuVegetable(storeMenuDatas.get(index++));   // 1.야채/김치/만두
        System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ index);
        storeMenuDTO.setStoreMenuMini(storeMenuDatas.get(index++));         // 2.미니
        System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ index);
        storeMenuDTO.setStoreMenuPotato(storeMenuDatas.get(index++));      // 3.고구마
        System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ index);
        storeMenuDTO.setStoreMenuIceCream(storeMenuDatas.get(index++));      // 4.아이스크림/초코
        System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ index);
        storeMenuDTO.setStoreMenuCheese(storeMenuDatas.get(index++));      // 5.치즈
        System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ index);
        storeMenuDTO.setStoreMenuPastry(storeMenuDatas.get(index++));      // 6.패스츄리
        System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ index);
        storeMenuDTO.setStoreMenuOthers(storeMenuDatas.get(index));      // 7. 기타

        // 가게 등록에 실패 시
        if(!storeMenuDAO.insert(storeMenuDTO)) {
            // insert 실패 문구 및 경로
            System.out.println("log: addStore - menu insert fail");
            model.addAttribute("msg", "가게 메뉴 등록에 실패했습니다.");
            return failPath;
        }
        System.out.println("log: addStore - menu insert success");
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //결제 방식 insert 시작
        System.out.println("log: addStore - payment start");
        // 결제 방식 ================================================================================
        // 결제방식 받기 (현금, 카드, 계좌이체)
        // String[] 변수명 : storePayment
        //FIXME 정리필요
        String[] storePayment = businessPayments;

        // 결제방식
        // storePaymentDTO.set가게번호 하기
        storePaymentDTO.setStoreNum(storeNum);

        //FIXME 진짜 반드시 수정할 것
        int index2 = 0;
        String[] payment = {"현금결제", "카드결제", "계좌이체"};
        for(String data : storePayment) {
            // 만약 data가 "현금결제"이라면
            if(data.equals(payment[index2++]) || data.equals("Cash")) {
                // storeDTO.set현금결제에 'Y' 값을 넣음
                storePaymentDTO.setStorePaymentCashmoney("Y");
                System.out.println("   log : StoreMethods.storePaymentSet()   현금결제를 Y로 변경");
            }
            // 만약 data가 "카드결제"이라면
            else if(data.equals(payment[index2++]) || data.equals("Card")) {
                // storeDTO.set카드결제에 'Y' 값을 넣음
                storePaymentDTO.setStorePaymentCard("Y");
                System.out.println("   log : StoreMethods.storePaymentSet()   카드결제를 Y로 변경");
            }
            // 만약 data가 "계좌이체"이라면
            else if(data.equals(payment[index2]) || data.equals("Account")) {
                // storeDTO.set계좌이체에 'Y' 값을 넣음
                storePaymentDTO.setStorePaymentAccountTransfer("Y");
                System.out.println("   log : StoreMethods.storePaymentSet()   계좌결제를 Y로 변경");
            }
            else {
                // 로그 잘못된 storePayment 값이 들어왔음
                System.out.println("   log : StoreMethods.storePaymentSet()   결제 방법과 상관없는 값이 들어옴");
            }
        }
        // storePaymentDAO.insert로 storePaymentDTO 등록
        // flag에 insert 결과 반환값을 저장

        // 가게 등록에 실패 시
        // flag가 false일 때
        if(!storePaymentDAO.insert(storePaymentDTO)) {
            // insert 실패 문구 및 경로
            System.out.println("log: addStore - menu insert fail");
            model.addAttribute("msg", "가게 결제방식 등록에 실패했습니다.");
            return failPath;
        }

        // forward 객체 반환
        return successPath;
    }

    @RequestMapping("/updateStore.do")
    public String updateStore(Model model,
                              StoreDAO storeDAO, StoreDTO storeDTO,
                              StoreWorkDAO storeWorkDAO, StoreMenuDAO storeMenuDAO, StoreWorkDTO storeWorkDTO, StoreMenuDTO storeMenuDTO, StorePaymentDAO storePaymentDAO, StorePaymentDTO storePaymentDTO,
                              ArrayList<String> storeWorkWeekList, ArrayList<String> preStoreWorkWeek,
                              StoreWorkDTO preStoreWorkDTO, StoreWorkDAO preStoreWorkDAO,
                              //수동주입할 데이터들
                              int storeNum, String storeName, String storeAddress, String storeAddressDetail, String storePhone, String[] businessOff,
                              String[] businessDays, String startTime, String endTime, String[] businessMenus, String[] businessPayments
                              ) {
        System.out.println("   log : UpdateStoreAction.java   시작");

        // 사용할 데이터 선언 부분 ==================================================================
        // 가게 번호(PK)
        // int 변수명(가게 번호) : storeNum
        System.out.println("   log : UpdateStoreAction.java   storeNum : "+storeNum);

        // 기존 가게 영업 요일을 저장할 변수 생성

        // V에서 request.getParameter로 데이터를 받아옴

        // 가게 ---------------------------------------------------------------------------------
        // 가게 이름, 가게 주소, 가게 상세 주소, 연락처, 메뉴
        // String[] 변수명(영업상태) : storeClosedV
        String[] storeClosedV = businessOff;
        System.out.println("   log : UpdateStoreAction.java   storeClosed : "+storeClosedV);
        // storeClosed가 존재하는 지에 따라 값을 변경
        String storeClosed = null;
        // null이 아니라면
        if(storeClosedV != null && storeClosedV[0].equals("Y")) {
            System.out.println("   log : UpdateStoreAction.java   storeClosedV != null");
            System.out.println("   log : UpdateStoreAction.java   storeClosedV : "+storeClosedV[0]);
            // charStoreClosed의 값을 storeClosed[0] 값으로 변경
            storeClosed = storeClosedV[0];
        }
        else {
            storeClosed = "N";
        }

        // 가게 영업 -----------------------------------------------------------------------------
        // String[] 변수명(요일) : storeWorkWeek
        String[] storeWorkWeek = businessDays;
        System.out.println("   log : UpdateStoreAction.java   storeWorkWeek : "+storeWorkWeek);
        // String 변수명(영업시작 시간) : storeStartTime
        String storeStartTime = startTime;
        System.out.println("   log : UpdateStoreAction.java   storeStartTime : "+storeStartTime);
        // String 변수명(영업종료 시간) : storeEndTime
        String storeEndTime = endTime;
        System.out.println("   log : UpdateStoreAction.java   storeEndTime : "+storeEndTime);

        // 가게 영업 요일을 사용하기 편하게 ArrayList로 변경
        // 리스트명 : storeWorkWeekList
        // 배열 안에 있는 값을 반복하여 storeWorkWeekList에 추가
        for(String data : storeWorkWeek) {
            storeWorkWeekList.add(data);
        }
        System.out.println("   log : UpdateStoreAction.java   storeWorkWeek : "+storeWorkWeekList);

        // 가게 메뉴 ------------------------------------------------------------------------------
        // 가게 메뉴 받기 (팥/슈크림, 야채/김치/만두, 미니, 고구마, 아이스크림/초코, 치즈, 패스츄리, 기타)
        //String[] 변수명 : storeMenu
        String[] storeMenu = businessMenus;
        System.out.println("   log : UpdateStoreAction.java   storeMenu : "+storeMenu);

        // 가게 메뉴 체크박스 데이터 전달을 위한 배열리스트 생성
        // ArrayList<String> 변수명 : storeMenuDatas
        // storeMenuValue를 사용하여 메뉴 값을 받아옴
        ArrayList<String> storeMenuDatas = StoreMethods.storeMenuValue(storeMenu);

        // insert할 땐 null 값을 N으로 변경
        // storeMenuValuePlusN을 사용하여 N 추가
        storeMenuDatas = StoreMethods.storeListValuePlusN(storeMenuDatas);

        // 결제 방식 -------------------------------------------------------------------------------
        // 결제방식 받기 (현금, 카드, 계좌이체)
        // String[] 변수명 : storePayment
        String[] storePayment = businessPayments;
        System.out.println("   log : UpdateStoreAction.java   stroePayment : "+storePayment);

        // 필요한 기존 데이터 가져오는 부분 ============================================================
        // 기존 storeWorkDTO 리스트 가져오기
        // StoreWorkDTO, DAO 생성
        System.out.println("   log : UpdateStoreAction.java   preStoreWorkDTO,DAO 생성");

        // storeWorkDTO.set으로 condition, 가게번호(PK) 넣기
        // condition : STORE_NUM_SELECTONE
//      preStoreWorkDTO.setCondition("STORE_NUM_SELECTONE");
        preStoreWorkDTO.setStoreNum(storeNum);
        System.out.println("   log : UpdateStoreAction.java   preStoreWorkDTO.set가게 번호 완료");

        // DAO.selectAll로 가게 영업 정보 가져오기
        ArrayList<StoreWorkDTO> storeWorkDatas = preStoreWorkDAO.selectAll(preStoreWorkDTO);
        System.out.println("   log : UpdateStoreAction.java   prestoreWorkDAO.selecAll 완료 : "+storeWorkDatas);

        // 가게 영업 정보에서 영업 요일 데이터만 추출하기
        for(StoreWorkDTO data : storeWorkDatas) {
            preStoreWorkWeek.add(data.getStoreWorkWeek());
        }
        System.out.println("   log : UpdateStoreAction.java   preStoreWorkWeek : "+preStoreWorkWeek);

        // update 할 데이텨 세팅 부분 ==============================================================
        // storeDTO.set으로 가게 번호(PK), 가게 이름, 가게 기본 주소, 가게 상세 주소, 연락처, 영업상태를 입력
        storeDTO.setStoreNum(storeNum);
        storeDTO.setStoreName(storeName);
        storeDTO.setStoreDefaultAddress(storeAddress);
        storeDTO.setStoreDetailAddress(storeAddressDetail);
        storeDTO.setStorePhoneNum(storePhone);
        storeDTO.setStoreClosed(storeClosed);
        System.out.println("   log : UpdateStoreAction.java   storeDTO.set 완료");

        // storeWorkDTO.set으로 가게번호(PK), 영업시작 시간, 영업 종료 시간 넣기
        storeWorkDTO.setStoreNum(storeNum);
        storeWorkDTO.setStoreWorkOpen(storeStartTime);
        storeWorkDTO.setStoreWorkClose(storeEndTime);
        System.out.println("   log : UpdateStoreAction.java   storeWorkDTO.set 완료");

        // sotreMenuDTO.set가게 번호
        storeMenuDTO.setStoreNum(storeNum);
        // storeMenuSet 메서드로 storeMenuDTO.set 완료
        StoreMethods.storeMenuSet(storeMenuDatas, storeMenuDTO);
        System.out.println("   log : UpdateStoreAction.java   storeMenuDTO.set 완료");
        System.out.println("   log : UpdateStoreAction.java   storeMenuDTO : "+ storeMenuDTO);

        // sotrePaymentDTO.set가게 번호
        storePaymentDTO.setStoreNum(storeNum);

        // storePaymentSet 메서드를 사용하여 DTO에 세팅
        StoreMethods.storePaymentSet(storePayment, storePaymentDTO);
        System.out.println("   log : UpdateStoreAction.java   storePaymentDTO.set 완료");
        System.out.println("   log : UpdateStoreAction.java   storePaymentDTO : "+ storePaymentDTO);

        // storePaymentSetN 메서드를 사용하여 null 값에 N값 넣기
        StoreMethods.storePaymentSetPlusN(storePaymentDTO);
        System.out.println("   log : UpdateStoreAction.java   storePaymentDTO.set 완료");
        System.out.println("   log : UpdateStoreAction.java   storePaymentDTO : "+ storePaymentDTO);

        // 결과를 저장할 flag 생성
        // 기본값은 false
        boolean flag = false;

        // update 부분 ===========================================================================
        // 가게 update --------------------------------------------------------------------------
        System.out.println("   log : UpdateStoreAction.java   storeDTO.update 시작");
        // storeDAO.update를 사용하여 storeDTO 등록
        // flag에 update 결과 반환값을 저장
        flag = storeDAO.update(storeDTO);
        System.out.println("   log : UpdateStoreAction.java   storeDTO.update : "+flag);

        // flag가 false면
        if(!flag) {
            // 실패시 request.setAttribute(path, msg)를 해주는 메서드
            model.addAttribute("msg", "가게 업데이트에 실패했습니다.");

            // forward 값 반환
            System.err.println("   log : UpdateStoreAction.java   종료");
            return "failInfo";
        }

        // 가게 영업 시간 update -------------------------------------------------------------------
        System.out.println("   log : UpdateStoreAction.java   storeWorkDTO.update 시작");
        // storeWorkWeek의 갯수만큼 반복해서 업데이트

        // update, insert
        // storeWorkWeekList 값을 하나씩 가져와(newData) 반복
        // 기존 데이터인 preStoreWorkWeek 리스트 데이터 안에 newData 값이 존재하는지 판단하여 action 결정
        for(String newData : storeWorkWeekList) {
            // 기존 데이터와 비교하여 insert, update를 결정한다.
            // 일치 여부를 판단할 데이터 String action
            String action = null;
            // 판단 결과를 넣을 int result 변수 생성
            int result = 0;

            // indexOf 메서드를 사용하여 newData 값이 preStoreWorkWeek 안에 존재하는지 판단
            result = preStoreWorkWeek.indexOf(newData);
            System.out.println("   log : UpdateStoreAction.java   "+newData+"의 result : "+ result);

            // 일치하는 값이 있다면
            // result가 0보다 크다면
            if(result >= 0) {
                action = "update";
                System.out.println("   log : UpdateStoreAction.java   action : "+ action);
            }
            // newData가 preDatas에 없다면
            // result가 0보다 작다면
            else if(result < 0) {
                action = "insert";
                System.out.println("   log : UpdateStoreAction.java   action : "+ action);
            }

            // 해당 newData 값을 DTO.setStoreWeek 안에 넣고
            storeWorkDTO.setStoreWorkWeek(newData);

            // 결정된 action을 실행
            // action이 update라면
            if(action.equals("update")) {
                // storeWorkDAO.update로 storeWorkDTO 등록
                // flag에 update 결과 반환값을 저장
                flag = storeWorkDAO.update(storeWorkDTO);
                System.out.println("   log : UpdateStoreAction.java   storeWorkDTO.update : "+flag);
            }
            else if(action.equals("insert")) {
                // storeWorkDAO.insert로 storeWorkDTO 등록
                // flag에 insert 결과 반환값을 저장
                flag = storeWorkDAO.insert(storeWorkDTO);
                System.out.println("   log : UpdateStoreAction.java   storeWorkDTO.insert : "+flag);
            }

            // 가게 등록에 실패 시
            // flag가 false면
            if(!flag) {
                // 실패시 request.setAttribute(path, msg)를 해주는 메서드
                model.addAttribute("msg", "가게 영업시간 업데이트에 실패했습니다.");

                // forward 값 반환
                System.err.println("   log : UpdateStoreAction.java   종료");
                return "failInfo";
            }
        }

        // delete
        // preStoreWorkWeek 값을 하나씩 가져와(data) 반복
        // 기존 데이터인 storeWorkWeekList 리스트 데이터 안에 preData 값이 존재하는지 판단하여 delete 결정
        // 기존 데이터와 비교
        for(String preData : preStoreWorkWeek) {
            // 판단 결과를 넣을 int result 변수 생성
            int result = 0;

            // indexOf 메서드를 사용하여 preData 값이 storeWorkWeekList 안에 존재하는지 판단
            result = storeWorkWeekList.indexOf(preData);
            System.out.println("   log : UpdateStoreAction.java   "+preData+"의 result : "+ result);

            // 만약 데이터가 없다면
            // result가 0보다 작다면
            if(result < 0) {
                // data를 storeWorkDTO.set 함
                storeWorkDTO.setStoreWorkWeek(preData);

                // storeWorkDAO.delete로 storeWorkDTO 값 삭제
                // flag에 delete 결과 반환값을 저장
                flag = storeWorkDAO.delete(storeWorkDTO);
            }

            // 가게 삭제에 실패 시
            // flag가 false면
            if(!flag) {
                // 실패시 request.setAttribute(path, msg)를 해주는 메서드
                model.addAttribute("msg", "가게 영업시간 업데이트에 실패했습니다.");

                // forward 값 반환
                System.err.println("   log : UpdateStoreAction.java   종료");
                return "failInfo";
            }
        }


        // 가게 메뉴 update ----------------------------------------------------------------------
        // storeMenuDAO.update로 storeMenuDTO 등록
        // flag에 update 결과 반환값을 저장
        flag = storeMenuDAO.update(storeMenuDTO);
        System.out.println("   log : UpdateStoreAction.java   storeMenuDTO.update : "+flag);

        // 가게 등록에 실패 시
        // flag가 false면
        if(!flag) {
            // 실패시 request.setAttribute(path, msg)를 해주는 메서드
            model.addAttribute("msg", "가게 메뉴 업데이트에 실패했습니다.");

            // forward 값 반환
            System.err.println("   log : UpdateStoreAction.java   종료");
            return "failInfo";
        }

        // 가게 결제 방법 update -------------------------------------------------------------------
        // storePaymentDAO.update로 storeWorkDTO 등록
        // flag에 update 결과 반환값을 저장
        flag = storePaymentDAO.update(storePaymentDTO);
        System.out.println("   log : UpdateStoreAction.java   storePaymentDTO.update : "+flag);

        // 가게 등록에 실패 시
        // flag가 false면
        if(!flag) {
            // 실패시 request.setAttribute(path, msg)를 해주는 메서드
            model.addAttribute("msg", "가게 결제방법 업데이트에 실패했습니다.");

            // forward 값 반환
            System.err.println("   log : UpdateStoreAction.java   종료");
            return "failInfo";
        }

        // 성공 후 이동 ============================================================================

        // forward 객체 반환
        System.out.println("   log : UpdateStoreAction.java   searchStore");
        System.out.println("   log : UpdateStoreAction.java   종료");
        return "searchStore";
    }

    //가게 추가 페이지이동
    @RequestMapping("/insertStorePage.do")
    public String insertStorePage() {
        System.out.println("log: /insertStorePage.do - insertStorePage");
        return "redirect:storeRegister.jsp";
    }

    //가게 업데이트 페이지이동
    @RequestMapping("/updateStorePage.do")
    public String updateStorePage(Model model, int storeNum) {
        System.out.println("log: /updateStorePage.do - updateStorePage");

        //업데이트 대상 PK
        System.out.println("   log : UpdateStorePageAction.java      storeNum : "+ storeNum);

        // V에게 전달할 데이터 있음 : 변경하려는 가게 정보

        // StoreDTO 객체를 생성하고 입력한 번호와 일치하는 데이터를 찾아옴
        // StoreMethods.storeDetials 메서드 사용
        // 객체명 : storeDTO
        StoreDTO storeDTO = StoreMethods.storeDetails(storeNum);
        System.out.println("   log : UpdateStorePageAction.java      storeDTO 생성, storeDetails 메스드 사용");
        System.out.println("   log : UpdateStorePageAction.java      storeDTO : "+ storeDTO);

        // 만약 입력받은 가게 번호와 일치하는 가게가 없을 경우
        // 해당 정보가 없는 경우 밑의 selectOne 결과는 존재하지 않기 때문에 한 번 검사
        // storeDTO가 null이라면
        if(storeDTO == null) {
            // 에러페이지로 이동
            throw new RuntimeException();
        }

        // StoreWorkDTO
        // 객체명 : storeWorkList
        // StoreMethods.storeDetails(storeWorkDTO, storeNum)
        ArrayList<StoreWorkDTO> storeWorkList = StoreMethods.storeWorkDetails(storeNum);
        System.out.println("   log : UpdateStorePageAction.java      storeWorkList: "+ storeWorkList);

        // 전달하기 좋은 형태로 가공
        ArrayList<String> storeWorkWeekList = StoreMethods.storeWeekValue(storeWorkList);
        storeWorkWeekList = StoreMethods.storeListValuePlusN(storeWorkWeekList);
        System.out.println("   log : UpdateStorePageAction.java      storeWorkWeekList : "+ storeWorkWeekList);
        // 시간 데이터 가공
        String startTime = null;
        String endTime = null;
        // 만약 storeWorkList의 값이 존재한다면
        if(storeWorkList != null && !storeWorkList.isEmpty()) {
            System.out.println("   log : UpdateStorePageAction.java      storeWorkList.get(0).getStoreWorkClose() : "+ storeWorkList.get(0).getStoreWorkClose());
            // 시작 시간과 종료 시간을 변수에 넣음
            startTime = storeWorkList.get(0).getStoreWorkOpen();
            endTime = storeWorkList.get(0).getStoreWorkClose();
        }
        // 만약 존재하지 않는다면
        else {
            System.out.println("   log : UpdateStorePageAction.java      storeWorkList == null");
            // 시작, 종료 시간 모두 00:00으로 작성
            startTime = "00:00";
            endTime = "00:00";
        }
        System.out.println("   log : UpdateStorePageAction.java      startTime : "+ startTime);
        System.out.println("   log : UpdateStorePageAction.java      endTime : "+ endTime);

        // StoreMenuDTO
        // 객체명 : storeMenuDTO
        // StoreMethods.storeDetails(storeMenuDTO, storeNum)
        StoreMenuDTO storeMenuDTO = StoreMethods.storeMenuDetails(storeNum);
        System.out.println("   log : UpdateStorePageAction.java      storeMenuDTO : "+ storeMenuDTO);
        // StorePaymentDTO
        // 객체명 : storePaymentDTO
        // StoreMethods.storeDetails(storePaymentDTO, storeNum)
        StorePaymentDTO storePaymentDTO = StoreMethods.storePaymentDetails(storeNum);
        System.out.println("   log : UpdateStorePageAction.java      storePaymentDTO : "+ storePaymentDTO);

        // V에게 데이터 전달
        // V에게 request.setAttribute로 storeDTO, storeWorkWeekList, storeWorkStartTime, storeWorkEndTime, storeMenuDTO, storePaymentDTO 전달
        // 속성명 : storeData, storeWorkData, storeWorkWeek, getStoreWorkOpen(), getStoreWorkClose() storeMenuData, storePaymentData
        model.addAttribute("storeData", storeDTO);
        model.addAttribute("storeWorkWeek", storeWorkWeekList);
        model.addAttribute("storeWorkStartTime", startTime);
        model.addAttribute("storeWorkEndTime", endTime);
        model.addAttribute("storeMenuData", storeMenuDTO);
        model.addAttribute("storePaymentData", storePaymentDTO);
        System.out.println("   log : UpdateStorePageAction.java      V에게 storeDTO, storeWorkDTO, storeMenuDTO, storePaymentDTO 전달");

        System.out.println("   log : UpdateStorePageAction.java   storeUpdate");
        System.out.println("   log : UpdateStorePageAction.java   종료");
        return "storeUpdate";
    }
}

StoreMethods

package com.bungeabbang.app.view.util;

import com.bungeabbang.app.biz.model.dao.StoreDAO;
import com.bungeabbang.app.biz.model.dao.StoreMenuDAO;
import com.bungeabbang.app.biz.model.dao.StorePaymentDAO;
import com.bungeabbang.app.biz.model.dao.StoreWorkDAO;
import com.bungeabbang.app.biz.model.dto.StoreDTO;
import com.bungeabbang.app.biz.model.dto.StoreMenuDTO;
import com.bungeabbang.app.biz.model.dto.StorePaymentDTO;
import com.bungeabbang.app.biz.model.dto.StoreWorkDTO;

import java.util.ArrayList;


public class StoreMethods {
   // 0.팥/슈크림         1.야채/김치/만두      2.미니   3.고구마   4.아이스크림/초코   5.치즈   6.패스츄리   7.기타
   private static final String[] menu = {"팥/슈크림", "야채/김치/만두", "미니", "고구마", "아이스크림/초코", "치즈", "패스츄리", "기타"}; 
   // 0.현금결제      1.카드결제      2.계좌이체
   private static final String[] payment = {"현금결제", "카드결제", "계좌이체"};
   // 0.MON   1.TUE   2.WED   3.THU   4.FRI   5.SAT   6.SUN
   private static final String[] week = {"MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"};
   

   // 가게 관련 DTO들의 상세정보를 가져오는 메서드 =======================================================================
   // data : 가져오려는 가게의 정보(dto)
   // storeNum : 가져오려는 가게의 번호

   // 가게 상세 정보 -----------------------------------------------------------------------------------------------
   public static StoreDTO storeDetails(int storeNum) {
      System.out.println("   log : StoreMethods.storeDetails()   시작");
      System.out.println("   log : StoreMethods.storeDetails()   storeNum : "+ storeNum);

      // StoreDTO, StoreDAO 생성 : storeDTO, storeDAO
      StoreDTO storeDTO = new StoreDTO();
      StoreDAO storeDAO = new StoreDAO();
      System.out.println("   log : StoreMethods.storeDetails()   storeDTO, storeDAO 생성");

      // DTO 객체에 condition 넣기
      // condition : INFO_STORE_SELECTONE
      storeDTO.setCondition("INFO_STORE_SELECTONE");
      System.out.println("   log : StoreMethods.storeDetails()   setCondition : "+ storeDTO.getCondition());
      // DTO 객체에 storeNum 넣기
      storeDTO.setStoreNum(storeNum);

      // DAO.selectOne으로 DTO 값 가져오기
      // storeDTO에 반환값 넣기
      storeDTO = storeDAO.selectOne(storeDTO);
      System.out.println("   log : StoreMethods.storeDetails()   storeDAO.selectOne 완료");
      System.out.println("   log : StoreMethods.storeDetails()   storeDTO : "+ storeDTO);

      // storeDTO 반환
      return storeDTO;
   }

   // 가게 운영 정보 ----------------------------------------------------------------------------------------------
   public static ArrayList<StoreWorkDTO> storeWorkDetails(int storeNum) {
      System.out.println("   log : StoreMethods.storeWorkDetails()   시작");
      System.out.println("   log : StoreMethods.storeWorkDetails()   storeNum : "+ storeNum);

      // StoreDTO, StoreDAO 생성 : storeDTO, storeDAO
      StoreWorkDTO storeWorkDTO = new StoreWorkDTO();
      StoreWorkDAO storeWorkDAO = new StoreWorkDAO();
      System.out.println("   log : StoreMethods.storeWorkDetails()   storeWorkDTO, storeWorkDAO 생성");

      // DTO 객체에 condition 넣기
      // condition : STORE_NUM_SELECTALL
      storeWorkDTO.setCondition("STORE_NUM_SELECTALL");
      System.out.println("   log : StoreMethods.storeWorkDetails()   setCondition : "+ storeWorkDTO.getCondition());
      // DTO 객체에 storeNum 넣기
      storeWorkDTO.setStoreNum(storeNum);

      // DAO.selectAll으로 DTO 값 가져오기
      // ArrayList datas에 반환값 넣기
      ArrayList<StoreWorkDTO> datas = storeWorkDAO.selectAll(storeWorkDTO);
      System.out.println("   log : StoreMethods.storeWorkDetails()   storeWorkDAO.selectOne 완료");
      System.out.println("   log : StoreMethods.storeWorkDetails()   storeWorkDTO : "+ datas);

      // storeDTO 반환
      return datas;
   }

   // 가게 메뉴 정보 ----------------------------------------------------------------------------------------------
   public static StoreMenuDTO storeMenuDetails(int storeNum) {
      System.out.println("   log : StoreMethods.storeMenuDetails()   시작");
      System.out.println("   log : StoreMethods.storeMenuDetails()   storeNum : "+ storeNum);

      // StoreDTO, StoreDAO 생성 : storeDTO, storeDAO
      StoreMenuDTO storeMenuDTO = new StoreMenuDTO();
      StoreMenuDAO storeMenuDAO = new StoreMenuDAO();
      System.out.println("   log : StoreMethods.storeMenuDetails()   storeDTO, storeDAO 생성");

      // DTO 객체에 condition 넣기
      // condition : STORE_NUM_SELECTONE
      //         storeMenuDTO.setCondition("STORE_NUM_SELECTONE");
      //         System.out.println("   log : StoreMethods.storeMenuDetails()   setCondition : "+ storeMenuDTO.getCondition());
      // DTO 객체에 storeNum 넣기
      storeMenuDTO.setStoreNum(storeNum);

      // DAO.selectOne으로 DTO 값 가져오기
      // storeDTO에 반환값 넣기
      storeMenuDTO = storeMenuDAO.selectOne(storeMenuDTO);
      System.out.println("   log : StoreMethods.storeMenuDetails()   storeDAO.selectOne 완료");
      System.out.println("   log : StoreMethods.storeMenuDetails()   storeDTO : "+ storeMenuDTO);

      // storeDTO 반환
      return storeMenuDTO;
   }

   // 가게 결제 정보 -----------------------------------------------------------------------------------------------
   public static StorePaymentDTO storePaymentDetails(int storeNum) {
      System.out.println("   log : StoreMethods.storePaymentDetails()   시작");
      System.out.println("   log : StoreMethods.storePaymentDetails()   storeNum : "+ storeNum);

      // StoreDTO, StoreDAO 생성 : storeDTO, storeDAO
      StorePaymentDTO storePaymentDTO = new StorePaymentDTO();
      StorePaymentDAO storePaymentDAO = new StorePaymentDAO();
      System.out.println("   log : StoreMethods.storePaymentDetails()   storeDTO, storeDAO 생성");

      // DTO 객체에 condition 넣기
      // condition : STORE_NUM_SELECTONE
      //         storePaymentDTO.setCondition("STORE_NUM_SELECTONE");
      //         System.out.println("   log : StoreMethods.storePaymentDetails()   setCondition : "+ storePaymentDTO.getCondition());
      // DTO 객체에 storeNum 넣기
      storePaymentDTO.setStoreNum(storeNum);

      // DAO.selectOne으로 DTO 값 가져오기
      // storeDTO에 반환값 넣기
      storePaymentDTO = storePaymentDAO.selectOne(storePaymentDTO);
      System.out.println("   log : StoreMethods.storePaymentDetails()   storeDAO.selectOne 완료");
      System.out.println("   log : StoreMethods.storePaymentDetails()   storeDTO : "+ storePaymentDTO);

      // storeDTO 반환
      return storePaymentDTO;
   }

   // CNT를 구한는 메서드 ============================================================================================
   // StoreDTO에서 영업중 가게 CNT 값을 구하는 메서드 ------------------------------------------------------------------
   public static int storeCntOne(StoreDTO data) {
      System.out.println("   log : StoreMethods.storeCnt()   data는 StoreDTO 타입");
      // data를 StoreDTO로 형변환 
      StoreDTO storeDTO = data;
      System.out.println("   log : StoreMethods.storeCnt()   StoreDTO으로 형변환");

      // StoreDAO 생성
      StoreDAO storeDAO = new StoreDAO();
      System.out.println("   log : StoreMethods.storeCnt()   StoreDAO 생성");

      // DTO.setCondition을 한다.
      // condition : NOT_CLOSED_NUM_CNT_SELECTONE
      storeDTO.setCondition("NOT_CLOSED_NUM_CNT_SELECTONE");
      System.out.println("   log : StoreMethods.storeCnt()   condition : "+storeDTO.getCondition());
      storeDTO.setStoreClosed("N");

      // DAO.selectOne으로 DTO 값 가져오기
      // DTO 객체에 반환값 넣기
      storeDTO = storeDAO.selectOne(storeDTO);
      System.out.println("   log : StoreMethods.storeCnt()   StoreDAO.selectAll 완료");

      // storeDTO의 영업중인 가게의 CNT 가져옥
      return storeDTO.getStoreNotClosedCount();
   }

   // 필터별 가게 수 --------------------------------------------------------------------------------------------
   // data : 가져오려는 가게 정보(dto)
   public static ArrayList<Integer> storeCnt(Object data) {
      System.out.println("   log : StoreMethods.storeCnt()   시작");
      System.out.println("   log : StoreMethods.storeCnt()   data : "+ data);

      // 반환할 ArrayList<Integer> 생성
      ArrayList<Integer> datas = null;
      System.out.println("   log : StoreMethods.storeCnt()   ArrayList<Integer> datas 생성");

      // 객체를 받아서 알맞은 dto 객체 생성
      // 만약 인자 타입이 StoreMenuDTO라면
      if(data instanceof StoreMenuDTO) {
         System.out.println("   log : StoreMethods.storeCnt()   data는 StoreMenuDTO 타입");
         // data를 StoreMenuDTO로 형변환 
         StoreMenuDTO storeMenuDTO = (StoreMenuDTO) data;
         System.out.println("   log : StoreMethods.storeCnt()   StoreMenuDTO으로 형변환");

         // datas 객체 생성
         datas = new ArrayList<Integer>();
         System.out.println("   log : StoreMethods.storeCnt()   datas 메모리 할당");

         // StoreMenuDAO 생성
         StoreMenuDAO storeMenuDAO = new StoreMenuDAO();
         System.out.println("   log : StoreMethods.storeCnt()   StoreMenuDAO 생성");

         // DTO.setCondition을 한다.
         // condition : STORE_CNT_SELECTONE
         // storeMenuDTO.setCondition("STORE_CNT_SELECTONE");
         // System.out.println("   log : StoreMethods.storeCnt()   condition : "+storeMenuDTO.getCondition());

         // selectAll의 반환값을 받을 datas 생성
         ArrayList<StoreMenuDTO> menuCNTDatas = new ArrayList<StoreMenuDTO>();
         System.out.println("   log : StoreMethods.storeCnt()   ArrayList<StoreMenuDTO> 생성");

         // DAO.selectAll으로 DTO 값 가져오기
         // menuCNTDatas에 반환값 넣기
         menuCNTDatas = storeMenuDAO.selectAll(storeMenuDTO);
         System.out.println("   log : StoreMethods.storeCnt()   StoreMenuDAO.selectoAll 완료");

         // 만약 menuCNTDatas의 size가 0보다 작으면
         if(menuCNTDatas.size() <= 0) {
            System.out.println("   log : StoreMethods.storeCnt()   StoreMenuDAO.selectoAll 결과가 없음");
            // null 값 반환하기
            return null;
         }
         // CNT 결과 뽑아내기
         // slectAll 결과만큼 반복해서 각 DTO에 있는 DTO 값 빼오기
         for(StoreMenuDTO cntData : menuCNTDatas) {
            datas.add(cntData.getStoreMenuCount());
         }
         System.out.println("   log : StoreMethods.storeCnt()   datas에 데이터 넣음");
      }
      // 만약 인자 타입이 StorePaymentDTO라면
      else if(data instanceof StorePaymentDTO) {
         System.out.println("   log : StoreMethods.storeCnt()   data는 StorePaymentDTO 타입");
         // data를 StorePaymentDTO로 형변환 
         StorePaymentDTO storePaymentDTO = (StorePaymentDTO) data;
         System.out.println("   log : StoreMethods.storeCnt()   StorePaymentDTO으로 형변환");

         // datas 객체 생성
         datas = new ArrayList<Integer>();
         System.out.println("   log : StoreMethods.storeCnt()   datas 메모리 할당");

         // StorePaymentDAO 생성
         StorePaymentDAO storePaymentDAO = new StorePaymentDAO();
         System.out.println("   log : StoreMethods.storeCnt()   StorePaymentDAO 생성");

         // DTO.setCondition을 한다.
         // condition : STORE_CNT_SELECTONE
         // storePaymentDTO.setCondition("STORE_CNT_SELECTONE");
         // System.out.println("   log : StoreMethods.storeCnt()   condition : "+storePaymentDTO.getCondition());

         // selectAll의 반환값을 받을 datas 생성
         ArrayList<StorePaymentDTO> paymentCNTDatas = new ArrayList<StorePaymentDTO>();
         System.out.println("   log : StoreMethods.storeCnt()   ArrayList<StorePaymentDTO> 생성");

         // DAO.selectAll으로 DTO 값 가져오기
         // menuCNTDatas에 반환값 넣기
         paymentCNTDatas = storePaymentDAO.selectAll(storePaymentDTO);
         System.out.println("   log : StoreMethods.storeCnt()   StorePaymentDAO.selectoAll 완료");

         // 만약 paymentCNTDatas의 size가 0보다 작으면
         if(paymentCNTDatas.size() <= 0) {
            System.out.println("   log : StoreMethods.storeCnt()   StorePaymentDAO.selectoAll 결과가 없음");
            // null 값 반환하기
            return null;
         }

         // CNT 결과 뽑아내기
         // slectAll 결과만큼 반복해서 각 DTO에 있는 DTO 값 빼오기
         for(StorePaymentDTO cntData : paymentCNTDatas) {
            datas.add(cntData.getStorPaymentCount());
         }
         System.out.println("   log : StoreMethods.storeCnt()   datas에 데이터 넣음");
      }
      // 지정 외의 객체이면
      else {
         System.out.println("   log : StoreMethods.storeCnt()   data가 지원되지 않는 타입");
         throw new IllegalArgumentException("지원되지 않는 DTO 타입입니다.");
      }
      
      System.out.println("   log : StoreMethods.storeCnt()   datas : "+ datas);
      
      System.out.println("   log : StoreMethods.storeCnt()   종료");
      return datas;
   }

   // 메뉴 데이터를 DB에 사용할 수 있도록 가공하는 메서드 ===============================================================
   // 입력받은 메뉴 배열을 Y와 null로 이루어진 배열리스트로 변환하는 메서드 -----------------------------------------------
   public static ArrayList<String> storeMenuValue(String[] storeMenu){
      System.out.println("   log : StoreMethods.storeMenuValue()   시작");
      System.out.println("   log : StoreMethods.storeMenuValue()   storeMenu : "+ storeMenu);
      // 반환할 객체 생성
      ArrayList<String> storeMenuDatas = null;

      // 값이 하나라도 있다면 검색 가능한 형태로 데이터 변경해주기
      // storeMenu가 null이 아니라면
      if(storeMenu != null) {
         System.out.println("   log : StoreMethods.storeMenuValue()   storeMenu != null");

         storeMenuDatas = new ArrayList<String>();
         System.out.println("   log : StoreMethods.storeMenuValue()   storeMenuDatas 생성");
         
         // 메뉴 크기 변수 (8개)
         // int 변수명 : menuSize
         int menuSize = 8;

         storeMenuDatas = new ArrayList<String>();
         System.out.println("   log : StoreMethods.storeMenuValue()   "
               + "ArrayList<String> storeMenuDatas 생성");

         // N이 menuSize만큼 데이터를 넣어줌
         for(int i = 1; i <= menuSize; i++) {
            // storeMenuDatas에 'null'을 넣어줌
            storeMenuDatas.add(null);
         }
         System.out.println("   log : StoreMethods.storeMenuValue()   storeMenuDatas : "+ storeMenuDatas);

         // 가게 메뉴
         // storeMenu의 크기만큼 반복
         for(String data : storeMenu) {
            // sotreMenu 안에 데이터에 따라 storeMenuDatas의 특정 위치의 값을 'Y'로 변경
            // 0.팥/슈크림      1.야채/김치/만두   2.미니   3.고구마   4.아이스크림/초코   5.치즈   6.패스츄리   7.기타
            System.out.println("   log : StoreMethods.storeMenuValue()   storeMenu : "+ data);

            // 인덱스 변수
            int index = 0;
            
            data = data.trim();
            // 만약 storeMenu가 "팥/슈크림"이라면
            if(data.equals(menu[index++])) {
               // storeMenuDatas의 인덱스 0 값을 'Y'로 변경함
               storeMenuDatas.set(0, "Y");
               System.out.println("   log : StoreMethods.storeMenuValue()"
                     + "   storeMenuDatas 인덱스 0을 'Y'로 변경");
            }
            // 만약 storeMenu가 "야채/김치/만두"이라면
            else if(data.equals(menu[index++])) {
               // storeMenuDatas의 인덱스 1 값을 'Y'로 변경함
               storeMenuDatas.set(1, "Y");
               System.out.println("   log : StoreMethods.storeMenuValue()"
                     + "   storeMenuDatas 인덱스 1을 'Y'로 변경");
            }
            // 만약 storeMenu가 "미니"이라면
            else if(data.equals(menu[index++])) {
               // storeMenuDatas의 인덱스 2 값을 'Y'로 변경함
               storeMenuDatas.set(2, "Y");
               System.out.println("   log : StoreMethods.storeMenuValue()"
                     + "   storeMenuDatas 인덱스 2를 'Y'로 변경");
            }
            // 만약 storeMenu가 "고구마"이라면
            else if(data.equals(menu[index++])) {
               // storeMenuDatas의 인덱스 3 값을 'Y'로 변경함
               storeMenuDatas.set(3, "Y");
               System.out.println("   log : StoreMethods.storeMenuValue()"
                     + "   storeMenuDatas 인덱스 3을 'Y'로 변경");
            }
            // 만약 storeMenu가 "아이스크림/초코"이라면
            else if(data.equals(menu[index++])) {
               // storeMenuDatas의 인덱스 4 값을 'Y'로 변경함
               storeMenuDatas.set(4, "Y");
               System.out.println("   log : StoreMethods.storeMenuValue()"
                     + "   storeMenuDatas 인덱스 4를 'Y'로 변경");
            }
            // 만약 storeMenu가 "치즈"이라면
            else if(data.equals(menu[index++])) {
               // storeMenuDatas의 인덱스 5 값을 'Y'로 변경함
               storeMenuDatas.set(5, "Y");
               System.out.println("   log : StoreMethods.storeMenuValue()"
                     + "   storeMenuDatas 인덱스 5를 'Y'로 변경");
            }
            // 만약 storeMenu가 "패스츄리"이라면
            else if(data.equals(menu[index++])) {
               // storeMenuDatas의 인덱스 6 값을 'Y'로 변경함
               storeMenuDatas.set(6, "Y");
               System.out.println("   log ㄴ: StoreMethods.storeMenuValue()"
                     + "   storeMenuDatas 인덱스 6을 'Y'로 변경");
            }
            // 만약 storeMenu가 "기타"이라면
            else if(data.equals(menu[index])) {
               // storeMenuDatas의 인덱스 7 값을 'Y'로 변경함
               storeMenuDatas.set(7, "Y");
               System.out.println("   log : StoreMethods.storeMenuValue()"
                     + "   storeMenuDatas 인덱스 7을 'Y'로 변경");
            }
            else {
               // 로그 메뉴 값에 다른 이름이 들어왔음
               System.out.println("   log : StoreMethods.storeMenuValue()   메뉴와 상관없는 값이 들어옴");
            }
         }
      }

      return storeMenuDatas;
   }

   // 요일 데이터를 V에서 사용할 수 있도록 가공하는 메서드 ===============================================================
   // 입력받은 리스트 Y와 null로 이루어진 배열리스트로 변환하는 메서드 -----------------------------------------------
   public static ArrayList<String> storeWeekValue(ArrayList<StoreWorkDTO> datas){
      System.out.println("   log : StoreMethods.storeWeekValue()   시작");
      System.out.println("   log : StoreMethods.storeWeekValue()   datas : "+ datas);
      // 반환할 객체 생성
      ArrayList<String> storeWeekDatas = null;

      // 값이 하나라도 있다면 검색 가능한 형태로 데이터 변경해주기
      // datas가 null이 아니라면
      if(datas != null) {
         System.out.println("   log : StoreMethods.storeWeekValue()   storeMenu != null");

         storeWeekDatas = new ArrayList<String>();
         System.out.println("   log : StoreMethods.storeWeekValue()   storeWeekDatas 생성");

         // 요일 크기 변수 (7개)
         // int 변수명 : weekSize
         int weekSize = 7;

         storeWeekDatas = new ArrayList<String>();
         System.out.println("   log : StoreMethods.storeWeekValue()   "
               + "ArrayList<String> storeWeekDatas 생성");

         // weekSize만큼 반복
         for(int i = 1; i <= weekSize; i++) {
            // storeWeekDatas에 'null'을 넣어줌
            storeWeekDatas.add(null);
         }
         System.out.println("   log : StoreMethods.storeWeekValue()   storeMenuDatas : "+ storeWeekDatas);

         // 가게 메뉴
         // datas의 크기만큼 반복
         for(StoreWorkDTO data : datas) {
            // data.getStoreWorkWeek 안에 데이터에 따라 storeWeekDatas의 특정 위치의 값을 'Y'로 변경
            // 0.MON   1.TUE   2.WED   3.THU   4.FRI   5.SAT   6.SUN
            System.out.println("   log : StoreMethods.storeWeekValue()   storeMenu : "+ data);

            // 인덱스 변수
            int index = 0;
            
            // 만약 storeWorkWeek "MON"이라면
            if(data.getStoreWorkWeek().equals(week[index++])) {
               // storeWeekDatas의 인덱스 0 값을 'Y'로 변경함
               storeWeekDatas.set(0, "Y");
               System.out.println("   log : StoreMethods.storeWeekValue()"
                     + "   storeWeekDatas 인덱스 0을 'Y'로 변경");
            }
            // 만약 storeWorkWeek가 "TUE"이라면
            else if(data.getStoreWorkWeek().equals(week[index++])) {
               // storeWeekDatas의 인덱스 1 값을 'Y'로 변경함
               storeWeekDatas.set(1, "Y");
               System.out.println("   log : StoreMethods.storeMenuValue()"
                     + "   storeMenuDatas 인덱스 1을 'Y'로 변경");
            }
            // 만약 storeWorkWeek가 "WED"이라면
            else if(data.getStoreWorkWeek().equals(week[index++])) {
               // storeWeekDatas의 인덱스 2 값을 'Y'로 변경함
               storeWeekDatas.set(2, "Y");
               System.out.println("   log : StoreMethods.storeWorkWeekValue()"
                     + "   storeWorkWeekDatas 인덱스 2를 'Y'로 변경");
            }
            // 만약 storeWorkWeek가 "THU"이라면
            else if(data.getStoreWorkWeek().equals(week[index++])) {
               // storeWeekDatas의 인덱스 3 값을 'Y'로 변경함
               storeWeekDatas.set(3, "Y");
               System.out.println("   log : StoreMethods.storeWorkWeekValue()"
                     + "   storeWorkWeekDatas 인덱스 3을 'Y'로 변경");
            }
            // 만약 storeWorkWeek가 "FRI"이라면
            else if(data.getStoreWorkWeek().equals(week[index++])) {
               // storeWeekDatas의 인덱스 4 값을 'Y'로 변경함
               storeWeekDatas.set(4, "Y");
               System.out.println("   log : StoreMethods.storeWorkWeekValue()"
                     + "   storeWorkWeekDatas 인덱스 4를 'Y'로 변경");
            }
            // 만약 storeWorkWeek가 "SAT"이라면
            else if(data.getStoreWorkWeek().equals(week[index++])) {
               // storeWeekDatas의 인덱스 5 값을 'Y'로 변경함
               storeWeekDatas.set(5, "Y");
               System.out.println("   log : StoreMethods.storeWorkWeekValue()"
                     + "   storeWorkWeekDatas 인덱스 5를 'Y'로 변경");
            }
            // 만약 storeWorkWeek가 "SUN"이라면
            else if(data.getStoreWorkWeek().equals(week[index])) {
               // storeWeekDatas의 인덱스 6 값을 'Y'로 변경함
               storeWeekDatas.set(6, "Y");
               System.out.println("   log : StoreMethods.storeWorkWeekValue()"
                     + "   storeWorkWeekDatas 인덱스 6을 'Y'로 변경");
            }
            else {
               // 로그 메뉴 값에 다른 이름이 들어왔음
               System.out.println("   log : StoreMethods.storeWeekValue()   메뉴와 상관없는 값이 들어옴");
            }
         }
      }

      return storeWeekDatas;
   }

   // 리스트에 null 값을 N으로 변경해주는 메서드 -----------------------------------------------------------
   public static ArrayList<String> storeListValuePlusN(ArrayList<String> datas) {
      System.out.println("   log : StoreMethods.storeListValuePlusN()   시작");
      ArrayList<String> storeListValue = datas;
      System.out.println("   log : StoreMethods.storeListValuePlusN()   storeListValue : " + storeListValue);

      // datas 크기만큼 반복
      // 해당 위치의 인덱스 값의 데이터를 변경해야 하므로 i번 반복하는 for문 사용
      for(int i = 0; i < storeListValue.size(); i++) {
         // 만약 data가 null이면
         if(storeListValue.get(i) == null) {
            System.out.println("   log : StoreMethods.storeListValuePlusN()   storeMenuValue.get("+i+") : " + storeListValue.get(i));
            // N으로 변경
            storeListValue.set(i, "N");
            System.out.println("   log : StoreMethods.storeListValuePlusN()   N으로 변경");
            System.out.println("   log : StoreMethods.storeListValuePlusN()   storeMenuValue.get("+i+") : " + storeListValue.get(i));
         }
      }
      System.out.println("   log : StoreMethods.storeListValuePlusN()   storeMenuValue : " + storeListValue);
      System.out.println("   log : StoreMethods.storeListValuePlusN()   storeMenuValue 반환");
      return storeListValue;
   }

   // 결제방법 데이터를 DB에 사용할 수 있도록 가공하는 메서드 =================================================================
   // 오버리딩
   // storePayment 값을 객체에 저장 (StoreDTO일 때) --------------------------------------------------------------------
   public static void storePaymentSet(String[] storePayment, StoreDTO storeDTO) {
      System.out.println("   log : StoreMethods.storePaymentSet()   시작");
      System.out.println("   log : StoreMethods.storePaymentSet()   storePayment : "+ storePayment);
      System.out.println("   log : StoreMethods.storePaymentSet()   storeDTO : "+ storeDTO);

      // 만약 storePayment가 null이 아니라면
      if(storePayment != null) {
         // storePayment의 크기만큼 반복)
         for(String data : storePayment) {
            // sotrePayment 안에 데이터에 따라 
            // 1.현금결제      2.카드결제   3.계좌이체

            // 인젝스 변수
            int index = 0;
            
            // 만약 data가 "현금결제"이라면
            if(data.equals(payment[index++])) {
               // storeDTO.set현금결제에 'Y' 값을 넣음
               storeDTO.setStorePaymentCashmoney("Y");
               System.out.println("   log : StoreMethods.storePaymentSet()   현금결제를 Y로 변경");
            }
            // 만약 data가 "카드결제"이라면
            else if(data.equals(payment[index++])) {
               // storeDTO.set카드결제에 'Y' 값을 넣음
               storeDTO.setStorePaymentCard("Y");
               System.out.println("   log : StoreMethods.storePaymentSet()   카드결제를 Y로 변경");
            }
            // 만약 data가 "계좌이체"이라면
            else if(data.equals(payment[index])) {
               // storeDTO.set계좌이체에 'Y' 값을 넣음
               storeDTO.setStorePaymentaccountTransfer("Y");
               System.out.println("   log : StoreMethods.storePaymentSet()   계좌결제를 Y로 변경");
            }
            else {
               // 로그 잘못된 storePayment 값이 들어왔음
               System.out.println("   log : StoreMethods.storePaymentSet()   결제 방법과 상관없는 값이 들어옴");
            }
         }
      }
      System.out.println("   log : StoreMethods.storePaymentSet()   종료");
   }

   // 인자값이 StorePaymentDTO일 때 ----------------------------------------------------------------------------------
   public static void storePaymentSet(String[] storePayment, StorePaymentDTO storePaymentDTO) {
      System.out.println("   log : StoreMethods.storePaymentSet()   시작");
      System.out.println("   log : StoreMethods.storePaymentSet()   storePayment : "+ storePayment);
      System.out.println("   log : StoreMethods.storePaymentSet()   storePaymentDTO : "+ storePaymentDTO);

      // 만약 storePayment가 null이 아니라면
      if(storePayment != null) {
         // storePayment의 크기만큼 반복)
         for(String data : storePayment) {
            // sotrePayment 안에 데이터에 따라 
            // 1.현금결제      2.카드결제   3.계좌이체

            // 인덱스 변수
            int index = 0;
            
            // 만약 data가 "현금결제"이라면
            if(data.equals(payment[index++]) || data.equals("Cash")) {
               // storeDTO.set현금결제에 'Y' 값을 넣음
               storePaymentDTO.setStorePaymentCashmoney("Y");
               System.out.println("   log : StoreMethods.storePaymentSet()   현금결제를 Y로 변경");
            }
            // 만약 data가 "카드결제"이라면
            else if(data.equals(payment[index++]) || data.equals("Card")) {
               // storeDTO.set카드결제에 'Y' 값을 넣음
               storePaymentDTO.setStorePaymentCard("Y");
               System.out.println("   log : StoreMethods.storePaymentSet()   카드결제를 Y로 변경");
            }
            // 만약 data가 "계좌이체"이라면
            else if(data.equals(payment[index]) || data.equals("Account")) {
               // storeDTO.set계좌이체에 'Y' 값을 넣음
               storePaymentDTO.setStorePaymentAccountTransfer("Y");
               System.out.println("   log : StoreMethods.storePaymentSet()   계좌결제를 Y로 변경");
            }
            else {
               // 로그 잘못된 storePayment 값이 들어왔음
               System.out.println("   log : StoreMethods.storePaymentSet()   결제 방법과 상관없는 값이 들어옴");
            }
         }
      }
      System.out.println("   log : StoreMethods.storePaymentSet()   종료");
   }

   // storePayment의 null 값을 N으로 변경하는 메서드 ----------------------------------------------------------------
   public static void storePaymentSetPlusN(StorePaymentDTO storePaymentDTO) {
      System.out.println("   log : StoreMethods.storePaymentSetN()   시작");
      System.out.println("   log : StoreMethods.storePaymentSetN()   storeDTO : "+ storePaymentDTO);

      // N을 넣는 작업
      // storePaymentDTO.getStorePaymentCashmoney()이 null이라면
      if(storePaymentDTO.getStorePaymentCashmoney() == null) {
         // N값을 넣어줌
         storePaymentDTO.setStorePaymentCashmoney("N");
         System.out.println("   log : StoreMethods.storePaymentSetN()   StorePaymentCashmoney를 N으로 변경 : "+ storePaymentDTO.getStorePaymentCashmoney());
      }
      // storePaymentDTO.getStorePaymentCard()이 null이라면
      if(storePaymentDTO.getStorePaymentCard() == null) {
         // N값을 넣어줌
         storePaymentDTO.setStorePaymentCard("N");
         System.out.println("   log : StoreMethods.storePaymentSetN()   StorePaymentCard()를 N으로 변경 : "+ storePaymentDTO.getStorePaymentCard());
      }
      // storePaymentDTO.getStorePaymentAccountTransfer()이 null이라면
      if(storePaymentDTO.getStorePaymentAccountTransfer() == null) {
         // N값을 넣어줌
         storePaymentDTO.setStorePaymentAccountTransfer("N");
         System.out.println("   log : StoreMethods.storePaymentSetN()   StorePaymentAccountTransfer()를 N으로 변경 : "+ storePaymentDTO.getStorePaymentAccountTransfer());
      }
      System.out.println("   log : StoreMethods.storePaymentSetN()   종료");
   }

   // 메뉴 값을 DTO에 set 하는 메서드 =========================================================================
   public static void storeMenuSet(ArrayList<String> storeMenuDatas, StoreMenuDTO storeMenuDTO) {
      System.out.println("   log : StoreMethods.storeMenuSet()   시작");
      // storeMenuDTO.set으로 storeMenuDatas 값 차례로 넣기
      // 0.팥/슈크림      1.야채/김치/만두   2.미니   3.고구마   4.아이스크림/초코   5.치즈   6.패스츄리   7.기타
      int i = 0;

      System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ i);
      storeMenuDTO.setStoreMenuNomal(storeMenuDatas.get(i++));      // 0.팥/슈크림
      System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ i);
      storeMenuDTO.setStoreMenuVegetable(storeMenuDatas.get(i++));   // 1.야채/김치/만두
      System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ i);
      storeMenuDTO.setStoreMenuMini(storeMenuDatas.get(i++));         // 2.미니
      System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ i);
      storeMenuDTO.setStoreMenuPotato(storeMenuDatas.get(i++));      // 3.고구마
      System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ i);
      storeMenuDTO.setStoreMenuIceCream(storeMenuDatas.get(i++));      // 4.아이스크림/초코
      System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ i);
      storeMenuDTO.setStoreMenuCheese(storeMenuDatas.get(i++));      // 5.치즈
      System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ i);
      storeMenuDTO.setStoreMenuPastry(storeMenuDatas.get(i++));      // 6.패스츄리
      System.out.println("   log : StoreMethods.storeMenuSet()   i : "+ i);
      storeMenuDTO.setStoreMenuOthers(storeMenuDatas.get(i));      // 7. 기타

      System.out.println("   log : StoreMethods.storeMenuSet()   .setMenu 완료");
      System.out.println("   log : StoreMethods.storeMenuSet()   종료");
   }
   
   // V가 출력하기 위해 dto를 리스트로 변환하는 메서드 ==============================================================
   // 메뉴 DTO를 배열리스트(메뉴 이름)로 변환하는 메서드 -------------------------------------------------------------
   public static ArrayList<String> storeMenuList(StoreMenuDTO storeMenuDTO){
      System.out.println("   log : StoreMethods.storeMenuList()   시작");
      
      // 반환할 객체 생성
      ArrayList<String> menuList = null;
      
      // 만약 storeDTO가 존재한다면
      if(storeMenuDTO != null) {
         System.out.println("   log : StoreMethods.storeMenuList()   storeMenuDTO 존재");
         
         // menuList 객체 생성
         menuList = new ArrayList<String>();
         
         // DTO에 있는 메뉴 변수 값이 Y이면 menuList에 추가
         // 만약 getStoreMenuNomal()이 Y라면
         if(storeMenuDTO.getStoreMenuNomal().equals("Y")) {
            menuList.add(menu[0]);
            System.out.println("   log : StoreMethods.storeMenuList()   getStoreMenuNomal()이 Y");
            System.out.println("   log : StoreMethods.storeMenuList()   menu[0] 추가");
         }
         // 만약 getStoreMenuVegetable()이 Y라면
         if(storeMenuDTO.getStoreMenuVegetable().equals("Y")) {
            menuList.add(menu[1]);
            System.out.println("   log : StoreMethods.storeMenuList()   getStoreMenuVegetable()이 Y");
            System.out.println("   log : StoreMethods.storeMenuList()   menu[1] 추가");
         }
         // 만약 getStoreMenuMini()이 Y라면
         if(storeMenuDTO.getStoreMenuMini().equals("Y")) {
            menuList.add(menu[2]);
            System.out.println("   log : StoreMethods.storeMenuList()   getStoreMenuMini()이 Y");
            System.out.println("   log : StoreMethods.storeMenuList()   menu[2] 추가");
         }
         // 만약 getStoreMenuPotato()이 Y라면
         if(storeMenuDTO.getStoreMenuPotato().equals("Y")) {
            menuList.add(menu[3]);
            System.out.println("   log : StoreMethods.storeMenuList()   getStoreMenuPotato()이 Y");
            System.out.println("   log : StoreMethods.storeMenuList()   menu[3] 추가");
         }
         // 만약 getStoreMenuIceCream()이 Y라면
         if(storeMenuDTO.getStoreMenuIceCream().equals("Y")) {
            menuList.add(menu[4]);
            System.out.println("   log : StoreMethods.storeMenuList()   getStoreMenuIceCream()이 Y");
            System.out.println("   log : StoreMethods.storeMenuList()   menu[4] 추가");
         }
         // 만약 getStoreMenuCheese()이 Y라면
         if(storeMenuDTO.getStoreMenuCheese().equals("Y")) {
            menuList.add(menu[5]);
            System.out.println("   log : StoreMethods.storeMenuList()   getStoreMenuCheese()이 Y");
            System.out.println("   log : StoreMethods.storeMenuList()   menu[5] 추가");
         }
         // 만약 getStoreMenuPastry()이 Y라면
         if(storeMenuDTO.getStoreMenuPastry().equals("Y")) {
            menuList.add(menu[6]);
            System.out.println("   log : StoreMethods.storeMenuList()   getStoreMenuPastry()이 Y");
            System.out.println("   log : StoreMethods.storeMenuList()   menu[6] 추가");
         }
         // 만약 getStoreMenuOthers()이 Y라면
         if(storeMenuDTO.getStoreMenuOthers().equals("Y")) {
            menuList.add(menu[7]);
            System.out.println("   log : StoreMethods.storeMenuList()   getStoreMenuOthers()이 Y");
            System.out.println("   log : StoreMethods.storeMenuList()   menu[7] 추가");
         }
      }
      
      System.out.println("   log : StoreMethods.storeMenuList()   종료");
      return menuList;
   }
   
   public static ArrayList<String> storePaymentList(StorePaymentDTO storePaymentDTO){
System.out.println("   log : StoreMethods.storeMenuList()   시작");
      
      // 반환할 객체 생성
      ArrayList<String> paymentList = null;
      
      // 만약 storeDTO가 존재한다면
      if(storePaymentDTO != null) {
         System.out.println("   log : StoreMethods.storePaymentList()   storePaymentDTO 존재");
         // DTO에 있는 메뉴 변수 값이 Y이면 menuList에 추가
         
         // paymentList 객체 생성
         paymentList = new ArrayList<String>();

         // 만약 getStoreMenuNomal()이 Y라면
         if(storePaymentDTO.getStorePaymentCashmoney().equals("Y")) {
            paymentList.add(payment[0]);
            System.out.println("   log : StoreMethods.storePaymentList()   getStorePaymentCashmoney()이 Y");
            System.out.println("   log : StoreMethods.storePaymentList()   menu[0] 추가");
         }
         // 만약 getStoreMenuVegetable()
         if(storePaymentDTO.getStorePaymentCard().equals("Y")) {
            paymentList.add(payment[1]);
            System.out.println("   log : StoreMethods.storePaymentList()   getStorePaymentCard()이 Y");
            System.out.println("   log : StoreMethods.storePaymentList()   menu[1] 추가");
         }
         // 만약 getStoreMenuMini()
         if(storePaymentDTO.getStorePaymentAccountTransfer().equals("Y")) {
            paymentList.add(payment[2]);
            System.out.println("   log : StoreMethods.storePaymentList()   getStorePaymentAccountTransfer()이 Y");
            System.out.println("   log : StoreMethods.storePaymentList()   menu[2] 추가");
         }
         
      }
      
      System.out.println("   log : StoreMethods.storeMenuList()   종료");
      return paymentList;
   }
}