저작권 안내: 저작권자표시 Yes 상업적이용 No 컨텐츠변경 No

스프링5 입문

JSP 2.3

JPA 입문

DDD Start

인프런 객체 지향 입문 강의
간단한 예를 통해 웹 기반의 데이터 송수신이 어떻게 이루어지는 지 그리고 웹-투-웹의 장단점에 대해서 살펴본다.

가상 인터넷 서점 시나리오

지난 Part 1 에서는 java.net.URL 클래스와 java.net.URLConnection 클래스를 사용하여 웹-투-웹 통신의 기본이 되는 HttpMessage 클래스를 작성해보았다. 이번 Part 2에서는 가상의 기업들을 설정해서 웹-투-웹 프로그래밍이 어떤 식으로 구현되는지에 살펴보도록 하자. 또한, 이 과정에서 우리는 XML을 사용하여 데이터를 주고 받을 때의 장단점에 대해서 살펴볼 것이다.

이 글에서 웹을 기반으로 하여 데이터를 주고 받는 것에 대해서 설명하기 위해 가상의 시나리오를 작성해보자. 이 시나리오에는 크게 고객, 인터넷서점, 출판사, 택배사가 출현한다. 고객은 인터넷 서점을 통해서 서적을 주문하며, 인터넷 서점은 사용자가 서적 주문을 하면(단, 여기서는 신용카드와 같이 구매와 동시에 결재가 된다고 가정한다) 실시간으로 구매 정보를 택배사에 전송한다. 이때, 고객은 인터넷 서점에 웹을 통해서 서적을 주문하게 되며 인터넷 서점은 웹을 기반으로 하여 택배사에 배송 정보를 전송한다. 이 과정을 간단하게 그림으로 표현하면 다음과 같다.


그림1 인터넷 서점과 택배사 사이의 데이터 이동 흐름
그리고, 인터넷 서점은 하루 간격으로 각 출판사의 신간 목록을 읽어오는데, 이 과정 역시 웹 기반의 통신을 통해서 이루어진다. 이때, 출판사는 신간 목록을 인터넷 서점에서 정한 DTD에 알맞도록 생성된 XML 문서를 인터넷 서점에 전송한다. 인터넷 서점은 전송받은 XML 문서를 알맞게 처리하여 자신들의 서적 목록 DB에 추가한다.

여기서 작성한 가상 시나리오는 인터넷 서점과 관련된 간단한 업무 흐름을 웹 기반으로 처리하고 있다. 모든 것이 웹 기반으로 이루어지기 때문에 웹 어플리케이션만을 개발하면 되며, 그 외에 별도의 클라이언트 프로그램은 필요하지 않게 된다. 즉, 모든 사용자들은 웹 브라우저만으로 자신의 업무를 처리할 수 있게 되는 것이다.

시나리오의 구현

가상 인터넷 서점의 구현은 기본적으로 다음과 같은 3 단계로 이루어진다.

  1. HTTP의 파라미터를 사용하여 다른 업체가 요구하는 데이터를 전송한다.(즉, HTTP 요청)
  2. 데이터를 전송받은 업체는 알맞은 프로토콜을 사용하여 전송 결과를 보낸다. (즉, HTTP 응답)
  3. HTTP 응답을 받은 업체는 결과에 알맞게 나머지 처리를 한다.
예를 들어, 사용자가 어떤 서적을 구매한다고 해 보자. 사용자는 인터넷 서점의 웹 사이트에서 구매할 책을 선택한 후 "구매" 버튼을 클릭할 것이다. 그러면 그 "구매" 요청을 처리하는 인터넷 서점의 서블릿은 사용자의 "구매" 요청 정보를 DB에 저장한다. 그런 후 (1) 인터넷 서점의 서블릿은 HTTP 프로토콜을 사용하여 택배 회사에서 발송 요청 정보를 전송한다. 그러면 (2) 인터넷 서점의 서블릿으로부터 요청을 받은 택배 회사의 서블릿은 처리 결과를 인터넷 서점과 미리 결정한 프로토콜에 맞춰 출력 스트림으로 전송한다. 마지막으로 (3) 인터넷 서점은 택배 회사로부터 전달받은 결과값을 사용하여 나머지 처리를 한다. 나머지 처리에 속하는 것으로는 사용자에게 구매한 서적이 발송되었음을 알리는 메일을 발송한다던가 데이터베이스에 기록을 남기는 등이 있을 것이다.

모든 웹-투-웹 기반의 프로그램은 이와 같이 3 단계 과정을 기본으로 하고 있으며, 서로 주고 받을 데이터에 대한 규약만 명확하게 정의해 놓는다면 안정적으로 기업간 통신을 이룰 수 있게 된다. (웹 기반 통신의 장점에 대해서는 이 글의 뒷 부분에서 언급할 것이다.)

발송 요청 및 발송확인 통보

이제부터 본격적으로 구현에 대해서 살펴보자. 먼저 알아볼 내용은 인터넷 서점이 택배 회사에 발송 요청을 하는 것과 택배 회사가 인터넷 서점에 발송 확인 통보를 하는 과정이다.

첫번째로 발송 요청부터 살펴보자. 가장 먼저 해야 할 일은 사용자가 서적을 구매할 경우 인터넷 서점에서 택배회사에 실시간으로 전송되어야 하는 파라미터를 결정하는 것이다. 이 예제에서는 표1에 나타낸 파라미터를 택배회사에 전송할 것이다.

파라미터 이름 의미
orderNo 주문번호
title 책이름
isbn ISBN
quantity 수량
receiver 받는사람
address 받는사람주소
contact 연락처

인터넷 서점의 구매 요청을 처리하는 JSP 페이지는 다음과 같은 순서로 구매 요청을 처리하게 된다.

  1. 사용자가 입력한 내용에 기반하여 주문번호를 생성한다.
  2. 해당하는 주문번호와 관련된 정보를 DB에 저장한다.
  3. 표1에 표시한 파라미터 정보를 저장하고 있는 java.util.Properties 객체를 생성한다.
  4. HttpMessage를 사용하여 3 에서 생성한 파라미터 정보를 택배회사 서블릿에 전송한다.
  5. 택배회사 서블릿으로부터 응답 결과에 따라 알맞은 처리를 한다.
  6. 최종 처리를 사용자에게 보여준다.
이 과정에서 우리가 살펴볼 부분은 과정 3에서 과정 5까지이다. 나머지 과정은 이 글의 목적과 관련성이 적으므로 생략하기로 한다. 먼저 과정 3에 해당하는 코드를 살펴보자. 이 코드는 다음과 같을 것이다.

  public void doPost(HttpServletRequest request,
                     HttpServletResponse response)
                     throws IOException, ServletException {
  
     // 책 주문 관련 정보를 OrderBean 이라는 자바빈 컴포넌트에 저장한다.
     ...
     ...
     
     Properties params = new Properties();  // 택배사에 전송될 파라미터를 저장한다.
     params.setProperty("orderNo", orderBean.getOrderNo());
     params.setProperty("title", orderBean.getTitle());
     params.setProperty("isbn", orderBean.getIsbn());
     params.setProperty("quantity", orderBean.getQuantity().toString());
     params.setProperty("receiver", orderBean.getReceiver());
     params.setProperty("address", orderBean.getAddress());
     params.setProperty("contact", orderBean.getContact());
     
     ...
     ...
  }

위와 같이 Properties 객체를 생성한 다음에는 4단계로 들어가면 된다. 4단계 코드는 다음과 같다.

  public void doPost(HttpServletRequest request,
                     HttpServletResponse response)
                     throws IOException, ServletException {
     
     // 책 주문 정보를 읽어오고 Properties 객체를 사용하여
     // 택배사 서블릿에 전송할 파라미터의 값을 지정한다.
     ...
     ...
     
     BufferedReader br = null; // 택배사 서블릿으로부터 결과를 읽어올 때 사용되는 스트림.
     try {
        HttpMessage httpMessage = new HttpMessage(url);
        InputStream is = httpMessage.sendPostMessage(params);
        br = new BufferedReader(new InputStreamReader(is));        
        // 응답 결과에 따라 알맞은 처리를 한다.
        ...
        ...
        
     } catch(IOException ex) {
        // 택배사 서버와 통신 과정에서 예외 발생
        ...
     } finally {
        if (br != null)
           try { br.close(); } catch(SQLException ex) {}
     }
     ...
  }

이제 마지막으로 해야 할 일은 택배사의 서블릿이 보내온 결과값을 이용하여 마무리 처리를 최종 처리를 하는 것이다. 여기서 필요한 것이 바로 프로토콜이다. 물론, 인터넷 서점의 서블릿과 택배사의 서블릿이 서로 정보를 몇 차례 주고 받는 것이 아니라 단 한번만 정보를 주고 받는 것이기 때문에(즉 인터넷 서점의 서블릿은 택배사 서블릿에 요청을 전송하고 택배사 서블릿은 그에 대한 응답을 전송한다) 특별히 복잡한 프로토콜은 필요없다. 택배 서블릿은 단순히 인터넷 서점의 택배 발송 요청에 대한 성공 실패 여부 정도만 알려줄 수 있으면 된다. 다음 표는 택배사 서블릿이 인터넷 서점에 결과 값을 전송할 때 사용하는 프로토콜을 나타내고 있다.

프로토콜 메시지 의미
OK [주문번호] 인터넷 서점의 택배 서비스 요청이 성공적으로 이루어졌음을 나타낸다. [주문번호]는 인터넷 서점에서 사용하는 주문 번호를 나타낸다.
ERROR [주문번호] [에러메시지] 택배 발송 서비스 요청 처리 과정에서 에러가 발생했음을 나타낸다. [에러메시지]는 발생한 에러의 원인을 나타낸다.

프로토콜이라는 용어를 사용해서 거창한 것 처럼 느꼈을지도 모르지만, 택배사 서블릿이 요청 결과로서 보내는 프로토콜은 표2와 같이 간단하다. 택배사 서블릿은 택배 서비스 요청 처리 결과를 표2에 표시한 프로토콜에 따라 인터넷 서점에 전송한다. 예를 들어, 택배사 서블릿은 요청한 주문번호에 대하여 이미 택배 서비스 요청이 처리되었을 경우 다음과 같은 메시지를 인터넷 서점에 전송할 것이다.

  ERROR S-2001-878124 이미 서비스 요청이 처리된 주문 번호입니다.

다음 코드는 앞에서 살펴본 코드에 프로토콜 처리 부분을 추가한 것이다.

  public void doPost(HttpServletRequest request,
                     HttpServletResponse response)
                     throws IOException, ServletException {
  
     // 책 주문 정보를 읽어오고 Properties 객체를 사용하여
     // 택배사 서블릿에 전송할 파라미터의 값을 지정한다.
     ...
     ...
     
     BufferedReader br = null; // 택배사 서블릿으로부터 결과를 읽어온다.
     try {
        HttpMessage httpMessage = new HttpMessage(url);
        InputStream is = httpMessage.sendPostMessage(params);
        br = new BufferedReader(new InputStreamReader(is));
        
        // 응답 결과에 따라 알맞은 처리를 한다.
        String line = br.readLine(); // 첫줄을 읽어온다.
        int indexOfSpace = line.indexOf(' ');
        if (indexOfSpace > 0) {
           String cmd = line.substring(0, indexOfSpace);
           if (cmd.equals("OK") ) {
              // 택배 서비스 요청 처리가 성공적으로 이루어졌음을 나타낸다.
              // 이 경우 사용자에게 주문 요청이 성공적으로 이루어졌다는
              // 메시지를 보여준다.
              ...
              
           } else if (cmd.equals("ERROR") ) {
              // 택배 서비스 요청 처리 과정에서 에러가 발생했음을 나타낸다.
              // 이 경우 사용자에게 택배 서비스 신청 과정 중 에러가
              // 발생하였음을 알린다.
              ...
           } else {
             // 프로토콜을 따르지 않는 응답 결과를 보내온 것임
             ...
           }
        } else {
           // 프로토콜을 따르지 않는 응답 결과를 보내온 것임
           ...
        }
        ...
        ...
     } catch(IOException ex) {
        // 택배사 서버와 통신 과정에서 예외 발생
        // 이에 대한 알맞은 메시지를 사용자에게 보여준다.
        ...
     } finally {
        if (br != null)
           try { br.close(); } catch(SQLException ex) {}
     }
     ...
  }

위 코드를 보면 웹-투-웹 프로그래밍이 복잡하지 않다는 것을 알 수 있다. 주고 받아야 하는 데이터에 따라 프로토콜이 더 복잡해질 수는 있겠지만, 대부분의 경우 위 코드의 형태를 크게 벗어나지 않는다. 물론, 위 코드에서 프로토콜에 따라 처리하는 부분을 좀더 객체 지향적으로 변경할 수는 있겠지만, 기본 구조는 위 코드와 같다.

택배사가 배송 결과를 다시 알려주는 과정은 인터넷 서점이 택배사에 택배 서비스를 요청하는 것과 크게 다르지 않으므로 그에 대한 설명은 하지 않겠다.

XML을 이용한 데이터 송수신

지금까지 살펴본 내용을 통해서 웹-투-웹 프로그래밍이 어떤식으로 구현된다는 것을 알 수 있었을 것이다. 하지만, 앞에서 살펴본 내용들이 모두 코드의 일부만을 보여줬기 때문에 실제 구현이 어떤식으로 이루어지는 지에 대해서는 여전히 궁금해할 것이라 생각된다. 그래서 이제부터는 웹-투-웹을 기반으로 XML 데이터를 주고 받는 것에 대해서 살펴보도록 하자.

여기서 살펴볼 예제는 앞에서 언급했던 것으로서 인터넷 서점이 출판사로부터 신간 목록을 읽어오는 부분이다. 출판사의 서블릿인 NewBookListServlet은 최근에 추가된 신간 목록을 XML 문서로 출력해준다. 출력되는 XML 문서는 다음과 같은 형식을 갖는다.

  <?xml version="1.0" encoding="euc-kr" ?>
  <book-list>
     <book>
        <isbn>8980781032</isbn>
        <title>JSP Professional</title>
        <publisher>가메</publisher>
        <author>이동훈,최범균</author>
        <page>873</page>
        <price>25000</price>
     </book>
     <book>
        <isbn>8980781024</isbn>
        <title>Windows 2000 Server 완전정복</title>
        <publisher>가메</publisher>
        <author>김형백</author>
        <page>891</page>
        <price>25000</price>
     </book>      
  </book-list>

실제로 NewBookListServlet은 다음과 같다.

  import javax.servlet.*;
  import javax.servlet.http.*;
  import java.io.*;
  
  import com.pub.book.BookMgr;
  import com.pub.book.BookMgrException;
  import com.pub.book.BookBean;
  
  public class NewBookListServlet extends HttpServlet {
  
     public void doGet(HttpServletRequest request,
                       HttpServletResponse response)
                       throws IOException, ServletException {
        response.setContentType("text/xml; charset=euc-kr");
        PrintWriter out = response.getWriter();
        
        out.println("<?xml version="1.0" encoding="euc-kr" ?>");
        out.println("<book-list>");
        
        try {
           BookMgr mgr = BookMgr.getInstance();
           BookBean[] newBookList = mgr.getNewBookList();
           for (int i = 0 ; i < newBookList.length ; i++) {
              out.println("    <book>");
              out.println("        <isbn>"+newBookList[i].getIsbn()+"</isbn>");
              out.println("        <title>"+newBookList[i].getTitle()+"</title>");
              out.println("        <publisher>"+
                          newBookList[i].getPublisher()+"</publisher>");
              out.println("        <author>"+newBookList[i].getAuthor()+"</author>");
              out.println("        <page>"+newBookList[i].getPage()+"</page>");
              out.println("        <price>"+newBookList[i].getPrice()+"</price>");
              out.println("    </book>");
           }
        } catch(BookMgrException ex) {
           // getInstance()나 getNewBookList()에서 예외가 발생한 경우
           // <error> 태그를 사용하여 에러 메시지를 출력한다.
           out.print("    <error>");
           out.print(ex.getMessage());
           out.println("</error>");
        }
        out.println("</book-list>");
        out.flush();
        out.close();
     }
  }

위 코드에서 BookMgr 클래스는 출판사의 서적을 관리해주는 역할을 맡고 있으며, BookBean 클래스는 책 정보를 저장할 때 사용되는 자바빈이다. BookMgr 클래스의 getNewBookList() 메소드는 어제 하루 동안 나온 신간 목록을 구해주는 메소드로서 NewBookListServlet은 이 메소드를 사용하여 신간 정보를 저장하고 있는 BookBean의 배열을 구한다. 일단 BookBean 배열을 구하게 되면, 그 배열의 정보를 이용하여 신간 목록 정보를 나타내는 XML 문서를 클라이언트에 출력한다. (여기서 BookMgr과 BookBean에 대한 내용은 언급하지 않겠다.)

XML 문서를 출력하기 위해서는 ServletResponse의 setContentType() 메소드를 사용하여 출력될 컨텐츠의 타입이 XML 문서라는 것을 알려주어야 한다. 위 코드를 보면 "text/xml; charset=euc-kr" 로 지정해준 것을 알 수 있다. 뒤에 있는 charset은 출력될 글자의 캐릭터셋이 EUC-KR 이라는 것을 나타낸다. XML 문서를 출력하는 것은 위 코드에서 볼 수 있듯이 서블릿의 Writer 객체에 HTML 문서를 출력하는 것과 완전히 같다.

여러분 중에는 아마도 DOM이나 JDOM을 사용하여 XML 문서를 나타내는 트리를 생성한 후 그 트리를 XML 문서 형태로 스트림에 출력하는 방법을 선택할 사람도 있을 것이다. 물론, 그 방법이 나쁘지는 않으며 또한 코드가 좀더 의미 있어지는 것이 사실이다. 하지만, 이 글은 DOM이나 JDOM을 사용하여 XML 문서를 생성하는 것에 대해서 살펴보는 것이 아니므로 위 코드에처럼 간단한 방법을 사용하기로 한다.

웹브라우저에서 NewBookListServlet으로 HTTP 요청을 보내면 다음 그림과 같은 결과가 출력된다. XML 문서가 요청에 대한 응답으로 출력되는 것을 알 수 있다.


그림2 출판사의 NewBookListServlet의 결과화면

신간 목록을 XML 문서로 출력해주는 출판사의 서블릿을 살펴보았으니 이제 인터넷 서점 부분을 살펴보자. 인터넷 서점은 출판사의 서블릿으로부터 신간 목록을 읽어와 XML 문서를 파싱한 후 알맞게 DB에 정보를 삽입하면 된다. 먼저 간단하게 인터넷 서점에서 신간 목록을 읽어오는 흐름을 살펴보자.

  1. HttpMessage를 이용하여 출판사의 http://host/servlet/NewBookListServlet 에 연결한다.
  2. 출판사 서블릿 NewBookListServlet으로부터의 응답 결과로부터 DOM 트리를 생성한다.
  3. DOM 트리로부터 서적 정보를 읽어와 자바빈에 저장한다.
  4. 인터넷 서점의 예비 신간 서적 DB에 자바빈 정보를 추가한다.
지금까지 살펴본 내용과 크게 다르지 않다. 다른 점이 있다면 프로토콜 부분이 XML 문서로 대체되었다는 것 뿐이다. 이를 구현하기 위해 이 글에서는 인턴넷 서점에서 사용될 세 개의 클래스 NewBookListCollector, NewBook, NewBookServlet을 살펴보기로 하자.

먼저 NewBook 클래스는 앞에서 출판사 부분에서 언급했던 BookBean과 마찬가지로 인터넷 서점의 신간 DB 테이블에 저장할 데이터를 담고 있는 자바빈이다. 그리고 NewBookListCollector는 출판사의 서블릿/JSP/CGI 등으로부터 신간 목록을 저장하고 있는 XML 문서를 읽어와 파싱하여 NewBook 자바빈 인스턴스를 생성해주는 역할을 한다. NewBookServlet은 NewBookListCollector 클래스를 사용하여 신간 목록을 사용자에게 보여주는 역할을 한다. 즉, 전체 구조는 다음과 같다.


그림3 인터넷 서점과 출판사 사이의 업무 흐름

XML 문서를 이용한 정보 교환에서 핵심적인 역할을 맡고 있는 NewBookListCollector 클래스를 살펴보자. 일단 이 클래스의 완전한 소스 코드부터 보도록 하자. 완전한 소스 코드는 다음과 같다. (코드가 좀 길긴 하지만 내부 로직은 복잡하지 않으므로 차분하게 살펴보기 바란다.)

  package com.interbook;
  
  import javax.xml.parsers.DocumentBuilderFactory;  import javax.xml.parsers.DocumentBuilder;  import javax.xml.parsers.ParserConfigurationException;  import org.xml.sax.SAXException;  import org.xml.sax.InputSource;  import org.w3c.dom.*;  import java.io.*;
  import java.util.*;
  import java.net.URL;
  import javacan.http.util.HttpMessage;  
  public class NewBookListCollector {
    /**
     * 지정한 URL로부터 신간 목록이 담긴 XML 문서를 읽어와
     * 파싱한 후 NewBook 배열을 리턴한다.
     */
    public static NewBook[] getNewBook(String url) {
      BufferedReader br = null; // 지정한 URL로부터
      try {
        HttpMessage httpMessage = new HttpMessage(new URL(url));
        InputStream is = httpMessage.sendGetMessage();
        br = new BufferedReader(new InputStreamReader(is));
        
        ArrayList newBookList = new ArrayList(5);
        
        InputSource source = new InputSource(br);        
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = dbFactory.newDocumentBuilder();
        Document document = builder.parse(source);        
        // document 로부터 ROOT 요소를 구한다.(<book-list>)
        Element rootElement = document.getDocumentElement();
        for (Node subNode = rootElement.getFirstChild() ;
             subNode != null ;
             subNode = subNode.getNextSibling() ) {
          
          if (subNode.getNodeType() == Node.ELEMENT_NODE && 
              subNode.getNodeName().compareTo("book") == 0) {
            // <book> 노드일 경우
            NewBook book = new NewBook();            // <book> 요소의 하위 요소를 처리한다.
            NodeList childNodeList = subNode.getChildNodes();
            int len = childNodeList.getLength();
            for (int i = 0; i < len ; i++) {
              Node childNode = childNodeList.item(i);
              // <book> 요소의 하위 노드의 타입이 ELEMENT 일 경우
              if (childNode.getNodeType() == Node.ELEMENT_NODE) {
                String childNodeName = childNode.getNodeName();
                String value = getSubTextNodeValue(childNode).trim();
                if (childNodeName.compareTo("isbn") == 0) {
                  book.setIsbn(value); 
               } else if (childNodeName.compareTo("title") == 0) {
                  book.setTitle(value);
                } else if (childNodeName.compareTo("publisher") == 0) {
                  book.setPublisher(value);
                } else if (childNodeName.compareTo("author") == 0) {
                  book.setAuthor(value);
                } else if (childNodeName.compareTo("page") == 0) {
                  try {
                    book.setPage(Integer.parseInt(value));
                  } catch(NumberFormatException ex) {
                    book.setPage(-1);
                  }
                } else if (childNodeName.compareTo("price") == 0) {
                  try {
                    book.setPrice(Integer.parseInt(value));
                  } catch(NumberFormatException ex) {
                    book.setPage(-1);
                  }
                }
              }
            }
            newBookList.add(book);
          } else if (subNode.getNodeType() == Node.ELEMENT_NODE && 
                       subNode.getNodeName().compareTo("error") == 0) {
            // <error> 요소인 경우 알맞은 처리
            // 이 예제에서는 처리하지 않는다.
            return null;
          }
        }
        
        NewBook[] bookList = new NewBook[newBookList.size()];
        newBookList.toArray(bookList);
        return bookList;      } catch(Exception ex) {
        // 처리하는 과정에서 예외가 발생한 경우 null을 리턴.
        ex.printStackTrace();
        return null;      } finally {
        if (br != null) try { br.close(); } catch(IOException ex) {}
      }
    }
    
    private static StringBuffer buff = new StringBuffer(512);
    
    private static String getSubTextNodeValue(Node node) {
      NodeList subNodeList = node.getChildNodes();
      int len = subNodeList.getLength();
      
      if (buff.length() > 0) buff.delete(0, buff.length());
      
      for (Node subNode = node.getFirstChild() ;
           subNode != null ;
           subNode = subNode.getNextSibling() ) {
        if (subNode.getNodeType() == Node.TEXT_NODE ) {
          buff.append(subNode.getNodeValue());
        } else if (subNode.getNodeType() == Node.ENTITY_REFERENCE_NODE) {
          buff.append(subNode.getFirstChild().getNodeValue().trim());
        }
      }
      return buff.toString();
    }
  
  }

위 코드를 보면 HttpMessage.sendGetMessage() 메소드를 사용하여 출판사의 /serlvet/NewBookListSerlvet에 접속한 후, NewBookListServlet이 전송하는 XML 문서를 Reader를 통해서 읽어들인다. XML 문서를 파싱하기 위해서 org.xml.sax.InputSource 클래스를 사용하고 있는데 InputSource는 DocumentBuilder가 다양한 자원으로부터 XML 문서를 읽어와 DOM 트리인 Document 객체를 생성할 수 있도록 해 준다. 일단 Document 객체가 생성되면 이제 그 Document 객체로부터 필요한 정보를 추출해내기만 하면 된다.

위 코드에서 XML 문서를 처리하는 부분이 있는데 조금 복잡해 보이지만 JAXP API와 DOM API를 사용하는 것에 대해서 조금만 공부한다면 쉽게 이해할 수 있을 것이다. 자바에서 DOM API를 사용하는 것에 대한 내용은 자바와 XML(한빛출판사)을 참고하기 바란다. 또는, 자바캔의 일반 강좌 게시판에 김인희씨가 올린 글을 참조해도 된다.

이제 인터넷 서점은 출판사로부터 XML 문서로 된 신간 목록을 읽어올 수 있게 되었다. 남은 작업은 서블릿을 사용하여 인터넷 서점 관리자에게 인터페이스를 제공하는 것이다. 이는 그림 3에서 보듯이 인터넷 서점의 NewBookServlet을 통해서 이루어진다. 이 글에서는 간단하게 출판사로부터 읽어온 신간 목록을 화면에 보여주도록 NewBookSerlvet을 구현해보았다. 다음은 NewBookServlet의 코드이다.

  import javax.servlet.*;
  import javax.servlet.http.*;
  import java.io.*;
  
  import com.interbook.NewBook;
  import com.interbook.NewBookListCollector;
  
  public class NewBookServlet extends HttpServlet {
  
     public void doGet(HttpServletRequest request,
                       HttpServletResponse response)
                       throws IOException, ServletException {
        
        NewBook[] list = NewBookListCollector.getNewBook(
                 "http://localhost:8080/servlet/NewBookListServlet");        
        response.setContentType("text/html; charset=euc-kr");
        PrintWriter out = response.getWriter();
        
        out.println("<html><head><title>신간 목록</title></head>");
        out.println("<body>");
        if (list == null) {
           out.println("신간 목록을 읽어오는 과정에서 에러가 발생하였습니다.");
        } else {
           out.println("신간 목록");
           
           for (int i = 0 ; i < list.length ; i++) {
              out.println("<hr>");
              out.println("도서명:"+list[i].getTitle());
              out.println("출판사:"+list[i].getPublisher());
              out.println("저자:"+list[i].getAuthor());
              out.println("가격:"+list[i].getPrice());
           }
        }
        out.println("</body></html>");
        out.flush();
        out.close();
     }
  }

물론, 실제로 인터넷 서점에서 사용되는 NewBookServlet은 위와 같이 단순하진 않을 것이며 다양한 기능을 제공할 것이다. 하지만 이 글는 여러분에게 XML과 웹-투-웹을 이용한 정보 교환을 보여주는 것에 중점을 두고 있으므로 다른 부차적인 기능은 살펴보지 않기로 한다.

실제로 웹브라우저를 통해서 NewBookServlet에 접근하면 다음과 같은 결과가 출력된다.


그림4를 보면 인터넷 서점의 관리자가 출판사로부터 읽어온 신간 목록을 간단하게 웹 브라우저를 통해서 읽어올 수 있다는 것을 알 수 있다. 이런 방법으로 인터넷 서점은 여러 출판사로부터 동시에 신간 목록을 읽어올 수 도 있을 것이다.(물론, 모든 출판사는 동일한 DTD/스키마를 사용하여 XML 문서를 생성한다.) 기존의 어떤 방법보다도 간편하게 신간 목록을 추가할 수 있다는 것을 알 수 있다.

Web-to-Web의 장단점

이제야 비로서 웹-투-웹 프로그래밍의 장단점에 대해서 알아볼 때가 되었다. 1주에서 장단점에 대해서 언급할 수도 있었으나 간단하게나마 예제를 살펴본 후에 논하는 것이 더 알맞을 것 같아서 이렇게 2부에서 웹-투-웹의 장단점에 대해서 언급하도록 한다. 먼저 장점부터 살펴보도록 하자.

  • 구현이 비교적 쉽다.
    앞의 예제에서 보았듯이 웹을 기반으로 데이터를 주고 받는 것은 매우 간단하게 구현된다. 일종의 웹 프로그래밍이기 때문에 JSP/서블릿, ASP, PHP 등과 같은 것으로 웹 사이트를 구축하듯 구현하면 된다. 게다가 JSP나 ASP와 같은 스크립트 언어는 CGI나 펄에 비해 쉽게 구현할 수 있다는 장점도 갖고 있다.

  • 복잡한 프로토콜이 필요없다.
    데이터의 전달은 파라미터를 통해서 이루어지며 결과는 HTTP 프로토콜을 응답을 통해서 이루어지기 때문에 데이터 송수신과 관련된 복잡한 프로토콜을 정의할 필요가 없다. 특히 XML을 응답 결과로서 사용할 경우 XML 문서와 관련된 DTD와 스키마만 서로 공유하면 되며 또한 XSL/T를 사용하여 응답 결과를 알맞은 형태로 어렵지 않게 변경할 수 있다.

  • 특정한 프로그래밍 언어에 구애받지 않아도 된다.
    웹을 기반으로 하는 통신에서는 서로 HTTP 프로토콜을 사용하여 정보를 주고 받는다. 따라서 자바든 VB 스크립트든 아니면 C 언어이건간에 서비스를 제공할 웹 페이지를 구현할 때 사용한 언어는 아무런 문제가 되지 않는다. 단지, 정해진 프로토콜에 따라 알맞게 정보만 주고 받으면 된다.

  • HTTPS를 사용하여 주고 받는 데이터를 쉽게 암호화할 수 있다.
    HTTPS는 HTTP 프로토콜에서 주고 받는 데이터를 암호화한 것이다. 비록 1부에서 작성한 HttpMessage 클래스가 HTTPS를 지원하고 있진 않지만 자바와 관련된 보안 관련 확장 API를 사용하면 어렵지 않게 구현할 수 있다. 또한, JDK 1.4 부터는 보안 관련 API가 기본적으로 포함되어 있기 때문에 별도의 라이브러리를 설치할 필요도 없어진다.

장점에 대해서 살펴봤는데 모든 게 그렇듯이 장점만 있을리가 없다. 이제 단점에 대해서 살펴보자.

  • 복잡한 흐름제어는 불가능하다.
    HTTP 프로토콜은 기본적으로 '연결 -> 요청전송 -> 응답받음 -> 연결해제'의 간단한 과정을 거친다. 몇번에 걸쳐서 서로 요청/응답을 반복적으로 수행하는 SMTP나 FTP와 같은 프로토콜과 달리 HTTP 프로토콜은 한번의 요청과 그 요청에 대한 한번의 응답으로 구성되어 있다. 따라서, 흐름제어와 같이 여러번의 요청/응답을 필요로 하는 업무에는 적용하기 힘들다.

한번의 연결에서 여러 차례의 요청/응답이 이루어지는 구조는 단순한 HTTP 프로토콜로는 구현이 불가능하다. 물론, 여러번에 걸쳐서 연결을 할 경우 이 단점이 극복될 수는 있지만 연결을 열었다 끊었다를 반복하는 것이 그리 좋은 방법은 아닐 것이다.

결론

이번 2부에서는 웹 기반의 정보 교환이 실제로 어떻게 적용될 수 있는 지 간단한 예를 통해서 알아보았으며, 웹 기반 통신의 장/단점에 대해서 알아보았다. 비록 여기서 살펴본 것이 웹 기반의 정보 교환을 위한 유일한 방법은 아니지만, HTTP 프로토콜을 이용하여 기업 사이에 정보를 주고 받는 것이 현실적으로 사용할 수 있는 알맞은 방법이라는 것은 확실하다. 물론 엔터프라즈 환경에 알맞은 자바 메시지 서비스(Java Message Service; JMS)를 사용하여 정보 교환을 할 수도 있겠지만, 여전히 많은 기업들은 아파치(또는 IIS) 웹서버와 JSP/ASP/PHP/펄CGI 등을 사용하여 웹 사이트를 구축하고 있으며 이러한 상황에서 기업간 정보 교환을 손쉽게 하기 위한 대안으로서 HTTP 프로토콜을 이용한 웹 기반의 통신을 제시해 보았다. (필자 역시 현재 진행하고 있는 프로젝트에서 다른 기업과의 공유를 위해서 웹 기반의 통신을 하고 있다.)

관련링크:
Posted by 최범균 madvirus

댓글을 달아 주세요

  1. 황타 2011.11.21 10:49 신고  댓글주소  수정/삭제  댓글쓰기

    OpenAPI를 사용하면서 제대로 이해도 못하고 openConnection을 사용했었는데,
    1부, 2부 강의를 보니 이해가되네요~ㅎ
    좋은글 감사합니다~

  2. 자바초보 2013.07.15 19:09 신고  댓글주소  수정/삭제  댓글쓰기

    님완전 개쩌는듯 .... 감사해요

  3. 오우 2017.11.21 09:29 신고  댓글주소  수정/삭제  댓글쓰기

    쓸일이 있었는데 유용하게 보았습니다 ^^
    감사합니다.

데이터의 교환 수단이 아닌 데이터의 표현 수단으로서 XML을 응용해본다.

풀다운 메뉴와 XML

XML은 이제 개발자들이 알아야할 하나의 기술이 되어가고 있는 것 같다. XML은 표준화된 데이터를 표현할 수 있는 특징을 갖고 있으며, XSL/T를 사용하여 손쉽게 다른 포맷으로 변경할 수 있다는 장점을 갖고 있기 때문에, XML-EDI와 같은 B2B 분야에서 그 진가를 조금씩 발휘하고 있다.

하지만, B2B와 같이 데이터를 교환하는 수단으로서만 XML이 가치 있는 것은 아니다. XML의 가장 기본적인 특징은 XML이 데이터를 표현하는 언어라는 점이다. 이 글에서는 XML을 데이터로 사용하여 웹 사이트에서 최근에 많이 사용되고 있는 풀다운 메뉴를 구현하는 방법에 대해서 살펴볼 것이다.

풀다운 메뉴는 이미 모든 컴퓨터 사용자에게 익숙한 GUI(Graphical User Interface)이다. 우리가 사용하고 있는 대부분의 응용프로그램은 사용자와의 인터페이스를 위해 대부분 풀다운 메뉴를 사용하고 있으며, 마이크로소프트의 웹 사이트를 비롯한 많은 웹 사이트가 풀 다운 메뉴를 사용하고 있다.

풀 다운 메뉴의 구조적 특징은 계층 구조를 갖는다는 점이다. 예를 들어, 다음 그림은 많이 사용되고 있는 웹브라우저인 인터넷 익스플로러의 메뉴 화면을 캡쳐한 화면이다.


위 그림을 보면 '편집'이라는 메뉴 밑에 '복사', '붙여넣기' 등의 메뉴 아이템이 존재하는 것을 알 수 있다. '파일', '보기'와 같은 다른 메뉴 역시 여러 메뉴 아이템을 포함하고 있다. 여기서 전체 메뉴 시스템은 계층적인 구조를 갖고 있다는 점을 알 수 있다. 계층적인 구조는 XML의 기본적인 특징으로서 XML은 태그를 중첩시킴으로써 계층적인 데이터를 표현할 수 있다. 예를 들어, 위 그림에 나타나 있는 메뉴의 구조를 XML을 사용하여 표현하면 다음과 같을 것이다.

<?xml version="1.0" encoding="euc-kr"?>
<root>
   <Menu>
      <MenuName>파일(F)</MenuName>
      <MenuItem>
         <MenuItemName>열기</MenuItemName>
      </MenuItem>
      <MenuItem>
         <MenuItemName>다른 이름으로 저장</MenuItemName>
      </MenuItem>
   </Menu>
   <Menu>
      <MenuName>편집</MenuName>
      <MenuItem>
         <MenuItemName>잘라내기</MenuItemName>
      </MenuItem>
      <MenuItem>
         <MenuItemName>복사</MenuItemName>
      </MenuItem>
      <MenuItem>
         <MenuItemName>붙여넣기</MenuItemName>
      </MenuItem>
   </Menu>
</root>

위 XML 문서를 살펴보면 <Menu> 요소는 메뉴 바에 있는 '파일', '편집'과 같은 메뉴를 나타내고, <Menu> 요소에 중첩되어 있는 <MenuName> 요소는 <Menu> 요소가 나타내는 메뉴의 이름을 나타낸다. 또한, <MenuItem> 요소는 그 요소가 중첩되어 있는 <Menu> 요소가 나태는 메뉴의 메뉴 아이템을 나타낸다. 여기서, XML이 계층적 구조를 쉽게 나타낼 수 있기 때문에 XML을 이용하여 풀다운 메뉴를 매우 간단하게 표현할 수 있다는 것을 알았을 것이다.

웹에서 사용될 풀다운 메뉴를 위한 XML 문서의 구조

웹에서 풀다운 메뉴를 구현할 경우, 각각의 메뉴와 메뉴 아이템은 관련된 링크를 갖게 된다. 이 링크를 나타내기 위해서는 단순히 앞에서 살펴본 XML 구조에 <HyperLink>와 같은 태그를 추가하기만 하면 된다. 예를 들면 다음과 같다.

<?xml version="1.0" encoding="euc-kr"?>
<root>
   <Menu>
      <MenuName>HOME</MenuName>
      <HyperLink>/main/index.jsp</HyperLink>
   </Menu>
   <Menu>
      <MenuName>Help</MenuName>
      <HyperLink>/help/index.jsp</HyperLink>
      <MenuItem>
         <MenuItemName>FAQ</MenuItemName>
         <HyperLink>/help/faq.html</HyperLink>
      </MenuItem>
      <MenuItem>
         <MenuItemName>About JavaCan</MenuItemName>
         <HyperLink>/help/aboutJavaCan.html</HyperLink>
      </MenuItem>
   </Menu>
   
</root>

위 XML을 살펴보면 <Menu> 요소와 <MenuItem> 요소는 각각 <HyperLink> 요소를 중첩하고 있으며, 각각의 <HyperLink>는 관련된 URL을 값으로 갖고 있는 것을 알 수 있다. DTD를 사용하여 위 구조를 명시적으로 정의할 수도 있지만, 이 글에서는 생략하기로 한다.

XMLMenu 클래스

이제 XMLMenu 클래스를 작성해보자. 이 클래스의 역할은 풀다운 메뉴를 나타내는 XML 문서를 읽어와 그것을 알맞게 HTML로 만들어주는 것이다. XMLMenu는 XML 문서를 DOM API를 통해서 읽어온다. DOM API는 XML 문서를 메모리상에 트리 구조로 읽어온다. 트리 구조는 그 자체가 계층적 구조이기 때문에 메뉴를 나타내는 XML 문서를 처리하기에 알맞다.

XMLMenu 클래스에서 핵심적인 메소드는 createMenu(String systemURI) 메소드와 generateHTML() 메소드이다. createMenu() 메소드는 파라미터로 메뉴 데이터를 저장하고 있는 XML 문서를 나타내는 URI를 받으며, 그 XML 문서를 로딩하여 분석한다. XMLMenu.createMenu() 메소드는 다음과 같다.

public void createMenu(String systemURI) throws SAXException, IOException {
   Document document = null;
   DOMParser parser = new DOMParser();   
   parser.parse(systemURI);
   document = parser.getDocument();
   
   // <Menu> 노드 목록을 구한다.
   NodeList nodeList = document.getDocumentElement().getChildNodes();
   Node node; // 현재 처리하고 있는 <Menu> 노드
   NodeList childNodes; // <Menu>의 자식 노드
   Node cNode; // 현재 처리하고 있는 <Menu>의 자식 노드
   Node cNode2; // 현재 처리하고 있는 <MenuName>의 자식 노드
   
   for (int i = 0 ; i < nodeList.getLength() ; i++) {
      node = nodeList.item(i);
      if ( node.getNodeType() == Node.ELEMENT_NODE &&
           node.getNodeName().compareTo("Menu") == 0) {
         // <Menu> element일 경우
         childNodes = node.getChildNodes();
         cNode = childNodes.item(1); // <MenuName> 노드
         String menuName = getNodeValue(cNode);
         cNode = childNodes.item(3); // <HyperLink> 노드
         String hyperLink = getNodeValue(cNode);
         
         menuList.add(menuName);
         menuLinkList.add(hyperLink);
         
         if (childNodes.getLength() > 5) {
            // <MenuItem> 노드가 있는 경우
            StringBuffer sb = new StringBuffer( (childNodes.getLength() - 5) * 250);
            
            for (int j = 5 ; j < childNodes.getLength() ; j++) {
               cNode = childNodes.item(j);
               if ( cNode.getNodeType() == Node.ELEMENT_NODE &&
                    cNode.getNodeName().compareTo("MenuItem") == 0) {
                  cNode2 = cNode.getChildNodes().item(1); // <MenuItemName>
                  String menuItemName = getNodeValue(cNode2);
                  cNode2 = cNode.getChildNodes().item(3); // <HyperLink>
                  String menuItemLink = getNodeValue(cNode2);
                  
                  String tempString =
"<span id=\""+menuName+"\" class=\""+menuItemSpanClass+"\">"+
"<a href=\""+menuItemLink+"\" class=\""+menuItemLinkClass+"\">"+menuItemName+
"</a></span><br>\n";
                  sb.append(tempString);
               }
            }
            menuItemList.add(sb.toString());
         } else {
            menuItemList.add("");
         }
      }
   }
   generateHTML();
}

createMenu() 메소드는 다음과 같은 순서로 작업을 진행한다.

  1. DOMParser를 사용하여 XML 문서를 읽어온다.
  2. <Menu> 노드의 목록을 구한 후, 이 노드의 자식 노드인 <MenuName>과 <HyperLink>의 값을 각각 menuList와 menuLinkList에 저장한다.
  3. <Menu> 노드가 <MenuItem> 노드를 갖고 있다면, <MenuItem> 노드를 읽어와 알맞은 처리를한다.
위 코드를 볼 때 주의해야 할점이 있다면, 공백문자(' ')나 '\n'과 같은 글자 역시 자식 노드가 된다는 점이다. 예를 들어, 다음과 같은 형태의 XML 문서가 있다고 해 보자.

   <Menu>
      <MenuName>HOME</MenuName>
      <HyperLink>/main/index.jsp</HyperLink>
   </Menu>

이 경우 <Menu> 노드는 <MenuName>노드와 <HyperLink> 노드를 자식 노드로 갖지만, <Menu>와 <MenuName>사이에 있는 '\n\t\t' 역시 자식 노드로 갖는다. 따라서 <Menu> 노드의 자식 노드중에서 <MenuName>노드를 구하기 위해서는 두번째 자식 노드를 참조해야만 한다. createMenu() 메소드에서 <Menu> 노드의 자식 노드인 <MenuName>과 <HyperLink> 노드를 구하는 코드를 살펴보면 이런 점을 알 수 있다.

createMenu() 메소드는 <MenuItem> 노드가 있을 경우, 그 자식 노드인 <MenuItemName>과 <HyperLink> 태그의 값을 이용하여 다음과 같은 형태의 HTML 태그를 생성한다.

<span id="[MenuName 노드의 값]" class="menuitemspan">
<a href="[HyperLink 노드의 값]" class="menuitemlink">[MenuItemName 노드의 값]</a></span><br>

위와 같은 형태의 태그는 menuItemList에 저장된다. createMenu() 메소드는 XML 문서에 있는 모든 노드를 알맞게 처리하면, generateHTML()메소드를 호출한다. generateHTML() 메소드는 createMenu() 메소드에서 분석한 결과를 이용하여 메뉴바와 각 메뉴와 관련된 메뉴 아이템 목록을 HTML 형식으로 출력한다. 메뉴바와 메뉴 아이템 목록은 HTML에서 레이어를 표현할 수 있도록 해 주는 <div> 태그를 사용하여 표시된다. 풀다운 메뉴를 구현하기 위해서는 마우스가 특정한 영역에 들어오거나 그 영역을 벗어나는 경우 알맞게 메뉴를 보여주어야 하기 때문에, 자바 스크립트를 사용해야 한다. 이 때 사용되는 자바 스크립트에 대한 내용은 관련링크에서 제공되는 소스 코드를 참조하기 바란다.

다음은 generateHTML() 메소드이다.

private void generateHTML() {
   menuList.trimToSize();
   menuLinkList.trimToSize();
   menuItemList.trimToSize();
   Object[] menuArray = menuList.toArray();
   Object[] menuLinkArray = menuLinkList.toArray();
   Object[] menuItemArray = menuItemList.toArray();
   
   StringBuffer output = new StringBuffer(1024*8); // buffer 8K
   output.append("<div id=\"menuBar\" class=\"").append(menuBarClass).append("\">");
   for (int i = 0 ; i < menuArray.length ; i++) {
      output.append(" <span id=\"m").append(i).append("\">")
            .append("<a href=\"").append(menuLinkArray[i].toString())
            .append("\" class=\"").append(menuLinkClass).append("\" ");
      
      if ( !menuItemArray[i].toString().equals("") ) {
         output.append("onMouseOver=\"viewMenu('m").append(i)
               .append("', 'menu").append(i).append("')\" ")
               .append("onMouseOut=\"checkBound('m").append(i)
               .append("', 'menu").append(i).append("')\"");
      }
      output.append(">");
      output.append(menuArray[i].toString()).append("</a> </span>");
      
      if ( i < menuArray.length - 1 )
         output.append(" | ");
   }
   output.append("</div>");
   
   menuBar = output.toString();   output.delete(0, output.length());
   
   for (int i = 0 ; i < menuItemArray.length ; i++) {
      String temp = menuItemArray[i].toString();
      if (!temp.equals("")) {
         output.append("<div id=\"menu").append(i).append("\" ")
               .append("class=\"").append(menuItemDivClass).append("\" ")
               .append("onMouseOut=\"checkBound('', 'menu")
               .append(i).append("')\">\n");
         output.append(temp);
         output.append("</div>");
      }
   }
   menuItemLayer = output.toString();   output.delete(0, output.length());
}

XMLMenu 클래스를 컴파일하기 위해서는 알맞은 XML 파서가 필요하다. 필자는 여기서 아파치의 Xerces 파서를 사용하였다. 아파치 Xerces 파서는 http://xml.apache.org에서 구할 수 있다. 사용가능한 파서에 대한 내용은 자바캔의 또 다른 기사인 'XML의 소개와 XML 관련 기술'를 참고하기 바란다.

XMLMenu의 사용

XMLMenu.generateHTML() 메소드를 살펴보면 HTML로 변환한 결과를 각각 menuBar와 menuItemLayer에 저장하는 것을 알 수 있다. menuBar는 메뉴바와 관련된 HTML 코드를 갖고 있으며, menuItemLayer는 각각의 메뉴와 관련된 HTML 레이어를 값으로 갖게 된다. 이 두 값은 각각 XMLMenu.getMenuBar() 메소드와 XMLMenu.getMenuItemLayer() 메소드를 통해서 구할 수 있다.

JSP 페이지나 서블릿에서 XMLMenu 클래스를 사용하는 예제는 다음과 같다.

<%@ page language="java" session="false" %>
<%@ page import="javacan.xml.xmlmenu.XMLMenu" %>
<%
   XMLMenu xmlMenu = new XMLMenu();
   String filepath = "file:///" + getServletContext().getRealPath("xmlmenu.xml");   try {
      xmlMenu.setCSSClassName("menubar", "menulink", 
        "menuitemdiv", "menuitemspan", "menuitemlink");
      xmlMenu.createMenu(filepath);   } catch(Exception ex) {
      ex.printStackTrace();
   }
   String menuBar = xmlMenu.getMenuBar();   String menuItemLayer = xmlMenu.getMenuItemLayer();%>
<html>
<head>
<title>XML Hierarchical Menus</title>
<link rel=STYLESHEET type="text/css" href="xmlmenu.css">
<Script Language="JavaScript" src="xmlmenu.js"></script>
</head>
<body id="body" bgcolor="#FFFFFF" 
         TOPMARGIN="0" LEFTMARGIN="0" MARGINWIDTH="0" MARGINHEIGHT="0" >
<center>
<table width="500">
<tr>
   <td><%= menuBar %></td>
</tr>
<tr>
   <td>위 메뉴 시스템은 xmlmenu.xml 문서를 XMLMenu 클래스를
          사용하여 만들어진 것입니다.</td>
</table>
</center><%= menuItemLayer %></body>
</html>

위 JSP 페이지를 웹 브라우저에서 출력한 결과는 다음과 같다.


위 그림에서 메뉴바는 XMLMenu.getMenuBar() 메소드의 리턴 값을 출력해서 생성되며, 각각의 메뉴에 마우스가 올라갈 때 나타내는 메뉴 아이템들은 XMLMenu.getMenuItemLayer() 메소드의 리턴값을 출력해서 생성된다.

위 코드에서 사용된 자바스크립트와 스타일쉬트 파일은 "xmlmenu.js"와 "xmlmenu.css"는 관련 링크에 있는 소크 코드를 통해서 구할 수 있다.

결론

이 글에서는 XML을 사용하여 웹 페이지의 풀다운 메뉴를 표현하는 것에 대해서 알아보았다. 이처럼 XML을 사용하여 메뉴를 생성할 경우의 장점은 메뉴를 변경하기 위해서 JSP나 서블릿의 코드를 변경할 필요가 없다는 점이다. 출력되는 모양의 경우 CSS 파일만 변경해주면 되며, 이벤트에 대한 반응을 다르게 하고 싶을 경우 자바스크립트 파일만 변경해주면 된다. 즉, 풀다운 메뉴 자체가 거의 완벽하게 모듈화되는 것이다.

XML의 응용 분야는 무수히 많다고 할 수 있다. 특히, 데이터를 표현하는 분야에서는 XML을 손쉽게 활용할 수 있다. 이 글에서는 그러한 활용 중의 하나만을 선보였을 뿐이다. 독자 여러분 스스로도 XML을 다양한 곳에서 활용하는 방법을 찾아보기 바란다.

관련링크:
Posted by 최범균 madvirus

댓글을 달아 주세요