JSP Model 2 Architecture 3부, 웹어플리케이션의 흐름 제어

Lecture/Java&JSP 강좌 2008/04/30 14:25
웹 어플리케이션의 흐름 제어를 위한 인터페이스를 정의해본다.
프로바이더: 최범균

지금까지 2회에 걸쳐서 모델 2 구조를 이용한 '로직과 프리젠테이션의 분리' 및 모델 2 구조에 커맨드 패턴을 적용하는 것에 대해서 살펴보았다. 물론, 이 두가지 요소를 통해서 우리는 모델 2 구조를 상당부분 객체 지향적으로 구현할 수 있게 되었지만 여기에 추가적으로 우리가 해야 할 부분이 있다. 바로 흐름제어를 위한 별도의 방안을 강구하는 것이다.

2부에서는 커맨드 패턴에서 사용되는 각 커맨드 처리 객체가 다음에 보여줄 JSP 페이지를 처리의 결과값을 리턴하는 방식을 사용하여 웹 어플리케이션의 흐름을 제어했었다. 물론, 이처럼 커맨드 패턴의 각 객체가 흐름제어를 하는 방식만으로 충분할 수도 있다. 하지만 커맨드 패턴에서 사용되는 객체가 아닌 별도의 객체에서 흐름 제어를 할 수 있다면, 즉 흐름 제어의 역할을 담당하는 객체를 별도로 사용한다면, 웹 어플리케이션은 더욱 객체 지향적인 구조를 갖게 될 것이다. 이번 3부에서는 흐름 제어를 위한 인터페이스를 작성해봄으로써 모델 2 구조에 대한 애기를 끝맺도록 하겠다.

처음 흐름 제어를 위한 인터페이스를 생각했을 때 생각났던 것이 JDBC API 였다. JDBC의 java.sql.ResultSet 인터페이스를 보면 next(), absolute() 등 결과 집합 행을 이동할 때 사용되는 메소드가 존재하는 것을 알 수 있으며, 이를 통해 읽어올 행의 순서를 제어한다는 사실도 알수 있다. 필자는 이러한 ResultSet 인터페이스와 비슷한 방법으로 웹 어플리케이션의 흐름 제어를 위한 인터페이스를 설계해보았으며, 그 인터페이스는 다음과 같다. (주석문은 소스 코드를 쉽게 볼 수 있도록 하기 위해서 삭제하였다.)

  package org.jcore.webapp.control.spi;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import org.jcore.webapp.control.exception.ControlBoxException;
  
  public interface ControlBox {
     
     public void setHttpInfo(HttpServletRequest request,
                             HttpServletResponse response);
     
     public int getPreviousStep();
     public int getNextStep();
     public int getCurrentStep();
     public int getRequestStep();
     public boolean isValidStep();
     public boolean isFirstStep();
     public boolean isLastStep();
     public void goNextStep() throws ControlBoxException;
     public void goPreviousStep() throws ControlBoxException;
     public void goFirstStep() throws ControlBoxException;
     public void goLastStep() throws ControlBoxException;
     public void goInvalidStep() throws ControlBoxException;
     public void clearControlBox() throws ControlBoxException;
  }

ControlBox 인터페이스를 보면 getXXX() 메소드와 isXXX() 메소드 그리고 goXXX() 메소드의 세 가지 종류의 메소드가 존재하는 것을 알 수 있다. 이러한 메소드들이 무엇을 의미하지 살펴보기 전에 ControlBox 인터페이스가 어떤 의미로 설계되었는지 이해해야만 한다. 필자는 ControlBox를 설계할 때 스텝이라는 개념을 도입하였다. 여기서 스텝은 어떤 일을 처리하는 단계를 의미하는 것이다. 스텝의 의미를 좀더 구체적으로 정의하기 위해서 다음 그림을 살펴보자.

위 그림은 사이트 가입 절차의 일부를 표시한 것으로서 유저는 일반적으로 사이트에 가입신청을 하면 약관을 보게 되고, 이후 회원 정보 입력과 확인 절차 후 최종적으로 사이트의 회원으로 가입하게 된다. 이러한 과정은 크게 두 개의 부분으로 나뉜다. 하나는 위 그림에서 윗줄에 표시된 어떤 행위를 요청하는 부분이고 다른 하나는 위 그림에서 아랫줄에 표시된 요청을 처리하는 부분이다. 여기서 각각의 요청을 하나의 스텝으로 볼 수도 있고 또는 요청의 처리를 하나의 스텝으로 볼 수도 있다. 각각의 요청을 하나의 스텝으로 볼 때, 위 그림에서 "약관보기요청", "화면1 요청", "입력확인 요청" 등이 하나의 스텝이 된다.

그렇다면 흐름 제어는 무엇인가? 위 그림에서 흐름은 "사용자가 일정한 순서로 스텝을 거치는 것"이라고 정의할 수 있으며, 따라서 흐름 제어는 "사용자가 거치게 될 스텝의 순서를 제어해주는 것"으로 정의할 수 있다. 스텝의 순서를 제어하는 것에는 다음과 같은 것이 있을 수 있다.

  • 다음 스텝으로 이동
  • 이전 스텝으로 이동
  • 처음 스텝으로 이동
  • 마지막 스텝으로 이동

ControlBox 인터페이스에 선언되어 있는 goNextStep(), goPreviousStep(), goFirstStep(), goLastStep() 메소드가 바로 이러한 스텝의 이동을 위한 것들이다. 그리고 ControlBox 인터페이스는 현재 스텝이 무엇이고 사용자가 요청한 스텝이 무엇인지 그리고 요청한 스텝은 흐름에서 올바른 지의 여부를 판단하기 위한 메소드를 정의하고 있는 데, 이들 메소드는 다음과 같다.

  • getCurrentStep() - 현재 처리할(또는 처리하는) 스텝을 구한다.
  • getRequestStep() - 요청한 스텝을 구한다.
  • goInvalidStep() - 잘못된 스텝을 요청할 경우 에러 페이지로 이동한다.
  • clearControlBox() - ControlBox와 관련해서 저장된 정보를 삭제한다.
  • isValidStep() - 올바른 스텝인지 판단한다.
  • isFirstStep() - 첫번째 스텝인지 판단한다.
  • isLastStep() - 마지막 스텝인지 판단한다.

그리고 ControlBox 인터페이스는 웹 어플리케이션의 요청/응답과 관련된 객체를 전달받기 위한 메소드인 setHttpInfo()를 선언하고 있다. ControlBox 인터페이스의 기본적인 사용 방법은 다음과 같다.

  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
                    throws IOException, ServletException {
	  
	  // ControlBoxImpl은 ControlBox 인터페이스를 구현한 클래스
	  ControlBox box = new ControlBoxImpl();
	  
	  box.setHttpInfo(request, response);
	  if (box.isValidStep()) {
	    // 어떤 알맞은 처리를 한다.
	    ...
	    box.goNext();
	  } else {
	    // 알맞은 스텝이 아니면,
	    box.goInvalidStep();
	  }
  }

위 코드를 보면, 웹 어플리케이션의 흐름 제어는 ControlBox 인터페이스에 정의되어 있는 메소드를 통해서 처리되기 때문에 서블릿이나 기타 로직을 처리하는 객체에서 흐름을 제어하기 위한 코드를 삽입할 필요가 없음을 알 수 있다. 흐름 제어에 있어서 중요한 것은 ControlBox 인터페이스를 구현하는 것 뿐이다. 실제 ControlBox 인터페이스를 구현한 예제는 뒤에서 살펴볼 것이다.

 

프로바이더 최범균 ( madvirus@madvirus.net ) :
가메출판사의 'JSP Professional'을 저술하였으며 Oreilly의 'Java and XML'을 번역하기도 하였다. 현재는 티페이지 글로벌의 기술팀에서 근무하고 있다.

3개의 커멘트가 등록되어 있습니다.
이올린에 북마크하기(0) 이올린에 추천하기(0)
Posted by 백성용 헬로우보이
TAG MVC, MVC패턴, 모델2
트랙백 0개, 댓글 0개가 달렸습니다

JSP Model 2 Architecture 2부, 커맨드 패턴의 적용

Lecture/Java&JSP 강좌 2008/04/30 14:23
모델 2 구조를 객체 지향적으로 구현하는 방법에 대해서 살펴본다.
프로바이더: 최범균
모델 2 구조의 올바른 구현 방법

1부에서 살펴보았듯이 모델 2 구조에서 모든 클라이언트의 요청은 서블릿으로 전달되며, 서블릿은 그 요청을 알맞게 처리해야 할 책임이 따른다. 여기서 모든 클라이언트의 요청이라는 것은 연관성이 있는 기능등을 함께 묶어 놓은 집합을 의미한다. 예를 들어 게시판을 생각해보자. 게시판은 읽기/쓰기/삭제/목록보기 등의 기능을 필요로 하며 이러한 각 기능을 하나의 서블릿에서 구현하는 것이 바로 모델 2 구조의 알맞은 구현 방법이라 할 수 있다.

언뜻 생각해보면 모든 기능을 하나의 서블릿에서 처리한다는 것이 매우 이상하게 느껴질 것이다. 아마 여러분은 게시판을 서블릿으로 구현하고자 할 때 글 목록을 보여주는 ListServlet, 글을 작성하는 WriteServlet 그리고 글을 삭제하는 DeleteServlet 처럼 기능등을 각각 하나의 서블릿을 통해서 구현하고자 할 것이다. 이는 여러분들이 지금까지 살펴본 대부분의 서적에서는(또한 필자와 이동훈씨가 함쎄 지은 JSP Professional에서 조차도) 게시판의 각 기능을 별도의 서블릿 또는 JSP 페이지에서 처리하고 있기 때문이며, 또한 여러분이 이러한 사고 방식에 익숙해져 있기 때문이다.

이 시점에서 그러면 다음과 같은 질문이 떠오를 것이다.

  그렇다면 모든 일련의 기능을 하나의 서블릿에서 구현하는 것이 정말로 좋은가?

이 질문에 대한 대답은 바로 "그렇다" 이다. 조금은 못미덥겠지만 이 글을 끝까지 읽어나가면 여러 서블릿에 분산시키는 것 보다 하나의 서블릿에서 관련된 일련의 기능을 구현하는 것이(좀더 정확하게 표현하면 관련된 일련의 기능을 제어하는 것이) 효과적이며 또한 확장성도 뛰어나다는 것을 알 수 있을 것이다.

하나의 서블릿에 모든 관련된 기능을 집중시키자!

이제부터 서블릿에서 관련된 모든 기능을 구현하는 것에 대해서 살펴보자. 일단 모든 관련된 기능을 하나의 서블릿에서 구현하기 위해서는 서블릿이 각각의 요청이 어떤 기능을 요구하는 것인지 구분할 수 있어야 한다. 어떤 클라이언트는 게시판 목록을 보길 원할 것이고, 어떤 클라이언트는 글쓰기를 원할 것이고 그리고 어떤 클라이언트는 글에 대한 답변을 작성하기를 원할 것이다. 이처럼 각각의 요청은 서블릿으로부터 서로 다른 서비스를 받길 원하며 서블릿은 이를 구분하여 각각의 요청에 대해 알맞은 응답을 해 주어야 한다.

서블릿이 각 기능을 구분할 수 있는 한 가지 방법은 각 기능마다 고유의 명령어를 부여하는 것이다. 예를 들어, 게시판 목록 보기는 "List" 명령어를, 글 쓰기 작성 폼은 "WriteForm" 명령어를, 그리고 작성한 글을 저장하는 것은 "Write" 명령어를 부여하는 것이다. 이제 클라이언트는 이렇게 기능별로 부여한 명령어를 서블릿에 전달하기만 하면 된다. 몇몇 독자는 짐작했겠지만 서블릿에 명령어를 전달하는 방법은 파라미터를 통해서 이루어진다. 예를 들어, command 라는 파라미터를 통해서 명령어를 전달한다고 할 경우 게시판 목록 보기 요청은 /servlet/BoardServlet?command=List 와 같은 URL을 통해서 표현될 것이다.

각 기능별로 고유의 명령어를 부여했기 때문에 서블릿은 클라이언트가 보내온 명령어에 따라 알맞은 응답을 해 주기만 하면 된다. 간단하게 전체적인 코드의 형태를 보여준다면 다음과 같다.

   public void doGet(HttpServletRequest request,
                     HttpServletResponse response)
                     throws IOException, ServletException {
   
      String command = request.getParameter("command");
      String nextPage = "";
      
      if (command.compareTo("List") == 0) {
         // 목록 보여주기 위한 처리를 한다.
         BoardManager bMgr = BoardManager.getInstance();
         BoardList[] bList = bMgr.getList(request.getParameter("pageno");
         ...
         nextPage = "/board/list.jsp";
      } else if (command.compareTo("WriteForm") == 0) {
         // 글을 작성할 수 있는 폼을 보여준다.
         ...
         nextPage = "/board/writeform.jsp";
      } else if (command.compareTo("Write") == 0) {
         // 사용자가 입력한 데이터를 알맞게 저장한다.
         ...
         nextPage = "/board/write.jsp";
      }
      
      RequestDispatcher rd = request.getRequestDispatcher(nextPage);
      rs.forward(request, response);
   }

위 코드를 보면 command 파라미터의 값에 따라 알맞은 처리를 한 후 결과를 보여줄 JSP 페이지를 nextPage에 저장한느 것을 알 수 있다. 모든 처리가 끝나면 서블릿은 RequestDispatcher를 사용하여 nextPage에서 지정한 JSP 페이지를 보여준다. 위 코드의 경우 간단하게 "..."을 삽입하긴 했지만 실제로 "..."이 대신 완전한 코드를 넣었다면 위 코드는 아마 매우 길어졌을 것이다. 또한 위와 같이 하나의 메소드에 모든 구현을 다 넣는 것이 이상하게 느껴질 것이다.

물론, 위와 같이 하나의 메소드에 모든 기능을 다 넣는 것은 좋지 않은 방법이며 요구하는 기능이 많아질 경우 소스 코드가 복잡해지는 단점이 있다. 일단 덜 복잡한 코드를 작성하기 위해서는 기능들을 각각 별도의 메소드에서 구현해야 한다. 다음은 각각의 명령어를 별도의 메소드를 통해서 처리하도록 수정한 서블릿의 형태이다.

   public void doGet(HttpServletRequest request,
                     HttpServletResponse response)
                     throws IOException, ServletException {
   
      String command = request.getParameter("command");
      String nextPage = "";
      
      if (command.compareTo("List") == 0) {
         nextPage = processListCommand(request, response);
      } else if (command.compareTo("WriteForm") == 0) {
         nextPage = processWriteFormCommand(request, response);
      } else if (command.compareTo("Write") == 0) {
         nextPage = processWriteFormCommand(request, response);
      }
      
      RequestDispatcher rd = request.getRequestDispatcher(nextPage);
      rs.forward(request, response);
   }
   
   private String processListCommand(HttpServletRequest request,
                     HttpServletResponse response)
                     throws IOException, ServletException {
      // 목록 보여주기 위한 처리를 한다.
      BoardManager bMgr = BoardManager.getInstance();
      BoardList[] bList = bMgr.getList(request.getParameter("pageno");
      ...
      return "/board/list.jsp";
   }

   private String processWriteFormCommand(HttpServletRequest request,
                     HttpServletResponse response)
                     throws IOException, ServletException {
      // 글을 작성할 수 있는 폼을 보여준다.
      ...
      return "/board/writeform.jsp";
   }

   private String processWriteFormCommand(HttpServletRequest request,
                     HttpServletResponse response)
                     throws IOException, ServletException {
      // 사용자가 입력한 데이터를 알맞게 저장한다.
      ...
      return "/board/write.jsp";
   }

위 코드를 보면 하나의 메소드에서 하나의 명령어를 처리하는 것을 알 수 있다. 각각의 메소드는 자신의 처리해야 할 명령어에 대한 알맞은 처리를 한 후 request나 session의 setAttribute() 메소드를 사용하여 그 결과값을 저장해서 결과 화면을 보여주는 JSP 페이지에서 사용할 수 있도록 하고, 또한 결과를 보여줄 JSP 페이지를 리턴값으로 돌려준다. 그려면 서블릿의 doGet()이나 doPost() 메소드에서는 메소드가 리턴한 URI(즉, 결과를 보여줄 JSP 페이지)로 포워딩시키면 된다. 이것이 모델 2 구조의 가장 기본적인 구조라 할 수 있다.

명령어 기반 모델 2 구조의 가장 기본적인 구현 형태를 정리하면 다음과 같다.

  public class CommandBaseServlet extends HttpServlet {
     
     public static final String DEFAULT_COMMAND = "...";
     
     public void doGet(HttpServletRequest request,
                       HttpServletResponse response)
                       throws IOException, ServletException {
        processCommand(request, response);
     }
  
     public void doProcess(HttpServletRequest request,
                       HttpServletResponse response)
                       throws IOException, ServletException {
        process(request, response);
     }
     
     private void process(HttpServletRequest request,
                       HttpServletResponse response)
                       throws IOException, ServletException {
        String command = request.getParameter("command");
        if (command == null) command = DEFAULT_COMMAND;
        
        String nextPage = null;
        
        if (command.compareTo("Command1") == 0) {
           nextPage = processCommand1(request, response);
        } else if (command.compareTo("Command2") == 0) {
           nextPage = processCommand2(request, response);
        } else ...
           ...
        }
        RequestDispatcher rd = request.getRequestDispatcher(nextPage);
        rs.forward(request, response);
     }
     
     private String processCommand1(HttpServletRequest request,
                       HttpServletResponse response)
                       throws IOException, ServletException {
        // 어떤 처리를 한다.
        ...
        return "/process/command1result.jsp";
     }
     
     ...
     
     private String processCommandN(HttpServletRequest request,
                       HttpServletResponse response)
                       throws IOException, ServletException {
        // 어떤 처리를 한다.
        ...
        return "/process/commandNresult.jsp";
     }
  }

위 코드에서 doGet() 메소드와 doPost() 메소드에서 모두 process() 메소드를 호출하는 것을 알 수 있다. 이렇게 함으로써 doGet()과 doPost()에서 중복되는 코드를 없앨 수 있다. 단 하나 주의할 점이 있다면 인코딩 타입이 multipart/form-data로 전송될 경우 추가적으로 이에 알맞은 처리를 해 주어야 한다.

명령어 기반의 모델 2 구조의 구현을 잘 살펴보면 하나의 명령어는 하나의 작업(또는 역할)과 관련된 것을 알 수 있다. 예를 들어, 게시판과 관련된 명령어가 "List", "Write", "Edit"라고 할 경우 이 명령어들 각각은 "목록보기", "글쓰기", "글 수정하기"라는 역할을 나타내고 있는 것이다.

여기서부터 우리는 좀더 객체 지향적으로 나아가 보자! 하나의 명령어가 하나의 작업을 처리한다는 것은 또는 하나의 역할을 의미한다는 것은 각각의 명령어들을 하나의 클래스로 표현할 수 있다는 것을 의미한다. (객체 지향에서 대부분의 클래스는 그 클래스만의 역할을 갖고 있다.) 즉, 커맨드 패턴을 적용할 수 있는 것이다. 커맨드 패턴은 하나의 명령어에 대하여 하나의 클래스를 대응시키는 것으로서 이에 대한 자세한 내용은 필자가 자바캔에 기고했던 글인 '커맨드(Command) 패턴과 그 구현'을 참고하기 바란다. (이 부분을 읽기 전에 먼저 커맨드 패턴에 대한 것부터 반드시 숙지하기 바란다!)

'커맨드 패턴과 그 구현'을 읽었다면 (또는 커맨드 패턴에 대해서 이해하고 있다면) 이제부터 커맨드 패턴을 모델 2 구조에 적용하는 것에 대해서 살펴보자. (이 글에서는 각각의 커맨드의 기능을 실제로 구현한 클래스를 커맨드 클래스라고 표현하고 모든 커맨드 클래스가 공통으로 구현해야 하는 인터페이스를 커맨드 인터페이스라고 표현할 것이다.)

먼저 커맨드 인터페이스에 대해서 살펴보자. 모델 2 구조에서 사용될 커맨드 인터페이스는 HTTP 요청으로부터 정보를 추출할 수 있어야 하고 또한 세션, 요청 객체(HttpServletRequest 클래스의 객체) 등에 접근할 수 있어야 한다. 뿐만 아니라 HTTP 응답 객체(HttpServletResponse 클래스의 객체)를 사용할 수 있어야 한다. 이러한 것을 충족시키기 위해서는 다음과 같이 커맨드 인터페이스를 정의해주어야 한다.

  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import com.board.command.ProcessingException;
  
  public interface CommandIF {
     public String processCommand(HttpServletRequest request,
                                  HttpServletResponse response)
                                  throws ProcessingException;
  }

여기서 processCommand() 메소드의 리턴 타입이 String인 것을 알 수 있는데, 여기서 String은 CommandIF를 통해서 커맨드를 처리한 후 서블릿이 포워딩할 페이지의 URI를 나타낸다. 이에 대한 것은 뒤에서 좀더 구체적으로 설명하도록 하자.

명령어를 처리해주는 모든 커맨드 클래스가 구현해야할 인터페이스를 정의하였으므로, 그 다음으로 해야 할 것은 각각의 명령어에 알맞게 커맨드 클래스를 처리해주는 것이다. 예를 들어, 앞에서 예로 들었던 게시판 관련 명령어 중에서 "List"를 처리해주는 커맨드 클래스를 com.board.command.ListCommand 라고 해 보자. 이 경우 ListCommand 클래스는 다음과 비슷할 것이다.

  package com.board.command;
  
  import com.board.BoardMgr;
  import com.board.BoardData;
  import com.board.command.ProcessingException;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  public class ListCommand implements CommandIF {
     
     public String processCommand(HttpServletRequest request,
                                  HttpServletResponse response)
                                  throws ProcessingException {
        try {
           String pageNo = request.getParameter("page");
           String boardCode = request.getParameter("board");
           
           int page = Integer.parseInt(pageNo);
           
           BoardMgr boardMgr = BoardMgr.getInstance();
           BoardData[] list = boardMgr.getBoardDataAtPage(boardCode, page);
           
           request.setAttribute("boardMgr.boardList", list);
           
           return "/board/list.jsp";
        } catch(Exception ex) {
           throw new ProcessingException(ex);
        }
     }
  }

위 코드에서 ListCommand 클래스의 processCommand() 메소드는 파라미터로 전달받은 request 객체를 통해서 서블릿에서 해야 할 모든 작업을 할 수 있다. (그리고 서블릿에서 해야 할 작업을 커맨드 클래스로 옮겨놓은 것이 커맨드 패턴을 모델 2 구조에 적용한 목적이었다.) 따라서 request 기본 객체의 속성(attribute)을 사용하여 서블릿이나 JSP 페이지에 특정한 값을 전달할 수 있으며, 위 코드의 경우는 게시판 글 목록을 저장하고 있는 BoardData 배열인 list를 request 기본객체의 속성에 저장하고 있음을 알 수 있다.

ListCommand와 비슷하게 모든 다른 명령어에 대해서 각각 하나의 커맨드 클래스를 작성을 하면 비로서 서블릿에서 커맨드 클래스들을 사용할 수 있게 된다. 다음은 서블릿에 커맨드 패턴을 적용했을 때의 코드 형태이다.

  public class BoardServlet extends HttpServlet {
  
     public void doGet(HttpServletRequest request,
                       HttpServletResponse response)
                       throws IOException, ServletException {
        process(request, response);
     }
  
     public void doPost(HttpServletRequest request,
                        HttpServletResponse response)
                        throws IOException, ServletException {
        process(request, response);
     }
     
     private void process(HttpServletRequest request,
                          HttpServletResponse response)
                          throws IOException, ServletException {
        String command = request.getParameter("command");
        CommandIF processor = null;
        // 명령어에 따라서 알맞은 커맨드 클래스의 인스턴스를 생성한다.
        if (command == null) {
           command = new NullCommand();
        } else if (command.compareTo("List") == 0) {
           command = new ListCommand();
        } else if (command.compareTo("Write") == 0) {
           command = new WriteCommand();
        }
        
        ...
        
        String nextPage = null; // 명령어를 처리한 후 보여줄 JSP 페이지
        try {
           nextPage = command.processCommand(request, response);
        } catch(ProcessingException ex) {
           request.setAttribute("javax.servlet.jsp.jspException", ex);
           nextPage = "/error/noticeError.jsp";
        }
        ServletContext sc = getServletContext();
        RequestDispatcher rd = sc.getRequestDispatcher(nextPage);
        rd.forward(request, response);
     }
  }

앞에서 살펴봤던 코드가 command 파라미터의 값에 따라 같은 클래스에 정의되어 있는 알맞은 메소드를 호출하였다면, 커맨드 패턴을 적용한 이후에는 알맞은 명령어에 따라 알맞은 커맨드 클래스의 인스턴스를 생성하고 그 인스턴스의 processCommand() 메소드를 호출한다는 점이 다르다.

팩토리 패턴을 커맨드 패턴과 함께 사용한다면 위 코드는 더욱 간단해진다. 예를 들어, CommandFactory 라는 클래스가 있고, 이 클래스의 createCommand(String command) 메소드는 파라미터로 전달받은 command의 값에 따라 알맞은 커맨드 객체를 리턴한다고 해 보자. 이는 다음과 같이 CommandFactory를 통해서 커맨드 객체를 생성할 수 있다는 것을 의미한다.

  CommandIF processor = CommandFactory.createCommand("List");

이를 모델 2의 서블릿 코드에 적용하면 다음과 같이 변한다.

  public class BoardServlet extends HttpServlet {
  
     public void doGet(HttpServletRequest request,
                       HttpServletResponse response)
                       throws IOException, ServletException {
        process(request, response);
     }
  
     public void doPost(HttpServletRequest request,
                        HttpServletResponse response)
                        throws IOException, ServletException {
        process(request, response);
     }
     
     private void process(HttpServletRequest request,
                          HttpServletResponse response)
                          throws IOException, ServletException {
        String command = request.getParameter("command");
        CommandIF processor = CommandFactory.createCommand(command);
        String nextPage = null; // 명령어를 처리한 후 보여줄 JSP 페이지
        try {
           nextPage = command.processCommand(request, response);
        } catch(ProcessingException ex) {
           request.setAttribute("javax.servlet.jsp.jspException", ex);
           nextPage = "/error/noticeError.jsp";
        }
        ServletContext sc = getServletContext();
        RequestDispatcher rd = sc.getRequestDispatcher(nextPage);
        rd.forward(request, response);
     }
  }

if - else 가 사라짐으로써 서블릿 코드가 매우 간결해진다는 것을 알 수 있다.

 
프로바이더 최범균 ( madvirus@madvirus.net ) :
최범균씨는 최근에 출간된 'JSP Professional'(가메출판사)을 이동훈씨와 함께 저술하였으며, 현재 e-마켓플레이스 티페이지 글로벌에서 근무하고 있다. 한빛출판사의 'Java and XML'을 번역하기도 하였다
2개의 커멘트가 등록되어 있습니다.
이올린에 북마크하기(0) 이올린에 추천하기(0)
Posted by 백성용 헬로우보이
TAG MVC, MVC패턴, 모델2
트랙백 0개, 댓글 0개가 달렸습니다

JSP Model 2 Architecture 1부, 로직과 프리젠테이션의 분리

Lecture/Java&JSP 강좌 2008/04/30 14:18
모델2 구조에 대한 기본적인 내용을 살펴본다.
프로바이더: 최범균
모델1 구조

JSP는 이제 더 이상 일부 자바 개발자만 사용하는 기술이 아닌 웹 프로그래밍을 해야 하는 개발자들이 알아야 하는 기술이 되고 있다. 서점에 가보면 20여종에 가까운 JSP 서적이 존재하고 있으며 JSP 서적을 찾는 사람들 역시 많아지고 있다.

JSP가 이처럼 인기를 얻어 가고 있지만 막상 JSP 자체를 올바르게 사용하는 개발자는 매우 드문 것 같다. 특히 JSP 페이지로만 모든 걸 해결하는 개발자들도 많다고 볼 수 있다. 심지어는 ASP 코드를 그대로 JSP에서 사용하고(물론, VB 스크립트를 Java 언어로 변경하지만) 또는 PHP와 비슷한 형태로 사용하는 경우도 있다. 하지만, JSP가 세상에 나온 이유 중의 하나는 로직(logic)과 프리젠테이션(presentation)을 구분하기 위한 것이었다.

JSP는 로직과 표현부를 알맞게 구분하기 위해 모델 2 구조를 지원하고 있다. 이 글에서는 모델 2 구조가 무엇이며 어떤 식으로 구현되는 지, 그리고 모델 2 구조를 사용했을 때의 장단점에 대해서 살펴보도록 하자.

모델 1 구조와 단점

모델 2 구조에 대해 알아보기 전에 먼저 모델 1 구조에 대해서 살펴보자. 모델 1 구조는 JSP 페이지만으로 구성되어 있는 구조를 말한다. 즉, JSP 페이지에서 동적인 부분(즉, 로직 부분)은 스크립트릿으로 처리하고 그외 나머지 부분은 템플릿으로 처리하는 것이다. 그림1은 모델 1 구조의 전체 흐름을 보여주고 있다.


모델 1 구조의 전체 흐름

위 그림에서 클라이언트는 JSP 콘테이너에 HTTP 요청을 전송한다. 그러면 JSP 콘테이너는 HTTP 요청에 따라 알맞은 JSP에 그 요청을 전달하며, JSP 페이지는 클라이언트의 요청을 알맞게 처리한 후 응답을 클라이언트에 전송한다. 여기서 JSP 페이지는 클라이언트의 요청을 알맞게 처리하는 로직 부분을 구현하고 있다. 때에 따라 자바빈 컴포넌트에 로직 부분을 옮길 수도 있으나, 대부분의 경우 자바빈 컴포넌트는 단순히 데이터를 저장하는 역할만을 맡게 되며 모델 1 구조에서 JSP 페이지는 로직과 프리젠테이션의 역할을 동시에 맡게 된다.

예를 들어, 사용자가 특정한 JSP 페이지를 몇번 보았는지 알려주는 것을 생각해보자. 이 경우 세션이나 쿠키를 사용하여 사용자가 방문한 회수를 저장할 수 있다. 세션을 사용한다고 할 경우, JSP 페이지만을 사용하는 모델 1 구조에서는 다음과 같은 JSP 페이지를 작성할 것이다.

  <%@ page contentType="text/html; charset="euc-kr" %>
  <%@ page import="SessionCountBean" %>
  <%
     SessionCountBean count = (SessionCountBean)session.getAttribute("count");
     if (count == null) {
        count = new SessionCountBean();
        session.setAttribute("count", count);
     } else {
        count.increase();
     }
  %>
  <html>
  <head><title>방문회수</title></head>
  <body>
  지금까지 <%= count.getPageCount() %> 만큼 이 페이지에 방문하셨습니다.
  </body>
  </html>

위 코드를 보면 알겠지만 이 간단한 JSP 페이지에서조차도 HTML 코드 못지 않게 많은 양의 스크립트 코드가 JSP에 삽입되어 있다. JSP 페이지에서 데이터베이스부터 시작해서 모든 걸 처리한다고 할 경우 스크립트 코드와 HTML 코드는 스파게티처럼 막 뒤 섞이게 된다.

이렇게 로직 부분과 프리젠테이션 부분이 함께 섞여 있는 것은 JSP 개발자와 웹 디자이너가 함께 작업하는 데 많은 불편을 제공한다. 예를 들어, 개발자는 웹 디자이너가 작업한 HTML 문서의 알맞은 위치를 찾아서 스크립트 코드를 삽입해야 한다. 반대로 웹 디자이너는 디자인을 변경해야 할 때 최소한 JSP 스크립트 코드가 어떤 것인지 알아야 하며, 또한 HTML 코드 사이에 난잡하게 존재하는 스크립트 코드 때문에 사소한 디자인 변경 작업조차도 어려운 상황이 발생한다. 심지어, 개발자가 없이는 디자인을 변경하지 못하는 상황이 발생하기도 한다.

물론 위 코드를 다음과 같이 변경할 수도 있다.

  <%@ page contentType="text/html; charset="euc-kr" %>
  <jsp:useBean id="count" scope="session" class="SessionCountBean" />
  <%
     SessionCountBean count = (SessionCountBean)session.getAttribute("count");
     count.increase();
  %>
  <html>
  <head><title>방문회수</title></head>
  <body>
  지금까지 <jsp:getProperty name="count" property="pageCount" />
  만큼 이 페이지에 방문하셨습니다.
  </body>
  </html>

위 예제는 자바빈 컴포넌트 관련 JSP 태그를 사용한 것이다. 이전 예제에 비해 확실히 스크립트 코드의 양이 준것을 알 수 있다. 하지만, 여전히 JSP 페이지에서 로직과 관련된 부분을 처리하고 있으며 좀더 복잡한 로직을 갖는 웹 어플리케이션을 개발해야 할 경우 JSP 페이지는 로직과 프리젠테이션이 복잡하게 뒤섞이는 스파게티 코드가 될 것이다.

지금까지 살펴본 바와 같이 JSP 페이지가 모든 역할을 맡는 모델 1 구조의 경우는 JSP의 기본 목적인 로직과 프리젠테이션의 분리를 제대로 할 수 없음을 알 수 있다. 물론, 기본의 CGI나 서블릿에 비교해보면 많은 발전이 있지만 ASP나 PHP와 비교해볼 때 별다른 장점을 보이고 있지 못하다.

 
관련링크:

프로바이더 최범균 ( madvirus@madvirus.net ) :
최범균씨는 최근에 출간된 'JSP Professional'(가메출판사)을 이동훈씨와 함께 저술하였으며, 현재 e-마켓플레이스 티페이지 글로벌에서 근무하고 있다. 한빛출판사의 'Java and XML'을 번역하기도 하였다.

4개의 커멘트가 등록되어 있습니다.
이올린에 북마크하기(0) 이올린에 추천하기(0)
Posted by 백성용 헬로우보이
TAG MVC, MVC패턴, 모델1, 모델2
트랙백 0개, 댓글 0개가 달렸습니다