3. EJBアプリケーションの開発

3.1. チュートリアル

本節ではEJB3.1 アプリケーションについて以下の内容を記述しています。

本手順を行う前に、 [ アプリケーション開発ガイド(概要) > 1. Developer(with Developer's Studio) > 1.2. 環境設定 ] の設定を行ってください。

Memo
ステートレスセッションBean と ステートフルセッションBean と SingletonセッションBean は、手順が類似しているので、 ステートレスセッションBean の場合の説明を詳細に記載しています。 ステートフルセッションBean と SingletonセッションBean の手順については、適宜、該当箇所の読み替えでご理解ください。

3.1.1. ステートレスセッションBeanの作成

ここでは、文字列のやり取りを行うステートレスセッションBeanを作成します。

3.1.1.1. EJB プロジェクトの作成

EJB プロジェクト生成ウィザードを利用して、EJB プロジェクトを作成します。

メニュー ファイル>新規  > プロジェクト を選択して、新規プロジェクト 画面を開きます。

EJB > EJB プロジェクト を選択して、次へ をクリックします。


図3.1.1.1-1

新規 EJB プロジェクト 画面が表示されます。

プロジェクト名 に新規プロジェクト名StatelessBeanSampleを入力して、

ターゲット・ランタイム でWebOTX Application Server v9(Local Default)を選択します。

EJB モジュール バージョン が自動的に3.1となるのを確認した後、次へ をクリックします。

ターゲット・ランタイム にWebOTXサーバーランタイムがない場合、WebOTXマニュアル 1.2.4.1. WebOTXランタイムの設定 を参照の上、設定を行ってください。


図3.1.1.1-2

Java画面が表示されます。

次へ をクリックします。


図3.1.1.1-3

EJB モジュール 画面が表示されます。

完了 をクリックします。


図3.1.1.1-4

プロジェクトStatelessBeanSampleが作成されます。


図3.1.1.1-5

ejbModule/META-INFフォルダ配下にMANIFEST.MFファイルが生成されています。
EJB モジュール画面で、ejb-jar.xmlデプロイメント記述子の生成ON を指定した場合、META-INFフォルダ配下に ejb-jar.xml ファイルも存在することを確認してください。

3.1.1.2. EJB の生成

EJB 生成ウィザード を使用して、EJB アプリケーションをプロジェクトに追加します。

メニュー の ファイル > 新規 > その他 を選択して、新規 画面を開きます。

EJBセッション Bean(EJB 3.x) を選択して、次へ をクリックします。


図3.1.1.2-1

EJB 3.x セッション Beanの作成 画面が表示されます。

Java パッケージにsampleを入力して、

クラス名にTestStatelessSessionBeanを入力して、

ビジネス・インターフェースの作成リモートONにして、ローカルOFF にして、次へ をクリックします。


図3.1.1.2-2

次のEJB 3.x セッション Beanの作成画面が表示されます。 

完了をクリックします。 


図3.1.1.2-3

EJB アプリケーションのソースが追加されます。


図3.1.1.2-4

3.1.1.3. EJBメソッドの作成

Memo
本節での手順は、ステートレスセッションBean の場合と、後述のステートフルセッションBean、SingletonセッションBean の場合とで、 ほとんど違いがありません。
そのため、本節では、ステートフルセッションBeanとSingletonセッションBean の場合の説明も兼ねて、
    (※ステートフルの場合:・・・)
との記載をしていますが、ステートレスセッションBean の場合は、この記載は無視して頂いて結構です。
また、ステートフルセッションBeanやSingletonセッションBean の場合、図中の表記は上記の記載内容で読み替えてご理解ください。

EJBのメソッド追加を行います。
ビジネスメソッドの定義
TestStatelessSessionBeanRemote (※ステートフルの場合:TestStatefulSessionBeanRemote、 Singletonの場合:TestSingletonSessionBeanRemote)クラスに 次のメソッドを定義します。
public String testString( String param );


図3.1.1.3-1

ビジネスメソッドの実装

TestStatelessSessionBean.java (※ステートフルの場合:TestStatefulSessionBean.java、 Singletonの場合:TestSingletonSessionBean.java) に 次のビジネスメソッドを実装します。

public String testString(String param) {
  return param + " come from StatelessBeanSample";";
}
(※ステートフルの場合:return param + " come from StatefulBeanSample"; 、Singletonの場合:return param + " come from SingletonBeanSample";)


図3.1.1.3-2

ビジネスメソッド追加後の再ビルド

最後に、メニュー プロジェクト > クリーンでビルドしてください。


図3.1.1.3-3

3.1.1.4. nec-ejb-jar.xmlデプロイメント記述子の作成

WebOTX専用デプロイメント記述子 nec-ejb-jar.xmlを追加します。

StatelessBeanSample (※ステートフルの場合:StatefulBeanSample、Singletonの場合:SingletonBeanSample) プロジェクトの右クリックメニュー新規 > ファイルを選択します。


図3.1.1.4-1

新規ファイル 画面が表示されます。

親フォルダーを入力または選択 の内容を「StatelessBeanSample/ejbModule/META-INF」とします。 (※ステートフルの場合:「StatefulBeanSample/ejbModule/META-INF」 Singletonの場合:「SingletonBeanSample/ejbModule/META-INF」)

ファイル名 にnec-ejb-jar.xmlを入力します。

完了 をクリックします。


図3.1.1.4-2

StatelessBeanSample(※ステートフルの場合:StatefulBeanSample、Singletonの場合:SingletonBeanSample) プロジェクトのnec-ejb-jar.xmlが作成されます。


図3.1.1.4-3

nec-ejb-jar.xmlのSourceタブをクリックして、下記の内容を追加します。

<?xml version="1.0" encoding="UTF-8"?>
<nec-ejb-jar>
  <enterprise-beans>
    <ejb>
     <ejb-name>TestStatelessSessionBean</ejb-name>
    </ejb>
  </enterprise-beans>
</nec-ejb-jar>
(※ステートフルの場合: <ejb-name>TestStatefulSessionBean</ejb-name>
Singletonの場合: <ejb-name>TestSingletonSessionBean</ejb-name>)

作成されたnec-ejb-jar.xmlファイルは以下のようになります。


図3.1.1.4-4

3.1.2. ステートレスセッションBeanのデプロイ

このチュートリアルでは、ステートレスセッションBean (※ステートフルの場合:ステートフルセッションBean 、Singletonの場合: SingletonセッションBean)を、呼び出し元である 動的 Web プロジェクト とまとめた、 Java EE モジュールとしてデプロイするため、 単独でのデプロイは行いません。

Memo
単独でのデプロイに関しては、3.2.7. EJBコンポーネントのデプロイ をご覧下さい。

3.1.3. ステートレスセッションBeanにアクセスするWebアプリケーションの作成

EJBの使用例として、動的Web プロジェクトから EJB へのアクセスを行います。 

3.1.3.1. Webプロジェクトの作成

ここでは、文字列のやり取りを行う動的 Web プロジェクトを作成します。 

Webプロジェクト生成ウィザードを利用して、動的Webプロジェクトを作成します。

メニュー ファイル > 新規  > プロジェクト を選択して、新規プロジェクト 画面を開きます。

Web > 動的 Web プロジェクト を選択して、次へ をクリックします。


図3.1.3.1-1

動的 Web プロジェクト 画面が表示されます。

プロジェクト名 にDynWebTestを入力して、

ターゲット・ランタイム でWebOTX Application Server v9(Local Default)を選択します。

動的 Web モジュール バージョン が3.0であることを確認し、次へ をクリックします。

ターゲット・ランタイム にWebOTXサーバーランタイムがない場合、WebOTXマニュアル 1.2.4.1. WebOTXランタイムの設定 を参照の上、設定を行ってください。

Memo
ステートフルやSingletonセッションBeanのチュートリアル実施時に、既にステートレスセッションBean のチュートリアルで作成した 動的 Web プロジェクト DynWebTest が存在する場合には、DynWebTest 以外のプロジェクト名で作成し、以降の記載では、 作成した名前での読み替えをお願いします。


図3.1.3.1-2

表示されたJava 画面に 次へ をクリックします。


図3.1.3.1-3

表示されたWeb モジュール 画面に 完了 をクリックすると、プロジェクトDynWebTestが作成されます。


図3.1.3.1-4

3.1.3.2. 入力画面用JSPファイルの作成

Web プロジェクトからEJB プロジェクトへアクセスする、index.jspを作成します。

DynWebTestプロジェクトの右クリックメニュー新規 > JSP Fileを選択します。


図3.1.3.2-1

新規ファイル 画面の、親フォルダーを入力または選択 に 「DynWebTest/WebContent」を指定し、ファイル名 に「index」を入力して 次へ をクリックします。


図3.1.3.2-2

表示されたJSP テンプレートの選択 画面で 完了 をクリックします。


図3.1.3.2-3

DynWebTestプロジェクトのindex.jspが作成されます。


図3.1.3.2-4

EJBプロジェクトへのアクセスを可能するために、DynWebTestにStatelessBeanSample (※ステートフルの場合:StatefulBeanSample、 Singletonの場合:SingletonBeanSample)との依存関係を設定します。

DynWebTestの右クリックメニューの プロパティーを選択してください。 ツリーから、Deployment Assembly を選択すると、Web Deployment Assembly 画面が表示されます。

追加 ボタンをクリックし、New Assembly Directive 画面で、「プロジェクト」 を選択後、次へ ボタンをクリックします。


図3.1.3.2-5

StatelessBeanSample (※ステートフルの場合:StatefulBeanSample、Singletonの場合:SingletonBeanSample) を選択して、完了 ボタンをクリックします。


図3.1.3.2-6

「StatelessBeanSample」(※ステートフルの場合:「StatefulBeanSample」、Singletonの場合:「SingletonBeanSample」) が追加されたのを確認し、OK をクリックします。


図3.1.3.2-7

index.jspのファイルに、EJBプロジェクトへのアクセス処理を追加します。追加後の内容を入力します。

<%@ page language="java" contentType="text/html; charset=windows-31j"
  pageEncoding="windows-31j"%>
<%@ page import = "sample.TestStatelessSessionBeanRemote" %>
<%@ page import = "javax.naming.*" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-31j">
<title>Insert title here</title>
</head>
<body>
<%
  try {
      InitialContext ic  = new InitialContext();
      TestStatelessSessionBeanRemote  StatelessSessionBean =
        (TestStatelessSessionBeanRemote)ic.lookup(TestStatelessSessionBeanRemote.class.getName());
   String result =  StatelessSessionBean.testString("DynWebTest");

   out.println("<p>");
   out.println("Result from EJB: " +  result);
   out.println("<p>");
  } catch (Exception ex) {
   out.println(ex.getMessage());
  }
%>
</body>
</html>

Memo
ステートフルセッションBean の場合、上記のソース中の、"Stateless" は、"Stateful" に変更してください。 SingletonセッションBean の場合、上記のソース中の、"Stateless" は、"Singleton" に変更してください。 また、動的Webプロジェクト名 "DynWebTest" も、実際のプロジェクト名に合わせて変更してください。

入力後のindex.jspファイルです。(ステートレスの場合)


図3.1.3.2-8


3.1.3.3. Webアプリケーションのデプロイ

デプロイは、Webアプリケーションと、EJB アプリケーションを含む、Java EE アプリケーションとして行います。
Java EEアプリケーションの作成および、デプロイについては、Java EEアプリケーションのチュートリアルの 5.1.1. Java EEアプリケーションの作成 をご覧ください。

Memo
5.1.1. Java EEアプリケーションの作成 は、ここまでに説明した、 ステートレスセッションBean の場合を例に記載されています。
そのため、ステートレスセッションBean の場合は、そのままの手順に従って進める事が可能です。
一方、ステートフルやSingletonセッションBean の場合には、
    ・Java EE プロジェクト名(SampleApplication)
    ・Java EEモジュール依存関係での選択項目(DynWebTest, StatelessBeanSample)
を、ここまでに作成したステートフルやSingletonセッションBean の場合に合わせて、変更しながら進める必要があります。

3.1.4. ステートレスセッションBeanの実行(Webアプリケーションからの呼び出し)

配備した Java EE アプリケーションプロジェクトで動作確認を行います。

ツールバーメニューの Web ブラウザーを開く をクリックしてください。

開いたWeb ブラウザーのアドレスに「http://localhost/DynWebTest」を入力して、選択した URL へジャンプ をクリックしてください。(※ステートフルやSingletonの場合:"DynWebTest" は実際に作成した動的Webプロジェクト名に変更してください。) 


図3.1.4-1

EJBで処理が行われ、Web ブラウザーに、以下の結果が表示されます。


図3.1.4-2

3.1.5. ステートレスセッションBeanにアクセスするEJBテストクライアントの作成

Webブラウザーからのアクセス以外にも、EJBテストクライアントからEJBにアクセスすることもできます。 その方法について説明します。

3.1.5.1. EJBテストクライアントの作成

3.1.1. ステートレスセッションBeanの作成 で作成した EJB ステートレスセッションBeanを呼び出すテストクライアントアプリケーションを作成します。 

EJB プロジェクト ウィザードを使用して、プロジェクトを作成します。 

メニュー のファイル > 新規 > プロジェクト を選択して、新規プロジェクト画面を開きます。

EJB > EJB プロジェクト を選択して、次へをクリックします。


図3.1.5.1-1

新規 EJB プロジェクト 画面が表示されます。

プロジェクト名に作成するプロジェクト名、EJBTestを入力して、ターゲット・ランタイム で、 WebOTX Application Server v9(Local Default)を選択します。

EARにプロジェクトを追加ON にします。

EAR プロジェクト名 にEJBTestEARを入力します。

次へをクリックします。

ターゲット・ランタイム にWebOTXサーバーランタイムがない場合、WebOTXマニュアル1.2.4.1. WebOTXランタイムの設定 を参照の上、設定を行ってください。


図3.1.5.1-2

Java 画面が表示されます。

Java アプリケーションをビルドするためのプロジェクトを構成します。次へ をクリックします。


図3.1.5.1-3

EJB モジュール 画面が表示されます。

クライアントのインターフェースとクラスを持つ EJB クライアント JAR モジュールを作成する。ON にし、完了 をクリックすると、プロジェクトEJBTestが作成されます。


図3.1.5.1-4

WebOTXクライアントランタイムをクラスパスに追加します。EJBTestClientの右クリックメニュープロパティを選択します。
プロパティー画面で、Java のビルド・パス > ライブラリーをクリックして、外部JARの追加... をクリックします。


図3.1.5.1-5

JAR の選択ダイアログで、クラスパスを次のように設定します。

表3.1.5.1-1
JARファイル名
${INSTALL_ROOT}/lib/wo-client.jar


${INSTALL_ROOT}は、WebOTXのインストールディレクトリです。

EJBTestClientプロジェクトにEJBクライアント用クラスを作成します。

メニューの ファイル > 新規 > その他... を選択して、 新規 ウィザード画面を表示します。

クラス を選択して、次へをクリックします。


図3.1.5.1-6

新規Javaクラス 画面が表示されます。

名前 に「EJBTestClient」を入力します。

パッケージ に、EJBのクラスと同じ「sample」を入力します。

public static void main(String[] args) をONにします。

完了をクリックします。


図3.1.5.1-7

EJBTestClient プロジェクトのプロパティーを開き、左側ツリー画面で Javaのビルド・パス を選択し、 右画面で プロジェクト タブを選択してから、追加をクリックします。


図3.1.5.1-8

3.1.1. ステートレスセッションBeanの作成 で作成したプロジェクトStatelessBeanSample(※ステートフルの場合:StatefulBeanSample Singletonの場合:SingletonBeanSample)をONにして、OKをクリックします。


図3.1.5.1-9

EJBTestClientのプロパティー画面で、OKをクリックします。


図3.1.5.1-10

EJBを呼び出す記述を行います。以下の例は、 3.1.1. ステートレスセッションBeanの作成 で作成したステートレスセッションBeanを呼び出します。 EJBを呼び出すには、InitialContextクラスのインスタンスを使います。このインスタンスのlookup メソッドを、 EJBインターフェイスの完全限定名を引数に渡して呼び出します。 これで、EJBインターフェイスを取得することができるので、あとは、このEJBインターフェイスを使ってEJBメソッドを呼び出します。

package sample;
import javax.naming.InitialContext;
public class EJBTestClient {
  public static void main(String[] args) {
    try { 
      InitialContext ic = new InitialContext();
      
      TestStatelessSessionBeanRemote statelessRemote =(TestStatelessSessionBeanRemote)ic.lookup(TestStatelessSessionBeanRemote.class.getName()); 
      
      System.out.println("Return From StatelessRemote : = " +statelessRemote.testString("TestString")); 
      
    } catch (Exception ex) { 
      ex.printStackTrace();        
    }
  }
}

Memo
ステートフルセッションBean の場合、上記のソース中の、"Stateless" および、"stateless" は、"Stateful"、"stateful" に変更してください。 SingletonセッションBean の場合、上記のソース中の、"Stateless" および、"stateless" は、"Singleton"、"Singleton" に変更してください。

実行構成の設定

実行構成を設定します。

メニューの実行 > 実行構成 を選択します。Javaアプリケーション > EJBTestClientを選択します。プロジェクトをEJBTestClient とし、メイン・クラスをsample.EJBTestClientと設定します。


図3.1.5.1-11

ビルドを実行してエラーが無ければ、EJBアプリケーションの準備は完了です。

3.1.6. ステートレスセッションBeanの実行(EJBテストクライアントからの呼び出し)

3.1.5.1. EJBテストクライアントの作成で作成したテストクライアントアプリケーションを実行して、EJBの動作確認を行います。

EJBの配備

3.1.1. ステートレスセッションBeanの作成で作成したStatelessBeanSampleをJava EEアプリケーションのチュートリアルの 5.1.1. Java EEアプリケーションの作成 に従って配備を行ってください。

テストクライアントの実行: 

構成および実行を選択し、実行をクリックします。


図3.1.6-1

EJBで処理が行われ、コンソールに、以下の結果が表示されます。


図3.1.6-2

3.1.7. ステートフルセッションBeanの作成

3.1.7.1. EJB プロジェクトの作成

ここでは、文字列のやり取りを行うステートフルセッションBeanを作成します。

EJB プロジェクト生成ウィザードを使用して、EJB プロジェクトを作成します。

メニューの ファイル > 新規 > プロジェクトを選択して、 新規プロジェクト画面を開きます。

EJB > EJB プロジェクトを選択して、次へ をクリックします。


図3.1.7.1-1

新規 EJB プロジェクト 画面が表示されます。

プロジェクト名に作成するプロジェクト名StatefulBeanSampleを入力して、ターゲット・ランタイムにWebOTX Application Server v9(Local Default)を選択します。 次へ をクリックします。

ターゲット・ランタイムにWebOTXサーバーランタイムがない場合、WebOTXマニュアル 1.2.4.1. WebOTXランタイムの設定 を参照の上、設定を行ってください。


図3.1.7.1-2

Java画面が表示されます。

次へ をクリックします。


図3.1.7.1-3

EJB モジュール画面が表示されます。

完了 をクリックします。


図3.1.7.1-4

StatefulBeanSampleプロジェクトが作成されます。


図3.1.7.1-5

プロジェクトのejbModule/META-INFフォルダ配下にMANIFEST.MFファイルが存在することを確認します。

EJB モジュール画面で、ejb-jar.xmlデプロイメント記述子の生成ON の場合、META-INFフォルダ配下にejb-jar.xmlファイルも存在することを確認してください。

3.1.7.2. EJB の生成

セッション Bean生成ウィザードを利用して、セッションBeanをプロジェクトに追加します。

メニューの ファイル > 新規 > その他 を選択すると、新規 画面が表示されます。

EJBセッション Bean (EJB 3.x) を選択して、次へ をクリックします。


図3.1.7.2-1

EJB 3.x セッション Bean の作成画面が表示されます。

Java パッケージにsampleを入力し、

クラス名にTestStatefulSessionBeanを入力し、

状態タイプステートフルに設定し、 ビジネス・インターフェースの作成リモートをONにします。

次へをクリックします。


図3.1.7.2-2

次のEJB 3.x セッション Bean の作成画面で、完了 をクリックします。  


図3.1.7.2-3

ステートフルセッションBeanのソースが追加されます。


図3.1.7.2-4

StatefulBeanSampleプロジェクトのejbModule配下にsampleというパッケージが追加されていることを確認します。

次にsampleパッケージ配下にTestStatefulSessionBeanRemote.javaとTestStatefulSessionBean.javaファイルが追加されていることを確認します。

以降の、StatefulBeanSampleプロジェクトの、メソッド作成から、デプロイおよび動作確認に至る手順は、 前述のステートレスセッションBeanでの、3.1.1.3. EJBメソッドの作成3.1.4. ステートレスセッションBeanの実行(Webアプリケーションからの呼び出し)と同様ですので、そちらを参照してください。

ただし、EJBテストクラインアントの作成時に、必要なプロジェクトの選択で、 ステートフルセッションBeanのStatefulBeanSampleを選択するなど、一部、読み替えが必要な箇所があります。


図3.1.7.2-5

それらに関しては、文中に、
    (※ステートフルの場合:・・・)
という記載があるので、それに沿ってチュートリアルを進めてください。

3.1.8. ステートフルセッションBeanのデプロイ

デプロイは、Webアプリケーションと、EJB アプリケーションを含む、Java EE アプリケーションとして行います。
Java EEアプリケーションの作成および、デプロイについては、Java EEアプリケーションのチュートリアルの 5.1.1. Java EEアプリケーションの作成 を参照してください。

Memo
5.1.1. Java EEアプリケーションの作成 は、 ステートレスセッションBean の場合を例に記載されています。
そのため、ステートフルセッションBean の場合には、
    ・ Java EE プロジェクト名(SampleApplication)
    ・ Java EEモジュール依存関係での選択項目(DynWebTest, StatefulBeanSample)
を、ここまでに作成したステートフルセッションBean の場合に合わせて、変更しながら進める必要があります。

3.1.9. ステートフルセッションBeanの実行

実行に関しては、ステートレスセッションBean の場合と同様ですので、 3.1.4. ステートレスセッションBeanの実行(Webアプリケーションからの呼び出し) をご覧下さい。

3.1.10. SingletonセッションBeanの作成

3.1.10.1. EJB プロジェクトの作成

ここでは、文字列のやり取りを行うSingletonセッションBeanを作成します。

EJB プロジェクト生成ウィザードを使用して、EJB プロジェクトを作成します。

メニューの ファイル > 新規 > プロジェクトを選択して、 新規プロジェクト画面を開きます。

EJB > EJB プロジェクトを選択して、次へ をクリックします。


図3.1.10.1-1

新規 EJB プロジェクト 画面が表示されます。

プロジェクト名に作成するプロジェクト名SingletonBeanSampleを入力して、ターゲット・ランタイムにWebOTX Application Server v9(Local Default)を選択します。 次へ をクリックします。

ターゲット・ランタイムにWebOTXサーバーランタイムがない場合、WebOTXマニュアル 1.2.4.1. WebOTXランタイムの設定 を参照の上、設定を行ってください。


図3.1.10.1-2

Java画面が表示されます。

次へ をクリックします。


図3.1.10.1-3

EJB モジュール画面が表示されます。

完了 をクリックします。


図3.1.10.1-4

SingletonBeanSampleプロジェクトが作成されます。


図3.1.10.1-5

プロジェクトのejbModule/META-INFフォルダ配下にMANIFEST.MFファイルが存在することを確認します。

EJB モジュール画面で、ejb-jar.xmlデプロイメント記述子の生成ON の場合、META-INFフォルダ配下にejb-jar.xmlファイルも存在することを確認してください。

3.1.10.2. EJB の生成

セッション Bean生成ウィザードを利用して、セッションBeanをプロジェクトに追加します。

メニューの ファイル > 新規 > その他 を選択すると、新規 画面が表示されます。

EJBセッション Bean (EJB 3.x) を選択して、次へ をクリックします。


図3.1.10.2-1

EJB 3.x セッション Bean の作成画面が表示されます。

Java パッケージにsampleを入力し、

クラス名にTestSingletonSessionBeanを入力し、

状態タイプSingletonに設定し、 ビジネス・インターフェースの作成リモートをONにします。

次へをクリックします。


図3.1.10.2-2

次のEJB 3.x セッション Bean の作成画面で、完了 をクリックします。  


図3.1.10.2-3

SingletonセッションBeanのソースが追加されます。


図3.1.10.2-4

SingletonBeanSampleプロジェクトのejbModule配下にsampleというパッケージが追加されていることを確認します。

次にsampleパッケージ配下にTestSingletonSessionBeanRemote.javaとTestSingletonSessionBean.javaファイルが追加されていることを確認します。

以降の、SingletonBeanSampleプロジェクトの、メソッド作成から、デプロイおよび動作確認に至る手順は、 前述のステートレスセッションBeanでの、3.1.1.3. EJBメソッドの作成3.1.4. ステートレスセッションBeanの実行(Webアプリケーションからの呼び出し)と同様ですので、そちらを参照してください。

ただし、EJBテストクラインアントの作成時に、必要なプロジェクトの選択で、 SingletonセッションBeanのSingletonBeanSampleを選択するなど、一部、読み替えが必要な箇所があります。


図3.1.10.2-5

それらに関しては、文中に、
    (Singletonの場合:・・・)
という記載があるので、それに沿ってチュートリアルを進めてください。

3.1.11. SingletonセッションBeanのデプロイ

デプロイは、Webアプリケーションと、EJB アプリケーションを含む、Java EE アプリケーションとして行います。
Java EEアプリケーションの作成および、デプロイについては、Java EEアプリケーションのチュートリアルの 5.1.1. Java EEアプリケーションの作成 を参照してください。

Memo
5.1.1. Java EEアプリケーションの作成 は、 ステートレスセッションBean の場合を例に記載されています。
そのため、SingletonセッションBean の場合には、
    ・ Java EE プロジェクト名(SampleApplication)
    ・ Java EEモジュール依存関係での選択項目(DynWebTest, SingletonBeanSample)
を、ここまでに作成したSingletonセッションBean の場合に合わせて、変更しながら進める必要があります。

3.1.12. SingletonセッションBeanの実行

実行に関しては、ステートレスセッションBean の場合と同様ですので、 3.1.4. ステートレスセッションBeanの実行(Webアプリケーションからの呼び出し) をご覧下さい。

3.1.13. メッセージ駆動型Beanの作成

メッセージ駆動型 Bean にはホーム インタフェースやリモート インタフェースがありません。 したがって、内部または外部のクライアントから直接アクセスできません。 クライアントは、JMS キューまたは JMS トピックにメッセージを送信することで間接的にメッセージ駆動型 Bean にメッセージを渡します。

ここでは、JMS キューでメッセージを送信する例について説明します。

3.1.13.1. 事前設定

JMS キュー関連の設定を行います。
設定に際しては、まず、配備予定のユーザドメインへログインしてください。
物理的な送信先の作成
下記コマンドで物理的送信先(JMS キュー)を作成します。作成される送信先リソースのJNDI名は、jms/MyQueueとなります。
        otxadmin> create-jmsdest --desttype queue --cascade MyQueue
    
詳細は、7.1.4.2. 物理的な送信先の作成を参照してください。
コネクションファクトリリソースの作成
下記コマンドでJMSサーバへの接続に必要なコネクションファクトリリソースを作成します。
        otxadmin>  create-jms-resource --restype javax.jms.QueueConnectionFactory jms/MyQCF
    
詳細は、7.1.4.3. コネクションファクトリリソースの作成を参照してください。

3.1.13.2. EJB プロジェクトの作成

ここでは、文字列のやり取りを行うメッセージ駆動型Beanを作成します。

EJBプロジェクトの作成

EJBプロジェクト生成ウィザードを使用して、EJB プロジェクトを作成します。

メニューのファイル > 新規 > プロジェクトを選択して、新規プロジェクト画面を開きます。

EJB > EJB プロジェクトを選択して、次へ をクリックします。


図3.1.13.2-1

新規 EJB プロジェクト 画面が表示されます。

プロジェクト名に作成するプロジェクト名MessageDrivenBeanSampleを入力して、ターゲット・ランタイムにWebOTX Application Server v9(Local Default)を選択します。 次へ をクリックします。

ターゲット・ランタイムにWebOTXサーバーランタイムがない場合、WebOTXマニュアル 1.2.4.1. WebOTXランタイムの設定 を参照の上、設定を行ってください。


図3.1.13.2-2

Java画面が表示されます。

次へ をクリックします。


図3.1.13.2-3

EJB モジュール画面が表示されます。

完了 をクリックします。


図3.1.13.2-4

プロジェクトMessageDrivenBeanSampleが作成されます。


図3.1.13.2-5

プロジェクトのMETA-INFフォルダ配下にMANIFEST.MFファイルが存在することを確認します。

EJB モジュール画面で、ejb-jar.xmlデプロイメント記述子の生成ON の場合、META-INFフォルダ配下にejb-jar.xmlファイルも存在することを確認してください。

3.1.13.3. EJB の生成

メッセージ駆動型 Bean生成ウィザードを利用して、Beanをプロジェクトに追加します。

メニューの ファイル > 新規 > その他 を選択すると、新規 画面が表示されます。

EJBメッセージ駆動型 Bean (EJB 3.x) を選択して、次へ をクリックします。


図3.1.13.3-1

EJB 3.x メッセージ駆動型 Bean の作成画面が表示されます。

Java パッケージにsampleを入力し、

クラス名にTestMessageDrivenBeanを入力し、

JMSがONの状態のままで、宛先タイプキューに設定し、次へをクリックします。


図3.1.13.3-2

次のEJB 3.x メッセージ駆動型 Bean の作成画面で、完了をクリックします。


図3.1.13.3-3

MessageDrivenBeanSampleプロジェクトにメッセージ駆動型Beanのソースが追加されます。


図3.1.13.3-4

3.1.13.4. EJBメソッドの作成

EJBのメソッドの追加を行います。

ビジネスメソッドの実装

TestMessageDrivenBeanクラスに物理的な送信先の作成で作成したJMS キューを指定し、onMessageメソッドを実装します。

    import javax.ejb.ActivationConfigProperty;
    import javax.ejb.MessageDriven;
    import javax.jms.JMSException;
    import javax.jms.Message;
    import javax.jms.MessageListener;
    import javax.jms.TextMessage;
		
	
    @MessageDriven(
      activationConfig = { @ActivationConfigProperty(
        propertyName = "destinationType", propertyValue = "javax.jms.Queue"
      ) }, 
      mappedName = "jms/MyQueue")
    public class TestMessageDrivenBean implements MessageListener {
    
        /**
         * Default constructor. 
         */
        public TestMessageDrivenBean() {
            // TODO Auto-generated constructor stub
        }
     
        /**
         * @see MessageListener#onMessage(Message)
         */
        public void onMessage(Message message) {
            // TODO Auto-generated method stub
         TextMessage msg = (TextMessage)message;
           try {
            System.out.println(msg.getText()+" come from MessageDrivenBean");
           } catch (JMSException e) {
            e.printStackTrace();
           }
        }
    }
    
TestMessageDrivenBeanクラスは下図のようになります。


図3.1.13.4-1

最後に、メニュー プロジェクト>クリーンでビルドしてください。


図3.1.13.4-2

3.1.13.5. テストクライアントの作成

Java プロジェクト ウィザードを使用して、プロジェクトを作成します。 メニュー のファイル > 新規 > プロジェクト を選択して、新規プロジェクト画面を開きます。 Java > Java プロジェクト を選択して、次へ をクリックします。


図3.1.13.5-1

新規 Java プロジェクト 画面が表示されます。 プロジェクト名に作成するプロジェクト名、EJBTestMDClientを入力します。 完了をクリックします。


図3.1.13.5-2

プロジェクトEJBTestMDClientが作成されます。 実行用ライブラリをクラスパスに追加します。EJBTestMDClientの右クリックメニュープロパティを選択し ます。 プロパティー画面で、Javaのビルド・パス>ライブラリーをクリックして、外部JARの追加 をクリックします。


図3.1.13.5-3

JAR の選択ダイアログで、クラスパスを次のように設定します。{INSTALL_ROOT}は、WebOTXのインストールディレクトリです。
表3.1.13.5-1
JARファイル名
${INSTALL_ROOT}/lib/wo-client.jar
${INSTALL_ROOT}/lib/install/applications/jmsra/wojmsra.jar

EJBTestMDClientプロジェクトにクライアント用クラスを作成します。

メニューの ファイル > 新規 > その他... を選択して、新規 ウィザード画面を表示します。クラス を選択して、次へをクリックします。


図3.1.13.5-4

新規 Javaクラス画面が表示されます。
名前EJBTestClientを入力します。
パッケージに、EJBのクラスと同じsampleを入力します。
public static void main(String[] args)を選択します。
完了をクリックします。


図3.1.13.5-5

JMS キューにメッセージを送信する過程について説明します。以下の例は、 3.1.13.1. 事前設定 > 物理的な送信先の作成で作成したJMS キューにメッセージを送信します。
JMS キューにメッセージを送信するには、InitialContextクラスのインスタンスを使います。
このインスタンスのlookupメソッドを、コネクションファクトリ名を引数に渡して呼び出すと、コネクションファクトリを作成することができます。
同様に、このインスタンスのlookupメソッドを、 JMSキュー名のJNDI名を引数に渡して呼び出すと、メッセージ送信先を取得することができます。
ここまでに、作成したコネクションファクトリと取得したメッセージ送信先を利用し、JMS キューにメッセージを送信することができます。

コードは、以下のようになります:
 
    package sample;

    import javax.jms.QueueConnection;
    import javax.jms.QueueConnectionFactory;
    import javax.jms.QueueSession;
    import javax.jms.TextMessage;
    import javax.naming.Context;
    import javax.naming.InitialContext;

    public class EJBTestMDClient {
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		send("TestString");
    
    	}
    
    	public static void send(String msg) {
    		try {
    			Context ctx = new InitialContext();
    			QueueConnectionFactory factory = (QueueConnectionFactory) ctx
    					.lookup("jms/MyQCF");
    			QueueConnection con = factory.createQueueConnection();
    			QueueSession session = con.createQueueSession(false,
    					QueueSession.AUTO_ACKNOWLEDGE);
    			javax.jms.Queue destination = (javax.jms.Queue) ctx
    					.lookup("jms/MyQueue");
    			javax.jms.QueueSender sender = session.createSender(destination);
    			TextMessage message = session.createTextMessage(msg);
    			sender.send(message);
    			session.close();
    			con.close();
    			System.out.println("Success");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    
EJBTestMDClientクラスは下図のようになります。


図3.1.13.5-6

3.1.14. メッセージ駆動型Beanのデプロイ

メッセージ駆動型Bean MessageDrivenBeanSample をサーバにデプロイします。
デプロイの手順については、3.2.7. EJBコンポーネントのデプロイ をご覧下さい。

3.1.15. メッセージ駆動型Beanの実行

作成したテストクライアント EJBTestMDClient を実行して、EJBの動作確認を行います。
実行構成の設定方法について、3.1.5.1. EJBテストクライアントの作成 > 実行構成の設定をご覧下さい。 メニューから実行 > 構成実行を選択し、表示された構成実行画面で、実行をクリックします。


図3.1.15-1

EJBで処理が行われ、コンソールに、以下の結果が表示されます。


図3.1.15-2

同時に、サーバのログファイルserver.log(${INSTALL_ROOT}/domains/domain1/logs/server.log)に下記の内容は出力されます。
 
    TestString come from MessageDrivenBean
    
${INSTALL_ROOT}は、WebOTXのインストールディレクトリです。

3.1.16. JPAアプリケーションの作成

3.1.16.1. Java Persistence APIとは

ここでは、文字列のやり取りを行う JPA プロジェクトを作成します。

3.1.16.2. JPA環境の準備

JPAを利用するために、データベースが必要です。このチュートリアルでは、Apache Derby を利用します。
以下の説明では、C:\Program Files\Sun\JavaDB にインストールされているものとします。
JPAライブラリーのコンフィグレーション
メニューのウィンドウ > 設定 を選択し 設定 画面を開き、Java > ビルド・パス > ユーザー・ライブラリー を選択すると、ユーザー・ライブラリー 設定画面が表示されます。

新規... をクリックします。


図3.1.16.2-1

新規ユーザー・ライブラリー 画面が表示されるので、ユーザー・ライブラリー名JPAと入力して、OK をクリックします。


図3.1.16.2-2

ユーザー・ライブラリー 設定画面にJPAが表示されます。

外部 JARの追加... をクリックします。


図3.1.16.2-3

JARの選択 画面が表示されます。

{WebOTXインストールディレクトリ}\modulesから、
を選択して、開く をクリックします。
ユーザー・ライブラリー 設定画面で、OKをクリックします。
これで、JPAライブラリーのコンフィグレーションが完了します。


図3.1.16.2-4

データベース接続の新規作成
次の操作はJPA パースペクティブで行います。
メニューの ウィンドウ > パースペクティブ > その他...を選択します。
パースペクティブを開く 画面で、JPA を選択して、OK をクリックします。


図3.1.16.2-5

JPA Development パースペクティブが表示されます。


図3.1.16.2-6

データ・ソース・エクスプローラーが表示されることを確認します。
データ・ソース・エクスプローラーで、データベース接続の右クリックメニュー 新規... を選択します。


図3.1.16.2-7

接続プロファイル画面が表示されます。
Derby を選択して、 名前には新規 Derbyを入力します。
次へをクリックします。


図3.1.16.2-8

ドライバーおよび接続の詳細の指定画面が表示されます。
新規ドライバー定義をクリックします。


図3.1.16.2-9

ドライバー・テンプレートおよび定義名の指定画面が表示されます。
名前/タイプ のタブから データベースリストから Derby 10.0用 Derby 組み込みドライバー10.2 を選択して、
Jar リストタブをクリックします。


図3.1.16.2-10

ドライバー・テンプレートおよび定義名の指定画面のJar リストタブページが表示されます。
ドライバー・ファイルのリスト内のderby.jarを選択し、 JAR/Zip の編集ボタンで起動するダイアログで、環境内のライブラリのパス、

C:\Program Files\Sun\JavaDB\lib\derby.jar

で更新後、画面を閉じます。

ドライバーおよび接続の詳細の指定画面が表示されますので、一般タブページの項目を適宜、設定します。

※以下は、データベース・ロケーションC:\MyDBを設定した場合の画面です。


図3.1.16.2-11

全ての項目を入力した後、接続のテストをクリックします。
下の画面が表示されると、データベースへの接続は成功です。
OK をクリックします。


図3.1.16.2-12

データ・ソース・エクスプローラーで、新規されたデータベース情報が表示されます。
これで、チュートリアル用データベース接続は完了です。


図3.1.16.2-13

3.1.16.3. JPAモジュールを持つEJBプロジェクトの作成

WebOTX Developerでは、以下のプロジェクトで、JPAモジュールが利用できます。
EJB プロジェクト生成ウィザードを利用して、EJBプロジェクトを作成します。
メニューのファイル > 新規 > プロジェクト を選択し、新規プロジェクト 画面を開き、EJB > EJB プロジェクトを選択して、次へをクリックします。


図3.1.16.3-1

新規EJB プロジェクト画面が表示されます。
プロジェクト名に新規プロジェクト名TestEJB4JPAを入力して、
EJB モジュール バージョン3.1を選択して、 構成変更...をクリックします。


図3.1.16.3-2

プロジェクト・ファセット画面が表示されるので、 JPAファセットを選択後、 OKをクリックします。


図3.1.16.3-3

Memo
JPA の Version には、2.0 を選択してください。

新規EJB プロジェクト画面の次へ をクリックすると、Java画面が表示されます。


図3.1.16.3-4

次へで、JPA ファセット画面を表示し、次の値を設定します。


図3.1.16.3-5

表3.1.16.3-1
属性
プラットフォームGeneric 2.0
JPA 実装JPA を選択
接続新規 Derby
ビルド・パスにドライバー・ライブラリーを追加選択
ドライバーDerby 10.0用 Derby 組み込み JDBC ドライバー
注釈つきクラスをpersistence.xml に記述選択
Create mapping file非選択
完了をクリックすると、EJBプロジェクトTestEJB4JPAが作成されます。


図3.1.16.3-6

3.1.16.4. テーブルの生成

このEJBプロジェクトで利用するテーブルの作成を例に、データベースの操作について説明します。

プロジェクト・エクスプローラーで、TestEJB4JPAの右クリックメニューの 新規 > ファイル を選択して、新規ファイル 画面を開きます。
親フォルダーを入力または選択(E)に、 TestEJB4JPA/ejbModule/test/jpa を、ファイル名(M)createTable.sqlを入力して、完了をクリックします。


図3.1.16.4-1

EJBプロジェクトTestEJB4JPAに作成された、createTable.sqlがエディタで開かれます。


図3.1.16.4-2

createTable.sqlファイルの接続プロファイルに、
表3.1.16.4-1
属性
タイプDerby_10.x
名前新規 Derby
データベースMyDB
を設定し、状態接続であることを確認し、以下の内容を入力します。
drop table STUDENT;
create table STUDENT (
  ID integer not null primary key,
  MYLOCK integer,
  NAME VARCHAR(30),
  SPORT VARCHAR(30)
);
insert into STUDENT values(100, 10, 'WangHaidong', 'BasketBall');


図3.1.16.4-3

エディタで、createTable.sqlファイルの、create、insert のSQL文命令を順次選択して、右クリックメニュー の 選択したテキストを実行 を選択します。


図3.1.16.4-4

実行後、テーブルが作成されています。


図3.1.16.4-5

3.1.16.5. Entityの生成

JPAツールを使って、Entity クラスを作成します。

プロジェクト・エクスプローラーで、TestEJB4JPAの右クリックメニューの JPA ツール > テーブルからエンティティーを生成 を選択します。


図3.1.16.5-1

テーブルの選択 画面が表示されるので、 接続 コンボボックスから新規 Derbyを選択します。
スキーマコンボボックスから対応するスキーマを選択し、 テーブル リストのSTUDENTONにします。
Update class list in persistence.xmlONにします。


図3.1.16.5-2

次へをクリックしすると、 テーブルの関連付け 画面が表示されます。
テーブルの関連付け画面で、次へをクリックします。

ソース・フォルダーTestEJB4JPA\ejbModuleを、 パッケージtest.jpaを入力します。


図3.1.16.5-3

次へをクリックします。
個々のエンティティーカスタマイズ 画面が表示されます。


図3.1.16.5-4

ここでは、カスタマイズの例として、マッピング型の変更方法を紹介します。
後ほど、ここで変更したマッピング型を前提の Java ソースを記述しますので、必ず、変更を行ってください。

テーブルおよび列で、ID を選択すると、ID のマッピング型を変更できます。 ここでは、int から long に変更します。


図3.1.16.5-5

同様に、MYLOCK のマッピング型を BigDecimal に変更します。


図3.1.16.5-6

完了をクリックすると、 EJBプロジェクトTestEJB4JPAに、EntityクラスStudent.javaが作成されます。


図3.1.16.5-7

3.1.17. JPAアプリケーションの動作確認

ここでは、作成されたEntityを利用して、JPAの動作確認を行います。
まずは、Entityを呼び出す Java アプリケーションを作成します。

3.1.17.1. テストファイルの作成

パッケージ・エクスプローラーで、TestEJB4JPA の右クリックメニューの 新規 > クラス を選択します。


図3.1.17.1-1

新規 Java クラス 画面が表示されます。
ソース・フォルダー にTestEJB4JPA/ejbModuleを入力します。
パッケージtest.jpaを、 名前TestJPAClientを入力します。
public static void main(String[] args) をONにして、完了をクリックします。


図3.1.17.1-2

テストファイルTestJPAClient.javaが作成されます。


図3.1.17.1-3

処理の概要は、以下の通りです。
  1. 新たなデータを作成します。(乱数を用いたダミーのデータ)
  2. データベースからテーブルの一覧を取得し、表示します。
  3. 永続化によりデータを追加します。
  4. 再びテーブル一覧を取得し、データが追加されている事を確認します。
  5. 追加したデータを削除して終了します。 (これは、データベースを変更しないようにする為の、このチュートリアル特有の処理です。)
TestJPAClient.javaの実装例は以下のようになります。
package test.jpa;

import java.math.BigDecimal;
import java.util.List;
import java.util.Random;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

public class TestJPAClient {
	private static EntityManagerFactory factory = Persistence
			.createEntityManagerFactory("TestEJB4JPA");

	public static void main(String[] args) {
		EntityManager manager = TestJPAClient.factory.createEntityManager();

		/* データの作成 */
		Random random = new Random();
		Long id = new Long(random.nextInt(10000));
		BigDecimal index = new BigDecimal(random.nextInt(100));
		Student bean = new Student();
		bean.setId(id);
		bean.setMylock(index);
		bean.setName("name" + index);
		bean.setSport("sport" + index);

		manager.getTransaction().begin();
		try {
			/* 操作前のテーブルの一覧を表示 */
			Query query = manager.createQuery("select A from Student A");
			List<Student> list = query.getResultList();
			showResult(list, "***********Beforeinsertdata************");

			/* 永続化 */
			manager.persist(bean);

			/* 操作後のテーブルの一覧を表示 */
			list = query.getResultList();
			showResult(list, "***********Afterinsertdata************");

			/* remove 後に commit */
			manager.remove(bean);
			manager.getTransaction().commit();

		} catch (Exception e) {
			e.printStackTrace();
			manager.getTransaction().rollback();
		} finally {
			manager.close();
		}
	}

	/* 一覧の表示メソッド */
	private static void showResult(List<Student> list, String label) {
		System.out.println(label);
		for (Student student : list) {
			StringBuffer recordInfo = new StringBuffer();
			recordInfo.append(student.getId()).append("| ");
			recordInfo.append(student.getMylock()).append("| ");
			recordInfo.append(student.getName()).append("| ");
			recordInfo.append(student.getSport());
			System.out.println(recordInfo.toString());
			System.out.println("----------------------------------------");
		}
	}
}
@NamedQuery を用いた実装
先の実装例では、Java ソース内に、JPQL命令を静的に記載していました。
    Query query = manager.createQuery("select A from Student A");
このような、静的なJPQL命令は、Entity クラス内に @NamedQuery を用いて定義する事もできます。
@Entity
@NamedQuery(name="Student.select", query="select A from Student A")
public class Student implements Serializable {
  private static final long serialVersionUID = 1L;

  @Id
  private long id;
@NamedQuery で定義した命令は、name で指定した名前"Student.select"を用いて、以下のように利用する事ができます。
    Query query = manager.createNamedQuery("Student.select");
また、@NamedQuery は、@NamedQueries を用いる事で、複数定義する事も可能です。
@NamedQueries({
    @NamedQuery(name="Student.select", query="select A from Student A"),
    @NamedQuery(name="Student.select2", query="select A from Student A where A.sport='BasketBall'")
})
public class Student implements Serializable {
@NamedQuery での定義により静的なJPQL命令を集約することで、 Java ソースの可読性と保守性が向上します。

3.1.17.2. persistence.xmlの設定

データベース接続のプロパティ との関連性
persistence.xml の右クリックメニュー のアプリケーションから開くで、永続化 XML エディタを選択します。


図3.1.17.2-1

追加ボタンを用いて、次のプロパティーを設定します。
表3.1.17.2-1
属性
javax.persistence.jdbc.driverorg.apache.derby.jdbc.EmbeddedDriver
javax.persistence.jdbc.urljdbc:derby:C:\MyDB;Create=true
javax.persistence.jdbc.user
javax.persistence.jdbc.password
ここで設定する、eclipselink.jdbc.driver 以外の値は、データベース接続の新規作成で指定した値に対応させる必要があります。 その内容は、JPAパースペクティブのデータベース接続のプロパティで確認する事ができます。


図3.1.17.2-2

設定後の、persistence.xmlファイルの例は以下の通りです。 "eclipselink.jdbc.driver" 以外の指定は、環境設定により異なりますので、適宜、適切な値を指定してください。
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
  <persistence-unit name="TestEJB4JPA">
    <class>test.jpa.Student</class>
    <properties>
      <property name="javax.persistence.jdbc.driver" value="org.apache.derby.jdbc.EmbeddedDriver"/>
      <property name="javax.persistence.jdbc.url" value="jdbc:derby:C:\MyDB;create=true"/>
      <property name="javax.persistence.jdbc.user" value=""/>
      <property name="javax.persistence.jdbc.password" value=""/>
    </properties>
  </persistence-unit>
</persistence>
EntityManagerFactory との関連性
persistence.xmlファイル中の指定、
<persistence-unit name="TestEJB4JPA">
は、前掲の TestJPAClient.java 中の、
private static EntityManagerFactory factory =
         Persistence.createEntityManagerFactory("TestEJB4JPA");
と一致させる必要があります。

3.1.17.3. データベースのドライバーの追加

Memo
プロジェクトの作成時に、ビルド・パスにドライバー・ライブラリーを追加を選択している場合、 再度、データベースのドライバーを追加する必要はありません。 その場合、プロジェクト・ツリーに、Derby 組み込み JDBC ドライバーが表示されている事を確認の上、 次の、「テスト実行」の節に進んでください。

パッケージ・エクスプローラーの TestEJB4JPAの右クリックメニューでプロパティー を選択します。
表示された画面で Java のビルド・パスを選択後、ライブラリー タブを開き、 ライブラリーの追加 をクリックします。


図3.1.17.3-1

ライブラリーの追加 画面のリストから接続ドライバー定義を選択し、 次へをクリックします。


図3.1.17.3-2

接続ドライバー定義 画面で使用可能なドライバー定義 から Derby 組み込み JDBC ドライバー を選択し、完了をクリックします。


図3.1.17.3-3

ライブラリー タブに Derby 組み込み JDBC ドライバー が追加されているのを確認後、OKをクリックします。


図3.1.17.3-4

パッケージ・エクスプローラーでも Derby 組み込み JDBC ドライバー ライブラリーが追加されたことを確認します。


図3.1.17.3-5

3.1.17.4. テストの実行

パッケージ・エクスプローラーで、TestEJB4JPAのTestJPAClient.javaを選択して、
右クリックメニュー 実行 > 2 Javaアプリケーション を選択します。


図3.1.17.4-1

EJBプロジェクトが正しく実行されること、以下の結果が表示されます。


図3.1.17.4-2

Memo
"Derby の別のインスタンスがすでにデータベース 〜 をブートしている可能性があります。"
と言うエラーが発生した場合、JPAパースペクティブでのデータベース接続を切断してから、再度、実行してください。

3.1.18. JPAアプリケーションのデプロイ

ここで作成したアプリケーションは、クライアント環境でも動作する通常のアプリケーションですので、 サーバへのデプロイは不要です。

3.1.19. JPAアプリケーションの実行(Webアプリケーションからの呼び出し)

JPAモジュールを持つWebアプリケーションの例です。データベースのテーブル定義や、Entity クラスなどは、前述の例と共用しています。
まずは、[3.1.16.2. JPA環境の準備]を参照して、JPAの環境準備を行ってください。

3.1.19.1. テスト用Webプロジェクトの作成

動的 Web プロジェクト生成ウィザードを利用して、動的Webプロジェクトを作成します。
メニュー ファイル > 新規 > プロジェクト を選択して、新規プロジェクト 画面を開きます。
Web > 動的Web プロジェクト を選択して、次へをクリックします。


図3.1.19.1-1

新規動的 Web プロジェクト 画面が表示されます。
プロジェクト名 に新規プロジェクト名TestWeb4JPAを入力します。
ターゲット・ランタイムでWebOTX Application Server v9(Local Default)を選択します。
ターゲット・ランタイムが存在しない場合、[3.1.1.1. EJB プロジェクトの作成]を参照してください。
構成変更... をクリックします。


図3.1.19.1-2

プロジェクト・ファセット 画面が表示されます。
動的 Web モジュールファセットのバージョンを3.0にします。
Java ファセットのバージョンを1.7にします。
JPA ファセットをONにします。
OKをクリックします。


図3.1.19.1-3

新規動的 Web プロジェクト画面に戻ります、
次へをクリックすると、 Java画面が表示されます。


図3.1.19.1-4

JPA ファセット 画面が表示されるので以下を指定します。
表3.1.19.1-1
属性
プラットフォームGeneric 2.0
JPA 実装JPA を選択
接続新規 Derby
ビルド・パスにドライバー・ライブラリーを追加選択
ドライバーDerby 10.0用 Derby 組み込み JDBC ドライバー
注釈つきクラスをpersistence.xml に記述選択
Create mapping file非選択
完了をクリックします。


図3.1.19.1-5

次へをクリックすると、 Web モジュール画面が表示されます。
web.xmlデプロイメント記述子の生成 をONにします。
完了をクリックします。 


図3.1.19.1-6

WebプロジェクトTestWeb4JPAが作成されます。


図3.1.19.1-7

3.1.19.2. テーブルの生成

ここで利用するテーブルは、[3.1.16.4. テーブルの生成] で作成したものと同じです。

3.1.19.3. Entityの生成

ここで利用する Entity クラスは、[3.1.16.5. Entityの生成] で作成したものと同じです。

3.1.19.4. JSPファイルの作成

JSP生成ウィザードを使って、テスト用index.jspファイルを作成します。
パッケージ・エクスプローラーで、「TestWeb4JPA」の右クリックメニューの 新規 > その他... を選択します。
ウィザードを選択 画面が表示されます。
Web > JSP を選択して、
次へをクリックします。


図3.1.19.4-1

JavaServer ページ画面が表示されます。
親フォルダーを入力または選択 にTestWeb4JPA\WebContentを入力します。
ファイル名 にindex.jspを入力します。
完了をクリックします。


図3.1.19.4-2

TestWeb4JPAプロジェクトにindex.jspファイルが追加されます。


図3.1.19.4-3

動作時の index.jspの外観は以下の通りです。


図3.1.19.4-4

また、以下の JavaScript の関数を実装しています。
表3.1.19.4-1
処理 javascript ボタン
一覧表示 getDbInfo() Inquire
データの挿入 insertInfoToDb() insert
データの削除 deleteInfoFromoDb() Delete
初期化 initialize() -
結果出力 updatePage() -
ボタン押下時の、各データベース操作は独立した処理で、それらを一つの JSP に記載した結果、 index.jspの全体像は、以下のようになります。
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>TestWeb4JPA</title>
<script language="javascript" type="text/javascript">

   var request = false;
   
   function initialize(){
      try {
        request = new XMLHttpRequest();
      } catch (trymicrosoft) {
        try {
          request= new ActiveXObject("Msxml2.XMLHTTP");
        } catch (othermicrosoft){
          try {
            request= new ActiveXObject("Microsoft.XMLHTTP");
          }catch (failed) {
            request=false;
        }
      }
    }
    if (!request) alert("Error initializing XMLHttpRequest!");
  }
  
  /* Insert Button */
  function insertInfoToDb() {
    var idForInert =document.getElementById("idForInert").value;
    var myLock =document.getElementById("myLock").value;
    var name =document.getElementById("name").value;
    var sport =document.getElementById("sport").value;
    if (isNaN(idForInert) || idForInert == null || idForInert=="") {
      alert("Id must is a number");
      return;
    }
    if (isNaN(myLock) || myLock == null || myLock =="") {
      alert("my Lock must is a number");
      return;
    }
    var commonad = "<request><command name=\"insert\">" + "<param id=\"" +
    idForInert + "\" myLock=\"" + myLock + "\" name=\"" +
    name + "\" sport=\"" + sport + "\" /></command></request>";
    var url = "TestServlet";
    request.open("POST",url, true);
    request.onreadystatechange =updatePage;
    request.send(commonad);
  }
  
  /* Inquire Button */
   function getDbInfo() {
    var myLock =document.getElementById("myLock").value;
    var name= document.getElementById("name").value;
    var sport= document.getElementById("sport").value;
    var commonad= "<request><command  name=\"inquire\">"+
                 "<parammy  Lock=\"" + myLock + "\"  name=\"" + name +
                 "\"  sport=\"" + sport + "\"/></command></request>";
    var url= "TestServlet";
    request.open("POST",url,true);
    request.onreadystatechange =updatePage;
    request.send(commonad);
  }
  
  /* Delete Button */
  function deleteInfoFromoDb() {
    var studentId =document.getElementById("studentId").value;
    if(isNaN(studentId)|| studentId == null || studentId==""){
      alert("IDmust is a number");
      return;
    }
    var commonad ="<request><command name=\"delete\">" +
                "<param studentId=\"" + studentId + "\"/></command></request>";
    var url = "TestServlet";
    request.open("POST",url, true);
    request.onreadystatechange =updatePage;
    request.send(commonad);
  }
  
  /* View Update */
  function updatePage() {
   if (request.readyState== 4) {
      if (request.status== 200) {
        var response =request.responseText;
        document.getElementById("resultFromDb").innerHTML= response.replace(/\n/g, "");
        document.getElementById("studentId").disabled=false;
        document.getElementById("deleteButton").disabled=false;
      }else {
        alert("status is " + request.status);
      }
    }
  }
</script>
</head>

<body onLoad="initialize();">
<h1>TestWeb4JPA</h1>
    <table>
      <tr>
        <th bgColor="palegreen"></th>
        <th bgColor="palegreen">ID</th>
        <th bgColor="palegreen">MYLOCK</th>
        <th bgColor="palegreen">NAME</th>
        <th bgColor="palegreen">SPORT</th>
      </tr>
      <tr>
        <td colspan="5">
          <input type="button" style="width: 80px" value="Inquire" onclick="getDbInfo();">
        </td>
      </tr>
      <tr>
         <td>
           <input type="button" style="width: 80px" value="Insert" onclick="insertInfoToDb();">
         </td>
         <td><input type="text" id="idForInert" size="5" maxlength="5"></td>
         <td><input type="text" id="myLock" size="5" maxlength="5"></td>
         <td><input type="text" id="name" size="15" maxlength="15"></td>
         <td><input type="text" id="sport" size="15" maxlength="15"></td>
      </tr>
      <tr>
        <td>
          <input type="button" id="deleteButton" style="width: 80px" value="Delete" onclick="deleteInfoFromoDb();" disabled="disabled">
        </td>
        <td  colspan="4"><input type="text" id="studentId" disabled="disabled" size="5" maxlength="5"></td>
      </tr>
    </table>
    <div id="resultFromDb"></div>
</body>
</html>

3.1.19.5. サーブレットの作成

サーブレット生成ウィザードを使って、テスト用サーブレットを作成します。
パッケージ・エクスプローラーで、「TestWeb4JPA」の右クリックメニューの 新規 > その他... を選択します。
ウィザードを選択 画面が表示されます。
Web > サーブレットを選択して、
次へをクリックします。


図3.1.19.5-1

サーブレット作成画面が表示されます。
Web プロジェクトでTestWeb4JPAを選択します。
ソース・フォルダーに\TestWeb4JPA\srcを入力します。
Java パッケージにtest.jpa.servletを入力します。
クラス名にTestServletを入力します。
スーパークラスはjavax.servlet.http.HttpServletのままにしてください。
既存サーブレット・クラスまたはJSPを使用をOFFにします。
完了をクリックします。


図3.1.19.5-2

TestWeb4JPAプロジェクトにTestServlet.javaファイルが追加されます。


図3.1.19.5-3

実装の概要
JSP からの処理要求は、まず、

void doPost(HttpServletRequest request, HttpServletResponse response)

に渡されます。doPost 内では、その要求を判別し、JSP 側のそれぞれのボタンに対応する、以下の処理へ振り分けます。 データベース操作の結果は、 で、html 記述に整形され、JSP に返送されます。
最終的な、TestServlet.javaの内容は、以下のようになります。
package test.jpa.servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import java.math.BigDecimal;
import java.util.List;
import java.util.Random;
import test.jpa.Student;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;

/**
 * Servlet implementation class TestServlet
 */
@WebServlet("/TestServlet")
public class TestServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    private EntityManagerFactory entityManagerFactory =
             Persistence.createEntityManagerFactory("TestWeb4JPA");

    /**
     * @see HttpServlet#HttpServlet()
     */
    public TestServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
     *      response)
     */
    protected void doPost(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub

        SAXBuilder builder = new SAXBuilder();
        Document requestDoc;
        EntityManager manager = null;
        try {
            requestDoc = builder.build(request.getInputStream());
            List elements = requestDoc.getRootElement().getChildren("command");
            Element element = (Element) elements.get(0);
            String commondName = element.getAttributeValue("name");
            manager = entityManagerFactory.createEntityManager();
            // Insert Record
            if (commondName.equals("insert")) {
                boolean isOk = insert(manager, element);
                inquire(manager, response);
                if (isOk) {
                    response.getWriter()
                            .write("<label style='color:blue'>insert is successful!</label>");
                } else {
                    response.getWriter()
                            .write("<label style='color:red'>"
                                    + "insert is failed! because this id has existed in the database</label>");
                }
            }
            // Select Record
            else if (commondName.equals("inquire")) {
                inquire(manager, response);
            }
            // Delete Record
            else {
                boolean isOk = delete(manager, element);
                inquire(manager, response);
                if (!isOk) {
                    response.getWriter()
                            .write("<label style='color:red'>"
                                    + "Delete is failed! because this id doesn't exist in the database</label>");
                } else {
                    response.getWriter()
                            .write("<label style='color:blue'>delete is successful!</label>");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (manager != null) {
                manager.close();
            }
        }
    }

    /* inquire テーブルの一覧取得 */
    private void inquire(EntityManager manager, HttpServletResponse response)
            throws IOException {
        Query query = manager.createQuery("select A from Student A");
        List<Student> list = query.getResultList();
        StringBuffer buffer = new StringBuffer();
        beginResult(buffer);
        for (Student student : list) {
            addRecorder(buffer, student);
        }
        endResult(buffer);
        response.getWriter().write(buffer.toString());
    }

    /* delete テーブルの要素削除 */
    private boolean delete(EntityManager manager, Element element) {
        List<Element> paramElementList = element.getChildren("param");
        Element param = paramElementList.get(0);
        String id = param.getAttributeValue("studentId");
        Query query = manager
                .createQuery("select A from Student A where A.id =" + id);
        List<Student> list = query.getResultList();
        if (list.size() > 0) {
            Student student = list.get(0);
            manager.getTransaction().begin();
            manager.remove(student);
            manager.getTransaction().commit();
            return true;
        }
        return false;
    }

    /* insert テーブルへの要素挿入 */
    private boolean insert(EntityManager manager, Element element)
            throws Exception {
        List<Element> paramElementList = element.getChildren("param");
        Element param = paramElementList.get(0);
        String id = param.getAttributeValue("id");
        Query query = manager
                .createQuery("select A from Student A where A.id =" + id);
        List<Student> list = query.getResultList();
        if (list.size() <= 0) {
            Student bean = new Student();
            Random random = new Random();
            String myLock = param.getAttributeValue("myLock");
            String name = param.getAttributeValue("name");
            String sport = param.getAttributeValue("sport");
            bean.setId(new Long(Integer.parseInt(id)));
            bean.setMylock(new BigDecimal(Integer.parseInt(myLock)));
            bean.setName(name);
            bean.setSport(sport);
            manager.getTransaction().begin();
            try {
                manager.persist(bean);
                manager.getTransaction().commit();
            } catch (Exception e) {
                e.printStackTrace();
                manager.getTransaction().rollback();
                throw e;
            }
            return true;
        }
        return false;
    }

    /* 以下は、出力の整形(html の table 形式) */
    private void beginResult(StringBuffer buffer) {
        buffer.append("<br>").append("<label>results form database</label>");
        buffer.append("<table border='1'>").append("<tr bgcolor='gray'>");
        buffer.append("<td>ID</td>").append("<td>MYLOCK</td>");
        buffer.append("<td>NAME</td>").append("<td>SPORT</td>").append("</tr>");
    }

    private void addRecorder(StringBuffer buffer, Student student) {
        Long id = student.getId();
        BigDecimal myLock = student.getMylock();
        String name = student.getName();
        if (name.length() == 0) {
            name = " ";
        }
        String sport = student.getSport();
        if (sport.length() == 0) {
            sport = " ";
        }
        buffer.append("<tr>").append("<td>").append(String.valueOf(id))
                .append("</td>");
        buffer.append("<td>").append(String.valueOf(myLock)).append("</td>");
        buffer.append("<td>").append(name).append("</td>");
        buffer.append("<td>").append(sport).append("</td>").append("</tr>");
    }

    private void endResult(StringBuffer buffer) {
        buffer.append("</table>");
    }
}

Memo
この時点では、エラーが表示されますが、後述の、 [3.1.19.7. ビルド・パスの変更及びライブラリーの追加] の、jdom.jar のコピー により解消します。

3.1.19.6. persistence.xmlの設定

Java Resources/src/META-INFフォルダー配下の persistence.xmlを、[3.1.17.2. persistence.xmlの設定] と同様の手順で編集します。
ここでは、persistence-unit の値が、TestServlet 内で entityManagerFactory 定義時に指定した、 "TestWeb4JPA" と一致している事を確認してください。

設定後の、persistence.xmlファイルの例は以下の通りです。 "javax.persistence.jdbc.driver" 以外の指定は、環境設定により異なりますので、適宜、適切な値を指定してください。
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
  <persistence-unit name="TestWeb4JPA">
    <class>test.jpa.Student</class>
    <properties>
      <property name="javax.persistence.jdbc.driver" value="org.apache.derby.jdbc.EmbeddedDriver"/>
      <property name="javax.persistence.jdbc.url" value="jdbc:derby:C:\MyDB;create=true"/>
      <property name="javax.persistence.jdbc.user" value=""/>
      <property name="javax.persistence.jdbc.password" value=""/>
    </properties>
  </persistence-unit>
</persistence>

3.1.19.7. ビルド・パスの変更及びライブラリーの追加

jdom.jar のコピー
jdom.jarを利用するので、このJARファイルをTestWeb4JPAプロジェクトのWebContent/WEB-INF/libに追加ます。

{WebOTXルートディレクトリ}\lib\install\applications\webcapps\manager_war\WEB-INF\lib\jdom.jar

を、TestWeb4JPAプロジェクトのWebContent/WEB-INF/lib に、ドラッグ&ドロップでコピーします。


図3.1.19.7-1

データベース・ドライバの配置
次に、Derbyデータベースへ接続するため、データベースのドライバを含むderby.jarファイルを、

{WebOTXインストールディレクトリ}\domains\domain1\lib\ext

にコピー後、ドメインを再起動してください。


図3.1.19.7-2

Memo
ドメインの再起動については、 [ドメイン構築・基本設定ガイド > 3. ドメイン > 3.4. ドメインの起動・停止 > 3.4.3. 一般ドメインの起動/停止] をご覧ください。

デフォルト出力フォルダーの変更
TestWeb4JPAプロジェクトの右クリックメニューの プロパティー を選択します。
TestWeb4JPAプロジェクトのJavaのビルド・パスを選択して、ソースタブをクリックします。
デフォルト出力フォルダー にTestWeb4JPA/WebContent/WEB-INF/classesを指定します。
OKをクリックします。


図3.1.19.7-3

3.1.19.8. 動的Webプロジェクトをサーバーで実行

下記の手順で、動的Webプロジェクトをサーバーで実行を行います。
パッケージ・エクスプローラーで、TestWeb4JPAProjの右クリックメニュー 実行 > サーバーで実行 を選択します。


図3.1.19.8-1

サーバーで実行ウィザードが起動されます。
サーバーの選択方法は、手動で新規サーバーを定義を選択して、サーバーのホスト名にlocalhostのままで、リストからNEC > WebOTX Application Server v9(Local Default)を選択します。
次へをクリックします。


図3.1.19.8-2

WebOTXサーバーの新規作成画面が表示されます。
サーバーユーザー名サーバーパスワードユーザードメイン名ユーザドメインポート、およびユーザードメインのHTTPポート番号を全て正しく設定して、次へをクリックします。


図3.1.19.8-3

プロジェクトの追加および除去画面が表示されます。
構成プロジェクトリストにTestWeb4JPAが追加されることを確認して、完了をクリックします。


図3.1.19.8-4

コンソール・ビューで、TestWeb4JPAが成功に配備されるメッセージが表示されます。 http://localhost/TestWeb4JPA/
同時に、内部ブラウザーが起動して、 http://localhost/TestWeb4JPA/ アドレスが表示されます。
下記の画面が表示されたら、正しく配備されています。


図3.1.19.8-5

Inquireをクリックして、検索処理を行います。
検索処理が正しく実行されたると、下記の実行結果が表示されます。


図3.1.19.8-6

下記の手順で、レコード追加処理を確認します。
Insert ボタンと同じ行にある Id に「11」を入力します。
myLock に「22」を入力します。
name に「mike」に入力します。
sport に「basketball」に入力します。
Insertをクリックします。
下記の実行結果があれば、レコード追加処理が正しく実行されたことが確認できます。


図3.1.19.8-7

下記の手順で、レコード削除処理を確認します。
Delete ボタンと同じ行にある Id に「11」を入力します。
Deleteをクリックします。
下記の実行結果があれば、レコード追加処理が正しく実行されたことが確認できます。


図3.1.19.8-8


3.1.19.9. ご参考)EJB2.1アプリケーション

本節ではEJB2.1 アプリケーションについて以下の内容を記述しています。
  ステートレスセッションBean
  ステートフルセッションBean
  CMP エンティティBean
  メッセージ駆動型Bean
簡単なプログラムを取り上げており、プロジェクトの作成ができるようになっています。本手順を行う前に [ アプリケーション開発ガイド(概要) > 1. Developer(with Developer's Studio) > 1.2. 環境設定 ] の設定を行ってください。
・ステートレスセッションBean
ここでは、文字列のやり取りを行うステートレスセッションBeanを作成します。
EJB プロジェクトの作成

EJBプロジェクト生成ウィザードを利用して、EJB プロジェクトを作成します。

メニュー ファイル > 新規  > プロジェクト を選択して、新規プロジェクト 画面を開きます。

EJB > EJB プロジェクト を選択して、次へ をクリックします。


図3.1.19.9-1

新規 EJB プロジェクト画面が表示されます。
プロジェクト名に新規プロジェクト名StatelessBeanSample21を入力して、ターゲット・ランタイムでWebOTX ApplicationServer v8(Local)を選択します。
EJB モジュール バージョン2.1にして、ます。
構成XDoclet 付き EJB プロジェクトを選択します。
次へをクリックします。 
ターゲット・ランタイムにWebOTXサーバーランタイムがない場合、 [ アプリケーション開発ガイド(概要) > 1. Developer(with Developer's Studio) > 1.2. 環境設定 > 1.2.4. テスト用サーバの設定 > 1.2.4.1. WebOTXランタイムの設定 ] を参照の上、設定を行ってください。


図3.1.19.9-2

EJB モジュール画面で、完了をクリックします。


図3.1.19.9-3

プロジェクトStatelessBeanSample21が作成されます。


図3.1.19.9-4

プロジェクトのWebOTX v9 Runtime配下にjavaee.jar ファイルが追加されていることを確認します。次にプロジェクトのMETA-INFフォルダ配下にMANIFEST.MFとejb-jar.xmlファイルが存在することを確認します。
javaee.jar
MANIFEST.MF
ejb-jar.xml
EJB の生成 XDoclet エンタープライズ JavaBean 生成ウィザードを利用して、バージョン2.1のBeanをプロジェクトに追加します。
メニューの ファイル > 新規 > その他 を選択して、新規 画面を開きます。
EJB > XDoclet エンタープライズ JavaBeanを選択して、次へ をクリックします。


図3.1.19.9-5

エンタープライズ JavaBean の作成画面が表示されます。
セッション Beanが選択していることを確認して、次へをクリックします。
XDocletの設定が不正の場合、EJBアプリケーションの「開発時のトラブルシューティング」の「1.XDocletが設定不正の場合の処理」を参照して設定してください。


図3.1.19.9-6

次の画面で、Java パッケージにsampleを入力して、他の項目を変更しなくて、次へ をクリックします。


図3.1.19.9-7

次の画面で、状態タイプStatelessが指定されていることを確認して、次へをクリックします。


図3.1.19.9-8

次の画面で、完了をクリックします。


図3.1.19.9-9

EJBプロジェクトにソースが追加されます。 同時に、配備記述子も更新されます。


図3.1.19.9-10

・ステートフルセッションBean
ここでは、文字列のやり取りを行うステートフルセッションBeanを作成します。
EJB プロジェクトの作成

EJBプロジェクト生成ウィザードを利用して、EJB プロジェクトを作成します。

メニュー ファイル > 新規  > プロジェクト を選択して、新規プロジェクト 画面を開きます。

EJB > EJB プロジェクト を選択して、次へ をクリックします。


図3.1.19.9-11

新規 EJB プロジェクト画面が表示されます。
プロジェクト名に新規プロジェクト名StatefulBeanSample21を入力して、ターゲット・ランタイムでWebOTX ApplicationServer v8(Local)を選択します。
EJB モジュール バージョン2.1にして、ます。
構成XDoclet 付き EJB プロジェクトを選択します。
次へをクリックします。 
ターゲット・ランタイムにWebOTXサーバーランタイムがない場合、 [ アプリケーション開発ガイド(概要) > 1. Developer(with Developer's Studio) > 1.2. 環境設定 > 1.2.4. テスト用サーバの設定 > 1.2.4.1. WebOTXランタイムの設定 ] を参照の上、設定を行ってください。


図3.1.19.9-12

EJB モジュール画面で、完了をクリックします。


図3.1.19.9-13

プロジェクトStatefulBeanSample21が作成されます。


図3.1.19.9-14

プロジェクトのWebOTX v8 Runtime配下にjavaee.jar ファイルが追加されていることを確認します。次にプロジェクトのMETA-INFフォルダ配下にMANIFEST.MFとejb-jar.xmlファイルが存在することを確認します。
javaee.jar
MANIFEST.MF
ejb-jar.xml
EJB の生成 XDoclet エンタープライズ JavaBean 生成ウィザードを利用して、バージョン2.1のEJBをプロジェクトに追加します。
メニュー ファイル > 新規 > その他 を選択して、新規 画面を開きます。
EJB > XDoclet エンタープライズ JavaBean を選択して、次へ をクリックします。


図3.1.19.9-15

エンタープライズ JavaBean の作成画面が表示されます。
セッション Beanが選択していることを確認して、次へをクリックします。
XDocletの設定が不正の場合、EJBアプリケーションの「開発時のトラブルシューティング」の「1.XDocletが設定不正の場合の処理」を参照して設定してください。


図3.1.19.9-16

次の画面で、プロジェクトStatefulBeanSample21が設定されていることを確認して、Java パッケージにsampleを入力して、次へ をクリックします。


図3.1.19.9-17

次の画面で、状態タイプStatefulにして、次へ をクリックします。


図3.1.19.9-18

次の画面で、完了をクリックします。


図3.1.19.9-19

StatefulBeanSample21プロジェクトにソースが追加されます。 同時に、配備記述子も変更されます。


図3.1.19.9-20

・CMP エンティティBean
ここでは、文字列のやり取りを行うCMP エンティティBeanを作成します。
EJB プロジェクトの作成

EJBプロジェクト生成ウィザードを利用して、EJB プロジェクトを作成します。

メニュー ファイル > 新規  > プロジェクト を選択して、新規プロジェクト 画面を開きます。

EJB > EJB プロジェクト を選択して、次へ をクリックします。


図3.1.19.9-21

新規 EJB プロジェクト画面が表示されます。
プロジェクト名に新規プロジェクト名ScheduleEJBを入力して、ターゲット・ランタイムでWebOTX ApplicationServer v8(Local)を選択します。
EJB モジュール バージョン2.1にして、ます。
構成XDoclet 付き EJB プロジェクトを選択します。

EAR にプロジェクトを追加をONにして、 EAR プロジェクト名ScheduleEJBEARを設定して、次へをクリックします。
ターゲット・ランタイムにWebOTXサーバーランタイムがない場合、 [ アプリケーション開発ガイド(概要) > 1. Developer(with Developer's Studio) > 1.2. 環境設定 > 1.2.4. テスト用サーバの設定 > 1.2.4.1. WebOTXランタイムの設定 ] を参照の上、設定を行ってください。


図3.1.19.9-22

EJB モジュール画面で、完了をクリックします。


図3.1.19.9-23

プロジェクトScheduleEJBが作成されます。


図3.1.19.9-24

プロジェクトのWebOTX v8 Runtime配下にjavaee.jar ファイルが追加されていることを確認します。次にプロジェクトのMETA-INFフォルダ配下にMANIFEST.MFとejb-jar.xmlファイルが存在することを確認します。
 javaee.jar
 MANIFEST.MF
 ejb-jar.xml
プロジェクトScheduleEJBClientとプロジェクトScheduleEJBEARが存在することを確認します。
EJB の生成 XDoclet エンタープライズ JavaBean 生成ウィザードを利用して、バージョン2.1のEJBをプロジェクトに追加します。
メニュー ファイル > 新規 > その他 を選択して、新規 画面を開きます。
EJB > XDoclet エンタープライズ JavaBean を選択して、次へ をクリックします。


図3.1.19.9-25

エンタープライズ JavaBean の作成画面が表示されます。
コンテナー管理エンティティー Beanが選択していることを確認して、次へをクリックします。
XDocletの設定が不正の場合、EJBアプリケーションの「開発時のトラブルシューティング」の「1.XDocletが設定不正の場合の処理」を参照して設定してください。 」を参照して設定してください。


図3.1.19.9-26

次の画面で、プロジェクトScheduleEJBが選択されていることを確認して、Java パッケージにsampleを入力し、次へ をクリックします。


図3.1.19.9-27

次の画面で、EJB名にMyScheduleItemを入力し、CMP バージョン2.xにして、ユースケース新規属性の定義を選択して、次へ をクリックします。


図3.1.19.9-28

CMP 属性画面が表示されます。
まず、追加 をクリックします。
追加された行の名前フィールドをクリックして、FieldAを入力します。
タイプフィールドはjava.lang.StringからStringに修正します。
主キーフィールドをONにします。
テーブルTable1を入力します。
次へをクリックします。


図3.1.19.9-29

次の画面で、完了をクリックします。


図3.1.19.9-30

EJBのソースが追加されます。 同時に、配備記述子も変更されます。


図3.1.19.9-31

ScheduleEJBプロジェクトのejbModule/sampleパッケージにMyScheduleItemCMPクラスを生成します。
ScheduleEJBClientプロジェクトのejbModuleにsampleパッケージが生成され、sampleパッケージにMyScheduleItemData、MyScheduleItemLocal、MyScheduleItemLocalHome、MyScheduleItemUtilというクラスが生成されます。


図3.1.19.9-32

・メッセージ駆動型Bean
ここでは、文字列のやり取りを行うメッセージ駆動型Beanを作成します。

EJBプロジェクト生成ウィザードを利用して、EJB プロジェクトを作成します。

メニュー ファイル > 新規  > プロジェクト を選択して、新規プロジェクト 画面を開きます。

EJB > EJB プロジェクト を選択して、次へ をクリックします。


図3.1.19.9-33

新規 EJB プロジェクト画面が表示されます。
プロジェクト名に新規プロジェクト名MDBeanSample21を入力して、ターゲット・ランタイムでWebOTX ApplicationServer v8(Local)を選択します。
EJB モジュール バージョン2.1にして、ます。
構成XDoclet 付き EJB プロジェクトを選択します。
次へをクリックします。 
ターゲット・ランタイムにWebOTXサーバーランタイムがない場合、 [ アプリケーション開発ガイド(概要) > 1. Developer(with Developer's Studio) > 1.2. 環境設定 > 1.2.4. テスト用サーバの設定 > 1.2.4.1. WebOTXランタイムの設定 ] を参照の上、設定を行ってください。


図3.1.19.9-34

EJB モジュール画面で、完了をクリックします。


図3.1.19.9-35

プロジェクトMDBeanSample21が作成されます。


図3.1.19.9-36

プロジェクトのWebOTX v8 Runtime配下にjavaee.jar ファイルが追加されていることを確認します。次にプロジェクトのMETA-INFフォルダ配下にMANIFEST.MFとejb-jar.xmlファイルが存在することを確認します。
javaee.jar
MANIFEST.MF
ejb-jar.xml
EJB の生成 XDoclet エンタープライズ JavaBean 生成ウィザードを利用して、バージョン2.1のEJBをプロジェクトに追加します。
メニュー ファイル > 新規 > その他 を選択して、新規 画面を開きます。
EJB > XDoclet エンタープライズ JavaBean を選択して、次へ をクリックします。


図3.1.19.9-37

エンタープライズ JavaBean の作成画面が表示されます。
メッセージ駆動型 Beanを選択して、次へをクリックします。
XDocletの設定が不正の場合、EJBアプリケーションの「開発時のトラブルシューティング」の「1.XDocletが設定不正の場合の処理」を参照して設定してください。


図3.1.19.9-38

次の画面で、プロジェクト名はMDBeanSample21が選択されていることを確認して、Java パッケージにsampleを入力し、次へ をクリックします。


図3.1.19.9-39

次の画面で、宛先Queueが選択されていることを確認して、次へをクリックします。


図3.1.19.9-40

次の画面で、完了をクリックします。


図3.1.19.9-41

EJB のソースが追加されます。 同時に、配備記述子も変更されます。


図3.1.19.9-42

・EJBメソッドの作成
EJBのメソッド追加を行います。
メソッドの実装 「ご参考)EJB2.1アプリケーション」の「ステートレスセッションBean」で作成されたMyBean.javaクラスにメソッドを実装します。今回は、testStringメソッドを追加します。
コードは、以下のようになります。
public java.lang.String testString( java.lang.String param ){
  return param;
}
定義コメントの実装 MyBean.javaクラスに実装したメソッドに定義コメント追加します。
コードは、以下のようになります。
/**
 * @ejb.interface-method
 *    view-type="both"
 */
public java.lang.String testString( java.lang.String param){
  return param;
}
    
@ejb.interface-methodview-typeの値は、EJBのリモートインタフェースとローカルインタフェース両方を選択することができます。指定記述を表に示します。
表3.1.19.9-1
オプション 説明
remote リモートインタフェースに設定します。
local ローカルインタフェースに設定します。
both リモート・ローカルインタフェースに設定します。
最後に、メニュー プロジェクト > クリーンを選択して、ビルドしてください。

Caution
定義コメントが無いメソッドは、インタフェースクラスに登録されないため、呼び出しができません。

・配備記述子
配備記述子(ejb-jar.xml)は、EJBプロジェクトウィザードを実行することにより、自動生成されます。配備記述子の修正は、XDocletの記述による方法と、配備記述子エディタで編集する方法があります。
XDocletによる編集 XDocletに従った文法を記述し、それをコンパイルすることで配備記述子を自動生成することができます。XDocletの記述は、EJB 生成ウィザードでEJBを作成するときに自動生成されます。例えば、配備記述子にある<ejb-name>タグの値をMyTestという名前に変更する場合、以下のようにXDocletで記述します。
/**
 *
 *<!-- begin-user-doc -->
 * Agenerated session bean
 *<!-- end-user-doc -->
 * *
 * <!-- begin-xdoclet-definition -->
 * @ejb.bean name="MyTest"          
 *          description="A session bean named My"
 *          display-name="My"
 *          jndi-name="My"
 *          type="Stateless"
 *          transaction-type="Container"
 *
 *<!-- end-xdoclet-definition -->
 * @generated
 */
上記の記述は、EJB実装クラスのソースコードにあります。クラス宣言の直前にコメント形式で記述します。( 「ご参考)EJB2.1アプリケーション」の「ステートレスセッションBean」で作成したEJBのソースならば、MyBean.javaに記述されます。)
ソースを保存後、再ビルドを行うと、XDocletで指定した値を元に配備記述子を自動生成します。以下は、ビルド後のejb-jar.xmlの内容です。
<?xml version="1.0" encoding="UTF-8"?>
<ejb-jar xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2eeejb-jar_2_1.xsd"  version="2.1" id="ejb-jar_1">
  <description>StatelessBeanSample generated by eclipse wtp xdocletextension.</description>
  <display-name>StatelessBeanSample21</display-name>
  <enterprise-beans>
    <session id="Session_MyTest">
      <description>A session bean named My</description>
      <display-name>My</display-name>
      <ejb-name>MyTest</ejb-name>
      <home>test.MyTestHome</home>
      <remote>test.MyTest</remote>
      <local-home>test.MyTestLocalHome</local-home>
      <local>test.MyTestLocal</local>
      <ejb-class>test.MyTestSession</ejb-class>
      <session-type>Stateless</session-type>
      <transaction-type>Container</transaction-type>
    </session>
  </enterprise-beans>
</ejb-jar>
XDocletの文法については、EJBアプリケーションの「プログラミング・開発」を参照してください。
詳細な記述箇所は「ご参考)EJB2.1アプリケーション」の「XDocletタグの一覧(クラスレベル)」です
配備記述子エディタによる編集 配備記述子を直接編集する場合は、以下の手順でXDocletの設定を行ってください。
ここでは、「ご参考)EJB2.1アプリケーション」の「ステートレスセッションBean」で作成したEJBプロジェクトStatelessBeanSample21を用いて説明します。
EJBプロジェクトの右クリックメニュー プロパティーを選択します。


図3.1.19.9-43

StatelessBeanSample21プロジェクトのプロパティー画面が開きます。
左側でXDocletを選択して、右側のグローバル xdoclet 設定の使用OFFにしてください。


図3.1.19.9-44

左側で、XDoclet > ejbdocletを選択して、右側で、DeploymentDescriptorOFFにしてください。
nec-ejb-jar.xmlも修正したい場合は、WebOTXOFFにしてください。
OKをクリックしてください。


図3.1.19.9-45

StatelessBeanSample21のejb-jar.xmlの右クリックメニュー アプリケーションから開く  配備記述子エディタを選択してください。


図3.1.19.9-46

配備記述子エディタが起動されます。各項目をGUI画面から設定してください。


図3.1.19.9-47

・配備
配備以降は、1.ステートレスセッションBeanで記述されたことと同じですから、参照して行ってください。
ただし、以下の点を注意してください。 
EJBテストクラインアントの作成の時に、下図のように、必要なプロジェクトの選択で、「ご参考)EJB2.1アプリケーション」の「ステートレスセッションBean」で作成したプロジェクトStatelessBeanSample21を選択してください 。


図3.1.19.9-48

 また、ソースは、次のようにEJBを呼び出す記述をしてください。以下の例は、 「ご参考」EJB2.1アプリケーション」の「ステートレスセッションBean」で作成したステートレスセッションBeanを呼び出す記述です。EJBインタフェースクラスは sample.Myを、HOMEクラスは、sample.MyHomeを使用します。また、ユーティリティクラスとして、sample.MyUtilクラスも自動生成されますので、それを利用してEJBのインスタンスを作成します。
package sample;      

import sample.My;
import sample.MyHome;
import sample.MyUtil;

public class EJBTestClient {
/**
  * @paramargs
  */
  public static void main(String[] args) throws Exception {  
    String returnData = "";
    MyHome home = MyUtil.getHome();
    My my = home.create();
    // EJBのビジネスメソッド実行
     returnData= my.testString("test");
    System.out.println("Data= " + returnData);
  }
}