JP2004530225A

JP2004530225A - System and method for mapping between software objects and document-based structured language elements

Info

Publication number: JP2004530225A
Application number: JP2003504271A
Authority: JP
Inventors: ベイシーゲル、マイケル; グリーン、ジョン、エイチ; ワーフィールド、ジェイ、ダブリュー
Original assignee: International Business Machines Corp
Current assignee: International Business Machines Corp
Priority date: 2001-06-07
Filing date: 2001-12-28
Publication date: 2004-09-30
Also published as: HUP0400135A2; TW573278B; CZ20033330A3; RU2003137567A; RU2287181C2; PL367225A1; WO2002101579A1; CN1313953C; CA2349905A1; EP1399841A1; CN1513145A; KR20040007545A; KR100583517B1

Abstract

【課題】文書（たとえばＸＭＬ文書）とソフトウェア・オブジェクト（たとえばＪａｖａ（Ｒ）オブジェクト）の間のマッピングの共通フレームワークを提供する方法およびシステムを提供すること。
【解決手段】このフレームワークでは、マッピングに関してプロパティがどのように得られるかをマスクするハンドラが使用される。これによって、マッピングの両方の方向で共通の外見を有するマッピング・コードがもたらされる。ＸＭＬ文書の要素とＪａｖａ（Ｒ）オブジェクトのプロパティの間のマッピングが、マッパに含まれる。マッパによって、パーサ（１０４）（ＤＯＭまたはＳＡＸなど）を使用して、ＸＭＬ文書（１０８）からオブジェクト（１１０）にマッピングされる。他の方向でのマッピング（Ｊａｖａ（Ｒ）からＸＭＬ）は、ＸＭＬ文書（１１８）の要素が、結果のＸＭＬ文書（１１８）の有効性を保証する特定の順序で構築されることを必要とする。本発明は、たとえば、ＪＳＰを使用するＸＭＬテンプレート文書を構築する。ＪＳＰベースのテンプレートを使用することによって、要素値および属性値を得るコールバックと共に、文書のタグをＪＳＰで記述することが可能になる。さらに、内容を、バッファに向けるか、サーブレットの応答ストリームに直接に向けることができる。
【選択図】図２A method and system for providing a common framework for mapping between documents (eg, XML documents) and software objects (eg, Java® objects).
The framework uses a handler to mask how properties are obtained for the mapping. This results in a mapping code that has a common appearance in both directions of the mapping. The mapping between the elements of the XML document and the properties of the Java object is included in the mapper. The mapper maps the XML document (108) to the object (110) using a parser (104) (such as DOM or SAX). Mapping in the other direction (from Java (R) to XML) requires that the elements of the XML document (118) be constructed in a particular order that guarantees the validity of the resulting XML document (118). . The present invention constructs an XML template document using, for example, JSP. The use of JSP-based templates allows document tags to be written in JSP, along with callbacks for obtaining element and attribute values. Further, the content can be directed to a buffer or directly to the servlet's response stream.
[Selection] Figure 2

Description

【技術分野】
【０００１】
本発明は、ソフトウェア・オブジェクトと構造化言語要素文書の間の変換またはマッピングの分野に関し、具体的には、Ｊａｖａ（Ｒ）オブジェクトなどのさまざまなソフトウェア・オブジェクトと拡張可能マークアップ言語（ＸＭＬ）文書の間のマッピングに関する。
【背景技術】
【０００２】
拡張可能マークアップ言語（ＸＭＬ）は、特にウェブ文書用に設計された、標準汎用マークアップ言語（ＳＧＭＬ）の縮小版である。ＸＭＬは、設計者が、自分自身のカスタマイズされたタグを作成することを可能とし、ＨＴＭＬを用いては使用不能な機能性を提供する。たとえば、ＸＭＬでは、それぞれが１つの宛先だけを参照できるＨＴＭＬリンクではなく、複数の文書をさすリンクがサポートされる。
【０００３】
ＸＭＬは、自己記述的なデータ（本明細書の説明では構造化言語要素とも称する）の形なので、リッチ・データ・モデルをエンコードするのに使用される。したがって、ＸＭＬは、異なるシステムの間のデータ交換媒体として有用である。データを、多数の種類のシステムすなわち、レガシーＣＯＢＯＬプログラム、データベース、Ｃ＋＋プログラムおよび類似物から、ＸＭＬとして抽出するか、パブリッシュすることができる。一般に遭遇するビジネス問題には、ＸＭＬ文書から他のデータ・フォーマットへおよびその逆で情報をどのようにマッピングするかを解決することが含まれる。たとえば、情報を企業間でＸＭＬ文書で交換した後に、その情報を、データベース要求またはトランザクション要求を行う時に使用できるＪａｖａ（Ｒ）オブジェクトにマッピングすることが必要になる場合がある。
【０００４】
２０００年９月２６日にメルツァ（Meltzer）他に発行された米国特許第６１２５３９１号で、ＸＭＬ／Ｊａｖａ（Ｒ）変換ツールの例が開示されている。ＸＭＬからＪａｖａ（Ｒ）への変換のために、メルツァ他では、ＸＭＬ文書を構文解析し、イベントを発生させる。具体的に言うと、パーサが、ＸＭＬ文書をウォークスルーし、照会することができるツリー表現をメモリ内に作り、別のパーサが、ＸＭＬ文書をウォークし、文書に関する情報を伴うイベント（たとえば、文書開始イベント、要素の名前、要素の内容を伴う要素開始イベント、要素終了イベント、文書終了イベントなど）を発生させる。
【０００５】
Ｊａｖａ（Ｒ）からＸＭＬへの変換について、メルツァ他では、各要素のアクセッサ（accessor）を含むコードを生成する。要素のアクセッサには、文字ごとにループするループが含まれる。ループには、文字が何であるかに基づいて処置を実行するｓｗｉｔｃｈステートメントが含まれる。処置は、ＸＭＬ文書の要素断片を含むＳｔｒｉｎｇＢｕｆｆｅｒを構築することである。メルツァ他の解決策は、Ｊａｖａ（Ｒ）からＸＭＬに変換するコードと共に動作するインフラストラクチャのサポートを提供しない。メルツァ他のコードのすべてが、生成されるコードであり、ユーザが編集する助けにはならない。
【特許文献１】
米国特許第６１２５３９１号
【発明の開示】
【発明が解決しようとする課題】
【０００６】
その結果、標準的なツールを使用して効率的に実施できる、ソフトウェア・オブジェクトと構造化言語要素ベースの文書（たとえばＸＭＬ）の間でのマッピングをサポートするマッピング・フレームワークの必要がある。
【課題を解決するための手段】
【０００７】
上で要約した従来技術の欠点は、文書（たとえばＸＭＬ文書）とソフトウェア・オブジェクト（たとえばＪａｖａ（Ｒ）オブジェクト）の間のマッピングの共通フレームワークを提供する、本発明の例示的な方法およびシステムによって克服される。このフレームワークでは、マッピングのためにプロパティを得る方法をマスクするハンドラが使用される。これによって、両方向のマッピングについて共通の外見を有するマッピング・コードがもたらされる。ＸＭＬ文書の要素とＪａｖａ（Ｒ）オブジェクトのプロパティの間のマッピングが、マッパー（mapper）に含まれる。マッパーによって、パーサ(Document Object Model（ＤＯＭ）またはSimpleApplication Programming Interface（ＡＰＩ）for XML（ＳＡＸ）など）の使用を介したＸＭＬ文書からソフトウェア・オブジェクトへのマッピングが行われる。
【０００８】
他の方向（Ｊａｖａ（Ｒ）からＸＭＬ）へのマッピングは、結果のＸＭＬ文書の有効性を保証するために、ＸＭＬ文書の要素が特定の順序で構築されることを必要とする。この有効性を保証するために、本発明の例示的実施形態では、たとえばＪａｖａ（Ｒ）ＳｅｒｖｅｒＰａｇｅｓ（商標）（ＪＳＰ）を使用してＸＭＬテンプレート文書を構築する。ＪＳＰベースのテンプレートを使用することによって、要素値および属性値を得るコールバックと共に文書のタグをＪＳＰに書き込めるようになる。ＪＳＰは、効率的なテンプレート作成を可能にするエディタ・サポートと共に、明確に文書化されている。さらに、内容を、バッファに向けるか、直接にサーブレット（servlet）の応答ストリームに向けることができる。本発明の１態様によれば、ソフトウェア・オブジェクトを表すデータ構造を、文書の構造化言語要素に変換するコンピュータ実施される方法であって、（ａ）構造化言語要素テンプレート文書を生成することと、（ｂ）前記ソフトウェア・オブジェクトから、前記文書の前記構造化言語要素に関連するプロパティを読み取ることと、（ｃ）前記プロパティを使用して、前記プロパティと前記構造化言語要素との間の前記関連に基づいて、前記構造化言語要素によって定義される構成を得ることと、（ｄ）前記構造化言語要素テンプレート文書に前記構成を移植することとを含むコンピュータ実施される方法が提供される。
【０００９】
本発明のもう１つの態様によれば、文書の構造化言語要素を、ソフトウェア・オブジェクトを表すデータ構造に変換する、コンピュータ実施される方法であって、（ａ）前記文書の前記構造化言語要素のそれぞれを読み取ることと、（ｂ）前記ソフトウェア・オブジェクトの前記データ構造によって定義される使用可能なプロパティの組から選択される、前記文書の構造化言語要素に関連するプロパティを決定することと、（ｃ）前記ソフトウェア・オブジェクトを表す前記データ構造の前記プロパティに、前記文書からの構造化言語要素値を移植することとを含む、コンピュータ実施される方法が提供される。
【００１０】
本発明のもう１つの態様によれば、プロパティを含むソフトウェア・オブジェクトを、構造化言語要素によって定義される文書に変換するシステムであって、（ａ）文書テンプレートと、（ｂ）前記文書テンプレートによって行われるコール・バックに基づいて、前記文書の前記構造化言語要素の表現を提供するハンドラ・インターフェースと、（ｃ）前記ハンドラ・インターフェースと通信して、前記ソフトウェア・オブジェクトのプロパティを前記文書によって認識される構造化言語要素に変換するマッピング・モジュールと、（ｄ）前記マッピング・モジュールと通信して、ステップ（ｃ）で生成される前記構造化言語要素を前記文書に書き込む出力ターゲット・クラスとを含むシステムが提供される。
【００１１】
本発明のもう１つの態様によれば、構造化言語要素を含む文書をソフトウェア・オブジェクトに変換するシステムであって、（ａ）前記文書の特徴を表すイベントを得るパーサと、（ｂ）前記文書を読み取る入力ソース・クラスと、（ｃ）前記入力ソース・クラスと通信して、前記パーサによって得られる前記イベントについてバッファを実施するコンテント・ハンドラ・クラスと、（ｄ）前記コンテント・ハンドラ・クラスと通信して、前記パーサによって得られる前記イベントを前記ソフトウェア・オブジェクトのプロパティに変換するマッピング・モジュールとを含むシステムが提供される。
【００１２】
本発明のもう１つの態様によれば、プロパティを有するソフトウェア・オブジェクトを、構造化言語要素によって表される文書に変換する方法であって、（ａ）呼び出されるマッピング・インターフェースのインスタンスに前記ソフトウェア・オブジェクトを供給することと、（ｂ）呼び出されるコンテナのインスタンスを使用してテンプレートをコンパイルし、実行することと、（ｃ）前記コンパイルされたテンプレートを使用して、指定された出力ストリームに前記文書を書き込むこととを含む方法が提供される。
【００１３】
本発明のもう１つの態様によれば、構造化言語要素を含む文書をソフトウェア・オブジェクトに変換する方法であって、（ａ）呼び出されるマッピング・インターフェースのインスタンスに前記文書を供給することと、（ｂ）前記マッピング・インターフェースをコンテント・ハンドラとして登録することと、（ｃ）呼び出されるパーサのインスタンスを使用して前記文書を構文解析することと、（ｄ）前記ソフトウェア・オブジェクトに、前記マッピング・インターフェースに対して行われるコール・バックを介して前記文書から解析される前記構造化言語要素に関連するプロパティを移植することとを含む方法が提供される。
【００１４】
本発明のもう１つの態様によれば、ソフトウェア・オブジェクトを表すデータ構造を、文書の構造化言語要素に変換するコンピュータ・プログラム製品であって、（ａ）構造化言語要素テンプレート文書を生成するコンピュータ可読プログラム・コード・デバイスと、（ｂ）前記ソフトウェア・オブジェクトから、前記文書の前記構造化言語要素に関連するプロパティを読み取るコンピュータ可読プログラム・コード・デバイスと、前記プロパティが、（ｃ）前記プロパティを使用して、前記プロパティと前記構造化言語要素との間の前記関連に基づいて、前記構造化言語要素によって定義される構成を得るコンピュータ可読プログラム・コード・デバイスと、（ｄ）前記構造化言語要素テンプレート文書に前記構成を移植するコンピュータ可読プログラム・コード・デバイスとを含むコンピュータ・プログラム製品が提供される。
【００１５】
本発明のもう１つの態様によれば、文書の構造化言語要素を、ソフトウェア・オブジェクトを表すデータ構造に変換するコンピュータ・プログラム製品であって、（ａ）前記文書の前記構造化言語要素のそれぞれを読み取るコンピュータ可読プログラム・コード・デバイスと、（ｂ）前記ソフトウェア・オブジェクトの前記データ構造によって定義される使用可能なプロパティの組から選択される、前記文書の構造化言語要素に関連するプロパティを決定するコンピュータ可読プログラム・コード・デバイスと、（ｃ）前記ソフトウェア・オブジェクトを表す前記データ構造の前記プロパティに、前記文書からの構造化言語要素値を移植するコンピュータ可読プログラム・コード・デバイスとを含むコンピュータ・プログラム製品が提供される。
【００１６】
本発明の他の態様および特徴は、添付図面と共に本発明の特定の実施形態の以下の説明を再検討する時に、当業者に明白になる。
【００１７】
本発明のさらなる特徴および長所を、添付図面と組み合わせて詳細な説明で説明する。
【発明を実施するための最良の形態】
【００１８】
図１および関連する説明は、本発明を実施することができる適切なコンピューティング環境の例を表す。本発明を、パーソナル・コンピュータで動作するコンピュータ・プログラムのコンピュータ実行可能命令という全般的な文脈で説明するが、本発明は、他のプログラム・モジュールと組み合わせて実施することもできる。
【００１９】
一般に、プログラム・モジュールには、特定のタスクを実行するか特定の抽象データ型を実施するルーチン、プログラム、コンポーネント、データ構造、および類似物が含まれる。さらに、本発明は、ハンドヘルド・デバイス、マルチプロセッサ・システム、マイクロプロセッサベースの民生用電子機器、プログラム可能な民生用電子機器、ミニコンピュータ、メインフレーム・コンピュータ、および類似物を含む、他のコンピュータ・システム構成を使用して実施することもできる。本発明は、通信ネットワークを介してリンクされたリモート処理装置によってタスクが実行される分散コンピューティング環境でも実施することができる。分散コンピューティング環境では、プログラム・モジュールを、ローカルおよびリモートの両方のメモリ・ストレージ・デバイスに配置することができる。
【００２０】
図１に関して、例示的なシステム１０に、普通のパーソナル・コンピュータ２０が含まれ、パーソナル・コンピュータ２０に、処理ユニット２２、システム・メモリ２４、およびシステム・メモリ２４を含むさまざまなシステム構成要素を処理ユニット２２に結合するシステム・バス２６が含まれる。システム・バス２６には、メモリ・バスまたはメモリ・コントローラ、周辺バス、およびさまざまな従来のバス・アーキテクチャ（たとえば、ＰＣＩ、ＶＥＳＡ、ＩＳＡ、ＥＩＳＡなど）のいずれかを使用するローカル・バスを含む複数のタイプのバス構造が含まれる。
【００２１】
システム・メモリ２４に、読取専用メモリ（ＲＯＭ）２８およびランダム・アクセス・メモリ（ＲＡＭ）３０が含まれる。スタートアップ時などにコンピュータ２０内の要素の間での情報転送を助ける基本ルーチンを含む基本入出力システム（ＢＩＯＳ）３２が、ＲＯＭ２８に格納される。コンピュータ２０には、ハード・ディスク・ドライブ３４、磁気ディスク・ドライブ３６（取外し可能ディスク３８から読み取り、これに書き込む）、光ディスク・ドライブ４０（ＣＤ−ＲＯＭディスク４２を読み取るか、他の光媒体から読み取り、これに書き込む）も含まれる。ドライブ３４、３６、および４０は、それぞれ、インターフェース４４、４６、および４８によってシステム・バス２６に接続される。
【００２２】
ドライブ３４、３６、および４０とそれに関連するコンピュータ可読媒体（３８、４２）によって、コンピュータ２０のデータ、データ構造、およびコンピュータ実行可能命令の不揮発性ストレージが提供される。図１の記憶媒体は、単に例であり、コンピュータによって可読の他のタイプの媒体（たとえば、磁気カセット、フラッシュ・メモリ・カード、ディジタル・ビデオ・ディスクなど）を含めることが、当業者に既知である。
【００２３】
オペレーティング・システム５０、１つまたは複数のアプリケーション・プログラム５２、他のプログラム・モジュール５４、およびプログラム・データ５６を含む複数のプログラム・モジュールを、ドライブ３４、３６、および４０ならびにＲＡＭ３０に保管することができる。ユーザは、キーボード５８および入力装置６０（たとえば、マウス、マイクロホン、ジョイスティック、ゲーム・パッド、衛星放送受信用パラボラ・アンテナ、スキャナなど）を介してコンピュータ２０にコマンドおよび情報を入力することができる。これらの装置（５８および６０）は、システム・バス２６に結合されたポート・インターフェース６２（たとえば、シリアル・ポート、パラレル・ポート、ゲーム・ポート、universal serial bus（ＵＳＢ）など）を介して処理ユニット２２に接続される。モニタ６４または他のタイプのディスプレイ装置も、インターフェース６６（たとえばビデオ・アダプタ）を介してバス２６に接続される。
【００２４】
コンピュータ２０は、リモート・コンピュータ６８などの１つまたは複数のリモート・コンピュータへの論理接続を使用して、ネットワーク化された環境で動作することができる。リモート・コンピュータ６８は、サーバ、ルータ、ピア・デバイス、または他の一般的なネットワーク・ノードとすることができ、リモート・コンピュータ６８には、通常は、コンピュータ２０に関して説明した要素の多数またはすべてが含まれるが、図を簡単にするために、メモリ・ストレージ・デバイス７０だけを図示した。図１に示された論理接続には、ローカル・エリア・ネットワーク（ＬＡＮ）７２および広域ネットワーク（ＷＡＮ）７４が含まれる。そのようなネットワーキング環境は、オフィス、会社全体のコンピュータ・ネットワーク、イントラネット、およびインターネットで一般的に使用されている。
【００２５】
ＬＡＮネットワーキング環境で使用される時に、コンピュータ２０は、ネットワーク・インターフェースまたはネットワーク・アダプタ７６を介してＬＡＮ７２に接続される。ＷＡＮネットワーキング環境で使用される時に、コンピュータ２０に、通常は、インターネットなどのＷＡＮ７４を介する通信を確立する、モデム７８または他の手段が含まれる。モデム７８は、内蔵または外付けとすることができるが、ポート・インターフェース６２を介してバス２６に接続される。ネットワーク化された環境では、コンピュータ２０に関して示されたプログラム・モジュールまたはその一部を、リモート・メモリ・ストレージ・デバイス７０に格納することができる。
【００２６】
本発明の方法の議論は、ＸＭＬからＪａｖａ（Ｒ）オブジェクトへおよびＪａｖａ（Ｒ）オブジェクトからＸＭＬへの変換／マッピングに関して基づく。他のデータ・フォーマットもサポートされる。たとえば、多数のレガシ・ビジネス・アプリケーションが、ＣＯＢＯＬ、Ｃ、およびＰＬ１で記述されている。これらのアプリケーションは、ＣＩＣＳ（商標）（汎用オンライン・トランザクション処理ソフトウェア）またはＩＭＳ（商標）（情報管理システム）などのエンタープライズ情報システム（ＥＩＳ）に常駐するプログラムからなる。ＣＯＢＯＬプログラムでは、入出力にＣＯＢＯＬ構造体が使用される。ＸＭＬからＣＯＢＯＬへおよびＣＯＢＯＬからＸＭＬへのマッピングの必要がある。本発明を使用して、これらのマッピングを行うことができ、ここで、ＸＭＬ−オブジェクトＸマッピング・ハンドラ（下で説明する）によって、ＸＭＬ文書からＣＯＢＯＬ構造体に移植され、オブジェクトＸ−ＸＭＬマッピング・ハンドラ（下で説明する）は、ＣＯＢＯＬ構造体からデータを抽出し、ＸＭＬ文書に移植するテンプレートによって使用される。
【００２７】
背景として、本発明のマッピング方法では、下記の高水準プロセスを使用する：（ａ）レクサによって、文字を、特定のシステムによって認識可能な単語またはトークンにグループ化し（トークン化と称する）、（ｂ）正しい言語構成を認識するために、パーサによって、トークンのグループを分析し、（ｃ）コード・ジェネレータによって、正しい言語構成の組をとり、実行可能コードを生成する。（ａ）から（ｃ）によって定義される機能を、混合することができる。
【００２８】
たとえば、ＸＭＬからＪａｖａ（Ｒ）オブジェクトへのマッピングについて、開始タグ、属性、終了タグ、および「ＣＤＡＴＡ」セクションなどの正しいＸＭＬトークンを認識するために、ＸＭＬ文書の各文字が分析される。次に、トークンが正しいＸＭＬ構成を形成することについて、トークンを検証しなければならない。最も基本的なレベルでは、タグ付けのすべてが、マッチする開始タグおよび終了タグを有し、属性が、開始タグ内で正しく構成されていることが検証される。文書型定義（ＤＴＤ）またはＸＭＬスキーマが使用可能な場合には、構文解析中に見つかったＸＭＬ構成が、ＤＴＤまたはＸＭＬスキーマに関して正しく、明確に形成されたＸＭＬであることを保証することができる。最後に、ＸＭＬ文書に含まれるデータが、有用なこと（たとえばＪａｖａ（Ｒ）オブジェクトへのマッピング）を達成するのに使用される。
【００２９】
上で識別された作業の一部を、少なくとも部分的に、すぐに入手可能なＸＭＬパーサによって実行することができる。ＸＭＬパーサによって、字句分析および構文解析の作業が処理される。構文解析標準規格の２つの例が、ＳＡＸおよびＤＯＭＡＰＩである（ＳＡＸはSimple Application Programming Interface (API) for XML、ＤＯＭはDocumentObject Model）。
【００３０】
ＳＡＸは、イベントベースである。ＳＡＸを実装するＸＭＬパーサは、構文解析されるＸＭＬ文書で見つかる異なる特徴に対応するイベントを生成する。ＤＯＭＡＰＩは、オブジェクトモデルベースＡＰＩである。ＤＯＭを実装するＸＭＬパーサは、ＸＭＬ文書の内容を表す汎用オブジェクト・モデルをメモリ内に作成する。ＸＭＬパーサが、構文解析を完了すると、メモリに、ＸＭＬ文書の構造および内容の両方に関する情報を提供するＤＯＭオブジェクトのツリーが含まれる。
【００３１】
図２に、本発明の実施形態によるフレームワーク１００の概略図を示す。フレームワーク１００は、図１のシステム１０で実施できるサーブレットなどの統合コンポーネント１０２でインスタンス化されるものとして図示されている。統合コンポーネント１０２には、たとえばＤＯＭまたはＳＡＸを使用して実装され、ＸＭＬ−オブジェクト・マッピング・モジュール１０６と相互作用するパーサ１０４が含まれる。説明をわかりやすくするために、本発明の実施形態を説明する際に、ＳＡＸをパーサ１０４の例として述べる。
【００３２】
ＸＭＬ−オブジェクト・マッピング・モジュール１０６によって、入力ＸＭＬ文書１０８が受け取られ、出力Ｊａｖａ（Ｒ）オブジェクト１１０が生成される。統合コンポーネント１０２には、さらに、オブジェクト−ＸＭＬマッピング・モジュール１１４と通信するＸＭＬ文書テンプレート・モジュール１１２（たとえば、Ｊａｖａ（Ｒ）ＳｅｒｖｅｒＰａｇｅｓ（商標）すなわちＪＳＰ技術に基づく）が含まれる。オブジェクト−ＸＭＬマッピング・モジュール１１４によって、入力Ｊａｖａ（Ｒ）オブジェクト１１６が受け取られ、出力ＸＭＬ文書１１８が生成される。
【００３３】
ＸＭＬ−ソフトウェア・オブジェクト・マッピング
図２に関して、ＸＭＬ−オブジェクト・マッピング・モジュール１０６に、下記のコンポーネントが含まれる。
（ａ）入力ＸＭＬ文書１０８を実施する入力ソース・クラス１０６−１（ＸＭＬ２ｘＩｎｐｕｔＳｏｕｒｃｅ）。
（ｂ）パーサ１０４によって生成されるＳＡＸイベントのバッファを実施するバッファード・コンテント・ハンドラ・クラス１０６−２（ＸＭＬ２ｘＢｕｆｆｅｒｅｄＣｏｎｔｅｎｔＨａｎｄｌｅｒ）。
（ｃ）マッピングを実行し、入力ターゲット・ストリームおよび出力ターゲットストリームをセットするマッピング・インターフェース１０６−３（ＸＭＬ２ｘＭａｐｐｉｎｇ）。
（ｄ）入力ＸＭＬ文書１０８から出力Ｊａｖａ（Ｒ）オブジェクト１１０へのマッピングのメソッドを提供するマッピング・クラス１０６−４（ＸＭＬ２ｘＭａｐｐｉｎｇＩｍｐｌ）。
【００３４】
さまざまなインターフェースおよびクラスのさらなる詳細を、下で説明する。用語「クラス」および「インターフェース」は、Ｊａｖａ（Ｒ）では固有の意味を有する。Ｊａｖａ（Ｒ）クラス（抽象、inner、またはfinal）は、特定のオブジェクトを定義するデータ・メンバおよびメソッドの集合であり、Ｊａｖａ（Ｒ）インターフェースは、ある機能性をそれを実装するクラスに強制するのに使用される（すなわち、インターフェースによって、クラスが行わなければならないことが指定される）。インターフェースは、そのインターフェースを実装するクラスによって使用することができる定数を提供するのにも使用される。インターフェースには、定数変数宣言およびメソッド宣言が含まれるが、メソッドの実装は、インターフェースを実装するクラスに委ねられる。１つのクラスによって、任意の個数のインターフェースを実装することができる。
【００３５】
表１に、入力ソース・クラス１０６−１（ＸＭＬ２ｘＩｎｐｕｔＳｏｕｒｃｅ）の主要な関数を要約する（すなわち、網羅的ではない）。
【００３６】
ＸＭＬ２ｘＩｎｐｕｔＳｏｕｒｃｅは、ＸＭ文書をバイト・ストリーム、文字ストリーム、またはＸＭＬ２ｘＢｕｆｆｅｒｅｄＣｏｎｔｅｎｔＨａｎｄｌｅｒ１０６−２から読み取ることができるようにするのに使用される。
【００３７】
【表１】

【００３８】
表２に、バッファード・コンテント・ハンドラ・クラス１０６−２（ＸＭＬ２ｘＢｕｆｆｅｒｅｄＣｏｎｔｅｎｔＨａｎｄｌｅｒ）の主要な関数を要約する（すなわち、網羅的でない）。ハンドラ・クラス１０６−２には、パーサ１０４からのＳＡＸイベントをバッファリングするコンテント・ハンドラも含まれる。これによって、イベントを再生できるようになる。この特徴が有用になる場合の例が、ＸＭＬ文書の異なる部分について異なるマッピング・ハンドラが使用される場合である。実装の例が、Simple Object Access Protocol（ＳＯＡＰ）である。
【００３９】
【表２】

【００４０】
ＳＯＡＰは、非集中分散環境で情報を交換する軽量プロトコルである。ＳＯＡＰは、ＸＭＬベースのプロトコルであり、（１）メッセージに含まれるものと、それを処理する方法を記述するフレームワークを定義するエンベロープと、（２）アプリケーション定義のデータ型のインスタンスを表すエンコーディング・ルールの組と、（３）リモート・プロシージャ呼出しおよび応答を表す規約、という３つの部分からなる。ＳＯＡＰメッセージは、必須のＳＯＡＰエンベロープ、任意選択のＳＯＡＰヘッダ、および必須のＳＯＡＰ本体からなるＸＭＬ文書である。この状況では、エンベロープと本体に異なるマッピング・ハンドラを使用することが可能である。
【００４１】
表３に、マッピング・インターフェース１０６−３（ＸＭＬ２ｘＭａｐｐｉｎｇ）の主要な関数を要約する（すなわち、網羅的でない）。ＸＭＬ２ｘＭａｐｐｉｎｇによって、マッピングが実行され、ＩｎｐｕｔＳｔｒｅａｍの構成が可能になる。
【００４２】
【表３】

【００４３】
表４に、マッピング・クラス１０６−４（ＸＭＬ２ｘＭａｐｐｉｎｇＩｍｐｌ）の主要な関数を要約する（すなわち、網羅的でない）。クラスおよびインターフェースの定義に関して上で述べたように、ＸＭＬ２ｘＭａｐｐｉｎｇＩｍｐｌクラスは、直接に使用されるのではなく、マッピングの元の入力ＸＭＬ文書１０８およびマッピング先の出力Ｊａｖａ（Ｒ）オブジェクト１１０の文書型定義に依存して、適当なメソッドに内容を追加されてサブクラス化される。
【００４４】
【表４】

【００４５】
図３を参照すると、ＸＭＬ文書１０８をソフトウェア・オブジェクト１１０（たとえばＪａｖａ（Ｒ）Ｂｅａｎ）にマッピングするために実行される全般的なステップを示すメソッド３００が示されており、これには下記が含まれる。
（ａ）ステップ３０２の、ＸＭＬからオブジェクトＸへのマッピングを実施するためにマッピング・インターフェース１０６−４（たとえば、ＸＭＬ２ＸＭａｐｐｉｎｇ）のインスタンスを取得することと、
（ｂ）ステップ３０４で、マッピング・インターフェース１０６−４を呼び出し、ステップ３０６で、入力ＸＭＬ文書１０８を供給することと、
（ｃ）ステップ３０８で、マッピング・インターフェース１０６−４によって、イベント・パーサのインスタンス（たとえばパーサ１０４）を取得し、ステップ３１０で、マッピング・インターフェース１０６−４をコンテント・ハンドラ（たとえばバッファード・コンテント・ハンドラ・クラス１０６−２）として登録することと、
（ｄ）ステップ３１２で、ＸＭＬ文書１０８に対してパーサ１０４を呼び出す（すなわち、文書の構文解析を開始する）ことと、
（ｅ）ステップ（ｄ）が実行される時に、ステップ３１４で、さまざまなメソッド（たとえば、ｓｔａｒｔＤｏｃｕｍｅｎｔ、ｓｔａｒｔＥｌｅｍｅｎｔ、ｃｈａｒａｃｔｅｒｓ、ｅｎｄＥｌｅｍｅｎｔ、ｅｎｄＤｏｃｕｍｅｎｔなど）を呼び出す、マッピング・インターフェース１０６−４へのコール・バックを行うことと、
（ｆ）ステップ３１６で、ｓｔａｒｔＤｏｃｕｍｅｎｔメソッドまたはｓｔａｒｔＥｌｅｍｅｎｔメソッドあるいはこの両方で、マッピング・インターフェース１０６−４によって、ソフトウェア・オブジェクト１１０を作成することと、
（ｇ）ステップ３１８で、ｅｎｄＥｌｅｍｅｎｔメソッドで、マッピング・インターフェース１０６−４によって、ソフトウェア・オブジェクト１１０に要素をセットすること。
【００４６】
上で説明したＳＡＸＡＰＩには、当技術分野で既知の多数の仕様が含まれる。本発明は、「ＣｏｎｔｅｎｔＨａｎｄｌｅｒ」インターフェースを実装するクラスの作成に関し、ＣｏｎｔｅｎｔＨａｎｄｌｅｒインターフェースは、ＸＭＬ文書内で見つかる時にＳＡＸイベントのプログラムを通知するためにＸＭＬパーサによって使用されるコールバック・インターフェースである。このインターフェースは、ＸＭＬ２ｘＢｕｆｆｅｒｅｄＣｏｎｔｅｎｔＨａｎｄｌｅｒクラス１０６−２およびＸＭＬ２ｘＩｎｐｕｔＳｏｕｒｃｅクラス１０６−１と共に使用される。ＳＡＸＡＰＩによって、「ＣｏｎｔｅｎｔＨａｎｄｌｅｒ」インターフェースの「ＤｅｆａｕｌｔＨａｎｄｌｅｒ」実装クラスも提供される。下で詳細に説明する例Ｉ「ＸＭＬ−Ｊａｖａ（Ｒ）カスタマ」では、「ＤｅｆａｕｌｔＨａｎｄｌｅｒ」を拡張して、カスタマＸＭＬ文書からカスタマＪａｖａ（Ｒ）Ｂｅａｎを生成する。
【００４７】
例Ｉ
ＸＭＬ−Ｊａｖａ（Ｒ）カスタマ
以下のコンポーネント（下で詳細に説明する）が、例Ｉの一部である。
（Ａ）ｃｕｓｔｏｍｅｒ．ｘｍｌ入力ＸＭＬ文書１０８のサンプルである。
（Ｂ）ＸＭＬ２ＣｕｓｔｏｍｅｒＭａｐｐｉｎｇ．ｊａｖａパーサ１０４がコール・バックするハンドラ・クラス１０６−２である。これには、カスタマ・オブジェクトを構成し、その値を確立する指示が含まれる。
（Ｃ）ｅｘｅｃｕｔｅ．ｊａｖａＸＭＬからＪａｖａ（Ｒ）へおよびＪａｖａ（Ｒ）からＸＭＬへ（下の例ＩＩ）のマッピングを実行するのに使用されるマッピング・クラス／インターフェース１０６−３、１０６−４のプログラムである。
（Ｄ）ｃｕｓｔｏｍｅｒ．ｊａｖａ出力カスタマＪａｖａ（Ｒ）Ｂｅａｎ１１０である。
（Ｅ）ＣｕｓｔｏｍｅｒＳｙｍｂｏｌｓ．ｊａｖａ整数定数およびハッシュマップが含まれる。ハッシュマップは、タグの名前を、ＸＭＬ２ＣｕｓｔｏｍｅｒＭａｐｐｉｎｇ．ｊａｖａ（Ｒ）で使用される整数定数にマッピングするのに使用される。
【００４８】
Ａ．入力ＸＭＬ文書（ｃｕｓｔｏｍｅｒ．ｘｍｌ）を下に示す。

【００４９】
Ｂ．簡潔にするために部分的に省略された、カスタマ・オブジェクトを構成し、値をセットするプログラム（ＸＭＬ２ＣｕｓｔｏｍｅｒＭａｐｐｉｎｇ．ｊａｖａ）（すなわち、イベント・パーサがコール・バックするハンドラ）を下に示す。

【００５０】
Ｃ．簡潔にするために部分的に省略された、ＸＭＬからＪａｖａ（Ｒ）へ（および、下の例ＩＩで詳細に示されるように、Ｊａｖａ（Ｒ）からＸＭＬへ）のマッピングを実行するのに使用されるプログラム（ｅｘｅｃｕｔｅ．ｊａｖａ）。

【００５１】
Ｄ．カスタマＪａｖａ（Ｒ）Ｂｅａｎ（ｃｕｓｔｏｍｅｒ．ｊａｖａ）の詳細を下に示す。Ｊａｖａ（Ｒ）Ｂｅａｎは、当技術分野で既知の標準設計アーキテクチャを厳守する再利用可能なコンポーネントである。Ｂｅａｎは、実行時に可視または不可視とすることができるクラス・オブジェクトである。Ｊａｖａ（Ｒ）Ｂｅａｎｓによって、コンポーネント・アーキテクチャ、コンポーネント開発の標準フレームワークがもたらされる。

【００５２】
例Ｉからわかるように、ＸＭＬからＪａｖａ（Ｒ）へのマッピングは、パーサ１０４によって、開始タグ、要素タグ、および終了タグのすべてのイベントが処理され、イベントのトラッキングが改善されるので効率的である。
【００５３】
もう１つの例として、カスタマの配列への単一のカスタマＸＭＬ文書の拡張を検討されたい。カスタマ・ジャバ・ビーンズの配列を生成するには、下記の手順に従う。
（ｉ）ＣｕｓｔｏｍｅｒｓのｓｔａｒｔＥｌｅｍｅｎｔを使用して、ベクトルを作成する。
（ｉｉ）各ＣｕｓｔｏｍｅｒのｓｔａｒｔＥｌｅｍｅｎｔで、Ｃｕｓｔｏｍｅｒオブジェクトを作成する。
（ｉｉｉ）ＦｉｒｓｔＮａｍｅ、ＬａｓｔＮａｍｅ、およびＣｕｓｔＩＤのｓｔａｒｔＥｌｅｍｅｎｔイベント、ｇｅｔＥｌｅｍｅｎｔイベント、およびｅｎｄＥｌｅｍｅｎｔイベントを使用してＣｕｓｔｏｍｅｒオブジェクトに移植し、ＣｕｓｔｏｍｅｒのｅｎｄＥｌｅｍｅｎｔイベントを使用して、Ｃｕｓｔｏｍｅｒオブジェクトをベクトルに挿入し、ＣｕｓｔｏｍｅｒｓのｅｎｄＥｌｅｍｅｎｔイベントを使用して、ベクトルからＣｕｓｔｏｍｅｒｓの配列を作成し、共に動作するＪａｖａ（Ｒ）オブジェクトにセットする。
【００５４】
パーサ１０４によって、再帰的ＸＭＬ構造（すなわち、リストのリストを表すＸＭＬ要素）についてスタックが維持される。ｓｔａｒｔＥｌｅｍｅｎｔごとに１つのオブジェクトが作成される。スタックを使用して、必要に応じて状態を保存することができる。子要素が作成されたならば、その子要素を親オブジェクトにセットすることができる。
【００５５】
ソフトウェア・オブジェクト−ＸＭＬマッピング
図２に関して、オブジェクト−ＸＭＬマッピング・モジュール１１４に、下記のコンポーネントが含まれる。
（ａ）構文解析イベントを管理するハンドラ・インターフェース１１４−１（Ｘ２ＸＭＬＨａｎｄｌｅｒ）
（ｂ）マッピングおよび出力ターゲット・ストリームのセットを実行するマッピング・インターフェース１１４−２（Ｘ２ＸＭＬＭａｐｐｉｎｇ）
（ｃ）入力Ｊａｖａ（Ｒ）オブジェクト１１６から出力ＸＭＬ文書１１８へのマッピングのメソッドを提供するマッピング・クラス１１４−３（Ｘ２ＸＭＬＭａｐｐｉｎｇＩｍｐｌ）
（ｄ）出力ＸＭＬ文書１１８を実装する出力ターゲット・クラス１１４−４（Ｘ２ＸＭＬＯｕｔｐｕｔＴａｒｇｅｔ）
【００５６】
表５に、ハンドラ・インターフェース１１４−１（Ｘ２ＸＭＬＨａｎｄｌｅｒ）の主要な関数を要約する（すなわち、網羅的でない）。マッピング・モジュール１１４によって、インターフェース１１４−１が実装され、そのインスタンスがＪＳＰコンテナに登録される。文書テンプレート１１２によって、要素の開始および終了などと要素値の入手のための基本的な文書関連イベントについてマッピング・モジュール１１４へのコール・バックが行われる。
【００５７】
【表５】

【００５８】
一般に、コンテナは、ライフ・サイクル管理、セキュリティ、デプロイメント、および実行時サービスをコンポーネントに提供する実体である。コンテナには、コンポーネント固有のサービスを提供する多数の固有のタイプ（ウェブ、ＪＳＰ、サーブレット、アプレットなど）がある。サーブレット・コンテナは、それを介して要求および応答が送られ、要求がデコードされ、応答がフォーマットされるネットワーク・サービスを提供するコンテナである。ＪＳＰコンテナは、サーブレット・コンテナと同一のサービスを提供するコンテナであり、ＪＳＰページを解釈し、サーブレットに処理するエンジンである。
【００５９】
Ｘ２ＸＭＬＨａｎｄｌｅｒ１１４−１によって、パーサ１０４によって作られる構文解析イベントに対する構文解析イベントのミラー（同一ではないが）イメージが提供される。効果的に、パーサ１０４によって提供される構造が、Ｘ２ＸＭＬからのパスにミラーリングされる。
【００６０】
パーサ１０４が、ＳＡＸを使用して実装される時に、イベントが、それを処理するハンドラ１０６−２（すなわち、効果的にコールバック機構）によって受け取られる。この例では、ハンドラ１０６−２が、Ｊａｖａ（Ｒ）クラスを移植するのに使用される。
【００６１】
テンプレート１１２は、呼び出される時に、Ｘ２ＸＭＬＨａｎｄｌｅｒインターフェース１１４−１をコール・バックする。ハンドラ１１４−１は、要求されたデータを取得し、構文解析の状態を維持することによって、コールバックを処理する。
【００６２】
ハンドラ・インターフェース１１４−１は、ＸＭＬ−オブジェクト・マッピング・モジュール１０６によって実行されるさまざまな機能に関して類似するが、ある種の相違がある。要素名は、生成されるか手でコーディングされ、「ネームスペース」サポートを有するスキーマからは取られない。要素名を、要素ごとに一意にすることができる。したがって、ｓｔａｒｔＥｌｅｍｅｎｔメソッドおよびｅｎｄＥｌｅｍｅｎｔメソッドでは、ｎａｍｅパラメータだけが必要である。
【００６３】
マッピングが、ＸＭＬ−オブジェクト・マッピング・モジュール１０６によって実行される時に、入力ソース・クラス１０６−１（すなわちＸＭＬＲｅａｄｅｒ）によって、要素の名前がストリングとして返される。マッピング・クラス／インターフェース１０６−３、１０６−４では、要素名が、一意の番号と対にされる。この番号は、要素の処理を制御するために、ｓｗｉｔｃｈステートメントで使用される。オブジェクト−ＸＭＬモジュール１１４では、要素名を整数定数として定義することによって、処理が最適化され、コーディング・アシスタンスが改善される。したがって、これらのメソッドへのコールバックでは、ストリングの代わりに整数定数が使用される。
【００６４】
ハンドラ・インターフェース１１４−１のイベントの順序は、オブジェクト１１６自体の情報の順序の鏡像になる。
【００６５】
ＸＭＬ文書テンプレート１１２（Ｊａｖａ（Ｒ）ＳｅｒｖｅｒＰａｇｅｓ技術を使用して書き込まれる）では、下で詳細を示すコーディング・スタイルが使用される。ＪＳＰ技術では、ユーザ・インターフェースが内容生成から分離され、基礎になる動的な内容を変更せずに、全体的なページ・レイアウトを変更できるようになる。Ｊａｖａ（Ｒ）ＳｅｒｖｅｒＰａｇｅｓは、当業者に周知のＪａｖａ（Ｒ）Ｓｅｒｖｌｅｔ技術の拡張である。
【００６６】
ＸＭＬ文書テンプレート１１２−ＪＳＰコーディング・スタイルの例
コールバックが、文書１１８の開始タグおよび終了タグと、複合型に関してコーディングされる。これによって、ハンドラ１１４−１が状態を維持できるようになる。ＪＳＰＸＭＬ文書テンプレート１１２では、開始タグおよび終了タグも、直接にコーディングされ、その結果、これらのタグが、ターゲットに設定された出力ストリームに向けられる。単純型を扱う時には、コールバックをコーディングする必要はないが、開始タグおよび終了タグをコーディングし、その結果、これらのタグがターゲットに設定された出力ストリームに向けられるようにしなければならない。
【００６７】
複合型または単純型が、任意選択である場合には、テンプレート１１２内の条件文節でｉｓＯｐｔｉｏｎａｌＥｌｅｍｅｎｔＰｒｅｓｅｎｔ（）を使用して、任意選択要素を生成するかどうかを制御する。
【００６８】
属性が任意選択である場合には、複合型ではｉｓＯｐｔｉｏｎａｌＡｔｔｒｉｂｕｔｅＰｒｅｓｅｎｔ（ｉｎｔａｔｔｒｉｂｕｔｅＮａｍｅ）を、単純型ではｉｓＯｐｔｉｏｎａｌＡｔｔｒｉｂｕｔｅＰｒｅｓｅｎｔ（ｉｎｔｅｌｅｍｅｎｔＮａｍｅ、ｉｎｔａｔｔｒｉｂｕｔｅＮａｍｅ）を使用する。要素型が、反復される単純型である場合には、ｉｓＯｐｔｉｏｎａｌＡｔｔｒｉｂｕｔｅＰｒｅｓｅｎｔ（ｉｎｔｉｎｄｅｘ、ｉｎｔｅｌｅｍｅｎｔＮａｍｅ、ｉｎｔａｔｔｒｉｂｕｔｅＮａｍｅ）メソッドを使用して、任意選択の属性が含まれるかどうかを判定する。
【００６９】
反復される要素の場合には、ｇｅｔＥｌｅｍｅｎｔＲｅｐｅｔｉｔｉｏｎｓメソッドを使用して、反復される要素の数を返す。これは、テンプレート１１２内でループを構成して、各要素を処理するのに使用される。単純型の場合に、テンプレート１１２に、開始タグおよび終了タグが含まれなければならず、値を得るためにｇｅｔＥｌｅｍｅｎｔＶａｌｕｅ（ｉｎｔｉｎｄｅｘ、ｉｎｔｅｌｅｍｅｎｔＮａｍｅ）が呼び出される。複合型の場合には、状態を維持しなければならないので、テンプレート１１２によって、ｓｔａｒｔＥｌｅｍｅｎｔ（ｉｎｔｉｎｄｅｘ、ｉｎｔｅｌｅｍｅｎｔＮａｍｅ）メソッドおよびｅｎｄＥｌｅｍｅｎｔ（ｉｎｔｉｎｄｅｘ、ｉｎｔｅｌｅｍｅｎｔＮａｍｅ）メソッドを呼び出さなければならない。
【００７０】
表６に、マッピング・インターフェース１１４−２（Ｘ２ＸＭＬＭａｐｐｉｎｇ）の主要な関数を要約する（すなわち、網羅的でない）。マッピング・インターフェース１１４−２によって、マッピング機能（Ｊａｖａ（Ｒ）とＸＭＬの間の）が実行され、出力ターゲット・ストリームが確立される。マッピング・インターフェース１１４−２によって、ハンドラ・インターフェース１１４−１が拡張され、これによって出力ＸＭＬ文書１１８を生成するのに必要な文書テンプレート１１２のコール・バック・メソッドが提供される。
【００７１】
【表６】

【００７２】
表７に、マッピング・クラス１１４−３（Ｘ２ＸＭＬＭａｐｐｉｎｇＩｍｐｌ）の主要な関数を要約する（すなわち、網羅的でない）。マッピング・クラス１１４−３によって、入力Ｊａｖａ（Ｒ）オブジェクト１１６から出力ＸＭＬ文書１１８へのマッピングのメソッドが提供される。クラスおよびインターフェースの定義に関して上で述べたように、Ｘ２ＸＭＬＭａｐｐｉｎｇＩｍｐｌクラス１１４−３は、直接に使用されるのではなく、マッピング先の出力ＸＭＬ文書１１８およびマッピング元の入力Ｊａｖａ（Ｒ）オブジェクト１１６の文書型定義に依存して、適当なメソッドに内容を追加されてサブクラス化される。
【００７３】
【表７】

【００７４】
表８に、出力ターゲット・クラス１１４−４（Ｘ２ＸＭＬＯｕｔｐｕｔＴａｒｇｅｔ）の主要な関数を要約する（すなわち、網羅的でない）。
【００７５】
Ｘ２ＸＭＬＯｕｔｐｕｔＴａｒｇｅｔクラス１１４−４を用いると、ＸＭＬ文書１１８を、バイト・ストリームまたは文字ストリームに書き込めるようになる。クラス１１４−４によって、バイト・ストリームのターゲットをサーブレットの出力ストリームにすることを可能にするなど、最適化が提供される。したがって、ＸＭＬ文書１１８は、書き込まれる前にバッファリングされない。
【００７６】
【表８】

【００７７】
要約すると、Ｘ２ＸＭＬＭａｐｐｉｎｇＩｍｐｌクラス１１４−３によって、Ｘ２ＸＭＬＭａｐｐｉｎｇインターフェース１１４−２が実装される。Ｘ２ＸＭＬＭａｐｐｉｎｇインターフェース１１４−２によって、Ｘ２ＸＭＬＨａｎｄｌｅｒインターフェース１１４−１が拡張される。したがって、Ｘ２ＸＭＬＭａｐｐｉｎｇＩｍｐｌクラス１１４−３によって、Ｘ２ＸＭＬＨａｎｄｌｅｒインターフェース１１４−１で定義されたメソッドが実装される。
【００７８】
図４に関して、ソフトウェア・オブジェクト１１６（たとえばＪａｖａ（Ｒ）Ｂｅａｎ）をＸＭＬ文書１１８にマッピングするために実行される一般的なステップを示すメソッド４００が示されており、この方法には下記が含まれる。
（ａ）ステップ４０２で、入力オブジェクトＸ１１６から出力ＸＭＬ文書１１８へのマッピングを実施するマッピング・インターフェース１１４−２（たとえばＸ２ＸＭＬＭａｐｐｉｎｇ）のインスタンスを得ることと、
（ｂ）ステップ４０４で、マッピング・インターフェース１１４−３でソフトウェア・オブジェクト１１６および出力ＸＭＬ文書１１８の出力ストリームをセットすることと、
（ｃ）ステップ４０６で、マッピング・インターフェース１１４−２を呼び出すことと、
（ｄ）ステップ４０８で、ＪＳＰコンテナを作成することと、
（ｅ）ステップ４１０で、マッピング・インターフェース１１４−２によって、ＸＭＬ文書１１８を作成するＪＳＰＸＭＬテンプレート１１２を使用してＪＳＰコンテナを呼び出すことと、
（ｆ）ステップ４１２で、ＪＳＰコンテナによって、ＪＳＰＸＭＬテンプレート１１２をコンパイルし、実行することと、
（ｇ）ステップ４１４で、コンパイルされたＪＳＰＸＭＬテンプレート１１２によって、指定された出力ストリーム（ステップ４０４から）へのＸＭＬ文書１１８の書込を開始することと、
（ｈ）ステップ４１６で、要素／属性データおよび開始／終了タグについて適当な時に、コンパイルされたＪＳＰＸＭＬテンプレート１１２によって、マッピング・インターフェース１１４−２をコール・バックして、処理の状態を維持し、出力ＸＭＬ文書１１８にデータを追加することと（データは、ソフトウェア・オブジェクト１１６から検索される）、
（ｉ）ステップ４１８で、コンパイルされたＪＳＰＸＭＬテンプレート１１２によって、任意選択として、ｉｓＯｐｔｉｏｎａｌＥｌｅｍｅｎｔＰｒｅｓｅｎｔメソッドまたはｉｓＯｐｔｉｏｎａｌＡｔｔｒｉｂｕｔｅＰｒｅｓｅｎｔメソッドを呼び出して、ＸＭＬ文書のある部分を生成しなければならないかどうかを判定することができることと、
（ｊ）ステップ４２０で、ＪＳＰＸＭＬテンプレート１１２によって、ｇｅｔＥｌｅｍｅｎｔＲｅｐｅｔｉｔｉｏｎｓメソッドをコール・バックして、ＸＭＬ文書のある部分の生成で何回ループしなければならないかを判定することと、
（ｋ）ステップ４２２で、スタックによって処理の状態を維持すること（これは、配列がある、再帰がある、または複合型が別の複合型に含まれる場合に、ＸＭＬ文書内で複合型を生成する時に有用である）。
【００７９】
Ｊａｖａ（Ｒ）からＸＭＬへのマッピングでは、ＸＭＬ文書テンプレート１１２が使用され、ＸＭＬ文書テンプレート１１２は、イベントを処理する（少なくとも複合オブジェクトについて）パーサ１０４によって課せられるものに類似する標準規格を用いてコーディングされる。たとえば、複合型について、開始タグおよび終了タグをコーディングしなければならない（プリミティブ型では不要）。下で詳細を示す例ＩＩ「Ｊａｖａ（Ｒ）−ＸＭＬカスタマ」では、入力カスタマｊａｖａ（Ｒ）オブジェクトから出力カスタマＸＭＬ文書を生成する。
【００８０】
例ＩＩ
Ｊａｖａ（Ｒ）−ＸＭＬカスタマ
下記のコンポーネント（下で詳細を示す）が、例ＩＩの一部である。
（Ａ）Ｃｕｓｔｏｍｅｒ２ＸＭＬＭａｐｐｉｎｇ．ｊａｖａ出力ＸＭＬ文書１１８に移植される入力カスタマＪａｖａ（Ｒ）オブジェクト１１６から値を得るためにＪＳＰ１１２によって呼び出されるハンドラ・クラス１１４−１
（Ｂ）ｃｕｓｔｏｍｅｒ．ｊｓｐ出力ＸＭＬ文書１１８を生成するのに使用されるＪＳＰテンプレート１１２
（Ｃ）ＣｕｓｔｏｍｅｒＳｙｍｂｏｌｓ．ｊａｖａ定数およびハッシュマップが含まれる。ハッシュマップは、タグの名前を整数定数にマッピングするのに使用される。ＪＳＰテンプレート１１２では、整数定数が使用される
（Ｄ）ｅｘｅｃｕｔｅ．ｊａｖａＪａｖａ（Ｒ）からＸＭＬへおよびＸＭＬからＪａｖａ（Ｒ）へのマッピングを実行するのに使用されるマッピング・クラス／インターフェース１１４−２、１１４−３のプログラム（上の例Ｉの項目Ｃ）
【００８１】
Ａ．簡潔にするために部分的に省略された、入力Ｊａｖａ（Ｒ）オブジェクトからＸＭＬ文書を構成するプログラム（Ｃｕｓｔｏｍｅｒ２ＸＭＬＭａｐｐｉｎｇ．ｊａｖａ）。

【００８２】
Ｂ．簡潔にするために部分的に省略された、モジュール１１２のＪＳＰの文書テンプレート（Ｃｕｓｔｏｍｅｒ．ｊｓｐ）。

【００８３】
Ｃ．簡潔にするために部分的に省略された、Ｃｕｓｔｏｍｅｒ．ｊｓｐによって使用されるハッシュマップおよび定数のプログラム（Ｃｕｓｔｏｍｅｒｓｙｍｂｏｌｓ．ｊａｖａ）。

【００８４】
例Ｉに関して言及した状況でカスタマの配列に関するＸＭＬ文書を生成するために、改訂されたｃｕｓｔｏｍｅｒ．ｊｓｐの例を下に示す。

【００８５】
ハンドラ１１４−１は、配列サイズ（すなわち、何回のループを実行するか）を判定し、ｇｅｔＥｌｅｍｅｎｔＲｅｐｉｔｉｏｎｓでリターンする。ｃｕｓｔｏｍｅｒ．ｊｓｐによって、ｉｎｄｅｘおよびｎａｍｅを用いてｓｔａｒｔＥｌｅｍｅｎｔが呼び出される時に、ハンドラ１１４−１によって、配列内の特定のカスタマ・オブジェクトへの参照がセットされる。
【００８６】
再帰を処理するために、ハンドラ１１４−１によって、スタックが使用される。オブジェクトが再帰する時に、ハンドラ１１４−１によって、ｓｔａｒｔＥｌｅｍｅｎｔでスタックにプッシュされ、ｅｎｄＥｌｅｍｅｎｔでスタックからポップされる。作業オブジェクトは、スタック最上部のオブジェクトである。
【００８７】
オブジェクトが任意選択である場合には、ｉｓＯｐｔｉｏｎａｌＥｌｅｍｅｎｔ（）メソッドまたはｉｓＯｐｔｉｏｎａｌＡｔｔｒｉｂｕｔｅ（）メソッドを使用して、オブジェクトが存在するかどうかを判定する。ｃｕｓｔｏｍｅｒ．ｊｓｐでの処理を改訂して、ｉｓＯｐｔｉｏｎａｌｘｘｘメソッドの１つについて返されるブール値を使用する条件ステートメントを追加する。要約すると、本発明の例示的実施形態の長所には、下記が含まれる。
（ａ）ＸＭＬ文書からＪａｖａ（Ｒ）オブジェクトへおよびＪａｖａ（Ｒ）オブジェクトからＸＭＬ文書へのマッピングの共通フレームワークが提供され、このフレームワークでは、マッピングに関してプロパティがどのように得られるかをマスクするハンドラが使用される。
（ｂ）本発明のマッピング方法（ＸＭＬ／Ｊａｖａ（Ｒ））をインスタンス化するのに、すぐに入手可能なツール（たとえば、ＳＡＸパーサ、ＪＳＰ）が使用される。
（ｃ）本発明のマッピング処理の構造を単純にし、両方のマッピング方向でマッピング処理を似たものにするインターフェースおよびクラス（Ｊａｖａ（Ｒ）環境での）が提供される。
【図面の簡単な説明】
【００８８】
【図１】本発明を実施する方法および装置を実施するのに使用することができるコンピュータ・システムを示すブロック図である。
【図２】ＸＭＬとＪａｖａ（Ｒ）オブジェクトの間およびその逆でのマッピングのフレームワークを示すブロック図である。
【図３】図２のフレームワークを使用してＸＭＬ文書をソフトウェア・オブジェクトにマッピングする方法を示す流れ図である。
【図４】図２のフレームワークを使用してソフトウェア・オブジェクトをＸＭＬ文書にマッピングする方法を示す流れ図である。【Technical field】
[0001]
The present invention relates to the field of conversion or mapping between software objects and structured language element documents, and in particular, various software objects, such as Java objects, and extensible markup language (XML) documents. Regarding mapping between.
[Background Art]
[0002]
Extensible Markup Language (XML) is a reduced version of the Standard General Purpose Markup Language (SGML), specifically designed for web documents. XML allows designers to create their own customized tags and provides functionality that is not available using HTML. For example, XML supports links that point to multiple documents, rather than HTML links, each of which can refer to only one destination.
[0003]
XML is used to encode a rich data model because it is a form of self-describing data (also referred to herein as a structured language element). Therefore, XML is useful as a data exchange medium between different systems. Data can be extracted or published as XML from many types of systems: legacy COBOL programs, databases, C ++ programs and the like. Commonly encountered business problems include solving how to map information from XML documents to other data formats and vice versa. For example, after exchanging information in XML documents between companies, it may be necessary to map that information to Java objects that can be used when making database or transaction requests.
[0004]
U.S. Pat. No. 6,125,391 issued Sep. 26, 2000 to Meltzer et al. Discloses an example of an XML / Java conversion tool. In order to convert XML to Java (R), Melza et al. Parses an XML document and generates an event. Specifically, a parser walks through an XML document and creates a tree representation in memory that can be queried, and another parser walks through the XML document and events with information about the document (eg, document Start event, element name, element start event with element content, element end event, document end event, etc.).
[0005]
For conversion from Java (R) to XML, Melza et al. Generate a code including an accessor of each element. The element accessor contains a loop that loops for each character. The loop includes a switch statement that performs an action based on what the character is. The action is to build a StringBuffer that contains the element fragments of the XML document. The Melza et al. Solution does not provide infrastructure support to work with code that converts Java to XML. All of Melza's other code is generated code and does not help the user edit it.
[Patent Document 1]
U.S. Pat. No. 6,125,391
DISCLOSURE OF THE INVENTION
[Problems to be solved by the invention]
[0006]
As a result, there is a need for a mapping framework that supports mapping between software objects and structured language element-based documents (eg, XML), which can be efficiently implemented using standard tools.
[Means for Solving the Problems]
[0007]
A disadvantage of the prior art summarized above is that the exemplary method and system of the present invention provides a common framework for mapping between documents (eg, XML documents) and software objects (eg, Java objects). Overcome. This framework uses a handler to mask the way properties are obtained for mapping. This results in a mapping code that has a common look for mapping in both directions. The mapping between the elements of the XML document and the properties of the Java (R) object is contained in a mapper. The mapper maps XML documents to software objects through the use of a parser (such as a Document Object Model (DOM) or Simple Application Programming Interface (API) for XML (SAX)).
[0008]
Mapping in the other direction (Java (R) to XML) requires that the elements of the XML document be constructed in a particular order to ensure the validity of the resulting XML document. To ensure this validity, an exemplary embodiment of the present invention constructs an XML template document using, for example, Java (R) Server Pages (TM) (JSP). The use of JSP-based templates allows document tags to be written to JSP with callbacks to obtain element and attribute values. JSPs are well-documented, with editor support allowing efficient template creation. Further, the content can be directed to a buffer or directly to a servlet response stream. According to one aspect of the invention, a computer-implemented method for converting a data structure representing a software object into structured language elements of a document, comprising: (a) generating a structured language element template document; (B) reading, from the software object, properties associated with the structured language element of the document; and (c) using the properties to define the property between the property and the structured language element. A computer-implemented method is provided that includes obtaining a configuration defined by the structured language element based on the association, and (d) porting the configuration to the structured language element template document.
[0009]
According to another aspect of the present invention, a computer-implemented method for converting a structured language element of a document into a data structure representing a software object, comprising: (a) the structured language element of the document. And (b) determining a property associated with the structured language element of the document selected from a set of available properties defined by the data structure of the software object; (C) populating a structured language element value from the document to the property of the data structure representing the software object.
[0010]
According to another aspect of the present invention, there is provided a system for converting a software object including a property into a document defined by a structured language element, comprising: (a) a document template; A handler interface for providing a representation of the structured language element of the document based on a callback made; and (c) communicating with the handler interface to recognize properties of the software object by the document. And (d) an output target class that communicates with the mapping module and writes the structured language element generated in step (c) to the document. A system is provided that includes:
[0011]
According to another aspect of the present invention, there is provided a system for converting a document including a structured language element into a software object, comprising: (a) a parser for obtaining an event representing a characteristic of the document; An input source class that reads from the input source class; and (c) a content handler class that communicates with the input source class and implements a buffer for the event obtained by the parser; and (d) the content handler class. A mapping module for communicating and converting the events obtained by the parser into properties of the software object.
[0012]
According to another aspect of the present invention, there is provided a method of converting a software object having properties into a document represented by a structured language element, comprising: (a) placing the software object in an instance of a mapping interface to be invoked; Providing an object; (b) compiling and executing a template using an instance of the called container; and (c) using the compiled template to output the document to a specified output stream. Writing.
[0013]
According to another aspect of the invention, there is provided a method of converting a document containing structured language elements into a software object, comprising: (a) providing the document to an instance of a mapping interface to be invoked; b) registering the mapping interface as a content handler; (c) parsing the document using an instance of the called parser; and (d) the mapping interface in the software object. And populating properties associated with the structured language element parsed from the document via a callback made to the document.
[0014]
According to another aspect of the present invention, a computer program product for converting a data structure representing a software object into a structured language element of a document, comprising: (a) a computer for generating a structured language element template document; A computer readable program code device that reads properties associated with the structured language elements of the document from the software object; and (c) reads the properties from the software object. A computer readable program code device for use in obtaining a configuration defined by the structured language element based on the association between the property and the structured language element; and (d) the structured language. Computer for porting the configuration to element template document Computer program product comprising a reading program code devices is provided.
[0015]
According to another aspect of the invention, there is provided a computer program product for converting a structured language element of a document into a data structure representing a software object, comprising: (a) each of the structured language elements of the document; Determining a property associated with the structured language element of the document, selected from a set of available properties defined by the data structure of the software object. A computer readable program code device, and (c) a computer readable program code device for populating a structured language element value from the document into the property of the data structure representing the software object.・ Program products are provided .
[0016]
Other aspects and features of the present invention will become apparent to one of ordinary skill in the art upon reviewing the following description of particular embodiments of the invention in conjunction with the accompanying drawings.
[0017]
Further features and advantages of the present invention are described in the detailed description, taken in conjunction with the accompanying drawings.
BEST MODE FOR CARRYING OUT THE INVENTION
[0018]
FIG. 1 and the associated description represent examples of suitable computing environments in which the invention may be implemented. Although the invention is described in the general context of computer-executable instructions in a computer program running on a personal computer, the invention may be implemented in combination with other program modules.
[0019]
Generally, program modules include routines, programs, components, data structures, and the like that perform particular tasks or implement particular abstract data types. Further, the present invention relates to other computer systems, including handheld devices, multiprocessor systems, microprocessor-based consumer electronics, programmable consumer electronics, minicomputers, mainframe computers, and the like. It can also be implemented using a system configuration. The invention can also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote memory storage devices.
[0020]
With reference to FIG. 1, an exemplary system 10 includes a conventional personal computer 20, which processes a processing unit 22, a system memory 24, and various system components including the system memory 24. A system bus 26 that couples to unit 22 is included. The system bus 26 includes a memory bus or memory controller, a peripheral bus, and a plurality of local buses using any of a variety of conventional bus architectures (eg, PCI, VESA, ISA, EISA, etc.). Types of bus structures are included.
[0021]
System memory 24 includes read-only memory (ROM) 28 and random access memory (RAM) 30. A basic input / output system (BIOS) 32 containing basic routines to help transfer information between elements within the computer 20, such as at startup, is stored in the ROM. The computer 20 includes a hard disk drive 34, a magnetic disk drive 36 (reads from and writes to a removable disk 38), an optical disk drive 40 (reads a CD-ROM disk 42 or reads from other optical media). , Write in this).

Drives

34, 36, and 40 are connected to system bus 26 by

interfaces

44, 46, and 48, respectively.
[0022]

Drives

34, 36, and 40 and their associated computer-readable media (38, 42) provide nonvolatile storage of computer 20 data, data structures, and computer-executable instructions. The storage media of FIG. 1 is merely exemplary and it is known to those skilled in the art to include other types of media readable by a computer (eg, magnetic cassettes, flash memory cards, digital video disks, etc.). is there.
[0023]
A plurality of program modules, including operating system 50, one or more application programs 52, other program modules 54, and program data 56, may be stored in

drives

34, 36, and 40 and RAM 30. it can. A user can enter commands and information into computer 20 via keyboard 58 and input device 60 (eg, a mouse, microphone, joystick, game pad, satellite dish, scanner, etc.). These devices (58 and 60) are connected to a processing unit via a port interface 62 (eg, a serial port, a parallel port, a game port, a universal serial bus (USB), etc.) coupled to the system bus 26. 22. A monitor 64 or other type of display device is also connected to bus 26 via interface 66 (eg, a video adapter).
[0024]
Computer 20 can operate in a networked environment using logical connections to one or more remote computers, such as remote computer 68. Remote computer 68 may be a server, router, peer device, or other common network node, and typically includes many or all of the elements described with respect to computer 20. Although included, only the memory storage device 70 is shown for simplicity of illustration. The logical connections shown in FIG. 1 include a local area network (LAN) 72 and a wide area network (WAN) 74. Such networking environments are commonly used in offices, enterprise-wide computer networks, intranets, and the Internet.
[0025]
When used in a LAN networking environment, computer 20 is connected to LAN 72 via a network interface or adapter 76. When used in a WAN networking environment, the computer 20 typically includes a modem 78 or other means for establishing communication over the WAN 74, such as the Internet. Modem 78, which may be internal or external, is connected to bus 26 via port interface 62. In a networked environment, program modules depicted relative to the computer 20, or portions thereof, may be stored in the remote memory storage device 70.
[0026]
The discussion of the method of the present invention is based on the transformation / mapping from XML to Java objects and from Java objects to XML. Other data formats are also supported. For example, a number of legacy business applications have been written in COBOL, C, and PL1. These applications consist of programs residing in an enterprise information system (EIS) such as CICS ™ (general purpose online transaction processing software) or IMS ™ (information management system). In the COBOL program, a COBOL structure is used for input and output. There is a need for mapping XML to COBOL and COBOL to XML. The present invention can be used to perform these mappings, where the XML-to-object X mapping handler (described below) is used to populate the COBOL structure from the XML document with the object X-to-XML mapping. Handlers (described below) are used by templates to extract data from COBOL structures and port them to XML documents.
[0027]
By way of background, the mapping method of the present invention uses the following high-level process: (a) The lexer groups characters into words or tokens recognizable by a particular system (referred to as tokenization); A) parsing the group of tokens by a parser to recognize the correct language construct, and (c) taking the correct set of language constructs and generating executable code by a code generator. The functions defined by (a) to (c) can be mixed.
[0028]
For example, for a mapping from XML to a Java object, each character of the XML document is analyzed to recognize the correct XML token, such as the start tag, attributes, end tag, and "CDATA" section. Next, the token must be verified that the token forms the correct XML configuration. At the most basic level, all of the tagging has matching start and end tags, and it is verified that the attributes are correctly configured within the start tag. If a document type definition (DTD) or XML schema is available, it can be ensured that the XML constructs found during parsing are correct and well-formed XML for the DTD or XML schema. Finally, the data contained in the XML document is used to achieve usefulness (eg, mapping to Java objects).
[0029]
Some of the work identified above may be performed, at least in part, by a readily available XML parser. The XML parser handles the lexical and parsing tasks. Two examples of parsing standards are SAX and DOM API (SAX is Simple Application Programming Interface (API) for XML, DOM is DocumentObject Model).
[0030]
SAX is event-based. XML parsers implementing SAX generate events corresponding to different features found in the parsed XML document. The DOM API is an object model based API. An XML parser that implements DOM creates a generic object model in memory that represents the contents of an XML document. When the XML parser has completed parsing, the memory contains a tree of DOM objects that provides information about both the structure and content of the XML document.
[0031]
FIG. 2 shows a schematic diagram of a framework 100 according to an embodiment of the present invention. Framework 100 is illustrated as being instantiated with an integration component 102, such as a servlet, that can be implemented in system 10 of FIG. The integration component 102 includes a parser 104 implemented using, for example, DOM or SAX and interacting with an XML-to-object mapping module 106. For ease of explanation, SAX will be described as an example of the parser 104 when describing embodiments of the present invention.
[0032]
An input XML document 108 is received by an XML-object mapping module 106 and an output Java object 110 is generated. Integration component 102 further includes an XML document template module 112 (e.g., based on Java (R) Server Pages (TM) or JSP technology) that communicates with an object-to-XML mapping module 114. An input Java (R) object 116 is received by the object-to-XML mapping module 114 and an output XML document 118 is generated.
[0033]
XML-Software Object Mapping
Referring to FIG. 2, the XML-to-object mapping module 106 includes the following components:
(A) Input source class 106-1 (XML2xInputSource) that implements the input XML document 108.
(B) Buffered content handler class 106-2 (XML2xBufferedContentHandler) that implements a buffer for SAX events generated by parser 104.
(C) Mapping interface 106-3 (XML2xMapping) that performs mapping and sets the input and output target streams.
(D) A mapping class 106-4 (XML2xMappingImpl) that provides a method of mapping from the input XML document 108 to the output Java (R) object 110.
[0034]
Further details of the various interfaces and classes are described below. The terms "class" and "interface" have their own meaning in Java. A Java class (abstract, inner, or final) is a collection of data members and methods that define a particular object, and a Java interface forces some functionality on the class that implements it. (Ie, the interface specifies what the class must do). Interfaces are also used to provide constants that can be used by the class that implements the interface. The interface includes constant variable declarations and method declarations, but the implementation of the method is left to the class implementing the interface. An arbitrary number of interfaces can be implemented by one class.
[0035]
Table 1 summarizes the key functions of the input source class 106-1 (XML2xInputSource) (ie, not exhaustive).
[0036]
XML2xInputSource is used to allow an XML document to be read from a byte stream, a character stream, or an XML2xBufferedContentHandler106-2.
[0037]
[Table 1]

[0038]
Table 2 summarizes the key functions of the buffered content handler class 106-2 (XML2xBufferedContentHandler) (ie, not exhaustive). The handler class 106-2 also includes a content handler that buffers SAX events from the parser 104. This allows the event to be played. An example where this feature is useful is when different mapping handlers are used for different parts of an XML document. An example of an implementation is the Simple Object Access Protocol (SOAP).
[0039]
[Table 2]

[0040]
SOAP is a lightweight protocol for exchanging information in a decentralized distributed environment. SOAP is an XML-based protocol that includes (1) an envelope that defines what is contained in a message and how to process it, and (2) an encoding that represents an instance of an application-defined data type. It consists of three parts: a set of rules and (3) a convention representing remote procedure calls and responses. A SOAP message is an XML document consisting of a mandatory SOAP envelope, an optional SOAP header, and a mandatory SOAP body. In this situation, it is possible to use different mapping handlers for the envelope and the body.
[0041]
Table 3 summarizes the key functions of the mapping interface 106-3 (XML2xMapping) (ie, not exhaustive). XML2xMapping performs the mapping and allows for the construction of an InputStream.
[0042]
[Table 3]

[0043]
Table 4 summarizes the key functions of mapping class 106-4 (XML2xMappingImpl) (ie, not exhaustive). As discussed above with respect to class and interface definitions, the XML2xMappingImpl class is not used directly, but rather in the document type definition of the mapping source input XML document 108 and the mapping destination Java (R) object 110. Depending on the method, the content is added to the appropriate method and subclassed.
[0044]
[Table 4]

[0045]
Referring to FIG. 3, a method 300 is shown that illustrates the general steps performed to map an XML document 108 to a software object 110 (eg, Java Bean), including: It is.
(A) obtaining an instance of the mapping interface 106-4 (eg, XML2XMapping) to perform the XML to object X mapping of step 302;
(B) In step 304, call the mapping interface 106-4, and in step 306, supply the input XML document 108;
(C) At step 308, an instance of the event parser (eg, parser 104) is obtained by mapping interface 106-4, and at step 310, mapping interface 106-4 is converted to a content handler (eg, buffered content. Registering as handler class 106-2)
(D) In step 312, calling the parser 104 for the XML document 108 (ie, starting parsing the document);
(E) When step (d) is performed, at step 314, make a callback to the mapping interface 106-4 that invokes various methods (eg, startDocument, startElement, characters, endElement, endDocument, etc.). That
(F) In step 316, creating the software object 110 by the mapping interface 106-4 with the startDocument method and / or the startElement method;
(G) At step 318, setting an element in the software object 110 by the mapping interface 106-4 with the endElement method.
[0046]
The SAX API described above includes a number of specifications known in the art. The present invention relates to the creation of a class that implements the "ContentHandler" interface, which is a callback interface used by an XML parser to notify the program of SAX events when found in an XML document. This interface is used with the XML2xBufferedContentHandler class 106-2 and the XML2xInputSource class 106-1. The SAX API also provides a "DefaultHandler" implementation class for the "ContentHandler" interface. In Example I “XML-Java (R) Customer” described in detail below, “DefaultHandler” is extended to generate a customer Java (R) Bean from a customer XML document.
[0047]
Example I
XML-Java (R) customer
The following components (described in detail below) are part of Example I:
(A) customer. xml This is a sample of the input XML document 108.
(B) XML2CustomerMapping. The handler class 106-2 that the Java parser 104 calls back. This includes instructions for configuring the customer object and establishing its values.
(C) execute. Java A mapping class / interface 106-3, 106-4 program used to perform the mapping from XML to Java (R) and from Java (R) to XML (Example II below).
(D) customer. Java The output customer is Java (R) Bean110.
(E) CustomerSymbols. java Includes integer constants and hash maps. The hash map stores the names of the tags in XML2CustomerMapping. Used to map to integer constants used in java (R).
[0048]
A. The input XML document (customer.xml) is shown below.

[0049]
B. Shown below is a program (XML2CustomerMapping.java) that constructs and sets the value of the customer object (ie, the handler that the event parser calls back), partially omitted for brevity.

[0050]
C. Used to perform XML to Java (R) mapping (and Java to XML as detailed in Example II below), partially omitted for brevity Program (execute.java) to be executed.

[0051]
D. Details of the customer Java (R) Bean (customer.java) are shown below. Java (R) Bean is a reusable component that adheres to standard design architectures known in the art. Beans are class objects that can be made visible or invisible at runtime. Java Beans provides a standard framework for component architecture, component development.

[0052]
As can be seen from Example I, the mapping from XML to Java (R) is efficient because parser 104 processes all start tag, element tag, and end tag events, improving event tracking. is there.
[0053]
As another example, consider extending a single customer XML document to an array of customers. To generate an array of customer Java beans, follow these steps:
(I) Create a vector using the Starters element of Customers.
(Ii) Create a Customer object with the startElement of each Customer.
(Iii) Populate the Customer object using the FirstName, LastName, and StartElement, getElement, and endElement events of the CustID, insert the Customer object into the vector using the Customer's endElement event, and insert the CustomerElement's event into the CustomerElement event. To create an array of Customers from the vector and set it on the Java (R) object that works with it.
[0054]
The parser 104 maintains a stack for a recursive XML structure (ie, an XML element representing a list of lists). One object is created for each startElement. Stacks can be used to save state as needed. Once a child element has been created, it can be set to the parent object.
[0055]
Software Object-XML Mapping
With reference to FIG. 2, the object-XML mapping module 114 includes the following components:
(A) Handler interface 114-1 (X2XMLHandler) for managing parsing events
(B) Mapping interface 114-2 (X2XMLMapping) that performs mapping and a set of output target streams
(C) Mapping class 114-3 (X2XMLMappingImpl) that provides a method for mapping from the input Java (R) object 116 to the output XML document 118
(D) Output target class 114-4 that implements the output XML document 118 (X2XMLOutputTarget)
[0056]
Table 5 summarizes the key functions of the handler interface 114-1 (X2XMLHandler) (ie, not exhaustive). The interface 114-1 is implemented by the mapping module 114, and the instance is registered in the JSP container. The document template 112 provides a callback to the mapping module 114 for basic document-related events such as the start and end of an element and the acquisition of an element value.
[0057]
[Table 5]

[0058]
Generally, a container is an entity that provides life cycle management, security, deployment, and runtime services to components. There are many unique types of containers (web, JSP, servlets, applets, etc.) that provide component-specific services. A servlet container is a container that provides network services through which requests and responses are sent, requests are decoded, and responses are formatted. The JSP container is a container that provides the same service as the servlet container, and is an engine that interprets a JSP page and processes the JSP page.
[0059]
The X2XMLHandler 114-1 provides a mirror (but not identical) image of the parse event to the parse event created by parser 104. Effectively, the structure provided by parser 104 is mirrored in the path from X2XML.
[0060]
When the parser 104 is implemented using SAX, the event is received by the handler 106-2 that processes it (ie, effectively a callback mechanism). In this example, handler 106-2 is used to port a Java class.
[0061]
When the template 112 is invoked, it calls back the X2XMLHandler interface 114-1. Handler 114-1 processes the callback by obtaining the requested data and maintaining the parsing state.
[0062]
The handler interface 114-1 is similar with respect to various functions performed by the XML-to-object mapping module 106, but with certain differences. Element names are generated or hand-coded and are not taken from schemas with "namespace" support. Element names can be unique for each element. Therefore, only the name parameter is required in the startElement and endElement methods.
[0063]
When the mapping is performed by the XML-to-object mapping module 106, the name of the element is returned as a string by the input source class 106-1 (ie, XMLReader). In mapping classes / interfaces 106-3, 106-4, element names are paired with unique numbers. This number is used in the switch statement to control the processing of the element. In the object-XML module 114, by defining the element names as integer constants, processing is optimized and coding assistance is improved. Therefore, callbacks to these methods use integer constants instead of strings.
[0064]
The order of events in handler interface 114-1 is a mirror image of the order of information in object 116 itself.
[0065]
The XML document template 112 (written using Java (R) Server Pages technology) uses a coding style detailed below. In JSP technology, the user interface is separated from content generation, allowing the overall page layout to be changed without changing the underlying dynamic content. Java Server Pages is an extension of the Java Servlet technology well known to those skilled in the art.
[0066]
XML Document Template 112-Example of JSP Coding Style
A callback is coded for the start and end tags of the document 118 and for the complex type. As a result, the handler 114-1 can maintain the state. In the JSP XML document template 112, the start and end tags are also coded directly, so that these tags are directed to the targeted output stream. When dealing with simple types, you do not need to code the callback, but you must code the start and end tags so that they are directed to the targeted output stream.
[0067]
If the complex or simple type is optional, use isOptionalElementPresent () in the conditional clause in template 112 to control whether an optional element is generated.
[0068]
If the attribute is optional, use isOptionAttributePresent (int attributeName) for the complex type and use isOptionAttributePresent (int elementName, intAttributeName) for the simple type. If the element type is a repeated simple type, use the isOptionAttributePresent (int index, int elementName, int attributeName) method to determine if an optional attribute is included.
[0069]
For repeated elements, use the getElementRepetitions method to return the number of repeated elements. This is used to construct a loop in the template 112 and process each element. In the case of a simple type, the template 112 must include a start tag and an end tag, and getElementValue (int index, int elementName) is called to get the value. In the case of a composite type, since the state must be maintained, the template 112 must call the startElement (int index, int elementName) method and the endElement (int index, int elementName) method.
[0070]
Table 6 summarizes the key functions of mapping interface 114-2 (X2XMLMapping) (ie, not exhaustive). The mapping interface 114-2 performs a mapping function (between Java (R) and XML) and establishes an output target stream. The mapping interface 114-2 extends the handler interface 114-1 to provide the callback methods of the document template 112 needed to generate the output XML document 118.
[0071]
[Table 6]

[0072]
Table 7 summarizes the key functions of mapping class 114-3 (X2XMLMappingImpl) (ie, not exhaustive). The mapping class 114-3 provides a method of mapping from the input Java (R) object 116 to the output XML document 118. As described above with respect to class and interface definitions, the X2XMLMappingImpl class 114-3 is not used directly, but rather the document type of the output XML document 118 of the mapping destination and the input Java (R) object 116 of the mapping source. Depending on the definition, it is subclassed with content added to the appropriate method.
[0073]
[Table 7]

[0074]
Table 8 summarizes the key functions of the output target class 114-4 (X2XMLOutputTarget) (ie, not exhaustive).
[0075]
The X2XMLOutputTarget class 114-4 allows an XML document 118 to be written to a byte or character stream. Class 114-4 provides optimizations, such as allowing the byte stream to be targeted to the servlet output stream. Therefore, the XML document 118 is not buffered before being written.
[0076]
[Table 8]

[0077]
In summary, the X2XMLMappingImpl class 114-3 implements the X2XMLMapping interface 114-2. The X2XMLMapping interface 114-2 extends the X2XMLHandler interface 114-1. Therefore, the method defined by the X2XMLHandler interface 114-1 is implemented by the X2XMLMappingImpl class 114-3.
[0078]
Referring to FIG. 4, a method 400 is shown that illustrates the general steps performed to map a software object 116 (eg, Java (R) Bean) to an XML document 118, which includes the following: .
(A) obtaining an instance of a mapping interface 114-2 (eg, X2XMLMapping) that performs a mapping from the input object X116 to the output XML document 118 at step 402;
(B) setting the software object 116 and the output stream of the output XML document 118 at the mapping interface 114-3 at step 404;
(C) In step 406, calling the mapping interface 114-2;
(D) creating a JSP container in step 408;
(E) In step 410, using the mapping XML interface 112-2 to invoke the JSP container using the JSP XML template 112 to create the XML document 118;
(F) compiling and executing the JSP XML template 112 by the JSP container in step 412;
(G) in step 414, starting writing the XML document 118 to the specified output stream (from step 404) with the compiled JSP XML template 112;
(H) In step 416, at the appropriate time for element / attribute data and start / end tags, the compiled JSP XML template 112 calls back the mapping interface 114-2 to maintain processing state; Adding data to the output XML document 118 (the data is retrieved from the software object 116);
(I) In step 418, the compiled JSP XML template 112 can optionally invoke the isOptionalElementPresent or isOptionAttributePresent methods to determine whether a portion of the XML document must be generated.
(J) In step 420, the JSP XML template 112 calls back the getElementRepetitions method to determine how many times the generation of a portion of the XML document must be looped;
(K) maintaining the state of processing by the stack in step 422 (this creates a complex type in the XML document if there is an array, there is recursion, or the complex type is contained in another complex type) Useful when you do).
[0079]
The Java to XML mapping uses an XML document template 112, which is coded using a standard similar to that imposed by parser 104 (at least for complex objects) that processes events. Is done. For example, for complex types, the start and end tags must be coded (not required for primitive types). In Example II, "Java (R) -XML Customer", detailed below, an output customer XML document is generated from an input customer Java (R) object.
[0080]
Example II
Java (R) -XML Customer
The following components (detailed below) are part of Example II.
(A) Customer2XMLMapping. Java A handler class 114-1 called by the JSP 112 to obtain a value from the input customer Java (R) object 116 to be ported to the output XML document 118.
(B) customer. jsp JSP template 112 used to generate output XML document 118
(C) CustomerSymbols. Java constants and hash maps are included. Hash maps are used to map tag names to integer constants. In the JSP template 112, an integer constant is used.
(D) execute. A program of mapping classes / interfaces 114-2, 114-3 used to perform Java-to-XML and XML-to-Java mappings (item C in Example I above).
[0081]
A. A program (Customer2XMLMapping.java) that constructs an XML document from input Java objects, partially omitted for brevity.

[0082]
B. Document template for JSP of module 112 (Customer.jsp), partially omitted for brevity.

[0083]
C. Customer. Partially omitted for brevity. A program of hash maps and constants used by jsp (Customersymbols.java).

[0084]
Revised customer. An example of jsp is shown below.

[0085]
The handler 114-1 determines the array size (that is, how many loops to execute) and returns with getElementRepetitions. customer. When jsp invokes startElement with index and name, handler 114-1 sets a reference to a particular customer object in the array.
[0086]
The stack is used by handler 114-1 to handle recursion. When the object recurs, the handler 114-1 pushes it on the stack at startElement and pops it off the stack at endElement. The work object is the object at the top of the stack.
[0087]
If the object is optional, use the isOptionalElement () or isOptionAttribute () method to determine if the object exists. customer. Revise the processing in jsp to add a conditional statement that uses the boolean value returned for one of the isOptionalxxx methods. In summary, advantages of an exemplary embodiment of the present invention include:
(A) A common framework is provided for mapping from XML documents to Java objects and from Java objects to XML documents, which masks how properties are obtained for the mapping. Handler is used.
(B) A readily available tool (eg, SAX parser, JSP) is used to instantiate the mapping method (XML / Java®) of the present invention.
(C) Interfaces and classes (in a Java environment) are provided that simplify the structure of the mapping process of the present invention and make the mapping process similar in both mapping directions.
[Brief description of the drawings]
[0088]
FIG. 1 is a block diagram illustrating a computer system that can be used to implement a method and apparatus for practicing the present invention.
FIG. 2 is a block diagram illustrating a framework for mapping between XML and Java objects and vice versa.
FIG. 3 is a flowchart illustrating a method of mapping an XML document to a software object using the framework of FIG.
FIG. 4 is a flowchart illustrating a method for mapping software objects to XML documents using the framework of FIG.

Claims

A computer-implemented method for converting a data structure representing a software object into structured language elements of a document, comprising:
(A) generating a structured language element template document;
(B) reading from the software object properties associated with the structured language element of the document;
(C) using the property to obtain a configuration defined by the structured language element based on the association between the property and the structured language element;
(D) porting the configuration to the structured language element template document.

The computer-implemented method of claim 1, wherein step (c) comprises a direct callback to the software object to obtain properties representing the structure that define the structure and content of the document.

The computer-implemented method of claim 1, wherein step (c) comprises creating an object model representing the structure and content of the document.

The computer-implemented method of claim 1, wherein the structured language element represents an extensible markup language (XML) configuration.

The computer-implemented method of claim 1, wherein step (c) comprises constructing a loop in the template document to process the repeated structured language element.

A computer-implemented method for converting a structured language element of a document into a data structure representing a software object, comprising:
(A) reading each of the structured language elements of the document;
(B) determining a property associated with a structured language element of the document selected from a set of available properties defined by the data structure of the software object;
(C) populating a structured language element value from the document into the property of the data structure representing the software object.

The computer-implemented method of claim 6, wherein step (a) comprises generating an event representing the structure and content of the document.

7. The computer-implemented method of claim 6, wherein step (a) comprises calling back a handler with events representing the structure and content of the document.

7. The computer-implemented method of claim 6, wherein step (a) comprises creating an object model representing the structure and content of the document.

7. The method of claim 6, wherein the structured language element represents an extensible markup language (XML) construct, and step (a) further comprises implementing a document type definition (DTD) and an XML schema standard. Computer implemented method.

The computer-implemented method of claim 10, further comprising maintaining a stack for a recursive XML configuration.

A system for converting a software object (116) containing properties into a document (118) defined by structured language elements, comprising:
(A) a document template (112);
(B) a handler interface (114-1) for providing a representation of the structured language element of the document (118) based on a callback made by the document template (112);
(C) a mapping module (114-2; 114-2) that communicates with the handler interface (114-1) and converts the properties of the software object (116) into structured language elements recognized by the document (118). 114-3),
(D) an output target class (114-4) that communicates with the mapping module (114-2, 114-3) and writes the structured language element generated in step (c) into the document (118) And a system including:

The mapping module includes a mapping interface (114-2) and a mapping class (114-3), wherein the mapping interface (114-2) performs the conversion of the property to the structured language element. 13. A method for executing and setting an output target stream of the document (118), wherein the mapping class (114-3) provides methods used by the mapping interface (114-2). System.

14. The system of claim 13, wherein the output target stream is defined as a buffer.

14. The system of claim 13, wherein the output target stream is defined as a servlet response stream.

The system of claim 12, wherein the structured language element represents an extensible markup language (XML) configuration.

17. The system of claim 16, wherein the document template is created using Java (R) Server Pages (JSP).

A system for converting a document (108) containing structured language elements into a software object (110),
(A) a parser (104) for acquiring an event representing a characteristic of the document (108);
(B) an input source class (106-1) for reading the document (108);
(C) a content handler class (106-2) that communicates with the input source class (106-1) and buffers the event obtained by the parser (104);
(D) a mapping module (106-3, 106) that communicates with the content handler class (106-2) and converts the event obtained by the parser (104) into a property of the software object (110). -4).

The mapping module includes a mapping interface (106-4) and a mapping class (106-3), wherein the mapping interface (106-4) performs the conversion of the event to the property. And setting an output target stream of the software object (110), wherein the mapping class (106-3) provides a method used by the mapping interface (106-4). System.

20. The system of claim 19, wherein the structured language element represents an extensible markup language (XML) configuration.

A method of converting a software object having properties into a document represented by a structured language element, comprising:
(A) providing the software object to an instance of a mapping interface to be invoked;
(B) compiling and executing the template using the instance of the container to be invoked;
(C) writing the document to a specified output stream using the compiled template.

22. The method of claim 21, further comprising calling back the mapping interface to maintain a state of processing.

22. The method of claim 21, further comprising calling an isOptionalElementPresent method via the compiled template to determine whether a selected portion of the document must be generated.

22. The method of claim 21, further comprising calling an isOptionalAttributePresent method via the compiled template to determine whether a selected portion of the document must be generated.

Further comprising maintaining a state of processing using a stack when generating the composite type in the document, wherein the composite type comprises an array, recursion, and a composite type contained within another composite type. 22. The method of claim 21, wherein the method is selected from a group.

26. The method of claim 25, wherein the state of the stack is maintained by calling back from the compiled template to the mapping interface to indicate when the complex type is started and finished.

22. The method of claim 21, further comprising invoking a getElementRepetitions method to determine how many times the template loops at a selected portion of the document.

22. The method of claim 21, wherein the structured language element represents an extensible markup language (XML) configuration and the template is created using Java Server Pages (JSP).

A method of converting a document containing structured language elements into a software object,
(A) providing the document to an instance of the mapping interface to be invoked;
(B) registering the mapping interface as a content handler;
(C) parsing said document using an instance of the called parser;
(D) populating the software object with properties associated with the structured language element parsed from the document via a callback made to the mapping interface.

30. The method of claim 29, wherein step (d) includes a callback for invoking a method selected from the group consisting of startDocument, startElement, characters, endElement, and endDocument.

31. The method of claim 30, wherein a startDocument method and a startElement method executed by the mapping interface create the software object.

30. The method of claim 29, wherein an endElement method executed by the mapping interface sets the property on the software object.

The method of claim 29, wherein the structured language element represents an extensible markup language (XML) configuration.

A computer program product for converting a data structure representing a software object into a structured language element of a document,
(A) a computer readable program code device for generating a structured language element template document;
(B) a computer readable program code device for reading properties associated with the structured language element of the document from the software object;
(C) using the property to obtain a configuration defined by the structured language element based on the association between the property and the structured language element; and
(D) a computer readable program code device for porting the configuration to the structured language element template document.

35. The computer program product of claim 34, wherein step (c) comprises a direct call back to the software object to obtain an event representing the structure defining the structure and content of the document.

35. The computer program product of claim 34, wherein step (c) comprises creating an object model representing the structure and content of the document.

35. The computer program product of claim 34, wherein the structured language element represents an extensible markup language (XML) configuration.

35. The computer program product of claim 34, wherein step (c) comprises constructing a loop in the template document to process the repeated structured language element.

A computer program product that converts a structured language element of a document into a data structure representing a software object,
(A) a computer readable program code device for reading each of the structured language elements of the document;
(B) a computer readable program code device for determining a property associated with a structured language element of the document selected from a set of available properties defined by the data structure of the software object;
(C) a computer readable program code device for populating a structured language element value from the document into the property of the data structure representing the software object.

40. The computer program product of claim 39, wherein step (a) comprises generating an event representing the structure and content of the document.

40. The computer program product of claim 39, wherein step (a) comprises calling back a handler with events representing the structure and content of the document.

40. The computer program product of claim 39, wherein step (a) comprises creating an object model representing the structure and content of the document.

40. The structured language element according to claim 39, wherein the structured language element represents an extensible markup language (XML) construct, and step (a) further comprises implementing a document type definition (DTD) and an XML schema standard. Computer program products.

44. The computer program product of claim 43, further comprising maintaining a stack for a recursive XML configuration.