Model 2(MVC:Model, View, Controller)의 이해, MVC 개발 순서

출처: https://m.blog.naver.com/sunmaket/50113449506

[01] Model 2(MVC:Model, View, Controller)의 이해, MVC 개발 순서

 

 

 

[01] Model 2(MVC:Model, View, Controller)의 이해

    - Web Application Framework의 발전 형태

                                                          
  CGI --> Servlet(JSP) --> MVC --+--> Struts1 --> Struts1+XWork --> Struts2(MVC+OOP)
               |                    |   
               |                    +--> Spring(MVC+OOP+AOP+DI+CoC)
               | 
               +-------------> Beans -----------------> iBATIS, Hibernate
               |        DTO, DAO, Mgr(process)
               |
               +-------------> JAVA 기반 분산 시스템 구축용: EJB 2 --> EJB 3
               |
               +-------------> Cross Flatform 분산 시스템 구축용: Web Service --> SOA

               --------------> Spring + iBATIS + Hibernate: 전자 정부 구축 Framework
               모든 정부 프로젝트는 의무적으로 사용,
               민간 기업용도 같이 배포되고 있으나 사용의 의무는 없음. 
     

    - Client의 요청을 처리하는 객체를 Servlet Controller로 단일화해 인증, 권한, 국제화 등 여러 통합된 기능을

     Model1(JSP, DAO, Manager)에 비해 쉽게 구현 할 수 있다.
        
    - 비즈니스 로직을 처리하는 모델과 결과 화면을 보여주는 뷰(JSP)가 분리되어 있다. 따라서 JSP 페이지에는

     필요한 최소한의 자바코드만 구현한다.
      
    - 모델과 뷰, 컨트롤러가 분리되어 있어 변경이 쉽고 유지 보수 비용을 획기적으로 절감할 수 있는 콤포넌트 기반 기술이다.
     프로젝트 규모가 커지면 더욱 큰 효과를 발휘한다.
      . Model: JSP Beans(DTO, Manager Class, DAO)
      . View: JSP, HTML, CSS, Javascript
      . Controller: Servlet, OOP에 기반하여 설계해야 작동 가능.
   
    - 개발인력이 MVC에 대한 이해가 제대로 서 있지 않으면 Model1보다 개발 속도가 느리다. 하지만 이해를 하고 있다면

     속도가 훨씬 빠르고 유지보수가 신속한 사이트를 제작할 수 있다.

 

    - MVC 모델은 매우 유지보수성이 좋은 구조를 가지고 있으나 개발자가 web application의 기능을 전부 구현해야 하므로

     많은 부담이 발생하게 되며 이런 프로젝트에서 공통적으로 쓰이는 기능을 구현해 솔루션화한 프레임웍이 Spring, Struts 이다.

 

    - 솔루션은 프로젝트 관련 코드를 일부 제공하여 프로젝트의 개발을 돕는 구조를 가지고 있는 코드 집합.

 

    - 전자 정부 프레임웍은 자동화되어 있어 개발자를 단순 조작자로 업무를 진행하게 하는 함정이 있음으로 프레임웍의 원리와

     새로운 기술을 꾸준히 공부하여 특정 분야의 솔루션 연구원이나 Software Architecture가 되도록 꾸준히 연구할 필요가 있음.

 

  1. model1 과 model2의 비교

    - JSP Model 1 - 장점  
      . 기본적인 HTML, JavaScript, JAVA만 알아도 배우기 쉽다.

      . 객체지향 원리, OOP를 잘 몰라도 기능을 구현 할 수 있다.

      . 처리 로직이 jsp 페이지 상에 JAVA 코드로 구현 되어 있다.
    

    - JSP Model 1 - 단점  
      . 디자인(HTML, CSS, JavaScript)과 로직(JAVA)이 혼합되어 있어 소스 수정시 예상하지 못한 곳에서 많은 시간이 지연되며,

       팀별 분할 작업이 어렵다.

      . 같은 JAVA코드가 여러 JSP페이지에 중복되어 있어 소스 수정이 어렵다.(SSI(조각 JSP 파일)로 일부 해결 가능)

      . 권한 등의 구현 시 모든 jsp페이지 상에 SSI(ssi_admin.jsp)등을 이용해 구현해야 한다.(Filter로 일부 해결 가능)

   

    - JSP Model 1 변형  
      . Interface, Manager class, DAO class, DTO class, Connection Pool, Filter등으로 JSP Model 1을 개선 할 수 있다.

 

    - JSP Model 2(MVC) - 장점  
      . Client의 요청을 받는 부분, 처리 로직 부분, 뷰 부분이 분리되어 있어 유지보수가 편리하고 작업 시간이 줄어든다.
       (개발 비용의 80%는 작업 시간에 의해 좌우되는 인건비가 결정함으로 개발 시간은 매우 중요함)

      . 모든 기능이 세분화해 구조를 이루고 있음으로 기능 확장이 용이하다.

      . 설계 문서 등을 이용하여 프로젝트 전반을 체계적으로 관리하기 용이함.(개발자간의 책임 소재가 명확하게 구분이 됨)
      . 컨트롤러 서블릿에서 권한 및 인증 구현을 편리하게 할 수 있다.(일반적으로 Model1에서는 모든 JSP페이지에 권한관련

       코드가 필요한 경우도 있음)

 

    - JSP Model 2(MVC) - 단점  
      . 디자인 패턴등의 개념과 자바 언어의  OOP 기능을 잘 알고 있어야 한다.

      . Application(웹페이지)이 처리 파트 별로 나뉘어져 있음으로 개발 작업의 양이 많다.

      . 디버깅 작업을 처리 파트별로 살펴야 하므로 다른 연관 파트를 같이 연결해서 확인해야 하는 부분이 있다.

       따라서 객체 설계도가 매우 중요하다.

     . 개발자들이 MVC에 대한 원리를 이해하고 있어야 효과를 볼 수 있다.

   ※ Model1도 design pattern, beans, template적용 등을 사용하여 어느정도 성능 향상을 가져올 수 있다.

     하지만 프로젝트의 규모가 커지면 유지보수에 어려움이 발생하게 된다.

   ※ 개발자가 2명이상인 프로젝트 부터는 MVC사용을 권장한다.

 

  2. Model 1의 구조

    - Model 1의 구조
      Browser ---> 요청 ---> JSP
                           입력 form
                             ▲
                             │
                             │
                             ▼
      Browser <--- 응답 <--- JSP
                           DB 처리

 

    - 변형된 Model 1의 구조
      Browser ---> 요청 ---> JSP
                           입력 form
                             ▲
                             │
                             │
                             │       
                             ▼        
     Browser <--- 응답 <--- JSP <---> Business Logic(DAO, Manager) <---> DB

 

  3. MVC Model2 구조

    - request 객체(JSP 내부 객체)의 사용
      . request 객체는 클라이언트로부터 값을 가져오는 목적으로 사용되나 값을 출력하는 목적으로도 사용된다.
      . 저장소 역활을 한다.

        예)
          값을 가져오는 형태           

          String name = request.getParameter("name");

          값을 request에 저장하는 형태

            MemberDTO dto = new MemberDTO();
            request.setAttribute("dto", dto);

 

    - 컨트롤러(Controller)
      . 어플리케이션의 흐름 제어나 사용자의 처리 요청을 구현한다.
      . 사용자 인증, 보안 설정 등 전체 어플리케이션에 영향을 미치는 요소를 구현한다.
      . 사용자의 요청에 대해서 알맞은 모델을 사용하고 사용자에게 보여줄 뷰를 선택하기만 하면 된다.
      . Servlet 으로 제작

 

    - 모델(Model)
      . 비즈니스 로직과 관련된 부분만 처리한다.
      . 데이터베이스 관련 로직을 구현한다.
      . JSP Beans, DAO class, DTO class, Manager class, EJB Component 

 

    - 뷰(View)
      . 사용자에게 알맞은 화면을 보여주는 역활만 수행한다.
      . JSP, EL, JSTL, Custom Tag, XML

                           (컨트롤러)       (모델)
      ------------------------------------------------------------------
                            service()        Manager Class
      Browser ---> 요청 ---> Servlet ------> Business Logic  <---> DB
                                           ┌---------- request, session 
                                           │    
                                           │     
                                           ↓ 
                     Browser <--- 응답 <--- JSP(뷰)

 

#############################################################################################################

  4. Controller의 처리순서

    Browser --------> Servlet(Controller)
                       1. HTTP 요청 받음, doGet(), doPost() 메소드 호출
                       2. 클라이언트가 요구하는 기능을 분석(방명록의 경우 글쓰기 등)
                       3. 요청한 비즈니스 로직을 처리하는 Model 사용, Business Logic Class
                       4. 결과를 request 또는 session의 setAttribute()메소드를 사용하여 저장
                       5. 알맞은 뷰 선택 후, 뷰로 포워딩(또는 리다이렉트), jsp 페이지로 이동
                     ↙
                  JSP
                ↙
            HTTP 응답
          ↙
     Browser

  

 

  5. Command Pattern에 기반한 Controller의 처리순서
    - Command Handler
      . Interface, 추상 클래스를 이용하여 구현.
      . JSP Beans class, EJB를 통해서 Command Handler를 구현한다.

         Browser --------> Servlet(Controller)
                                    1. HTTP 요청 받음
                                    2. 클라이언트가 요구하는 기능을 분석
                                    3. 로직을 처리할 명령어 핸들어 생성 ---> Command Handler
                                    4. 명령어 핸들러를 이용해 로직 처리 ---> 로직 처리 (Class)
                                                                                                 │
                                                                                                 │
                                                                                                 ↓
                                                                                            결과 저장 
                                                                                                 │
                                                                                                 │
                                                                                                 ↓
                                                                                         JSP등 뷰 리턴
                                                                                                 │
                                                       ┌──────────────┘ 
                                                       ↓
                                   5. 명령어 핸들러가 리턴한 뷰로 페이지 이동(포워딩, 리다이렉트)
                                 ↙
                              JSP
                            ↙
                    HTTP 응답
                       ↙
                Browser

  
  6. 수평적인 실행 순서

    JSP Model 1
      jsp form ---> jsp proc ---> Manager ---> DAO ---> JSP 최종 결과 출력 
                                                                                 ------------------
                                                                                       response

 

    JSP Model 2
                           servlet            Interface
      jsp form ---> controler ---> Action class ---> Manager ---> DAO -----> JSP 최종 결과 출력 
                        --------------------------                                              --------------------
                                   request                                                               request --> response

 

 

 

[02] MVC Application과 일반 JSP 개발 순서의 비교
    - 순수 코딩을 기준으로 한 경우

 

  1. Web Application(JSP Model 1) 개발 순서

    ① DBMS 설정

    ② DTO(Data Transfer Object, Domain, Model) Class 제작

    ③ DAO(Data Access Object, Persistence) Class 제작

    ④ Manager Class(Process, Business Logic) 제작

    ⑤ Manager Test

    ⑥ JSP 생성 연동

  2. MVC Web Application(JSP Model 2) 개발 순서

    ① DBMS 설정

    ② DTO(Data Transfer Object, Domain, Model) Class 제작

    ③ DAO(Data Access Object, Persistence) Class 제작

    ④ Manager Class(Process, Business Logic) 제작

    ⑤ Manager Test

    -----------------------------------------------
    ⑥ Servlet Controller 제작

    ⑦ Action Interface 제작

    ⑧ Action 구현 Class 제작
    ⑨ Manager Class 연동 
    ----------------------------------------------

    ⑩ JSP 생성 연동