KR100583517B1

KR100583517B1 - 소프트웨어 객체와 구조화 언어 요소 기반 문서간의 매핑시스템 및 방법

Info

Publication number: KR100583517B1
Application number: KR1020037014561A
Authority: KR
Inventors: 마이클 비씨젤; 존 에이치. 그린; 제이 더블유. 워필드
Original assignee: 인터내셔널 비지네스 머신즈 코포레이션
Priority date: 2001-06-07
Filing date: 2001-12-28
Publication date: 2006-05-24
Also published as: EP1399841A1; PL367225A1; RU2287181C2; KR20040007545A; WO2002101579A1; CZ20033330A3; CA2349905A1; HUP0400135A2; CN1513145A; JP2004530225A; CN1313953C; RU2003137567A; TW573278B

Abstract

본 발명에 따른 방법 및 시스템은 문서(예, XML 문서)와 소프트웨어 객체(예, 자바 객체)간의 매핑을 위한 공통 프레임워크를 제공한다. 프레임워크는 매핑을 위해 속성이 어떻게 획득되는지를 마스크하는(mask) 핸들러를 이용한다. 매핑 코드의 결과는 매핑의 양쪽 방향 모두에 공통의 외관을 갖는다. XML 문서의 요소들과 자바 객체 속성들간의 매핑은 매퍼에 포함된다. 매퍼는 파서(DOM 또는 SAX)를 이용함으로써 XML 문서를 소프트웨어 객체에 매핑시킨다.

반대방향의 매핑(자바에서 XML)은 최종 XML 문서의 유효성을 보장하기 위해 XML 문서의 요소들이 특정 순서로 구축될 것을 필요로 한다. 본 발명은 예를 들어 JSP를 이용하여 XML 템플릿 문서를 구축한다. JSP 기반 템플릿을 이용함으로써 문서 태그들이 요소 및 속성 값을 얻기 위한 콜백(callback)으로 JSP내에 기록될 수 있게 된다. 콘텐트는 버퍼로 향하거나, 서브렛의 응답 스트림으로 직접 향할 수 있다.

소프트웨어 객체, XML 문서, 매핑, 변환

Description

소프트웨어 객체와 구조화 언어 요소 기반 문서간의 매핑 시스템 및 방법{System and method of mapping between software objects and structured language element based documents}

본 발명은 소프트웨어 객체와 구조화 언어 요소 문서간의 변환 또는 매핑 분야에 관한 것으로서, 구체적으로는 자바(Java) 객체와 같은 다양한 소프트웨어 객체와 확장형 마크업 언어(Extensible Markup Language:XML) 문서간의 매핑에 관한 것이다.

XML은 특별히 웹 문서용으로 개발된 표준 범용 마크업 언어(Standard Generalized Markup Language: SGML)의 축소(pared down) 버전이다. 개발자들은 이것을 이용하여 HTML로는 이용가능하지 않은 기능을 제공하기 위해 그들 자신의 맞춤화된 태그를 생성할 수 있다. 예를 들어, XML은 단지 하나의 목적지 각각을 참조할 수 있는 HTML 링크와는 다르게 다수의 문서를 가리키는 링크를 지원한다.

XML은 자체-기술(self-describing) 데이터(본 명세서에서는 구조화 언어 요소라고도 지칭됨)의 형태이기 때문에, 풍부한 데이터 모델을 인코드하는데 이용된다. 따라서, XML은 이종 시스템간에 데이터 교환 매체로서 유용하다. 데이터는 다수 종류의 시스템들(레거시 COBOL 프로그램, 데이터베이스, C++ 프로그램 등)로 부터 XML으로서 노출되거나 공표될 수 있다. 흔히 직면하는 비즈니스 문제점에는 XML 문서로부터 다른 형태의 데이터 포맷 또는 그 역으로 정보를 어떻게 매핑시키는지에 관련된다. 예를 들어, XML 문서간의 엔티티들간에 정보가 교환되면, 데이터베이스 또는 트랜잭션 요청을 할 때 이용될 수 있는 자바 객체로 그 정보를 매핑할 필요가 있다.

2000년 9월 26일 멜츠러(Meltzer) 등에 허여된 미국특허공보 제6,125,391호는 XML/자바 변환툴의 예를 개시한다. XML로부터 자바로의 변환을 위해, 멜츠러 등은 XML 문서를 파싱하고 이벤트를 일으킨다. 구체적으로, 파서는 XML 문서를 분석하고 질의될 수 있는 트리 표현식을 메모리에 구축하고 또다른 파서가 XML 문서를 파싱하고 문서에 대한 정보로써 이벤트를 일으킨다(예, 개시 문서 이벤트, 요소명칭, 요소내용을 갖는 개시 요소 이벤트, 종료 요소 이벤트 및 문서 이벤트 등). 자바에서 XML로 변환하기 위해서는, 멜츠러 등은 각 요소에 대한 액세서를 포함하는 코드를 생성한다. 요소에 대한 액세서는 각 문자에 대해 루핑하는 루프를 포함한다. 루프는 문자가 무엇이냐에 기초하여 동작을 수행하는 전환문(switch statement)를 포함한다. 동작은 XML 문서의 요소 프래그먼트를 포함하는 스트링 버퍼(StringBuffer)를 구축하는 것이다. 멜츠러의 해결책은 자바를 XML로 변환하는 코드와 함께 동작하기 위한 지원 인프라구조를 제공하지 않는다. 멜츠러의 모든 코드는 생성되며 사용자가 편집하는데 도움이 되지 않는다.

결과적으로, 표준 툴을 이용하여 효율적으로 구현될 수 있는 소프트웨어 객체와 구조 언어 요소 기반 문서(예, XML)간의 매핑을 지원하는 매핑 프레임워크가 필요하다.

전술한 종래 기술의 단점들은 문서(예, XML 문서)와 소프트웨어 객체(예, 자바 객체)간의 매핑을 위한 공통 프레임워크를 제공하는 본 발명의 방법 및 시스템에 따라 극복된다. 프레임워크는 매핑을 위해 속성이 어떻게 획득되는지를 마스크하는(mask) 핸들러를 이용한다. 매핑 코드의 결과는 매핑의 양쪽 방향 모두에 공통의 외관을 갖는다. XML 문서의 요소들과 자바 객체 속성들간의 매핑은 매퍼에 포함된다. 매퍼는 파서(문서객체모델(Document Object Model:DOM)를 이용하거나 XML용 단순 어플리케이션 프로그래밍 인터페이스(Simple Application Prgramming Interface)(SAX)를 이용함으로써 XML 문서를 소프트웨어 객체에 매핑시킨다.

반대방향의 매핑(자바에서 XML)은 최종 XML 문서의 유효성을 보장하기 위해 XML 문서의 요소들이 특정 순서로 구축될 것을 필요로 한다. 이러한 유효성 보장을 위해, 본 발명에 따른 예시적인 실시예는 예를 들어 자바서버 페이지(JavaServer Pages^TM:JSP)를 이용하여 XML 템플릿 문서를 구축한다. 템플릿에 근거한 JSP를 이용함으로써, 문서의 태그들이 요소 및 속성 값들을 얻기 위한 콜백(callback)으로, JSP에 기록될 수 있다. JSP는 효율적인 템플릿 생성을 허용하기 위해 편집기 지원기로써 잘 문서화된다. 또한, 콘텐츠는 버퍼로 향하거나, 서브렛(servelet)의 응답 스트림으로 직접 향할 수 있다.

본 발명의 일특징에 따르면, 소프트웨어 객체를 나타내는 데이터 구조를 문서의 구조화 언어 요소들로 변환하기 위한 컴퓨터-구현 방법이 제공되는데, 상기 방법은 (a) 구조화된 언어 요소 템플릿 문서를 생성하는 단계와, (b) 상기 소프트웨어 객체의 속성들 - 상기 속성들은 상기 문서의 구조화언어 요소들과 연관됨- 을 판독하는 단계와, (c) 상기 속성들을 이용하여, 상기 속성들과 상기 구조화 언어 요소들간의 연관성에 기초하여 상기 구조화 언어 요소들에 의해 정의된 구문(construct)들을 획득하는 단계와, (d) 상기 구문들로 상기 구조화 언어 요소 템플릿 문서를 파퓰레이트하는(populating) 단계를 포함한다.

본 발명의 또다른 특징에 따르면, 문서의 구조화 언어 요소들을 소프트웨어 객체를 나타내는 데이터 구조로 변환하기 위한 컴퓨터-구현 방법이 제공되는데, 이 방법은,(a) 상기 문서의 구조화 언어 요소들 각각을 판독하는 단계와, (b) 상기 소프트웨어 객체의 데이터 구조에 의해 정의되는 이용가능한 속성 집합으로부터 선택되며, 상기 문서의 구조화 언어 요소들에 연관된 속성을 판단하는 단계와, (c) 상기 소프트웨어 객체를 나타내는 데이터 구조의 속성들을 상기 문서의 구조화 언어 요소 값들로 파퓰레이트하는 단계를 포함한다.

본 발명의 또다른 특징에 따르면, 속성들을 포함하는 소프트웨어 객체를 구조화 언어 요소들에 의해 정의되는 문서로 변환하기 위한 시스템이 제공되는데, 상기 시스템은 (a) 문서 템플릿과,(b) 상기 문서 템플릿에 의해 이루어지는 콜백에 근거하여 상기 문서의 구조화 언어 요소들의 표현을 제공하기 위한 핸들러 인터페이스와, (c) 상기 핸들러 인터페이스와 통신하여, 상기 소프트웨어 객체의 속성들을 상기 문서에 의해 인식되는 구조화 언어 요소들로 변환하기 위한 매핑 모듈과, (d) 상기 매핑 모듈과 통신하여, 상기 단계(c)에서 생성된 상기 구조화 언어 요소들을 상기 문서에 기록하기 위한 출력 타겟 클래스를 포함한다.

본 발명의 또다른 특징에 따르면, 구조화 언어 요소들을 포함하는 문서를 소프트웨어 객체로 변환하기 위한 시스템이 제공되는데, 상기 시스템은 (a) 상기 문서의 특징들을 나타내는 이벤트를 획득하기 위한 파서와,(b) 상기 문서를 판독하기 위한 입력 소스 클래스와, (c) 상기 입력 소스 클래스와 통신하여, 상기 파서에 의해 획득되는 이벤트들에 대한 버퍼를 구현하기 위한 콘텐트 핸들러 클래스와, (d) 상기 콘텐트 핸들러 클래스와 통신하여, 상기 파서에 의해 획득된 이벤트들을 상기 소프트웨어 객체(11)에 대한 속성들로 변환하기 위한 매핑 모듈을 포함한다.

본 발명의 또다른 특징에 따르면, 속성들을 갖는 소프트웨어 객체를 구조화 언어 요소들에 의해 표현되는 문서로 변환하는 방법이 제공되는데, 상기 방법은,(a) 상기 소프트웨어 객체를 호출된(invoked) 매핑 인터페이스의 인스턴스로 공급하는 단계와, (b) 호출된 컨테이너의 인스턴스를 이용하여 템플릿을 컴파일하고 실행하는 단계와, (c) 상기 컴파일된 템플릿을 이용하여 지정된 출력 스트림으로 상기 문서를 기록하는 단계를 포함한다.

본 발명의 또다른 특징에 따르면, 구조화 언어 요소들을 포함하는 문서를 소프트웨어 객체로 변환하는 방법이 제공되는데, 상기 방법은, (a) 상기 문서를 호출된 매핑 인터페이스의 인스턴스에 공급하는 단계와, (b) 상기 매핑 인터페이스를 콘텐트 핸들러로서 등록하는 단계와, (c) 상기 문서를 호출된 파서의 인스턴스를 이용하여 파싱하는 단계와, (d) 상기 매핑 인터페이스에 대해 이루어지는 콜백을 통해 상기 문서로부터 파싱된 구조화 언어 요소들에 연관된 속성들로 상기 소프트웨어 객체를 파퓰레이트하는 단계를 포함한다.

본 발명의 또다른 특징에 따르면, 소프트웨어 객체를 나타내는 데이터 구조를 문서의 구조화 언어 요소들로 변환하기 위한 컴퓨터 프로그램 제품이 제공되는데, 상기 컴퓨터 프로그램 제품은 (a) 구조화된 언어 요소 템플릿 문서를 생성하고, (b) 상기 소프트웨어 객체의 속성들 - 상기 속성들은 상기 문서의 구조화언어 요소들과 연관됨- 을 판독하고, (c) 상기 속성들을 이용하여, 상기 속성들과 상기 구조화 언어 요소들간의 연관성에 기초하여 상기 구조화 언어 요소들에 의해 정의된 구문(construct)들을 획득하고, (d) 상기 구문들로 상기 구조화 언어 요소 템플릿 문서를 파퓰레이트하기 위한 컴퓨터 판독가능 프로그램 코드 소자들을 포함한다.

본 발명의 또다른 특징에 따르면, 문서의 구조화 언어 요소들을 소프트웨어 객체를 나타내는 데이터 구조로 변환하기 위한 컴퓨터 프로그램 제품이 제공되는데, 상기 컴퓨터 프로그램 제품은 (a) 상기 문서의 구조화 언어 요소들 각각을 판독하고, b) 상기 소프트웨어 객체의 데이터 구조에 의해 정의되는 이용가능한 속성 집합으로부터 선택되며, 상기 문서의 구조화 언어 요소들에 연관된 속성을 판단하고, (c) 상기 소프트웨어 객체를 나타내는 데이터 구조의 속성들을 상기 문서의 구조화 언어 요소 값들로 파퓰레이트하기 위한 컴퓨터 판독가능 프로그램 소자들을 포함한다.

본 발명의 기타 특징 및 특성들은 첨부된 도면과 연관된 이하의 구체적인 실 시예에 대한 설명을 참조하면 당업자에게 용이하게 이해될 수 있을 것이다.

본 발명의 특징 및 장점들은 이하의 도면과 관련하여 상세히 설명될 것이다. 도 1은 본 발명을 실시하기 위한 방법 및 장치를 구현하는데 이용될 수 있는 컴퓨터 시스템의 블록도이다.

도 2는 XML과 자바 객체간 및 그 역방향의 매핑을 위한 프레임워크를 설명하는 블록도이다.

도 3은 도 2의 프레임워크를 이용하여 XML 문서를 소프트웨어 객체에 매핑시키는 방법을 설명한 흐름도이다.

도 4는 도 2의 프레임워크를 이용하여 소프트웨어 객체를 XML 문서로 매핑시키는 방법을 설명한 흐름도이다.

도 1 및 이에 연관된 설명은 발명이 구현되는 데 적합한 컴퓨팅 환경의 예를 나타낸다. 본 발명이 개인용 컴퓨터에서 실행되는 컴퓨터 프로그램의 컴퓨터-실행가능 명령의 일반적인 측면에서 설명되지만, 본 발명은 다른 프로그램 모듈과 결합하여 구현될 수도 있다.

일반적으로, 프로그램 모듈에는 특정 타스크를 수행하거나 특정의 추상적인 데이터 유형을 구현하는 루틴, 프로그램, 컴포넌트, 데이터 구조 등이 포함된다. 또한, 본 발명은 휴대용 장치, 멀티프로세서 시스템, 마이크로프로세서-기반 또는 프로그래머블 소비자 전자장치, 미니컴퓨터, 메임프레임 컴퓨터 등을 포함하는 기 타 컴퓨터 시스템 구서을 이용하여 구현될 수 있다. 본 발명은 또한 통신망을 통해 링크되는 원격 프로세싱 장치들에 의해 타스크가 수행되는 분산 컴퓨팅 환경에서도 실시될 수 있다. 분산 컴퓨팅 환경에서, 프로그램 모듈은 로컬 및 원격 메모리 저장장치 모두에 위치할 수 있다.

도 1을 참조하면, 예시적인 시스템(10)은 처리 유니트(22), 시스템 메모리(24) 및 시스템 메모리(24)를 포함하는 다양한 시스템 컴포넌트들을 처리 유니트(22)에 연결시키는 시스템 버스(26)를 포함하는 전형적인 개인용 컴퓨터(20)를 포함한다. 시스템 버스(26)는 메모리 버스 또는 메모리 제어기, 주변장치 버스 및 다양한 종래의 버스 구조(예, PCI, VESA, ISA, EISA 등)를 이용하는 로컬 버스를 포함하는 여러 유형의 버스 구조를 포함한다.

시스템 메모리(24)는 ROM(28) 및 RAM(30)을 포함한다. 기본 입/출력 시스템(BIOS, 32)은, 예를 들어, 시스템 개시중에, 컴퓨터(20)내의 요소들간에 정보를 전송하는 것을 돕는 기본 루틴을 포함하고, 이는 ROM(28)에 저장된다. 컴퓨터(20)는 또한 하드디스크 드라이브(34), (리무부블 디스크(38)로부터/에 데이터를 읽고 기록하는)자기 디스크 드라이브(36), 광학 디스크 드라이브(40)(CD-ROM 디스크(42) 판독용 또는 다른 광학 매체에 기록/판독용)를 포함한다. 드라이브(34,36 40)는 각각 인터페이스(44,46,48)에 의해 시스템 버스(26)에 연결되어 있다.

드라이브(34,36,40) 및 그들에 연관된 컴퓨터-판독가능 매체(38,42)는 데이터, 데이터 구조 및 컴퓨터(20)용 컴퓨터-실행가능 명령어를 제공한다. 도 1의 저 장매체는 단순히 예시적인 것들이며 본 기술분야의 당업자들은 컴퓨터에 의해 판독가능한 기타 다른 유형의 매체들(예, 자기 카세트, 플래시 메모리 카드, 디지털 비디오 디스크 등)을 포함할 수 있음을 이해할 것이다.

운영체제(50), 하나 이상의 어플리케이션 프로그램(52), 기타 프로그램 모듈(54) 및 프로그램 데이터(56)를 포함하는 다수의 프로그램 모듈들이 드라이브(34,36 40) 및 RAM(30)에 저장될 수 있다. 사용자는 키보드(58) 및 입력장치(60, 예, 마우스, 마이크로폰, 조이스틱, 게임패드, 위성접시, 스캐너등)를 통해 명령 및 정보를 컴퓨터(20)에 입력할 수 있다. 이들 장치들(58, 60)은 버스(26)에 결합되는 포트 인터페이스(62, 예, 직렬포트, 병렬포트, 게임포트, 범용직렬포트(USB) 등)를 통해 처리 유니트(22)에 연결된다. 모니터(64) 또는 다른 유형의 디스플레이 장치가 또한 인터페이스(66, 예, 비디오 어댑터)를 통해 버스(26)에 연결된다.

컴퓨터(20)는 하나 이상의 원격 컴퓨터(40)로의 논리적 접속을 이용하는 네트워크 환경에서 작동될 수 있다. 원격 컴퓨터(68)는 서버, 라우터, 피어(peer) 장치 또는 기타 공통 네트워크 노드일 수 있으며, 컴퓨터(20)에 관련하여 설명되는 다수 또는 모든 요소를 일반적으로 포함하지만, 간략함을 위해 메모리 저장장치(70)만이 도시되어 있다. 도 1에 도시된 논리적 접속은 LAN(72) 및 WAN(74)를 포함한다. 이러한 네트워킹 환경은 사무실, 기업식 컴퓨터망, 인트라넷 및 인터넷에 흔히 이용된다.

LAN 네트워킹 환경에서 이용될 때, 컴퓨터(20)는 네트워크 인터페이스 또는 어댑터(76)를 통해 LAN(72)에 접속된다. WAN 네트워킹 환경에서 이용될때, 컴퓨터(20)는 인터넷과 같은 WAN(74)를 통해 접속을 확립하기 위해 모뎀(78) 또는 기타 수단을 전형적으로 포함한다. 모뎀(54)는 내장형 또는 외장형일 수 있으며, 이는 포트 인터페이스(62)를 통해 버스(26)에 연결된다. 네트워크 환경에서, 컴퓨터(20)에 관련하여 도시된 프로그램 모듈들, 또는 이들의 일부는 원격 메모리 저장장치(70)에 저장될 수 있다.

본 발명에 따른 방법에 대한 설명은 XML로부터 자바 객체 및 자바 객체로부터 XML로의 변환/매핑 측면에 기하여 이루어진다. 다른 유형의 데이터 포맷들도 또한 지원된다. 예를 들어, 다수의 레거시 비즈니스 어플리케이션들이 COBOL, C 및 PL1으로 기록된다. 이들 어플리케이션들은 CICS(범용 온라인 트랜잭션 처리 소프트웨어) 또는 IMS(Information Management System:정보관리시스템)와 같은 기업 정보 시스템(Enterprise Information system:EIS)에 상주하는 프로그램들로 구성된다. COBOL 프로그램들은 그들의 입출력을 위해 COBOL 구조를 이용한다. XML에서 COBOL로 COBOL에서 XML로 매핑할 필요가 있다. 본 발명은 이러한 매핑을 처리하는데 이용될 수 있는데, 여기서, (이하에서 설명될) XML에서 객체 X로의 매핑 핸들러가 XML 문서로부터 COBOL 구조(structure)를 파퓰레이트(populate)할 것이고, 객체 X에서 XML로의 매핑 핸들러는 XML 문서를 파퓰레이트하기 위해 템플릿에 의해 이용될 데이터를 COBOL 구조로부터 추출할 것이다.

백그라운드로서, 본 발명에 따른 매핑 방법은 이하의 상위수준 프로세스를 이용한다.

(a) 렉서(lexer)는 특정 시스템에 의해 인식되는 단어 또는 토큰으로 문자들을 그룹화함(토큰화라 함);

(b) 파서는 적법한 언어 구문(constructs)을 인식하기 위해 일군의 토큰들을 분석함;

(c) 코드 생성기는 일단의 적법한 언어 구문을 취하여 실행가능한 코드를 생성함.

(a) 내지 (c)에 의해 정의된 기능들은 상호 혼합될 수 있다.

예를 들어, XML에서 자바 객체 매핑을 위해, 시작 태그, 속성들, 끝 태그 및 "CDATA" 섹션들과 같은 적법한 XML 토큰들을 인식하기 위해 XML 문서의 모든 문자가 분석된다. 그런 후에, 토큰들은 그들이 적법한 XML 구문을 이루는지 검증되어야 한다. 가장 기본적인 레벨에서, 모든 태깅들은 정합하는 열림(opening) 및 닫힘(closing) 태그들을 가지며 속성들은 열림 태그내에서 적합하게 구조화된다. 문서 유형 정의(Document Type Definition:DTD) 또는 XML 스키마가 이용가능하면, 파싱 관정에서 발견된 XML 구문들이 DTD 또는 XML 스키마 측면에서 적법한지와 잘 정의된 XML인지를 확인할 수 있다. 최종적으로, XML 문서에 포함된 데이터들은 유용한 무언가를 달성하기 위해(즉, 그것을 자바 객체로 매핑하기 위해) 이용된다.

상기에서 식별된 타스크들 몇몇은, 적어도 일부는, 쉽게 이용가능한 XML 파서에 의해 수행될 수 있다. XML 파서들은 적법성 분석과 파싱 타스크를 처리한다. 두가지 예시적인 파싱 표준은 XML용 SAX(Simple Application Programming Interface)와 DOM(Document Object Model) API들이다.

SAX는 이벤트-기반이다. SAX를 구현한 XML 파서들은 파싱된 XML 문서에서 발견되는 상이한 특징들에 대응하는 이벤트들을 생성한다. DOM API는 객체-모델-기반 API이다. DOM을 구현한 XML 파서들은 XML 문서의 콘텐츠를 나타내는 일반적인 객체 모델을 메모리에 생성한다. XML 파서가 파싱을 완료하면, 메모리는 XML 문서의 구조 및 컨텐츠에 대한 정보를 제공하는 DOM 객체 트리를 포함한다.

도 2는 본 발명의 실시예에 따른 프레임워크(100)의 개략적인 표현이다. 프레임워크(100)는 도 1의 시스템(10)에서 실행될 수 있는 서브렛과 같은 통합 컴포넌트(102)내에 인스턴스화된 것으로 도시되어 있다. 통합 컴포넌트(102)는, 예를 들어, DOM 또는 SAX를 이용하여 구현되는 파서(104)를 포함하는데, 이는 XML-객체 매핑 모듈(106)과 상호작용한다. 명료함을 위해, 본 발명의 구현 실시예를 설명하는데 있어서 파서(104)의 예로서 SAX가 설명될 것이다.

XML-객체 매핑 모듈(106)은 입력 XML 문서(108)을 수신하고 출력 자바 객체(110)를 생성한다. 통합 컴포넌트(102)는 또한 객체-XML 매핑 모듈(114)과 통신하는 XML 문서 템플릿 모듈(112, 예, 자바서버 페이지-JSP 기술에 기초함)을 포함한다. 객체-XML 매핑 모듈(114)은 입력 자바 객체(116)를 수신하고 출력 XML 문서(118)를 생성한다.

XML에서 소프트웨어 객체로의 매핑

도 2를 참조하면, XML-객체 매핑 모듈(106)은 다음의 컴포넌트들을 포함한다.

(a) 입력 XML 문서(108)를 구현하기 위한 입력 소스 클래스(106-1, XML2xInputSource);

(b) 파서(104)에 의해 생성된 SAX 이벤트들용 버퍼를 구현하기 위한 버퍼화된 콘텐트 핸들러 클래스(106-2, XML2xBufferedContenHandler);

(c) 매핑을 실행하고 입력 및 출력 타겟 스트림을 설정하기 위한 매핑 인터페이스(106-3,XML2xMapping); 및

(d) 입력 XML 문서(108)로부터 출력 자바 객체(110)에 매핑시키기 위한 방법을 제공하는 매핑 클래스(106-4, XML2xMappingImpl).

다양한 인터페이스 및 클래스들에 대한 상세사항은 이하에서 설명된다. 용어 "클래스" 및 "인터페이스"는 자바에서 특별한 의미를 갖는다. 자바 클래스(추상(abstract), 내부(inner) 또는 최종(final))는 특정 객체를 정의하는 데이터 멤버들 및 메소드(method)의 집합이고, 자바 인터페이스는 그들을 구현하는 클래스에 대해 특정 기능성을 부과하는데 이용된다(즉, 인터페이스는 클래스들이 하여야 하는 것을 지정한다). 또한, 인터페이스는 인터페이스를 구현하는 클래스들에 의해 이용될 수 있는 상수를 제공하는데도 이용될 수 있다. 인터페이스는 일정한 변수들 및 메소드 정의를 포함하지만, 메소드의 구현은 인터페이스를 구현하는 클래스에 남겨진다. 클래스는 임의 개수의 인터페이스들을 구현할 수 있다.

표 M106-1은 입력 소스 클래스(106-1,XML2xInputSource)의 주요 함수들(즉, 전부는 아님)을 요약한 것이다.

XML2xInputSource는 XML 문서가 바이트 스트림, 문자 스트림 또는 XML2xBufferedContentHandler(106-2)로부터 판독될 수 있도록 이용된다.

함수	설명
available()	차단없이 입력 스트림으로부터 판독될 수 있는 바이트 수를 리턴한다.
getBufferedHandler()	SAX 이벤트 버퍼링된 핸들러를 얻는다.
getByteStream()	바이트 스트림을 리턴한다.
getCharacterStream()	문자 스트림 리더를 리턴한다.
read()	이 입력 스트림으로부터 데이터의 다음 바이트를 판독한다.
skip()	이 입력 스트림으로부터 입력 바이트를 스킵한다.

표 M106-2는 버퍼화된 콘텐트 핸들러 클래스(106-2, XML2xBufferedContenHandler)의 주요 함수들(즉, 전부는 아님)을 요약한 것이다. 핸들러 클래스(106-2)는 파서(104)로부터 SAX 이벤트들을 버퍼링하는 콘텐트 핸들러를 또한 포함한다. 이는 이벤트들이 재생될(replayed) 수 있도록 해준다. 이러한 특징들이 유용한 예는 XML 문서의 상이한 부분들을 위해 상이한 매핑 핸들러들이 이용되는 경우이다. 구현예는 단순 객체 액세스 프로토콜(Simple Object Access Protocol:SOAP)이다.

삭제

함수	설명
characters(char[] ch, int start, int length)	메소드 코멘트, ch는 XML 문서(108)의 문자들이고, start는 배열의 시작 위치이고, length는 배열로부터 판독될 문자 개수이다.
parse()	버퍼의 SAX 이벤트들을 실행한다.

SOAP는 분산화된 환경에서 정보 교환을 위한 경량의 프로토콜이다. (1) 메시지내에 무엇이 있고 그것을 어떻게 처리해야 하는지에 대해 기술하기 위한 프레임워크를 정의하는 인벨로프(envelope), (2)어플리케이션-정의 데이터 유형의 인스턴스를 나타내기 위한 일단의 인코딩 규칙들, 및 (3) 원격 프로시져 호출 및 응답을 표현하기 위한 규약(convention)의 세가지 부분으로 구성되는 XML-기반 프로토콜이다. SOAP 메시지는 강제적인 SOAP 인벨로프, 선택적 SOAP 헤더 및 강제적인 SOAP 본체로 구성되는 XML 문서이다. 이러한 상황에서, 인벨로프 및 본체에 대해 상이한 매핑 핸들러를 사용하는 것이 가능하다.

표 M106-3은 매핑 인터페이스(106-3, XML2xMapping)의 주요 함수들(즉, 전부는 아님)을 요약한 것이다. XML2xMapping은 매핑을 실행하고 입력스트림의 구성을 허용한다.

함수	설명
execute()	입력 XML 문서(108)로부터 포맷을 생성할 매핑을 수행한다. execute()의 전체예는 이하에 제공된다.
setInputStream()	입력 스트림을 설정한다. 즉, 매핑될 입력 XML 문서(108)의 소스를 지정한다.

표 M106-4는 매핑 클래스 106-4(XML2xMappingImpl)의 주요 함수들(즉, 전부는 아님)을 요약한 것이다. 클래스 및 인터페이스에 관하여 전술한 바와 같이, XML2xMappingImpl 클래스는 직접 이용되는 것이 아니라, 매핑 대상이 되는 입력 XML 문서(108)의 문서 정의 유형 및 그것이 매핑되는 출력 자바 객체(110)에 따라적절한 메소드에 추가되는 컨텐트로써 서브-클래스화된다.

함수	설명
EndElement()	요소 종료에 대한 통지를 수신한다.파서(104)는 입력 XML 문서(108)의 모든 요소들 끝에서 이 메소드를 불러낸다. 요소가 공백인 경우에도, 모든 endElement에 대해 대응하는 startElement()가 있다.
execute()	입력 XML 문서(108)로부터 포맷을 생성할 매핑을 수행한다.
setDocumentLocator()	SAX 문서 이벤트의 근원을 로케이팅하기 위한 객체를 수신한다.
setInputStream()	입력 스트림을 설정한다. 매핑될 입력 XML 문서(108)의 소스를 지정한다.
startElemet()	요소의 시작에 대한 통지를 수신한다. 파서(104)는 입력 XML 문서(108)의 모든 요소들의 처음에서 이 메소드를 불러낸다. 요소가 공백인 경우에도, 모든 startElement에 대해 대응하는 endElement()가 있다. 대응하는 endElement() 이벤트 이전에 모든 요소들의 콘텐트가 순서대로 보고된다.

도 3을 참조하면, 방법(300)이 XML 문서(108)를 소프트웨어 객체(110, 예, 자바 빈)으로 매핑시키기 위해 수행되는 다음의 일반적인 단계들을 도시하며 설명된다.

(a) 단계(302)에서 XML로부터 객체 X로의 매핑을 구현하기 위하여 매핑 인터페이스 (106-4)(예, XML2xMapping)의 인스턴스를 획득한다.

(b) 단계(304)에서 매핑 인터페이스(106-4)를 호출하고(invoke), 단계(306)에서 입력 XML 문서(108)를 공급한다.

(c) 매핑 인터페이스(106-4)는 단계(308)에서 이벤트 파서(예, 파서(104))의인스턴스를 획득하고, 단계(310)에서 콘텐트 핸들러로서(예, 버퍼화된 콘텐트 핸들러 클래스 106-2) 매핑 인터페이스(106-4)를 등록한다.

(d) 단계(312)에서 XML 문서(108)에 대해 파서(104)를 호출한다(즉, 문서의 파싱을 시작한다).

(e) 단계(d)가 수행되면, 단계(314)에서 다양한 메소드(예, 문서시작(startDocument), 요소시작(startElement), 문자, 요소종료(endElement), 문서종료(endDocument) 등)를 호출하는 매핑 인터페이스(106-4)로의 콜백(call back)이 발생한다.

(f) 문서시작 및/또는 요소시작 메소드의 경우에, 단계(316)에서, 매핑 인터페이스 (106-4)는 소프트웨어 객체(110)를 생성한다.

(g) 요소끝 메소드의 경우에, 단계(318)에서, 매핑 인터페이스 106-4는 소프트웨어 객체(110)로 요소들을 세팅한다.

전술한 바와 같이, SAX API는 본 기술분야에 공지된 다양한 사양서를 포함한다. 본 발명은 "콘텐트핸들러(ContentHandler)" 인터페이스를 구현하는 클래스를 생성하는 것에 관련되어 있으며, 이는 SAX 이벤트가 XML 문서내에서 발견될 때 이들을 프로그램에 통지하기 위해 XML 파서에 의해 이용되는 콜백 인터페이스이다. 이 인터페이스는 XML2xBufferContentHandler 클래스(106-2) 및 XML2xInputSource 클래스(106-1)과 함께 이용된다. 또한, SAX API는 "콘텐트핸들러" 인터페이스를 위한 "디폴트핸들러(DefaultHandler)" 구현 클래스를 제공한다. 이하에서 설명되는 "XML-JAVA 고객(CUSTOMER)" 예는 고객 XML 문서로부터 고객 자바빈(Java Bean)을 생성하기 위해 "디폴트핸들러"를 확장한다.

예 I

XML-JAVA 고객

다음의 컴포넌트들이 예 I의 부분이다.

(A) customer.xml: 입력 XML 문서(108) 샘플.

(B) XML2CustomerMapping.java: 파서(104)가 콜백을 수행하는 핸들러 클래스 (106-2). 이는 고객 객체를 구성하고 그의 값을 설정하기 위한 명령어들을 포함한다.

(C) execute.java: XML에서 자바로, 자바에서 XML(예 II)로의 매핑을 수행하기 위해 이용되는 매핑 클래스/인터페이스(106-3, 106-4)의 프로그램.

(D) customer.java: 출력 고객 자바빈(110),

(E)CustomerSymbols.java: 정수 상수 및 해쉬맵(hashmap)을 포함한다. 해쉬맵은 태그 명칭들을 XML2CustomerMapping.java에서 이용하기 위한 정수 상수로 매핑하는데 이용된다.

A. 입력 XML 문서(customer.xml)은 다음과 같이 제공된다.

//START customer.xml

<?xml version="1.0"?>

<FirstN~me>Jane</FirstName>

</customer>

//END customer.xml

B. 고객 객체를 구성하고 그것에 값들을 설정하기 위한 프로그램(XML2CustmerMapping.java)(즉, 이벤트 파서가 콜백하는 핸들러)가 어느 정도 간결하게 축약된 형태로 다음과 같이 제공된다.

//START XML2CustomerMapping.java

public class XML2CustoraerMapping extends

com.xxx.xml2xmapping.XML2xMappinglmpl{

private StringBuffer fieldCurrentQualifiedElementName = new StringBuffer ("");

private Customer fieldCustomer;

private Stack elemnentStack;

* XMLCustomerlnfo2RecordCuStomerInfoMapper constructor comment.

public XML2CustomerMapping() {

super();

elementStack = new Stack();

}

*characters method comment.

public void characters(char[] ch, int start, int length) throws org.xml.sax.SAXException{

switch (this.fieldCurrentElementSymbol){

case CustomerSymbols. CUSTOMER_FIRSTNAME: case CustomerSymbols. CUSTOMER_LASTNAME:

case CustomerSymbols.CUSTOMER-ID:

{(StringBuffer)elementStack.lastElement()).

append(ch,start,length );

break;

}

* endElement method comment.

public void endElement(String namespaceURl, String localName, String rawName) throws org.xml.sax.SAXException {

String symbolName;

if (namespaceURl. equals ("")) symbolName = rawName; else symbolName = namespaceURl + "_" + localName;

this.fieldCurrentElementSymbol =

CustomerSymbols.getSymbol (symbolName);

II Get the value

String value =

((StringBuffer)elementStack.pop()).tostring();

switch (this.fieldCurrentElementSymbol) {

case CustomerSymbols. CUSTOMER_FIRSTNAME: {

this.fieldCustomer.setFirstName(value);

break;

}

case CustomerSymbols. CUSTOMER_LASTNAME: { this.fieldCustomer.setLastName (value);

break;

}

case CustomerSymbols. CUSTOMER_ID: { this.fieldCustomer.setId(value);

break;

}

this.fieldCurrentElementSymbol = 0;

}

*@return com.xxx.connector.mapping.xml.test.Customer

public Customer getCustomer(){

return this.fieldCustomer;

}

*startElement method comment.

public void startElement(String namespaceURl,

String localName, String rawName, org.xml.sax.Attributes atts) throws org.xml.sax.SAXException {

String symbolName;

if (namespaceURl.equals("")) symbolName = rawName; else symbolName = namespaceURl + "" + localName;

this.fieldCurrentElementSymbol =

CustomerSymbol. getSymbol (symbolName);

elementStack.push(new StringBuffer());

switch (this.fieldCurrentElementSymbol) {

case CustomerSymbols.CUSTOMER:{ this.fieldCustomer = new Customer();

break;

}

//END XML2CustomerMapping.java

C. XML에서 자바로의 매핑 (및 이하의 예 II에 설명되는 바와 같이 자바에서 XML로의 매핑)을 실행하는데 이용되는, 간결하게 축약된, 프로그램(execute.java).

//START execute.java

package com.xxx.xml2xmapping.sample.customer;

import java.io.*;

import org.xml.sax.*;

public class Execute {

* Execute constructor comment.

public Execute() {

super();

}

* Starts the application.

* @param args an array of command-line arguments

public static void main(java.lang.string[] args) {

int numIterations = l;

XML2CustomerMapping inMapping = new XML2CustomerMapping();

Customer2XMLMapping outEventBasedMapping = new

Customer2XMLMapping();

// Create the XML2Customer handler and the Customer2XML handler

XML2CustomerMapping in Mapping = new XML2CustomerMapping();

Customer2XMLMapping outEventBasedMapping = new

Customer2XMLMapping();

// read in the customer.xml file

ByteArrayInputStream inStream = null;

try {

FileInputStream fileInputStream = new

FileInputStream("customer.xml");

byte[] bytes = new byte[fileInputStream.available()];

fileInputStream.read(bytes, 0,

fileInputStream.available());

inStream = new ByteArrayInputStream(bytes);

} catch (Exception e) {

e.printStackTrace();

}

ByteArrayOutputStream outStream = new

ByteArrayOutputStream();

try {

long ts = System.correntTimeMillis();

for (int i=0; i<numIterations; i++) {

// inbound mapping

// map from XML document to customer Java Bean

inStream.reset();

inMapping.setInputStream(inStream);

inMapping.execute();

// some execution, here a connector would be called

// get the customer object and print its contents

Customer aCustomer = inMapping.getCustomer();

System.out.println("First name from XML document is

"+aCustomer.getFirstName());

System.out.println("Last nae from XML documents is

"+aCustomer.getLastName());

System.out.println("Customer id from XML document is

"+aCustomer.getId());

// Change the values on the customer object

aCustomer.setFirstName("James");

aCustomer.setLastName("Bond");

aCustomer.setId(007");

// outbound mapping

// map from Java to XML

outEventBasedMapping.setCustomer(aCustomer);

// outEventBasedMapping.setOutputStream(outStream);

outEventBasedMapping.setOutputStream(System.out);

outEventBasedMapping.execute();

}

long te = System.currentTimeMillis();

System.out.println("Average time "+(te-

ts)/numIterations+"ms.");

} catch (Exception e) {

e.printStackTrace();

}

//END execute.java***

D. 고객 자바 빈(customer.java)가 다음에 기재된다. 자바 빈은 본 기술분야에 공지된 표준 설계 구조를 따르는 재사용가능한 컴포넌트이다. 빈은 실행시간에 보이거나 보이지 않을수도 있는 클래스 객체이다. 자바빈은 컴포넌트를 개발하기 위한 컴포넌트 구조, 표준 프레임워크를 제공한다.

//START customer.java

package com.xxx.xml2xmapping.sample.customer;

public class Customer {

private java.lang.String fieldFirstName = new String();

private java.lang.String fieldLastName = new String();

private java.lang.String fieldId = new String();

* Customer constructor comment.

public Customer() {

super();

}

* Gets the firstName property (java.lang.String) value.

* @return The firstName property value.

* @see #setFirstName

public java.lang.String getFirstName() {

return fieldFirstName;

}

* Gets the id property (java.lang.String) value.

* @ruturn The id property value.

* @see #setId

public java.lang.String getId() {

ruturn fieldId;

}

* Gets the lastName property (java.lang.String) value.

* @ruturn The lastName property value.

* @see #setLastName

public java.lang.String getLastName() {

ruturn fieldLastName;

}

* Sets the firstName property (java.lang.String) value.

* @param firstName The new value fir the property.

* @see #getFirstName

public void setFirstName(java.lang.String firstName) {

fieldFirstName = firstName;

}

/

* Sets the id property (java.lang.String) value.

* @param id The new value for the property.

* @see #getId

public void setId(java.lang.String id) {

fieldId = id;

}

* Sets the lastName property (java.lang.String) value.

* @param lastName The new value for the property.

* @see #getLastName

Public void setLastName(java.lang.String lastName) {

fieldLastName = lastName;

}

//END customer.java

예 I에 도시된 바와 같이, 파서(104)가 모든 시작, 요소들 및 종료 태그들에 대한 이벤트들을 처리하고, 이는 이벤트의 추적을 향상시키기 때문에 XML에서 자바로의 매핑은 효율적이다.

또다른 예로서, 단일의 고객 XML 문서를 고객 배열로 확장시키는 것을 고려해본다. 고객 자바빈의 배열을 생성하기 위해 다음 절차를 따른다.

(i) 벡터 생성을 위해 고객용 startElement를 이용한다.

(ii) 각각의 고객에 대한 startElement에서, 고객 객체를 생성한다.

(iii) 고객 객체를 파퓰레이트하기 위해 FirstName, LastName 및 CustID에 대한 startElement, getElement, endElement를 이용한다. 고객 객체를 벡터에 삽입하기 위해 고객에 대한 endElement를 이용하고, 벡터로부터 고객 배열을 생성하고 그것을 작동하는 자바 객체로 세팅하기 위해 고객에 대한 endElement를 이용한다.

재귀적 XML 구조(즉, 리스트의 리스트를 나타내는 XML 문서)를 위해 파서(104)에 의해 스택이 유지된다. 각각의 startElement에 대해, 객체가 생성된 다. 스택은 필요한 상태를 유지하기 위해 이용될 수 있다. 자식 요소가 일단 생성되면, 이는 그의 부모 객체내로 세팅될 수 있다.

소프트웨어 객체에서 XML로의 매핑

도 2를 참조하면, 객체-XML 매핑 모듈(114)는 다음의 컴포넌트들을 포함한다.

(a) 파싱 이벤트들을 관리하기 위한 핸들러 인터페이스(114-1)(X2XMLHandler);

(b) 매핑을 실행하고 출력 타겟 스트림을 설정하기 위한 매핑 인터페이스 (114-2)(X2XMLMapping).

(c) 입력 자바 객체(116)로부터 출력 XML 문서(118)로의 매핑 수행을 위한 방법을 제공하는 매핑 클래스(114-3)(X2XML MappingImpl).

(d) 출력 XML 문서(118)를 구현하는 출력 타겟 클래스(114-4)(X2XMLOutputTarget).

표 M114-1은 핸들러 인터페이스(114-1)(X2XMLHandler)의 주요 함수들(즉,전부는 아님)을 요약한 것이다. 매핑 모듈(114)은 인터페이스(114-1)를 구현하고 JSP 컨테이너로 인스턴스를 등록한다. 문서 템플릿(112)은 요소 값을 얻기 위해 요소의 시작 및 종료와 같은 기본적인 문서 관련 이벤트들을 위해 매핑 모듈(114)에 대한 콜백을 수행한다.

함수	설명
getElementValue()	요소의 값을 리턴한다. 이는 시작 및 끝 요소 태그의 범위내에 있지 않은 단순 유형으로 작업하는 경우에 이용된다.
endElement()	요소의 끝에 대한 통지를 수신한다. 이는 복잡한 유형으로 작업할때 상태를 유지하기 위해 이용된다.
getElementAttribute()	지정된 속성값을 리턴한다. 이는 시작 및 끝 요소 태그들의 범위에 있는 복잡 유형으로 작업하는 경우에 이용된다.
getElementRepitions()	반복적인 요소의 경우에, 반복 회수를 리턴한다.
isOptionalAttributePresent()	선택적 속성이 존재하면 참값을 리턴한다. 그렇지 않으면 거짓을 리턴한다. 이는 XML 문서(118)의 선택적 소성을 위해 명칭 및 값이 생성되는지 여부를 제어하기 위해 XML 문서 템플릿(JSP,112)에서 이용된다.
startElement()	요소 처음에 대한 통지를 수신한다. 이는 복잡한 유형으로 작업할때 상태를 유지하기 위해 이용된다.

일반적으로, 컨테이너는 컴포넌트들에게 생존기간 관리, 보안, 개발 및 실행시간 서비스를 제공하는 개체이다. 컴포넌트-특정 서비스를 제공하는 다양한 구체적인 유형의 컨테이너들(웹, JSP, 서브렛, 애플릿 등)이 있다. 서블렛 컨테이너는 요청 및 응답이 전송되는 네트워크 서비스를 제공하고, 요청을 디코드하고,응답을 포맷하는 컨테이너이다. JSP 컨테이너는 서블렛 컨테이너와 동일한 서비스를 제공하는 컨테이너이며, JSP 페이지들을 서블렛으로 해석하고 처리하는 엔진이다. X2XML핸들러(114-1)는 파서(104)에 의해 생성되는 파싱 이벤트들의 미러(mirror) 이미지(동일하지는 않음)를 제공한다. 결과적으로, 파서(104)에 의해 제공되는 구조는 X2XML로부터의 경로내에 미러링된다.

파서(104)가 SAX를 이용하여 구현되면, 이벤트들은 그들을 처리하는 핸들러 106-2(즉, 콜백 메커니즘)에 의해 수신된다. 이러한 예에서, 핸들러 106-2는 자바 클래스를 파퓰레이트하기 위해 이용된다.

템플릿(112)이 호출되면, 그것은 X2XMLHandler 인터페이스 114-1에 콜백한다. 핸들러(114-1)은 요청된 데이터를 획득하고 파싱 상태를 유지함으로써 콜백을 처리한다.

핸들러 인터페이스(114-1)은 XML-객체 매핑 모듈(106)에 의해 수행되는 다양한 기능들 측면에서 유사하지만, 특정한 차이점들이 있다. 요소 명칭이 생성되거나 직접 코딩되며, "명칭공간(namespace)" 지원을 이용하여써 스키마로부터 취해지지 않는다. 요소 명칭은 각 요소에 대해 특정하게 만들어질 수 있다. 따라서, startElement 및 endElement 메소들에 대해 단지 명칭 파라미터만이 필요하다. XML-객체 매핑 모듈(106)에 의해 매핑이 수행될 때, 입력 소스 클래스 106-1(즉, XMLReader)는 스트링으로서 요소 명칭을 리턴한다. 매핑 클래스/인터페이스 106-3에서, 요소 명칭은 특정 번호로 한쌍이 된다. 이 번호는 요소의 처리를 제어하기 위해 전환문에서 이용된다. 객체-XML 모듈(114)에서, 요소 명칭을 정수 상수로 정의함으로써 처리가 최적화되고 코딩 지원이 개선된다. 따라서, 이들 메소드들에 대한 콜백은 스트링 대신에 정수 상수를 이용한다.

핸들러 인터페이스(114-1)내의 이벤트 순서는 객체(116) 자체 내의 정보 순서를 미러링한다.

XML 문서 템플릿(112,자바서버 페이지(JavaServer Pages:JSP) 기술을 이용하여 기록됨)은 이하에서 설명되는 코딩 스타일을 이용한다. JSP 기술은 사용자 콘텐트 생성으로부터 사용자 인터페이스를 분리시켜서 기초가 되는 동적 콘텐트의 변경없이도 전체 페이지 레이아웃을 변경시킬 수 있도록 해준다. 자바서버 페이지는 본 기술분야의 당업자들에 공지된 자바 서블렛 기술의 확장이다.

XML 문서 템플릿 112-JSP 코딩 스타일 예

문서(118)에 대한 시작 및 종료 태그들 및 복잡한 유형에 대해 콜백이 코딩된다. 이는 핸들러 114-1로 하여금 상태를 유지할 수 있도록 해준다. JSP　XML 문서 템플릿(112)에서, 시작 및 종료 태그들은 직접 코딩되어 타겟 출력 스트림에 향하도록 할 수 있다. 간단한 유형으로 작업할 때에, 콜백은 코딩될 필요없지만, 시작 및 종료 태그들은 여전히 코딩되어 타겟 출력 스트림으로 향햐도록 할 것이다.

복잡하거나 간단한 유형이 선택적이라면, 선택적 요소의 생성여부를 제어하기 위해 템플릿(112) 내의 조건절에서 OptionalElementPresent()가 이용된다.

속성이 선택적이라면 복잡한 유형에서는 OptionalAttributePresent(int attributeName)이 이용되고, 단순 유형에서는 OptionalAttributePresent(int elementName, int attributeName)이 이용된다. 요소 유형이 반복되는 단순 유형이라면, 그것이 isOptionalAttributePresent(int index, int elementName, intattributeName) 메소드를 이용하는 선택적 속성을 포함하는지를 판단한다. 반복적인 요소들에 대해, 반복되는 요소 개수를 얻기 위해 getElementRepetions 메소드가 이용된다. 이는 각가의 요소를 처리하기 위한 루프를 템플릿(112) 내에 구성하기 위해 이용된다. 단순 유형의 경우에, 템플릿(112)은 시작 및 종료 태그를 포함하여야 하며 값을 얻기 위해 getElementValue(int index, int elementName)을 호출한다. 복잡한 유형의 경우에, 상태가 유지되어야 하기 때문에, 템플릿(112)은 startElement(int index, int elementName) 및 endElement(int index, int elementName) 메소드들을 호출하여야 한다.

표 M114-2는 매핑 인터페이스(114-2)(X2XMLMapping)의 주요 함수들(즉, 전부는 아님)을 요약한 것이다. 매핑 인터페이스(114-2)는 (자바와 XML간의) 매핑 기능을 실행하고 출력 타겟 스트림을 설정한다. 매핑 인터페이스(114-2)는 핸들러 인터페이스(114-1)을 확장시키고, 이는 출력 XML 문서(117)을 생성하는데 필요하 콜백 메소드들을 문서 템플릿(112)에 제공한다.

함수	설명
execute()	출력 XML 문서(118)를 생성할 매핑을 수행한다.
setOutputStream()	출력 XML 문서(118)이 생성될 출력 스트림을 설정한다.

표 M114-3은 매핑 클래스(114-3)(X2XMLMappingImpl)의 주요 함수들(즉, 전부는 아님)을 요약한 것이다. 매핑 클래스(114-3)은 입력된 자바 객체(116)을 출력 XML 문서(118)로 매핑하기 위한 메소드들을 제공한다. 클래스 및 인터페이스의 정의와 관련하여 전술한 바와 같이, X2XMLMappingImpl 클래스(114-3)은 직접 이용되지 않고, 매핑될 출력 XML 문서(118)의 문서 유형 정의 및 매핑 대상인 입력 자바 객체(116)에 따라 적절한 메소드에 추가되는 콘텐트로 부-클래스화된다.

표 M114-4는 출력 타겟 클래스(114-4)(X2XMLOutputTarget)의 주요 함수들(즉, 전부는 아님)을 요약한 것이다.

X2XMLOutputTarget 클래스(114-4)는 XML 문서(118)이 바이트 스트림 또는 문자 스트림으로 기록되도록 해준다. 클래스(114-4)는 바이트 스트림이 서블렛의 출력 스트림으로 타겟화되도록 해줌으로써 최적화를 제공한다. 따라서, XML 문서(118)는 출력되기 이전에 버퍼링되지 않는다.

함수	설명
close()	출력 스트림을 닫고 이 스트림과 연관된 임의의 시스템 자원을 해제한다.
flush()	출력 스트림을 플러시하고 임의의 버퍼링된 출력 바이트가 기록되도록 한다.
write()	지정된 바이트 배열로부터의 바이트를 출력 스트림에 작성한다.

요약하면, X2XMLMappingImpl 클래스(114-3)은 X2XMLMapping 인터페이스(114-2)를 구현한다. X2XMLMapping 인터페이스(114-2)는 X2XMLHandler 인퍼테이스(114-1)을 확장시킨다. 따라서, X2XMLMappingImpl 클래스(114-3)은 X2XMLHandler 인퍼테이스(114-1)에서 정의된 메소드들을 구현한다.

도 4를 참조하면, 방법(400)은 소프트웨어 객체(116 예, 자바빈)을 XML 문서(118)로 매핑시키기 위해 수행되는 이하의 일반적인 단계들로 도시되어 설명된다.

(a) 단계(402)에서, 입력된 객체 X(116)를 출력 XML 문서(118)로 매핑하는 것을 구현하기 위한 매핑 인터페이스(114-2)(예, X2XMLMapping)의 인스턴스를 획득 한다.

(b) 단계(404)에서, 매핑 인터페이스(114-3)에 소프트웨어 객체(116) 및 XML 문서(118)용 출력 스트림을 설정한다.

(c) 단계(406)에서, 매핑 인터페이스(114-2)를 호출한다.

(d) 단계(408)에서, JSP 콘테이너를 생성한다.

(e) 단계(410)에서, 매핑 인터페이스(114-2)는 XML 문서(118)를 생성할 JSP 콘테이너를 JSP XML 템플릿(112)를 이용하여 호출한다.

(f) 단계(412)에서, JSP　콘테이너는 JSP XML 템플릿(112)를 컴파일하고 실행시킨다.

(g) 컴파일된 JSP XML 템플릿(112)은 단계(414)에서 (단계(404)에서) 지정된 출력 스트림에 XML 문서(118)를 기록하기 시작한다.

(h) 단계(416)에서, 요소/속성 데이터 및 시작/종료 태그들에 대해 적절한 때에, 컴파일된 JSP XML 템플릿(112)은 매핑 인터페이스(114-2)에 대한 콜백을 수행하여 처리 상태를 유지하고 출력 XML 문서에 데이터를 추가한다(데이터는 소프트웨어 객체(116)로부터 회수된 것이다).

(i) 단계(418)에서, 컴파일된 JSP XML 템플릿(112)은 XML 문서의 특정 부분이 생성되어야 하는지를 판단하기 위해 isOptionalElementPresent 메소드 또는 isOptionalAttributePresent 메소드를 호출한다.

(j) 단계(420)에서, JSP XML 템플릿(112)은 XML 문서으 일정 부분들의 생성에 대해 몇 번 루핑이 수행되어야 하는지를 판단하기 위해 getElementRepetitons을 콜백한다.

(k) 단계(422)에서 처리 상태는 스택에 의해 유지된다. 이는 배열이 발생하거나, 재귀적 반복(recursion)이 발생하거나, 복잡한 유형이 또다른 복잡한 유형내에 포함되는 복잡한 유형들을 XML 문서내에 생성할 때 유용하다.

자바에서 XML로의 매핑은 XML 문서 템플릿(112)을 이용하는데, 이는 (적어도 복잡한 객체에 대해) 이벤트들을 처리하는 파서(104)에 의해 부과되는 유사한 표준으로 코딩된다. 예를 들어, 복잡한 유형의 경우에, 시작 및 종료 태그들은 코딩되어야 한다( 단순한 유형에서는 필요하지 않다). 이하에서 설명되는 예 II "자바-XML 고객"는 입력된 고객 자바 객체로부터 출력 고객 XML 문서를 생성한다.

예 II

자바-XML 고객

다음의 컴포넌트들이 예 II의 일부이다.

(A) Customer2XMLMapping.java: 출력 XML 문서(118)를 파퓰레이트하기 위해 입력된 고객 자바 객체(116)로부터 값을 획득하기 위해 JSP(112)가 호출하는 핸들러 클래스(114-1).

(B) customer.jsp: 출력된 XML 문서(118)를 생성하기 위해 이용되는 JSP　템플릿(112).

(C) CustomerSymbols.java: 상수 및 해쉬맵을 포함한다. 해쉬맵은 태그명칭을 정수 상수로 매핑하는데 이용된다. JSP 템플릿(112)은 정수 상수를 이용한다. (D) execute.java: 자바를 XML로, XML을 자바로의(예 I의 항목 C에서 제공 됨) 매핑을 실행시키기 위해 이용되는 매핑 클래스/인터페이스 114-2, 114-3의 프로그램.

A. 입력 자바 객체로부터 XML 문서를 구성하기 위한, 간결하게 축소된 형태의 프로그램(Customer2XMLMapping.java)

//START Customer2XMLMapping.java

package com.xxx.xml2xmapping.sample.customer;

import java.util.*;

import com.ibm.xml2xmapping.util.*;

public class Customer2XMLMapping extends

com.xxx.xml2xmapping.X2XMLMappingImpl {

private Customer fieldCustomer;

/**

* Customer2XMLMapping constructor comment.

*/

public Customer2XMLMapping() {

super();

fieldPageName="customer.jsp";

}

/**

* getElementRepetitions method comment.

*/

public int getElementRepetjtions(int name) {

switch (name){

}

return 0;

}

/**

*getElementValue method comment.

*/

public String getElementValue(int name) {

switch (name){

case CustomerSymbols.CUSTOMER-FIRSTNAME: {

return this.fieldCustomer.getFirstName();

}

case Customersymbols.CUSTOMER-LastNAME : {

return this.fieldCustomer.getLastName();

}

case Customersymbols.CUSTOMER-ID: {

return this.fieldCustomer.getId();

}

return "";

}

* getElementValue method comment.

public String getElementValue(int index, int name) {

switch (name) {

}

return""; "

}

* @param aCustomer

com.xxx.xml2xmapping.sample.customer.Customer

public void setCustomer(Customer aCustomer) {

this.fieldCustomer = aCustomer;

}

//End Customer2XMLmapping.java

B. 간결하게 축소된 형태의 모듈(112)을 위한 JSP 내의 문서 템플릿(Customer.jsp).

//START Customer.jsp

<%@ page import= "com.ibm.xml2xmapping.*"%>

<%@ page

import="com.ibm.xml2xmapping.sample.customer.CustomerSymbols"

%>

<%X2XMLHandler handler =

(x2XMLHandler)request.getAttribute("com.ibm.xml2xmapping.X2XMLHandler");

handler.setWriter(out);%>

<?xml version="1.0"?>

<FirstName<>%=handler.getElementValue(CustomerSymbols.CUSTOMER_FIRSTNAM E) %></FirstName>

<LastName<>%=handler.getElementValue(CustomerSymbols.CUSTOMER_LASTNAME) %></LastName>

<CustID<>%=handler.getElementValue(CustomerSymbols.CUSTOMER_ID) %></CustId>

</customer>

//END Customer.jsp

C. 간결하게 축소된 형태의, customer.jsp에 의해 이용되는 해쉬맵 및 상수들의 프로그램(Customersymbols.java)

//START Customersymbols.java

package com.xxx.xml2xmapping.sample.customer;

import java.util.HashMap;

public class CustomerSymbols {

public static final int CUSTOMER =1;

public static final int CUSTOMER_FIRSTNAME =2;

public static final int CUSTOMER_LASTNAME =3;

public static final int CUSTOMER_ID =4;

private static CustomerSymbols fieldInstance;

private HashMap fieldName2SymbolDictionary;

private static Object anObject= new Object();

* CustomerlnfoElementSymbols constructor comment.

private CustomerSymbols()

super 0;

this.fieldName2SymbolDictionary= new HashMap();

this.fieldName2SymbolDictionary.put("customer",

new Integer (CustomerSymbols. CUSTOMER));

this.fieldName2SymbolDictionaiy.put("FirstNarne", new Integer (CustomerSymbols. CUSTOMER_FIRSTNAME));

this.fieldName2SymbolDictionary.put("LastName", new Integer (CustomerSymbols. CUSTOMER_LASTNAME));

this.fieldName2SymbolDictionary.put ("CustId", new

Integer (CustomerSymbols. CUSTOMER_ID));

}

@return int

*@param elementName java.lang.String

public static int getSymbol(String elementName) {

if (CustomerSymbols.fieldInstance == null){

synchronized (anObject) {

if (CustomerSymbols.fieldInstance == null) {

CustomerSymbols.fielInstance= new

Customersymbols ();

}

return

((Integer) CustomerSymbols.fieldInstance.fieldName2SymbolDictionary.get(elementName)).intValue();

}

//END Customersymbols.java

예 I과 관련하여 설명된 고객들의 배열 상황을 위한 XML 문서를 생성하기 위한 customer.jsp의 변경된 샘플이 다음에 제공된다.

for(int i=0);

i<handler.getElementRepetitions(CutomerSymbols.CUSTOMER);i++)

{

<%handler.startElement(i,CustomerSymbols.CUSTOMER);%>

<%=handler.getElementValue(CustomerSymbols.CUSTOMER_FIRSTNAME)%></Firstname>

<%=handler.getElementValue(CustomerSymbols.CUSTOMER__LASTNAME)%></LastName>

<%=handler.getElementValue(CustomerSymbols.CUSTOMER_ID)%></CustId>

</customer>

<%handler.endElement(i,CustomerSymbols.CUSTOMER);%>

<%}%>

핸들러(114-1)는 배열 크기(즉, 얼마나 많은 루프가 수행되어야 하는지)를 결정하고 getElementRepeititions 메소드에서 리턴한다. customer.jsp가 인덱스와 명칭으로써 startElement를 호출하면, 핸들러(114-1)은 배열내의 특정 고객 객체에 대한 레퍼런스를 설정한다.

재귀적 반복을 처리하기 위해, 핸들러(114-1)은 스택을 이용한다. 객체가 재귀적 반복할때에, 핸들러(114-1)은 startElement를 이용하여 스택상에 푸시(push)하고 endElement를 이용하여 팝(pop)한다. 작동 객체는 스택의 상부에 있는 객체이다.

객체가 선택적이라면, isOptionalElement() 또는 isOptionalAttribute() 메소드들이 객체의 존재를 판단하기 위해 이용된다. customer.jsp내의 처리는 Optionalxxx 메소드들중 하나에 대해 리턴되는 불린(boolean) 값을 이용하는 조건문을 추가하도록 수정된다.

요약하면, 본 발명의 예시적인 실시예의 장점들은 다음을 포함한다.

(a) XML 문서로부터 자바 객체로의 매핑 및 자바 객체로부터 XML 문서로의 매핑을 위한 공통 프레임워크를 제공하며, 여기서 프레임워크는 매핑을 위해 속성이 어떻게 얻어지는지를 마스크하는 핸들러를 이용한다.

(b) 본 발명에 따른 매핑 메소드들(XML/자바)을 인스턴스화하기 위해 쉽게 이용가능한 툴(예, SAX 파서, JSP)을 이용한다.

Claims

소프트웨어 객체를 나타내는 데이터 구조를 문서의 구조화 언어 요소들(structured language elements)로 변환하기 위한 컴퓨터-구현 방법에 있어서, 상기 방법은,

(a) 구조화된 언어 요소 템플릿 문서를 생성하는 단계와,

(b) 상기 소프트웨어 객체의 속성들 - 상기 속성들은 상기 문서의 구조화언어 요소들과 연관됨- 을 판독하는 단계와,

(c) 상기 속성들을 이용하여, 상기 속성들과 상기 구조화 언어 요소들간의 연관성에 기초하여 상기 구조화 언어 요소들에 의해 정의된 구문(construct)들을 획득하는 단계와,

(d) 상기 구문들로 상기 구조화 언어 요소 템플릿 문서를 파퓰레이트하는(populating) 단계

를 포함하는 방법.
제1항에 있어서, 상기 단계(c)는 상기 문서의 구조 및 콘텐트를 정의하는 구문들을 나타내는 속성들을 획득하기 위해 상기 소프트웨어 객체에 대한 직접 콜백(callback)을 포함하는 방법.
제1항에 있어서, 상기 단계(c)는 상기 문서의 구조 및 콘텐트를 나타내는 객 체 모델을 생성하는 단계를 포함하는 방법.
제1항에 있어서, 상기 구조화 언어 요소들은 확장형 마크업 언어(Extensible Markup Language:XML) 구문들을 나타내는 방법.
제1항에 있어서, 상기 단계(c)는 반복되는 구조화 언어 요소들을 처리하기 위해 상기 템플릿 문서내에 루프를 구성하는 단계를 포함하는 방법.
문서의 구조화 언어 요소들을 소프트웨어 객체를 나타내는 데이터 구조로 변환하기 위한 컴퓨터-구현 방법에 있어서, 상기 방법은,

(a) 상기 문서의 구조화 언어 요소들 각각을 판독하는 단계와,

(b) 상기 소프트웨어 객체의 데이터 구조에 의해 정의되는 이용가능한 속성 집합으로부터 선택되며, 상기 문서의 구조화 언어 요소들에 연관된 속성을 판단하는 단계와,

(c) 상기 소프트웨어 객체를 나타내는 데이터 구조의 속성들을 상기 문서의 구조화 언어 요소 값들로 파퓰레이트하는 단계

를 포함하는 방법.
제6항에 있어서, 상기 단계(a)는 상기 문서의 구조 및 콘텐트를 나타내는 이벤트를 생성하는 단계를 포함하는 방법.
제6항에 있어서, 상기 단계(a)는 상기 문서의 구조 및 콘텐트를 나타내는 이벤트로 핸들러에 콜백하는 단계를 포함하는 방법.
제6항에 있어서, 상기 단계(a)는 상기 문서의 구조 및 콘텐트를 나타내는 객체 모델을 생성하는 단계를 포함하는 방법.
제6항에 있어서, 상기 구조화 언어 요소들은 확장형 마크업 언어(XML)구문들을 나타내고 상기 단계(a)는 문서 유형 정의(Document Type Definition:DTD) 및 XML 스키마 표준을 실시하는(enforcing) 단계를 더 포함하는 방법.
제10항에 있어서, 재귀적(recursive) XML 구문들을 위한 스택을 유지하는 단계를 더 포함하는 방법.
속성들을 포함하는 소프트웨어 객체를 구조화 언어 요소들에 의해 정의되는 문서로 변환하기 위한 시스템에 있어서, 상기 시스템은

(a) 문서 템플릿과,

(b) 상기 문서 템플릿에 의해 이루어지는 콜백에 근거하여 상기 문서의 구조화 언어 요소들의 표현을 제공하기 위한 핸들러 인터페이스와,

(c) 상기 핸들러 인터페이스와 통신하여, 상기 소프트웨어 객체의 속성들을 상기 문서18)에 의해 인식되는 구조화 언어 요소들로 변환하기 위한 매핑 모듈과,

(d) 상기 매핑 모듈과 통신하여, 상기 단계(c)에서 생성된 상기 구조화 언어 요소들을 상기 문서에 기록하기 위한 출력 타겟 클래스

를 포함하는 시스템.
제12항에 있어서, 상기 매핑 모듈은 상기 속성들을 상기 구조화 언어 요소들로 변환하는 것을 실행하고 상기 문서에 대한 출력 타겟 스트림을 설정하기 위한 매핑 인터페이스와, 상기 매핑 인터페이스에 의해 이용되는 메소드(method)들을 제공하기 위한 매핑 클래스를 포함하는 시스템.
제13항에 있어서, 상기 출력 타겟 스트림은 버퍼로서 정의되는 시스템.
제13항에 있어서, 상기 출력 타겟 스트림은 서블렛(servlet)의 응답 스트림으로서 정의되는 시스템.
제12항에 있어서, 상기 구조화 언어 요소들은 확장형 마크업 언어(XML) 구문들을 나타내는 시스템.
제16항에 있어서, 상기 문서 템플릿은 자바서버 페이지(JavaServer Pages:JSP)를 이용하여 생성되는 시스템.
구조화 언어 요소들을 포함하는 문서를 소프트웨어 객체로 변환하기 위한 시스템에 있어서, 상기 시스템은,

(a) 상기 문서의 특징들을 나타내는 이벤트를 획득하기 위한 파서와,

(b) 상기 문서를 판독하기 위한 입력 소스 클래스와,

(c) 상기 입력 소스 클래스와 통신하여, 상기 파서에 의해 획득되는 이벤트들에 대한 버퍼를 구현하기 위한 콘텐트 핸들러 클래스와,

(d) 상기 콘텐트 핸들러 클래스와 통신하여, 상기 파서에 의해 획득된 이벤트들을 상기 소프트웨어 객체에 대한 속성들로 변환하기 위한 매핑 모듈

을 포함하는 시스템.
제18항에 있어서, 상기 매핑 모듈은 상기 이벤트들을 속성들로 변환하는 것을 실행하고 상기 소프트웨어 객체의 출력 타겟 스트림을 설정하기 위한 매핑 인터페이스와 상기 매핑 인터페이스에 의해 사용되는 메소드들을 제공하기 위한 매핑 클래스를 포함하는 시스템.
제19항에 있어서, 상기 구조화 언어 요소들은 확장형 마크업 언어(XML) 구문들을 포함하는 시스템.
속성들을 갖는 소프트웨어 객체를 구조화 언어 요소들에 의해 표현되는 문서로 변환하는 방법에 있어서, 상기 방법은,

(a) 상기 소프트웨어 객체를 호출된(invoked) 매핑 인터페이스의 인스턴스로 공급하는 단계와,

(b) 호출된 컨테이너의 인스턴스를 이용하여 템플릿을 컴파일하고 실행하는 단계와,

(c) 상기 컴파일된 템플릿을 이용하여 지정된 출력 스트림으로 상기 문서를 기록하는 단계

를 포함하는 방법.
제21항에 있어서, 처리 상태를 유지하기 위해 상기 매핑 인터페이스에 콜백하는 단계를 더 포함하는 방법.
제21항에 있어서, 상기 문서의 선택된 부분이 생성되어야 하는지를 판단하기 위해 상기 컴파일된 템플릿을 통해 isOptionalElementPresent(선택적요소존재여부판단) 메소드(method)를 호출하는 단계를 더 포함하는 방법.
제21항에 있어서, 상기 문서의 선택된 부분이 생성되어야 하는지를 판단하기 위해 상기 컴파일된 템플릿을 통해 isOptionalAttributePresent(선택적속성존재여부판단) 메소드를 호출하는 단계를 더 포함하는 방법.
제21항에 있어서, 상기 문서내에 복잡한 유형을 생성할 때 스택을 이용하여 처리 상태를 유지하는 단계를 더 포함하고, 상기 복잡한 유형은, 배열, 재귀적 반복(recursion) 및 복잡한 유형이 또다른 복잡한 유형에 포함되는 유형으로 구성된 그룹으로부터 선택되는 방법.
제25항에 있어서, 상기 복잡한 유형이 언제 시작하고 종료되는지를 가리키기 위해 상기 컴파일된 템플릿으로부터 상기 매핑 인터페이스로 콜백하는 것에 의해 상기 스택의 상태가 유지되는 방법.
제21항에 있어서, 상기 문서의 선택된 부분에 대해 상기 템플릿이 몇 번 루핑해야 하는지를 판단하기 위해 getElementRepetitions(요소반복회수구함) 메소드를 호출하는 단계를 더 포함하는 방법.
제21항에 있어서, 상기 구조화 언어 요소들은 XML 구문들을 나타내고 상기 템플릿은 JSP를 이용하여 생성되는 방법.
구조화 언어 요소들을 포함하는 문서를 소프트웨어 객체로 변환하는 방법에 있어서, 상기 방법은,

(a) 상기 문서를 호출된 매핑 인터페이스의 인스턴스에 공급하는 단계와,

(b) 상기 매핑 인터페이스를 콘텐트 핸들러로서 등록하는 단계와,

(c) 상기 문서를 호출된 파서의 인스턴스를 이용하여 파싱하는 단계와,

(d) 상기 매핑 인터페이스에 대해 이루어지는 콜백을 통해 상기 문서로부터 파싱된 구조화 언어 요소들에 연관된 속성들로 상기 소프트웨어 객체를 파퓰레이트하는 단계

를 포함하는 방법.
제29항에 있어서, 상기 단계(d)는 startDocument(문서시작), startElement(요소시작), characters(문자), endElement(요소종료) 및 endDocument(문서종료)로 구성된 그룹으로부터 선택된 메소드를 호출하는 콜백을 포함하는 방법.
제30항에 있어서, 상기 매핑 인터페이스에 의해 실행되는 startDocument(문서시작) 및 startElement(요소시작) 메소드들은 상기 소프트웨어 객체를 생성하는 방법.
제29항에 있어서, 상기 매핑 인터페이스에 의해 실행되는 endElement(요소종 료) 메소드는 상기 속성들을 상기 소프트웨어 객체내로 설정하는 방법.
제29항에 있어서, 상기 구조화 언어 요소들은 XML 구문들을 나타내는 방법.
제1항 내지 제5항중 어느 한 항에 따른 방법을 수행하기 위한 프로그램을 기록한 컴퓨터 판독가능한 기록매체.
삭제
삭제
삭제
삭제
제6항 내지 제11항중 어느 한 항에 따른 방법을 수행하기 위한 프로그램을 기록한 컴퓨터 판독가능한 기록매체.
삭제
삭제
삭제
삭제
삭제