JPA-クイックガイド
エンタープライズアプリケーションは、大量のデータを保存および取得することでデータベース操作を実行します。ストレージ管理に利用できるすべてのテクノロジーにもかかわらず、アプリケーション開発者は通常、データベース操作を効率的に実行するのに苦労しています。
一般に、Java開発者は多くのコードを使用するか、独自のフレームワークを使用してデータベースと対話しますが、JPAを使用すると、データベースと対話する負担が大幅に軽減されます。これは、オブジェクトモデル（Javaプログラム）とリレーショナルモデル（データベースプログラム）の間のブリッジを形成します。
リレーショナルモデルとオブジェクトモデルの不一致
リレーショナルオブジェクトは表形式で表され、オブジェクトモデルはオブジェクト形式の相互接続されたグラフで表されます。リレーショナルデータベースからオブジェクトモデルを保存および取得しているときに、次の理由で不一致が発生します。
Granularity ：オブジェクトモデルは、リレーショナルモデルよりも粒度が高くなっています。
Subtypes ：サブタイプ（継承を意味する）は、すべてのタイプのリレーショナルデータベースでサポートされているわけではありません。
Identity ：オブジェクトモデルと同様に、リレーショナルモデルは平等を記述している間はアイデンティティを公開しません。
Associations ：リレーショナルモデルは、オブジェクトドメインモデルを調べている間、複数の関係を判別できません。
Data navigation ：オブジェクトネットワーク内のオブジェクト間のデータナビゲーションは、両方のモデルで異なります。
JPAとは何ですか？
Java Persistence APIは、OracleCorporationが提供するデータベースに大量のデータを永続的に格納するためのクラスとメソッドのコレクションです。
JPAはどこで使用しますか？
リレーショナルオブジェクト管理用のコードを書く負担を軽減するために、プログラマーは「JPAプロバイダー」フレームワークに従います。これにより、データベースインスタンスとの簡単な対話が可能になります。ここで、必要なフレームワークがJPAに引き継がれます。
JPAの歴史
以前のバージョンのEJBは、javax.ejb.EntityBeanインターフェースを使用してビジネスロジックレイヤーと組み合わせた永続レイヤーを定義しました。
EJB 3.0の導入時に、永続層が分離され、JPA 1.0（Java Persistence API）として指定されました。このAPIの仕様は、2006年5月11日にJSR220を使用してJAVAEE5の仕様とともにリリースされました。
JPA 2.0は、Java Community Process JSR 317の一部として、2009年12月10日にJAVAEE6の仕様でリリースされました。
JPA 2.1は、JSR338を使用して2013年4月22日にJAVAEE7の仕様でリリースされました。
JPAプロバイダー
JPAはオープンソースAPIであるため、Oracle、Redhat、Eclipseなどのさまざまなエンタープライズベンダーが、JPA永続性フレーバーを追加することで新製品を提供しています。これらの製品の一部は次のとおりです。
Hibernate, Eclipselink, Toplink, Spring Data JPA, etc.
Java Persistence APIは、ビジネスエンティティをリレーショナルエンティティとして格納するためのソースです。PLAIN OLD JAVA OBJECT（POJO）をエンティティとして定義する方法と、リレーションを持つエンティティを管理する方法を示します。
クラスレベルのアーキテクチャ
次の画像は、JPAのクラスレベルのアーキテクチャを示しています。JPAのコアクラスとインターフェースを示しています。
次の表で、上記のアーキテクチャに示されている各ユニットについて説明します。
| 単位 | 説明 |
|---|---|
| EntityManagerFactory | これは、EntityManagerのファクトリクラスです。複数のEntityManagerインスタンスを作成および管理します。 |
| EntityManager | これはインターフェースであり、オブジェクトの永続化操作を管理します。クエリインスタンスのファクトリのように機能します。 |
| Entity | エンティティは永続オブジェクトであり、データベースにレコードとして格納されます。 |
| EntityTransaction | EntityManagerと1対1の関係にあります。EntityManagerごとに、操作はEntityTransactionクラスによって維持されます。 |
| Persistence | このクラスには、EntityManagerFactoryインスタンスを取得するための静的メソッドが含まれています。 |
| Query | このインターフェースは、基準を満たすリレーショナルオブジェクトを取得するために、各JPAベンダーによって実装されます。 |
上記のクラスとインターフェースは、エンティティをレコードとしてデータベースに格納するために使用されます。これらは、データベースにデータを格納するためのコードを作成する労力を削減することでプログラマーを支援し、クラスをデータベーステーブルにマッピングするためのコードの作成などのより重要なアクティビティに集中できるようにします。
JPAクラスの関係
上記のアーキテクチャでは、クラスとインターフェース間の関係はjavax.persistenceパッケージに属しています。次の図は、それらの関係を示しています。
EntityManagerFactoryとEntityManagerの関係は次のとおりです。 one-to-many。これは、EntityManagerインスタンスのファクトリクラスです。
EntityManagerとEntityTransactionの関係は one-to-one。EntityManager操作ごとに、EntityTransactionインスタンスがあります。
EntityManagerとクエリの関係は one-to-many。1つのEntityManagerインスタンスを使用して、多数のクエリを実行できます。
EntityManagerとEntityの関係は one-to-many。1つのEntityManagerインスタンスで複数のエンティティを管理できます。
最新のアプリケーションのほとんどは、リレーショナルデータベースを使用してデータを格納しています。最近、多くのベンダーがデータ保守の負担を軽減するためにオブジェクトデータベースに切り替えました。これは、オブジェクトデータベースまたはオブジェクトリレーショナルテクノロジがデータの保存、取得、更新、および保守を処理していることを意味します。このオブジェクトリレーショナルテクノロジの中核部分は、orm.xmlファイルのマッピングです。xmlはコンパイルを必要としないため、少ない管理で複数のデータソースに簡単に変更を加えることができます。
オブジェクトリレーショナルマッピング
オブジェクトリレーショナルマッピング（ORM）は、ORMとは何かとその仕組みについて簡単に説明します。ORMは、オブジェクトタイプからリレーショナルタイプに、またはその逆にデータを変換するプログラミング機能です。
ORMの主な機能は、オブジェクトをデータベース内のデータにマッピングまたはバインドすることです。マッピングする際には、データ、データのタイプ、および自己エンティティまたは他のテーブル内のエンティティとの関係を考慮する必要があります。
高度な機能
Idiomatic persistence ：オブジェクト指向クラスを使用して永続性クラスを作成できます。
High Performance ：多くのフェッチ技術と希望に満ちたロック技術があります。
Reliable ：非常に安定しており、多くのプロのプログラマーによって使用されています。
ORMアーキテクチャ
ORMアーキテクチャは次のようになります。
上記のアーキテクチャは、オブジェクトデータが3つのフェーズでリレーショナルデータベースに格納される方法を説明しています。
フェーズ1
と名付けられた最初のフェーズ object data phase、POJOクラス、サービスインターフェイス、およびクラスが含まれます。これは、ビジネスロジックの操作と属性を持つ主要なビジネスコンポーネントレイヤーです。
たとえば、従業員データベースをスキーマとして考えてみましょう。
従業員のPOJOクラスには、ID、名前、給与、指定などの属性が含まれています。また、これらの属性のsetterやgetterなどのメソッドも含まれています。
従業員DAO /サービスクラスには、従業員の作成、従業員の検索、従業員の削除などのサービスメソッドが含まれています。
フェーズ2
と名付けられた第2フェーズ mapping または persistence phaseには、JPAプロバイダー、マッピングファイル（ORM.xml）、JPAローダー、およびオブジェクトグリッドが含まれています。
JPA Provider：JPAフレーバー（javax.persistence）を含むベンダー製品です。たとえば、Eclipselink、Toplink、Hibernateなどです。
Mapping file ：マッピングファイル（ORM.xml）には、POJOクラスのデータとリレーショナルデータベースのデータの間のマッピング構成が含まれています。
JPA Loader：JPAローダーはキャッシュメモリのように機能します。リレーショナルグリッドデータをロードできます。これは、データベースのコピーのように機能して、POJOデータのサービスクラス（POJOクラスの属性）と対話します。
Object Grid：キャッシュメモリなど、リレーショナルデータのコピーを保存できる一時的な場所です。データベースに対するすべてのクエリは、最初にオブジェクトグリッドのデータに影響を与えます。コミットされた後でのみ、メインデータベースに影響します。
フェーズ3
3番目のフェーズは relational data phase。これには、ビジネスコンポーネントに論理的に接続されているリレーショナルデータが含まれています。上で説明したように、ビジネスコンポーネントがデータをコミットする場合にのみ、データはデータベースに物理的に保存されます。それまでは、変更されたデータはグリッド形式でキャッシュメモリに保存されます。データを取得するプロセスは、データを保存するプロセスと同じです。
上記の3つのフェーズのプログラムによる相互作用のメカニズムは次のように呼ばれます。 object relational mapping。
Mapping.xml
Mapping.xmlファイルは、エンティティクラスをデータベーステーブルにマップするようにJPAベンダーに指示するためのものです。
4つの属性を含むEmployeeエンティティの例を見てみましょう。名前が付けられたEmployeeエンティティのPOJOクラスEmployee.java 以下のとおりであります：
public class Employee
{
private int eid;
private String ename;
private double salary;
private String deg;
public Employee(int eid, String ename, double salary, String deg)
{
super( );
this.eid = eid;
this.ename = ename;
this.salary = salary;
this.deg = deg;
}
public Employee( )
{
super();
}
public int getEid( )
{
return eid;
}
public void setEid(int eid)
{
this.eid = eid;
}
public String getEname( )
{
return ename;
}
public void setEname(String ename)
{
this.ename = ename;
}
public double getSalary( )
{
return salary;
}
public void setSalary(double salary)
{
this.salary = salary;
}
public String getDeg( )
{
return deg;
}
public void setDeg(String deg)
{
this.deg = deg;
}
}上記のコードは、EmployeeエンティティのPOJOクラスです。4つの属性が含まれていますeid、 ename、 salary、および deg。これらの属性をテーブルのテーブルフィールドと見なし、eidこのテーブルの主キーとして。次に、そのためのHibernateマッピングファイルを設計する必要があります。名前の付いたマッピングファイルmapping.xml 以下のとおりであります：
<? xml version="1.0" encoding="UTF-8" ?>
<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm
http://java.sun.com/xml/ns/persistence/orm_1_0.xsd"
version="1.0">
<description> XML Mapping file</description>
<entity class="Employee">
<table name="EMPLOYEETABLE"/>
<attributes>
<id name="eid">
<generated-value strategy="TABLE"/>
</id>
<basic name="ename">
<column name="EMP_NAME" length="100"/>
</basic>
<basic name="salary">
</basic>
<basic name="deg">
</basic>
</attributes>
</entity>
</entity-mappings>上記のスクリプトは、エンティティクラスをデータベーステーブルにマッピングするために使用されます。このファイルでは
<entity-mappings> ：tagは、エンティティタグをxmlファイルに入れることができるようにスキーマ定義を定義します。
<description> ：タグは、アプリケーションに関する説明を提供します。
<entity>：タグは、データベース内のテーブルに変換するエンティティクラスを定義します。属性クラスは、POJOエンティティクラス名を定義します。
<table>：タグはテーブル名を定義します。クラスとテーブルの両方に同じ名前を付けたい場合は、このタグは必要ありません。
<attributes> ：タグは属性（テーブル内のフィールド）を定義します。
<id>：tagは、テーブルの主キーを定義します。ザ・<generated-value> タグは、次のような主キー値を割り当てる方法を定義します。 Automatic、 Manual、またはから取得 Sequence。
<basic> ：タグは、テーブルの残りの属性を定義するために使用されます。
<column-name> ：タグは、テーブル内のユーザー定義のテーブルフィールド名を定義するために使用されます。
注釈
通常、xmlファイルは、特定のコンポーネントを構成したり、コンポーネントの2つの異なる仕様をマッピングしたりするために使用されます。私たちの場合、フレームワークでxmlファイルを個別に維持する必要があります。つまり、マッピングxmlファイルを作成するときに、POJOクラスの属性をmapping.xmlファイルのエンティティタグと比較する必要があります。
これが解決策です。クラス定義では、アノテーションを使用して構成部分を記述できます。アノテーションは、クラス、プロパティ、およびメソッドに使用されます。注釈は「@」記号で始まります。アノテーションは、クラス、プロパティ、またはメソッドの前に宣言されます。JPAのすべての注釈は、javax.persistence パッケージ。
ここで、例で使用されているアノテーションのリストを以下に示します。
| 注釈 | 説明 |
|---|---|
| @エンティティ | クラスをエンティティまたはテーブルとして宣言します。 |
| @テーブル | テーブル名を宣言します。 |
| @Basic | 非制約フィールドを明示的に指定します。 |
| @埋め込み | 埋め込み可能なクラスのインスタンスを値とするクラスまたはエンティティのプロパティを指定します。 |
| @Id | クラスのID（テーブルの主キー）に使用するプロパティを指定します。 |
| @GeneratedValue | 自動、手動、シーケンステーブルから取得した値など、ID属性を初期化する方法を指定します。 |
| @トランジェント | 永続的ではないプロパティを指定します。つまり、値がデータベースに保存されることはありません。 |
| @カラム | 永続性プロパティの列属性を指定します。 |
| @SequenceGenerator | @GeneratedValueアノテーションで指定されているプロパティの値を指定します。シーケンスを作成します。 |
| @TableGenerator | @GeneratedValueアノテーションで指定されたプロパティの値ジェネレーターを指定します。値を生成するためのテーブルを作成します。 |
| @AccessType | このタイプの注釈は、アクセスタイプを設定するために使用されます。@AccessType（FIELD）を設定すると、アクセスはフィールド単位で行われます。@AccessType（PROPERTY）を設定すると、アクセスはプロパティごとに発生します。 |
| @JoinColumn | エンティティの関連付けまたはエンティティのコレクションを指定します。これは、多対1および1対多の関連付けで使用されます。 |
| @UniqueConstraint | プライマリテーブルまたはセカンダリテーブルのフィールドと一意の制約を指定します。 |
| @ColumnResult | select句を使用してSQLクエリの列の名前を参照します。 |
| @ManyToMany | 結合テーブル間の多対多の関係を定義します。 |
| @ManyToOne | 結合テーブル間の多対1の関係を定義します。 |
| @OneToMany | 結合テーブル間の1対多の関係を定義します。 |
| @OneToOne | 結合テーブル間の1対1の関係を定義します。 |
| @NamedQueries | 名前付きクエリのリストを指定します。 |
| @NamedQuery | 静的名を使用してクエリを指定します。 |
JavaBean標準
Javaクラスは、インスタンス値とその動作をオブジェクトと呼ばれる単一のユニットにカプセル化します。Java Beanは、一時ストレージであり、再利用可能なコンポーネントまたはオブジェクトです。これは、インスタンス属性を個別に初期化するためのデフォルトのコンストラクターとゲッターおよびセッターメソッドを持つシリアル化可能なクラスです。
Beanの規則
Beanには、デフォルトのコンストラクターまたはシリアル化されたインスタンスを含むファイルが含まれています。したがって、Beanは別のBeanをインスタンス化できます。
Beanのプロパティは、ブールプロパティまたは非ブールプロパティに分離できます。
非ブールプロパティには getter そして setter メソッド。
ブールプロパティに含まれる setter そして is 方法。
Getter プロパティのメソッドは小文字で始める必要があります get（Javaメソッドの規則）大文字で始まるフィールド名で続行します。たとえば、フィールド名はsalary したがって、このフィールドのゲッターメソッドは getSalary ()。
Setter プロパティのメソッドは小文字で始める必要があります set （Javaメソッド規則）、大文字で始まるフィールド名と argument valueフィールドに設定します。たとえば、フィールド名はsalary したがって、このフィールドのセッターメソッドは setSalary ( double sal )。
ブール型プロパティの場合、 isそれが真か偽かをチェックする方法。たとえば、ブール型プロパティempty、 is このフィールドの方法は isEmpty ()。
この章では、WindowsおよびLinuxベースのシステムでJPAを設定するプロセスについて説明します。JPAは、複雑なセットアップ手順なしで、いくつかの簡単な手順に従って、簡単にインストールして現在のJava環境に統合できます。インストール中にユーザー管理が必要です。
システム要求
| JDK | Java SE 2 JDK1.5以降 |
| 記憶 | 1 GB RAM（推奨） |
| ディスクスペース | 最小要件はありません |
| オペレーティングシステムのバージョン | Windows XP以降、Linux |
JPAをインストールする手順に進みましょう。
ステップ1：Javaのインストールを確認する
まず、システムにJavaソフトウェア開発キット（SDK）をインストールする必要があります。これを確認するには、作業しているプラットフォームに応じて、次の2つのコマンドのいずれかを実行します。
Javaのインストールが適切に行われている場合は、Javaインストールの現在のバージョンと仕様が表示されます。次の表に出力例を示します。
| プラットホーム | コマンド | サンプル出力 |
|---|---|---|
| ウィンドウズ | コマンドコンソールを開き、次のように入力します。 \>java –version |
Javaバージョン「1.7.0_60」 Java（TM）SEランタイム環境（ビルド1.7.0_60-b19） Java Hotspot（TM）64ビットサーバーVM（ビルド24.60-b09、混合モード） |
| Linux | コマンドターミナルを開き、次のように入力します。 $java –version |
Javaバージョン「1.7.0_25」 JDKランタイム環境を開きます（rhel-2.3.10.4.el6_4-x86_64） JDK 64ビットサーバーVMを開きます（ビルド23.7-b01、混合モード） |
このチュートリアルの読者は、JavaSDKバージョン1.7.0_60がシステムにインストールされていることを前提としています。
Java SDKをお持ちでない場合は、現在のバージョンをからダウンロードしてください。 http://www.oracle.com/technetwork/java/javase/downloads/index.html そしてそれをインストールしてもらいます。
ステップ2：Java環境を設定する
Javaがマシンにインストールされているベースディレクトリの場所を指すように環境変数JAVA_HOMEを設定します。例えば、
| プラットホーム | 説明 |
|---|---|
| ウィンドウズ | JAVA_HOMEをC：\ ProgramFiles \ java \ jdk1.7.0_60に設定します |
| Linux | JAVA_HOME = / usr / local / java-currentをエクスポートします |
Javaコンパイラの場所のフルパスをシステムパスに追加します。
| プラットホーム | 説明 |
|---|---|
| ウィンドウズ | 文字列「C：\ ProgramFiles \ Java \ jdk1.7.0_60 \ bin」をシステム変数PATHの最後に追加します。 |
| Linux | PATH = $ PATH：$ JAVA_HOME / bin /をエクスポートします |
コマンドを実行します java -version 上で説明したコマンドプロンプトから。
ステップ3：JPAのインストール
このチュートリアルのJPAプロバイダー（Eclipselink、Hibernateなど）を使用して、JPAのインストールを実行できます。Eclipselinkを使用してJPAのインストールを追跡しましょう。JPAプログラミングの場合、特定のフォルダーフレームワークに従う必要があるため、IDEを使用することをお勧めします。
次のリンクからEclipseIDEフォームをダウンロードします https://www.eclipse.org/downloads/ EclipseIDE forJavaEE開発者を選択してください Eclipse indigo。
EclipseのzipファイルをCドライブに解凍します。EclipseIDEを開きます。
Eclipselinkを使用したJPAのインストール
Eclipselinkはライブラリであるため、EclipseIDEに直接追加することはできません。Eclipselinkを使用してJPAをインストールするには、以下の手順に従う必要があります。
を選択して、新しいJPAプロジェクトを作成します File->New->JPA Project EclipseIDEでは次のようになります。
名前の付いたダイアログボックスが表示されます New JPA Project。プロジェクト名を入力してくださいtutorialspoint_JPA_Eclipselink、確認してください jre バージョンをクリックし、次へをクリックします。
ユーザーライブラリセクションでライブラリのダウンロード（ライブラリがない場合）をクリックします。
[ライブラリのダウンロード]ダイアログボックスでEclipselinkライブラリの最新バージョンを選択し、次のように[次へ]をクリックします。
ライセンス条項に同意し、[完了]をクリックしてライブラリをダウンロードします。
6.次のスクリーンショットに示すように、ダウンロードが開始されます。
ダウンロード後、ユーザーライブラリセクションでダウンロードしたライブラリを選択し、[完了]をクリックします。
最後に、プロジェクトファイルを Package ExplorerEclipseIDEで。すべてのファイルを抽出すると、次のようにフォルダとファイルの階層が取得されます。
プロジェクトへのMySQLコネクタの追加
ここで説明する例には、データベース接続が必要です。データベース操作用のMySQLデータベースについて考えてみましょう。Javaプログラムと対話するには、mysql-connectorjarが必要です。
手順に従って、プロジェクトでデータベースjarを構成します。
プロジェクトのプロパティに移動します ->Javaビルドパスを右クリックします。次のスクリーンショットに示すようなダイアログボックスが表示されます。[外部Jarの追加]をクリックします。
システムメモリ内のjarの場所に移動し、ファイルを選択して[開く]をクリックします。
プロパティダイアログで[OK]をクリックします。MySQLコネクタJarをプロジェクトに組み込みます。これで、MySQLを使用してデータベース操作を実行できるようになりました。
この章では、簡単な例を使用して、JPAがどのように機能するかを示します。例として従業員管理を考えてみましょう。従業員管理者が従業員のレコードを作成、更新、検索、および削除するとします。前述のように、データベース操作にはMySQLデータベースを使用しています。
この例の主なモジュールは次のとおりです。
Model or POJO
Employee.java
Persistence
Persistence.xml
Service
CreatingEmployee.java
UpdatingEmployee.java
FindingEmployee.java
DeletingEmployee.java
Eclipselinkを使用したJPAインストールで使用したパッケージ階層を見てみましょう。以下に示すように、この例の階層に従います。
エンティティの作成
エンティティはBeanまたはモデルに他なりません。この例では、Employee エンティティとして。 eid、 ename、 salary、および degこのエンティティの属性です。これには、デフォルトのコンストラクターと、それらの属性のsetterメソッドとgetterメソッドが含まれています。
上に示した階層で、という名前のパッケージを作成します ‘com.tutorialspoint.eclipselink.entity’、 下 ‘src’（ソース）パッケージ。という名前のクラスを作成しますEmployee.java 次のように与えられたパッケージの下で：
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table
public class Employee
{
@Id
@GeneratedValue(strategy= GenerationType.AUTO)
private int eid;
private String ename;
private double salary;
private String deg;
public Employee(int eid, String ename, double salary, String deg)
{
super( );
this.eid = eid;
this.ename = ename;
this.salary = salary;
this.deg = deg;
}
public Employee( )
{
super();
}
public int getEid( )
{
return eid;
}
public void setEid(int eid)
{
this.eid = eid;
}
public String getEname( )
{
return ename;
}
public void setEname(String ename)
{
this.ename = ename;
}
public double getSalary( )
{
return salary;
}
public void setSalary(double salary)
{
this.salary = salary;
}
public String getDeg( )
{
return deg;
}
public void setDeg(String deg)
{
this.deg = deg;
}
@Override
public String toString() {
return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
+ salary + ", deg=" + deg + "]";
}
}上記のコードでは、@ Entityアノテーションを使用して、このPOJOクラスをエンティティにしました。
次のモジュールに進む前に、リレーショナルエンティティのデータベースを作成する必要があります。これにより、データベースがに登録されます。 persistence.xmlファイル。MySQLワークベンチを開き、クエリに従ってhteと入力します。
create database jpadb
use jpadbPersistence.xml
このモジュールは、JPAの概念において重要な役割を果たします。このxmlファイルでは、データベースを登録し、エンティティクラスを指定します。
上記のパッケージ階層では、JPAコンテンツパッケージの下のpersistence.xmlは次のとおりです。
<?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="Eclipselink_JPA"
transaction-type="RESOURCE_LOCAL">
<class>com.tutorialspoint.eclipselink.entity.Employee</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/jpadb"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password" value="root"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.logging.level" value="FINE"/>
<property name="eclipselink.ddl-generation"
value="create-tables"/>
</properties>
</persistence-unit>
</persistence>上記のxmlでは、 <persistence-unit> タグは、JPA永続性の特定の名前で定義されます。ザ・<class>タグは、パッケージ名でエンティティクラスを定義します。ザ・<properties> タグはすべてのプロパティを定義し、 <property>タグは、データベース登録、URL仕様、ユーザー名、パスワードなどの各プロパティを定義します。これらはEclipselinkのプロパティです。このファイルはデータベースを構成します。
永続化操作
永続性操作はデータベースとの対話に使用され、 load そして store操作。ビジネスコンポーネントでは、すべての永続化操作がサービスクラスに分類されます。
上に示したパッケージ階層で、という名前のパッケージを作成します ‘com.tutorialspoint.eclipselink.service’、 下 ‘src’（ソース）パッケージ。CreateEmloyee.java、UpdateEmployee.java、FindEmployee.java、およびDeleteEmployee.javaという名前のすべてのサービスクラス。次のように指定されたパッケージに含まれます。
従業員を作成する
次のコードセグメントは、という名前のEmployeeクラスを作成する方法を示しています。 CreateEmployee.java。
package com.tutorialspoint.eclipselink.service;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;
public class CreateEmployee
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
entitymanager.getTransaction( ).begin( );
Employee employee = new Employee( );
employee.setEid( 1201 );
employee.setEname( "Gopal" );
employee.setSalary( 40000 );
employee.setDeg( "Technical Manager" );
entitymanager.persist( employee );
entitymanager.getTransaction( ).commit( );
entitymanager.close( );
emfactory.close( );
}
}上記のコードでは、 createEntityManagerFactory ()永続性ユニットに指定したのと同じ一意の名前をpersistent.xmlファイルで提供することにより、永続性ユニットを作成します。ザ・entitymanagerfactory オブジェクトはを作成します entitymanger を使用してインスタンス createEntityManager ()方法。ザ・entitymanager オブジェクトが作成します entitytransactionトランザクション管理のインスタンス。を使用してentitymanager オブジェクトの場合、エンティティをデータベースに永続化できます。
上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルにあるeclipselinkライブラリから通知が届きます。
結果として、MySQLワークベンチを開き、次のクエリを入力します。
use jpadb
select * from employee影響を受けるデータベーステーブルの名前 employee 次のように表形式で表示されます。
| イード | エナメ | 給料 | デグ |
|---|---|---|---|
| 1201 | ゴパル | 40000 | 技術管理者 |
従業員の更新
従業員のレコードを更新するには、データベースから既存のレコードを取得して変更を加え、最後にデータベースにコミットする必要があります。名前の付いたクラスUpdateEmployee.java 次のように表示されます。
package com.tutorialspoint.eclipselink.service;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;
public class UpdateEmployee
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
entitymanager.getTransaction( ).begin( );
Employee employee=entitymanager.
find( Employee.class, 1201 );
//before update
System.out.println( employee );
employee.setSalary( 46000 );
entitymanager.getTransaction( ).commit( );
//after update
System.out.println( employee );
entitymanager.close();
emfactory.close();
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルにあるEclipselinkライブラリから通知が届きます。
結果として、MySQLワークベンチを開き、次のクエリを入力します。
use jpadb
select * from employee影響を受けるデータベーステーブルの名前 employee 次のように表形式で表示されます。
| イード | エナメ | 給料 | デグ |
|---|---|---|---|
| 1201 | ゴパル | 46000 | 技術管理者 |
従業員の給与1201が46000に更新されます。
従業員を探す
従業員のレコードを見つけるには、データベースから既存のデータを取得して表示する必要があります。この操作では、レコードの取得中にEntityTransactionは適用されません。
名前の付いたクラス FindEmployee.java 次のように。
package com.tutorialspoint.eclipselink.service;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;
public class FindEmployee
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence
.createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager();
Employee employee = entitymanager.
find( Employee.class, 1201 );
System.out.println("employee ID = "+employee.getEid( ));
System.out.println("employee NAME = "+employee.getEname( ));
System.out.println("employee SALARY = "+employee.getSalary( ));
System.out.println("employee DESIGNATION = "+employee.getDeg( ));
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルのEclipselinkライブラリから次の出力が得られます。
employee ID = 1201
employee NAME = Gopal
employee SALARY = 46000.0
employee DESIGNATION = Technical Manager従業員の削除
従業員のレコードを削除するには、最初に既存のレコードを見つけてから削除します。ここで、EntityTransactionは重要な役割を果たします。
名前の付いたクラス DeleteEmployee.java 次のように：
package com.tutorialspoint.eclipselink.service;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;
public class DeleteEmployee
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
entitymanager.getTransaction( ).begin( );
Employee employee=entitymanager.
find( Employee.class, 1201 );
entitymanager.remove( employee );
entitymanager.getTransaction( ).commit( );
entitymanager.close( );
emfactory.close( );
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルにあるEclipselinkライブラリから通知が届きます。
結果として、MySQLワークベンチを開き、次のクエリを入力します。
use jpadb
select * from employee影響を受けるデータベースの名前 employee nullレコードがあります。
この例のすべてのモジュールが完了すると、パッケージとファイルの階層は次のようになります。
この章では、JPQLと、それが永続ユニットでどのように機能するかについて説明します。この章では、与えられた例は、前の章で使用したのと同じパッケージ階層に従います。
Java PersistenceQuery言語
JPQLはJavaPersistence QueryLanguageの略です。リレーショナルデータベースに格納するエンティティに対するクエリを作成するために使用されます。JPQLはSQL構文に基づいて開発されています。ただし、データベースに直接影響することはありません。
JPQLは、SELECT句を使用してデータを取得でき、UPDATE句とDELETE句を使用して一括更新を実行できます。
クエリ構造
JPQLの構文は、SQLの構文と非常によく似ています。SQLは単純で広く使用されているため、SQLのような構文を持つことは利点です。SQLはリレーショナルデータベースのテーブル、レコード、およびフィールドに対して直接機能しますが、JPQLはJavaクラスおよびインスタンスに対して機能します。
たとえば、JPQLクエリは、SQLの場合のように、データベースからフィールド結果セットではなくエンティティオブジェクトを取得できます。JPQLクエリの構造は次のとおりです。
SELECT ... FROM ...
[WHERE ...]
[GROUP BY ... [HAVING ...]]
[ORDER BY ...]JPQLDELETEおよびUPDATEクエリの構造は次のとおりです。
DELETE FROM ... [WHERE ...]
UPDATE ... SET ... [WHERE ...]スカラー関数と集計関数
スカラー関数は、入力値に基づいて結果の値を返します。集計関数は、入力値を計算することによって結果の値を返します。
前の章と同じ例の従業員管理を使用します。ここでは、JPQLのスカラー関数と集計関数を使用してサービスクラスについて説明します。
仮定しましょう jpadb.employee テーブルには次のレコードが含まれています。
| イード | エナメ | 給料 | デグ |
|---|---|---|---|
| 1201 | ゴパル | 40000 | 技術管理者 |
| 1202 | マニシャ | 40000 | 校正者 |
| 1203 | マスタンバリ | 40000 | テクニカルライター |
| 1204 | サティッシュ | 30000 | テクニカルライター |
| 1205 | クリシュナ | 30000 | テクニカルライター |
| 1206 | キラン | 35000 | 校正者 |
という名前のクラスを作成します ScalarandAggregateFunctions.java 下 com.tutorialspoint.eclipselink.service 次のようにパッケージします。
package com.tutorialspoint.eclipselink.service;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
public class ScalarandAggregateFunctions
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager();
//Scalar function
Query query = entitymanager.
createQuery("Select UPPER(e.ename) from Employee e");
List<String> list=query.getResultList();
for(String e:list)
{
System.out.println("Employee NAME :"+e);
}
//Aggregate function
Query query1 = entitymanager.
createQuery("Select MAX(e.salary) from Employee e");
Double result=(Double) query1.getSingleResult();
System.out.println("Max Employee Salary :"+result);
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに次の出力が表示されます。
Employee NAME :GOPAL
Employee NAME :MANISHA
Employee NAME :MASTHANVALI
Employee NAME :SATISH
Employee NAME :KRISHNA
Employee NAME :KIRAN
ax Employee Salary :40000.0間、そして、キーワードのように
Between、 And、および LikeJPQLの主なキーワードです。これらのキーワードは後に使用されますWhere clause クエリで。
という名前のクラスを作成します BetweenAndLikeFunctions.java 下 com.tutorialspoint.eclipselink.service 次のようにパッケージ化します。
package com.tutorialspoint.eclipselink.service;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.eclipselink.entity.Employee;
public class BetweenAndLikeFunctions
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager();
//Between
Query query = entitymanager.
createQuery( "Select e " +
"from Employee e " +
"where e.salary " +
"Between 30000 and 40000" )
List<Employee> list=(List<Employee>)query.getResultList( );
for( Employee e:list )
{
System.out.print("Employee ID :"+e.getEid( ));
System.out.println("\t Employee salary :"+e.getSalary( ));
}
//Like
Query query1 = entitymanager.
createQuery("Select e " +
"from Employee e " +
"where e.ename LIKE 'M%'");
List<Employee> list1=(List<Employee>)query1.getResultList( );
for( Employee e:list1 )
{
System.out.print("Employee ID :"+e.getEid( ));
System.out.println("\t Employee name :"+e.getEname( ));
}
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに次の出力が表示されます。
Employee ID :1201 Employee salary :40000.0
Employee ID :1202 Employee salary :40000.0
Employee ID :1203 Employee salary :40000.0
Employee ID :1204 Employee salary :30000.0
Employee ID :1205 Employee salary :30000.0
Employee ID :1206 Employee salary :35000.0
Employee ID :1202 Employee name :Manisha
Employee ID :1203 Employee name :Masthanvali注文
JPQLでレコードを注文するには、ORDERBY句を使用します。この句の使用法はSQLの場合と同じですが、エンティティを扱います。次の例は、ORDERBY句の使用方法を示しています。
クラスを作成する Ordering.java 下 com.tutorialspoint.eclipselink.service 次のようにパッケージ化します。
package com.tutorialspoint.eclipselink.service;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.eclipselink.entity.Employee;
public class Ordering
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager();
//Between
Query query = entitymanager.
createQuery( "Select e " +
"from Employee e " +
"ORDER BY e.ename ASC" );
List<Employee> list=(List<Employee>)query.getResultList( );
for( Employee e:list )
{
System.out.print("Employee ID :"+e.getEid( ));
System.out.println("\t Employee Name :"+e.getEname( ));
}
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに次の出力が生成されます。
Employee ID :1201 Employee Name :Gopal
Employee ID :1206 Employee Name :Kiran
Employee ID :1205 Employee Name :Krishna
Employee ID :1202 Employee Name :Manisha
Employee ID :1203 Employee Name :Masthanvali
Employee ID :1204 Employee Name :Satish名前付きクエリ
@NamedQueryアノテーションは、変更できない事前定義されたクエリ文字列を持つクエリとして定義されます。動的クエリとは対照的に、名前付きクエリは、JPQLクエリ文字列をPOJOから分離することにより、コード編成を改善する場合があります。また、リテラルをクエリ文字列に動的に埋め込むのではなく、クエリパラメータを渡すため、より効率的なクエリが生成されます。
まず、@ NamedQueryアノテーションを名前の付いたEmployeeエンティティクラスに追加します Employee.java 下 com.tutorialspoint.eclipselink.entity 次のようにパッケージ化します。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
@Entity
@Table
@NamedQuery(query = "Select e from Employee e where e.eid = :id",
name = "find employee by id")
public class Employee
{
@Id
@GeneratedValue(strategy= GenerationType.AUTO)
private int eid;
private String ename;
private double salary;
private String deg;
public Employee(int eid, String ename, double salary, String deg)
{
super( );
this.eid = eid;
this.ename = ename;
this.salary = salary;
this.deg = deg;
}
public Employee( )
{
super();
}
public int getEid( )
{
return eid;
}
public void setEid(int eid)
{
this.eid = eid;
}
public String getEname( )
{
return ename;
}
public void setEname(String ename)
{
this.ename = ename;
}
public double getSalary( )
{
return salary;
}
public void setSalary(double salary)
{
this.salary = salary;
}
public String getDeg( )
{
return deg;
}
public void setDeg(String deg)
{
this.deg = deg;
}
@Override
public String toString() {
return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
+ salary + ", deg=" + deg + "]";
}
}という名前のクラスを作成します NamedQueries.java 下 com.tutorialspoint.eclipselink.service 次のようにパッケージ化します。
package com.tutorialspoint.eclipselink.service;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.eclipselink.entity.Employee;
public class NamedQueries
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager();
Query query = entitymanager.createNamedQuery(
"find employee by id");
query.setParameter("id", 1204);
List<Employee> list = query.getResultList( );
for( Employee e:list )
{
System.out.print("Employee ID :"+e.getEid( ));
System.out.println("\t Employee Name :"+e.getEname( ));
}
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに次の出力が表示されます。
Employee ID :1204 Employee Name :Satish上記のすべてのクラスを追加すると、パッケージ階層は次のようになります。
熱心で遅延フェッチ
JPAの最も重要な概念は、キャッシュメモリにデータベースの複製コピーを作成することです。データベースとのトランザクション中に、JPAは最初に重複したデータセットを作成し、エンティティマネージャーを使用してコミットされた場合にのみ、変更がデータベースに反映されます。
データベースからレコードをフェッチする方法は2つあります。
熱心なフェッチ
イーガーフェッチでは、特定のレコードをフェッチしているときに、関連する子オブジェクトが自動的にアップロードされます。
レイジーフェッチ
遅延フェッチでは、特に要求しない限り、関連するオブジェクトは自動的にアップロードされません。まず、関連オブジェクトの可用性をチェックして通知します。後で、そのエンティティのgetterメソッドのいずれかを呼び出すと、すべてのレコードがフェッチされます。
初めてレコードをフェッチしようとすると、レイジーフェッチが可能です。そうすれば、レコード全体のコピーがすでにキャッシュメモリに保存されています。パフォーマンス面では、レイジーフェッチが推奨されます。
JPAは、Java仕様でリリースされたライブラリです。したがって、エンティティの永続性に関するすべてのオブジェクト指向の概念をサポートします。これまで、オブジェクトリレーショナルマッピングの基本はこれで終わりです。この章では、オブジェクトとリレーショナルエンティティ間の高度なマッピングについて説明します。
継承戦略
継承はオブジェクト指向言語のコアコンセプトであるため、エンティティ間の継承関係または戦略を使用できます。JPAは、SINGLE_TABLE、JOINED_TABLE、およびTABLE_PER_CONCRETE_CLASSの3種類の継承戦略をサポートします。
例を考えてみましょう。次の図は、3つのクラスを示しています。スタッフ、TeachingStaff、NonTeachingStaff、およびそれらの関係。
上の図では、Staffはエンティティであり、TeachingStaffとNonTeachingStaffはStaffのサブエンティティです。ここでは、上記の例を使用して、継承の3つの3つの戦略すべてを示します。
シングルテーブル戦略
単一テーブル戦略は、すべてのクラスフィールド（スーパークラスとサブクラスの両方）を取得し、それらをSINGLE_TABLE戦略と呼ばれる単一のテーブルにマップします。ここで、識別子の値は、1つのテーブル内の3つのエンティティの値を区別する上で重要な役割を果たします。
上記の例を考えてみましょう。TeachingStaffとNonTeachingStaffは、Staffのサブクラスです。継承の概念に従って、サブクラスはそのスーパークラスのプロパティを継承します。したがって、sidとsnameは、TeachingStaffとNonTeachingStaffの両方に属するフィールドです。JPAプロジェクトを作成します。このプロジェクトのすべてのモジュールは次のとおりです。
エンティティの作成
名前の付いたパッケージを作成します ‘com.tutorialspoint.eclipselink.entity’ 下 ‘src’パッケージ。名前の付いた新しいJavaクラスを作成しますStaff.java与えられたパッケージの下で。スタッフエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import java.io.Serializable;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;
@Entity
@Table
@Inheritance( strategy = InheritanceType.SINGLE_TABLE )
@DiscriminatorColumn( name="type" )
public class Staff implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.AUTO )
private int sid;
private String sname;
public Staff( int sid, String sname )
{
super( );
this.sid = sid;
this.sname = sname;
}
public Staff( )
{
super( );
}
public int getSid( )
{
return sid;
}
public void setSid( int sid )
{
this.sid = sid;
}
public String getSname( )
{
return sname;
}
public void setSname( String sname )
{
this.sname = sname;
}
}上記のコードでは @DescriminatorColumn フィールド名を指定します (type) その値は、残りの（TeachingおよびNonTeachingStaff）フィールドを示します。
名前の付いたStaffクラスのサブクラス（クラス）を作成します TeachingStaff.java 下 com.tutorialspoint.eclipselink.entityパッケージ。TeachingStaffエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
@Entity
@DiscriminatorValue( value="TS" )
public class TeachingStaff extends Staff
{
private String qualification;
private String subjectexpertise;
public TeachingStaff( int sid, String sname,
String qualification,String subjectexpertise )
{
super( sid, sname );
this.qualification = qualification;
this.subjectexpertise = subjectexpertise;
}
public TeachingStaff( )
{
super( );
}
public String getQualification( )
{
return qualification;
}
public void setQualification( String qualification )
{
this.qualification = qualification;
}
public String getSubjectexpertise( )
{
return subjectexpertise;
}
public void setSubjectexpertise( String subjectexpertise )
{
this.subjectexpertise = subjectexpertise;
}
}名前の付いたStaffクラスのサブクラス（クラス）を作成します NonTeachingStaff.java 下 com.tutorialspoint.eclipselink.entityパッケージ。NonTeachingStaffエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
@Entity
@DiscriminatorValue( value = "NS" )
public class NonTeachingStaff extends Staff
{
private String areaexpertise;
public NonTeachingStaff( int sid, String sname,
String areaexpertise )
{
super( sid, sname );
this.areaexpertise = areaexpertise;
}
public NonTeachingStaff( )
{
super( );
}
public String getAreaexpertise( )
{
return areaexpertise;
}
public void setAreaexpertise( String areaexpertise )
{
this.areaexpertise = areaexpertise;
}
}Persistence.xml
Persistence.xmlには、データベースの構成情報とエンティティークラスの登録情報が含まれています。xmlファイルは次のように表示されます。
<?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="Eclipselink_JPA"
transaction-type="RESOURCE_LOCAL">
<class>com.tutorialspoint.eclipselink.entity.Staff</class>
<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/jpadb"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password"
value="root"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.logging.level" value="FINE"/>
<property name="eclipselink.ddl-generation"
value="create-tables"/>
</properties>
</persistence-unit>
</persistence>サービスクラス
サービスクラスは、ビジネスコンポーネントの実装部分です。下にパッケージを作成します‘src’ 名前の付いたパッケージ ‘com.tutorialspoint.eclipselink.service’。
という名前のクラスを作成します SaveClient.java指定されたパッケージの下に、Staff、TeachingStaff、およびNonTeachingStaffクラスフィールドを格納します。SaveClientクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.service;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;
public class SaveClient
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
entitymanager.getTransaction( ).begin( );
//Teaching staff entity
TeachingStaff ts1=new TeachingStaff(
1,"Gopal","MSc MEd","Maths");
TeachingStaff ts2=new TeachingStaff(
2, "Manisha", "BSc BEd", "English");
//Non-Teaching Staff entity
NonTeachingStaff nts1=new NonTeachingStaff(
3, "Satish", "Accounts");
NonTeachingStaff nts2=new NonTeachingStaff(
4, "Krishna", "Office Admin");
//storing all entities
entitymanager.persist(ts1);
entitymanager.persist(ts2);
entitymanager.persist(nts1);
entitymanager.persist(nts2);
entitymanager.getTransaction().commit();
entitymanager.close();
emfactory.close();
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに通知が表示されます。MySQLワークベンチで出力を確認してください。表形式の出力は次のように表示されます。
| シド | タイプ | Sname | Areaexpertise | 資格 | 主題の専門知識 |
|---|---|---|---|---|---|
| 1 | TS | ゴパル | MSC MED | 数学 | |
| 2 | TS | マニシャ | BSCベッド | 英語 | |
| 3 | NS | サティッシュ | アカウント | ||
| 4 | NS | クリシュナ | オフィス管理者 |
最後に、3つのクラスすべてのフィールドを含む単一のテーブルを取得します。 Type （フィールド）。
参加テーブル戦略
結合テーブル戦略は、テーブルを結合してトランザクションを容易にするための一意の値を含む参照列を共有することです。上記と同じ例を考えてみましょう。
JPAプロジェクトを作成します。すべてのプロジェクトモジュールを以下に示します。
エンティティの作成
名前の付いたパッケージを作成します ‘com.tutorialspoint.eclipselink.entity’ 下 ‘src’パッケージ。名前の付いた新しいJavaクラスを作成しますStaff.java与えられたパッケージの下で。スタッフエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;
@Entity
@Table
@Inheritance( strategy = InheritanceType.JOINED )
public class Staff implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.AUTO )
private int sid;
private String sname;
public Staff( int sid, String sname )
{
super( );
this.sid = sid;
this.sname = sname;
}
public Staff( )
{
super( );
}
public int getSid( )
{
return sid;
}
public void setSid( int sid )
{
this.sid = sid;
}
public String getSname( )
{
return sname;
}
public void setSname( String sname )
{
this.sname = sname;
}
}名前の付いたStaffクラスのサブクラス（クラス）を作成します TeachingStaff.java 下 com.tutorialspoint.eclipselink.entityパッケージ。TeachingStaffエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
@Entity
@PrimaryKeyJoinColumn(referencedColumnName="sid")
public class TeachingStaff extends Staff
{
private String qualification;
private String subjectexpertise;
public TeachingStaff( int sid, String sname,
String qualification,String subjectexpertise )
{
super( sid, sname );
this.qualification = qualification;
this.subjectexpertise = subjectexpertise;
}
public TeachingStaff( )
{
super( );
}
public String getQualification( )
{
return qualification;
}
public void setQualification( String qualification )
{
this.qualification = qualification;
}
public String getSubjectexpertise( )
{
return subjectexpertise;
}
public void setSubjectexpertise( String subjectexpertise )
{
this.subjectexpertise = subjectexpertise;
}
}名前の付いたStaffクラスのサブクラス（クラス）を作成します NonTeachingStaff.java 下 com.tutorialspoint.eclipselink.entityパッケージ。NonTeachingStaffエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
@Entity
@PrimaryKeyJoinColumn(referencedColumnName="sid")
public class NonTeachingStaff extends Staff
{
private String areaexpertise;
public NonTeachingStaff( int sid, String sname,
String areaexpertise )
{
super( sid, sname );
this.areaexpertise = areaexpertise;
}
public NonTeachingStaff( )
{
super( );
}
public String getAreaexpertise( )
{
return areaexpertise;
}
public void setAreaexpertise( String areaexpertise )
{
this.areaexpertise = areaexpertise;
}
}Persistence.xml
Persistence.xmlファイルには、データベースの構成情報とエンティティークラスの登録情報が含まれています。xmlファイルは次のように表示されます。
<?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="Eclipselink_JPA"
transaction-type="RESOURCE_LOCAL">
<class>com.tutorialspoint.eclipselink.entity.Staff</class>
<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/jpadb"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password"
value="root"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.logging.level" value="FINE"/>
<property name="eclipselink.ddl-generation"
value="create-tables"/>
</properties>
</persistence-unit>
</persistence>サービスクラス
サービスクラスは、ビジネスコンポーネントの実装部分です。下にパッケージを作成します‘src’ 名前の付いたパッケージ ‘com.tutorialspoint.eclipselink.service’。
という名前のクラスを作成します SaveClient.java指定されたパッケージの下に、Staff、TeachingStaff、およびNonTeachingStaffクラスのフィールドを格納します。次に、SaveClientクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.service;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;
public class SaveClient
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
entitymanager.getTransaction( ).begin( );
//Teaching staff entity
TeachingStaff ts1=new TeachingStaff(
1,"Gopal","MSc MEd","Maths");
TeachingStaff ts2=new TeachingStaff(
2, "Manisha", "BSc BEd", "English");
//Non-Teaching Staff entity
NonTeachingStaff nts1=new NonTeachingStaff(
3, "Satish", "Accounts");
NonTeachingStaff nts2=new NonTeachingStaff(
4, "Krishna", "Office Admin");
//storing all entities
entitymanager.persist(ts1);
entitymanager.persist(ts2);
entitymanager.persist(nts1);
entitymanager.persist(nts2);
entitymanager.getTransaction().commit();
entitymanager.close();
emfactory.close();
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに通知が表示されます。出力については、MySQLワークベンチを確認してください。
ここで3つのテーブルが作成され、 staff 表は表形式で表示されます。
| シド | Dtype | Sname |
|---|---|---|
| 1 | 教員 | ゴパル |
| 2 | 教員 | マニシャ |
| 3 | NonTeachingStaff | サティッシュ |
| 4 | NonTeachingStaff | クリシュナ |
結果として TeachingStaff テーブルは次のように表示されます。
| シド | 資格 | 主題の専門知識 |
|---|---|---|
| 1 | MSC MED | 数学 |
| 2 | BSCベッド | 英語 |
上記のテーブルでは、sidは外部キー（スタッフテーブルからの参照フィールド）です。 NonTeachingStaff テーブルは次のように表示されます。
| シド | Areaexpertise |
|---|---|
| 3 | アカウント |
| 4 | オフィス管理者 |
最後に、それぞれのフィールドを使用して3つのテーブルが作成され、SIDフィールドは3つのテーブルすべてで共有されます。スタッフテーブルでは、SIDが主キーです。残りの2つのテーブル（TeachingStaffとNonTeachingStaff）では、SIDが外部キーです。
クラスごとのテーブル戦略
クラスごとのテーブル戦略は、サブエンティティごとにテーブルを作成することです。スタッフテーブルが作成されますが、null値が含まれます。Staffテーブルのフィールド値は、TeachingStaffテーブルとNonTeachingStaffテーブルの両方で共有する必要があります。
上記と同じ例を考えてみましょう。
エンティティの作成
名前の付いたパッケージを作成します ‘com.tutorialspoint.eclipselink.entity’ 下 ‘src’パッケージ。名前の付いた新しいJavaクラスを作成しますStaff.java与えられたパッケージの下で。スタッフエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;
@Entity
@Table
@Inheritance( strategy = InheritanceType.TABLE_PER_CLASS )
public class Staff implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.AUTO )
private int sid;
private String sname;
public Staff( int sid, String sname )
{
super( );
this.sid = sid;
this.sname = sname;
}
public Staff( )
{
super( );
}
public int getSid( )
{
return sid;
}
public void setSid( int sid )
{
this.sid = sid;
}
public String getSname( )
{
return sname;
}
public void setSname( String sname )
{
this.sname = sname;
}
}名前の付いたStaffクラスのサブクラス（クラス）を作成します TeachingStaff.java 下 com.tutorialspoint.eclipselink.entityパッケージ。TeachingStaffエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
@Entity
public class TeachingStaff extends Staff
{
private String qualification;
private String subjectexpertise;
public TeachingStaff( int sid, String sname,
String qualification,String subjectexpertise )
{
super( sid, sname );
this.qualification = qualification;
this.subjectexpertise = subjectexpertise;
}
public TeachingStaff( )
{
super( );
}
public String getQualification( )
{
return qualification;
}
public void setQualification( String qualification )
{
this.qualification = qualification;
}
public String getSubjectexpertise( )
{
return subjectexpertise;
}
public void setSubjectexpertise( String subjectexpertise )
{
this.subjectexpertise = subjectexpertise;
}
}名前の付いたStaffクラスのサブクラス（クラス）を作成します NonTeachingStaff.java 下 com.tutorialspoint.eclipselink.entityパッケージ。NonTeachingStaffエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
@Entity
public class NonTeachingStaff extends Staff
{
private String areaexpertise;
public NonTeachingStaff( int sid, String sname,
String areaexpertise )
{
super( sid, sname );
this.areaexpertise = areaexpertise;
}
public NonTeachingStaff( )
{
super( );
}
public String getAreaexpertise( )
{
return areaexpertise;
}
public void setAreaexpertise( String areaexpertise )
{
this.areaexpertise = areaexpertise;
}
}Persistence.xml
Persistence.xmlファイルには、データベースの構成情報とエンティティークラスの登録情報が含まれています。xmlファイルは次のように表示されます。
<?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="Eclipselink_JPA"
transaction-type="RESOURCE_LOCAL">
<class>com.tutorialspoint.eclipselink.entity.Staff</class>
<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/jpadb"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password"
value="root"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.logging.level" value="FINE"/>
<property name="eclipselink.ddl-generation"
value="create-tables"/>
</properties>
</persistence-unit>
</persistence>サービスクラス
サービスクラスは、ビジネスコンポーネントの実装部分です。下にパッケージを作成します‘src’ 名前の付いたパッケージ ‘com.tutorialspoint.eclipselink.service’。
という名前のクラスを作成します SaveClient.java指定されたパッケージの下に、Staff、TeachingStaff、およびNonTeachingStaffクラスフィールドを格納します。SaveClientクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.service;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;
public class SaveClient
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
entitymanager.getTransaction( ).begin( );
//Teaching staff entity
TeachingStaff ts1=new TeachingStaff(
1,"Gopal","MSc MEd","Maths");
TeachingStaff ts2=new TeachingStaff(
2, "Manisha", "BSc BEd", "English");
//Non-Teaching Staff entity
NonTeachingStaff nts1=new NonTeachingStaff(
3, "Satish", "Accounts");
NonTeachingStaff nts2=new NonTeachingStaff(
4, "Krishna", "Office Admin");
//storing all entities
entitymanager.persist(ts1);
entitymanager.persist(ts2);
entitymanager.persist(nts1);
entitymanager.persist(nts2);
entitymanager.getTransaction().commit();
entitymanager.close();
emfactory.close();
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに通知が表示されます。出力については、MySQLワークベンチを確認してください。
ここで3つのテーブルが作成され、 Staff テーブルにnullレコードが含まれています。
結果として TeachingStaff 次のように表示されます。
| シド | 資格 | Sname | 主題の専門知識 |
|---|---|---|---|
| 1 | MSC MED | ゴパル | 数学 |
| 2 | BSCベッド | マニシャ | 英語 |
上記のテーブルTeachingStaffには、StaffエンティティとTeachingStaffエンティティの両方のフィールドが含まれています。
結果として NonTeachingStaff 次のように表示されます。
| シド | Areaexpertise | Sname |
|---|---|---|
| 3 | アカウント | サティッシュ |
| 4 | オフィス管理者 | クリシュナ |
上記のテーブルNonTeachingStaffには、StaffエンティティとNonTeachingStaffエンティティの両方のフィールドが含まれています。
この章では、エンティティ間の関係について説明します。一般に、関係はデータベース内のテーブル間でより効果的です。ここでは、エンティティクラスはリレーショナルテーブル（JPAの概念）として扱われるため、エンティティクラス間の関係は次のようになります。
- @ManyToOneリレーション
- @OneToManyリレーション
- @OneToOneリレーション
- @ManyToManyリレーション
@ManyToOneリレーション
エンティティ間に多対1の関係が存在し、1つのエンティティ（列または列のセット）が、一意の値を含む別のエンティティ（列または列のセット）で参照されます。リレーショナルデータベースでは、これらの関係はテーブル間で外部キー/主キーを使用して適用されます。
従業員と部門のエンティティ間の関係の例を考えてみましょう。一方向、つまり従業員から部門へ、多対1の関係が適用されます。つまり、従業員の各レコードには1つの部門IDが含まれ、これは部門テーブルの主キーである必要があります。ここのEmployeeテーブルでは、Departmentidは外部キーです。
次の図は、2つのテーブル間の多対1の関係を示しています。
名前の付いたEclipseIDEでJPAプロジェクトを作成します JPA_Eclipselink_MTO。このプロジェクトのすべてのモジュールについて、以下で説明します。
エンティティの作成
エンティティを作成するには、上記の図に従ってください。名前の付いたパッケージを作成します‘com.tutorialspoin.eclipselink.entity’ 下 ‘src’パッケージ。という名前のクラスを作成しますDepartment.java与えられたパッケージの下で。クラスDepartmentエンティティは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Department
{
@Id
@GeneratedValue( strategy=GenerationType.AUTO )
private int id;
private String name;
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String getName( )
{
return name;
}
public void setName( String deptName )
{
this.name = deptName;
}
}この関係で2番目のエンティティを作成します-名前の付いた従業員エンティティクラス Employee.java 下 ‘com.tutorialspoint.eclipselink.entity’パッケージ。Employeeエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
@Entity
public class Employee
{
@Id
@GeneratedValue( strategy= GenerationType.AUTO )
private int eid;
private String ename;
private double salary;
private String deg;
@ManyToOne
private Department department;
public Employee(int eid,
String ename, double salary, String deg)
{
super( );
this.eid = eid;
this.ename = ename;
this.salary = salary;
this.deg = deg;
}
public Employee( )
{
super();
}
public int getEid( )
{
return eid;
}
public void setEid(int eid)
{
this.eid = eid;
}
public String getEname( )
{
return ename;
}
public void setEname(String ename)
{
this.ename = ename;
}
public double getSalary( )
{
return salary;
}
public void setSalary(double salary)
{
this.salary = salary;
}
public String getDeg( )
{
return deg;
}
public void setDeg(String deg)
{
this.deg = deg;
}
public Department getDepartment() {
return department;
}
public void setDepartment(Department department) {
this.department = department;
}
}Persistence.xml
データベースとエンティティクラスの登録を構成するには、Persistence.xmlファイルが必要です。
Persitence.xmlは、JPAプロジェクトの作成中にEclipseIDEによって作成されます。構成の詳細はユーザー仕様です。persistence.xmlファイルは次のように表示されます。
<?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="Eclipselink_JPA"
transaction-type="RESOURCE_LOCAL">
<class>com.tutorialspoint.eclipselink.entity.Employee</class>
<class>com.tutorialspoint.eclipselink.entity.Department</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/jpadb"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password"
value="root"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.logging.level" value="FINE"/>
<property name="eclipselink.ddl-generation"
value="create-tables"/>
</properties>
</persistence-unit>
</persistence>サービスクラス
このモジュールには、属性の初期化を使用してリレーショナル部分を実装するサービスクラスが含まれています。下にパッケージを作成します‘src’ 名前の付いたパッケージ ‘com.tutorialspoint.eclipselink.service’。名前の付いたDAOクラスManyToOne.java指定されたパッケージの下に作成されます。DAOクラスは次のように表示されます。
package com.tutorialspointeclipselink.service;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;
public class ManyToOne
{
public static void main( String[ ] args )
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
entitymanager.getTransaction( ).begin( );
//Create Department Entity
Department department = new Department();
department.setName("Development");
//Store Department
entitymanager.persist(department);
//Create Employee1 Entity
Employee employee1 = new Employee();
employee1.setEname("Satish");
employee1.setSalary(45000.0);
employee1.setDeg("Technical Writer");
employee1.setDepartment(department);
//Create Employee2 Entity
Employee employee2 = new Employee();
employee2.setEname("Krishna");
employee2.setSalary(45000.0);
employee2.setDeg("Technical Writer");
employee2.setDepartment(department);
//Create Employee3 Entity
Employee employee3 = new Employee();
employee3.setEname("Masthanvali");
employee3.setSalary(50000.0);
employee3.setDeg("Technical Writer");
employee3.setDepartment(department);
//Store Employees
entitymanager.persist(employee1);
entitymanager.persist(employee2);
entitymanager.persist(employee3);
entitymanager.getTransaction().commit();
entitymanager.close();
emfactory.close();
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに通知が表示されます。出力については、MySQLワークベンチを確認してください。この例では、2つのテーブルが作成されます。
MySQLインターフェースで次のクエリとの結果を渡します Department 表は次のように表示されます。
Select * from department| ID | 名前 |
|---|---|
| 101 | 開発 |
MySQLインターフェースで次のクエリとの結果を渡します Employee 表は次のように表示されます。
Select * from employee| イード | デグ | エナメ | 給料 | Department_Id |
|---|---|---|---|---|
| 102 | テクニカルライター | サティッシュ | 45000 | 101 |
| 103 | テクニカルライター | クリシュナ | 45000 | 101 |
| 104 | テクニカルライター | マスタンワリ | 50000 | 101 |
上記のテーブルでは、Deparment_IdはDepartmentテーブルの外部キー（参照フィールド）です。
@OneToManyリレーション
この関係では、1つのエンティティの各行は、他のエンティティの多くの子レコードを参照します。重要なことは、子レコードに複数の親を含めることはできないということです。表Aと表Bの間の1対多の関係では、表Aの各行を表Bの1つまたは複数の行にリンクできます。
上記の例を考えてみましょう。上記の例のEmployeeテーブルとDepartmentテーブルが逆一方向に接続されているとすると、関係は1対多の関係になります。名前の付いたEclipseIDEでJPAプロジェクトを作成しますJPA_Eclipselink_OTM。このプロジェクトのすべてのモジュールについて、以下で説明します。
エンティティの作成
エンティティを作成するには、上記の図に従ってください。名前の付いたパッケージを作成します‘com.tutorialspoin.eclipselink.entity’ 下 ‘src’パッケージ。という名前のクラスを作成しますDepartment.java与えられたパッケージの下で。クラスDepartmentエンティティは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
@Entity
public class Department
{
@Id
@GeneratedValue( strategy=GenerationType.AUTO )
private int id;
private String name;
@OneToMany( targetEntity=Employee.class )
private List employeelist;
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String getName( )
{
return name;
}
public void setName( String deptName )
{
this.name = deptName;
}
public List getEmployeelist()
{
return employeelist;
}
public void setEmployeelist(List employeelist)
{
this.employeelist = employeelist;
}
}このリレーションに2番目のエンティティを作成します-名前が付けられた従業員エンティティクラス Employee.java 下 ‘com.tutorialspoint.eclipselink.entity’パッケージ。Employeeエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Employee
{
@Id
@GeneratedValue( strategy= GenerationType.AUTO )
private int eid;
private String ename;
private double salary;
private String deg;
public Employee(int eid,
String ename, double salary, String deg)
{
super( );
this.eid = eid;
this.ename = ename;
this.salary = salary;
this.deg = deg;
}
public Employee( )
{
super();
}
public int getEid( )
{
return eid;
}
public void setEid(int eid)
{
this.eid = eid;
}
public String getEname( )
{
return ename;
}
public void setEname(String ename)
{
this.ename = ename;
}
public double getSalary( )
{
return salary;
}
public void setSalary(double salary)
{
this.salary = salary;
}
public String getDeg( )
{
return deg;
}
public void setDeg(String deg)
{
this.deg = deg;
}
}Persistence.xml
persistence.xmlファイルは次のとおりです。
<?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="Eclipselink_JPA"
transaction-type="RESOURCE_LOCAL">
<class>com.tutorialspoint.eclipselink.entity.Employee</class>
<class>com.tutorialspoint.eclipselink.entity.Department</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/jpadb"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password"
value="root"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.logging.level" value="FINE"/>
<property name="eclipselink.ddl-generation"
value="create-tables"/>
</properties>
</persistence-unit>
</persistence>サービスクラス
このモジュールには、属性の初期化を使用してリレーショナル部分を実装するサービスクラスが含まれています。下にパッケージを作成します‘src’ 名前の付いたパッケージ ‘com.tutorialspoint.eclipselink.service’。名前の付いたDAOクラスOneToMany.java指定されたパッケージの下に作成されます。DAOクラスは次のように表示されます。
package com.tutorialspointeclipselink.service;
import java.util.List;
import java.util.ArrayList;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;
public class OneToMany
{
public static void main(String[] args)
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
entitymanager.getTransaction( ).begin( );
//Create Employee1 Entity
Employee employee1 = new Employee();
employee1.setEname("Satish");
employee1.setSalary(45000.0);
employee1.setDeg("Technical Writer");
//Create Employee2 Entity
Employee employee2 = new Employee();
employee2.setEname("Krishna");
employee2.setSalary(45000.0);
employee2.setDeg("Technical Writer");
//Create Employee3 Entity
Employee employee3 = new Employee();
employee3.setEname("Masthanvali");
employee3.setSalary(50000.0);
employee3.setDeg("Technical Writer");
//Store Employee
entitymanager.persist(employee1);
entitymanager.persist(employee2);
entitymanager.persist(employee3);
//Create Employeelist
List<Employee> emplist = new ArrayList();
emplist.add(employee1);
emplist.add(employee2);
emplist.add(employee3);
//Create Department Entity
Department department= new Department();
department.setName("Development");
department.setEmployeelist(emplist);
//Store Department
entitymanager.persist(department);
entitymanager.getTransaction().commit();
entitymanager.close();
emfactory.close();
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに通知が表示されます。出力については、MySQLワークベンチを次のように確認してください。
このプロジェクトでは、3つのテーブルが作成されます。MySQLインターフェースで次のクエリを渡すと、department_employeeテーブルの結果が次のように表示されます。
Select * from department_Id;| Department_ID | Employee_Eid |
|---|---|
| 254 | 251 |
| 254 | 252 |
| 254 | 253 |
上記の表では、 deparment_id そして employee_id 部門および従業員テーブルからの外部キー（参照フィールド）です。
MySQLインターフェースで次のクエリを渡すと、部門テーブルの結果が次のように表形式で表示されます。
Select * from department;| ID | 名前 |
|---|---|
| 254 | 開発 |
MySQLインターフェースで次のクエリを渡すと、employeeテーブルの結果が次のように表示されます。
Select * from employee;| イード | デグ | エナメ | 給料 |
|---|---|---|---|
| 251 | テクニカルライター | サティッシュ | 45000 |
| 252 | テクニカルライター | クリシュナ | 45000 |
| 253 | テクニカルライター | マスタンワリ | 50000 |
@OneToOneリレーション
1対1の関係では、1つのアイテムを他の1つのアイテムにのみリンクできます。これは、1つのエンティティの各行が、別のエンティティの1つの行のみを参照することを意味します。
上記の例を考えてみましょう。 Employee そして Department逆一方向の方法では、関係は1対1の関係です。これは、各従業員が1つの部門にのみ属していることを意味します。名前の付いたEclipseIDEでJPAプロジェクトを作成しますJPA_Eclipselink_OTO。このプロジェクトのすべてのモジュールについて、以下で説明します。
エンティティの作成
エンティティを作成するには、上記の図に従ってください。名前の付いたパッケージを作成します‘com.tutorialspoin.eclipselink.entity’ 下 ‘src’パッケージ。という名前のクラスを作成しますDepartment.java与えられたパッケージの下で。クラスDepartmentエンティティは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Department
{
@Id
@GeneratedValue( strategy=GenerationType.AUTO )
private int id;
private String name;
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String getName( )
{
return name;
}
public void setName( String deptName )
{
this.name = deptName;
}
}このリレーションに2番目のエンティティを作成します-名前が付けられた従業員エンティティクラス Employee.java 下 ‘com.tutorialspoint.eclipselink.entity’パッケージ。Employeeエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
@Entity
public class Employee
{
@Id
@GeneratedValue( strategy= GenerationType.AUTO )
private int eid;
private String ename;
private double salary;
private String deg;
@OneToOne
private Department department;
public Employee(int eid,
String ename, double salary, String deg)
{
super( );
this.eid = eid;
this.ename = ename;
this.salary = salary;
this.deg = deg;
}
public Employee( )
{
super();
}
public int getEid( )
{
return eid;
}
public void setEid(int eid)
{
this.eid = eid;
}
public String getEname( )
{
return ename;
}
public void setEname(String ename)
{
this.ename = ename;
}
public double getSalary( )
{
return salary;
}
public void setSalary(double salary)
{
this.salary = salary;
}
public String getDeg( )
{
return deg;
}
public void setDeg(String deg)
{
this.deg = deg;
}
public Department getDepartment()
{
return department;
}
public void setDepartment(Department department)
{
this.department = department;
}
}Persistence.xml
Persistence.xmlファイルは次のとおりです。
<?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="Eclipselink_JPA"
transaction-type="RESOURCE_LOCAL">
<class>com.tutorialspoint.eclipselink.entity.Employee</class>
<class>com.tutorialspoint.eclipselink.entity.Department</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/jpadb"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password"
value="root"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.logging.level" value="FINE"/>
<property name="eclipselink.ddl-generation"
value="create-tables"/>
</properties>
</persistence-unit>
</persistence>サービスクラス
下にパッケージを作成します ‘src’ 名前の付いたパッケージ ‘com.tutorialspoint.eclipselink.service’。名前の付いたDAOクラスOneToOne.java指定されたパッケージの下に作成されます。DAOクラスは次のように表示されます。
package com.tutorialspointeclipselink.service;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;
public class OneToOne
{
public static void main(String[] args)
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
entitymanager.getTransaction( ).begin( );
//Create Department Entity
Department department = new Department();
department.setName("Development");
//Store Department
entitymanager.persist(department);
//Create Employee Entity
Employee employee = new Employee();
employee.setEname("Satish");
employee.setSalary(45000.0);
employee.setDeg("Technical Writer");
employee.setDepartment(department);
//Store Employee
entitymanager.persist(employee);
entitymanager.getTransaction().commit();
entitymanager.close();
emfactory.close();
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに通知が表示されます。出力については、次のようにMySQLワークベンチを確認してください。
上記の例では、2つのテーブルが作成されています。MySQLインターフェースで次のクエリを渡すと、部門テーブルの結果が次のように表示されます。
Select * from department| ID | 名前 |
|---|---|
| 301 | 開発 |
MySQLインターフェースで次のクエリとの結果を渡します employee 表は次のように表示されます。
Select * from employee| イード | デグ | エナメ | 給料 | Department_id |
|---|---|---|---|---|
| 302 | テクニカルライター | サティッシュ | 45000 | 301 |
@ManyToManyリレーション
多対多の関係とは、1つのエンティティの1つ以上の行が、他のエンティティの複数の行に関連付けられている場合です。
2つのエンティティ間の関係の例を考えてみましょう。 Class そして Teacher。双方向では、クラスと教師の両方が多対1の関係にあります。つまり、Classの各レコードはTeacherセット（teacher id）によって参照されます。これは、Teacherテーブルの主キーであり、Teacher_Classテーブルに格納されている必要があります。その逆も同様です。ここで、Teachers_Classテーブルには両方の外部キーフィールドが含まれています。名前の付いたEclipseIDEでJPAプロジェクトを作成しますJPA_Eclipselink_MTM。このプロジェクトのすべてのモジュールについて、以下で説明します。
エンティティの作成
上の図に示されているスキーマに従ってエンティティを作成します。名前の付いたパッケージを作成します‘com.tutorialspoin.eclipselink.entity’ 下 ‘src’パッケージ。という名前のクラスを作成しますClas.java与えられたパッケージの下で。クラスDepartmentエンティティは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
@Entity
public class Clas
{
@Id
@GeneratedValue( strategy = GenerationType.AUTO )
private int cid;
private String cname;
@ManyToMany(targetEntity=Teacher.class)
private Set teacherSet;
public Clas()
{
super();
}
public Clas(int cid,
String cname, Set teacherSet)
{
super();
this.cid = cid;
this.cname = cname;
this.teacherSet = teacherSet;
}
public int getCid()
{
return cid;
}
public void setCid(int cid)
{
this.cid = cid;
}
public String getCname()
{
return cname;
}
public void setCname(String cname)
{
this.cname = cname;
}
public Set getTeacherSet()
{
return teacherSet;
}
public void setTeacherSet(Set teacherSet)
{
this.teacherSet = teacherSet;
}
}このリレーションに2番目のエンティティを作成します-名前が付けられた従業員エンティティクラス Teacher.java 下 ‘com.tutorialspoint.eclipselink.entity’パッケージ。Employeeエンティティクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
@Entity
public class Teacher
{
@Id
@GeneratedValue( strategy = GenerationType.AUTO )
private int tid;
private String tname;
private String subject;
@ManyToMany(targetEntity=Clas.class)
private Set clasSet;
public Teacher()
{
super();
}
public Teacher(int tid, String tname, String subject,
Set clasSet)
{
super();
this.tid = tid;
this.tname = tname;
this.subject = subject;
this.clasSet = clasSet;
}
public int getTid()
{
return tid;
}
public void setTid(int tid)
{
this.tid = tid;
}
public String getTname()
{
return tname;
}
public void setTname(String tname)
{
this.tname = tname;
}
public String getSubject()
{
return subject;
}
public void setSubject(String subject)
{
this.subject = subject;
}
public Set getClasSet()
{
return clasSet;
}
public void setClasSet(Set clasSet)
{
this.clasSet = clasSet;
}
}Persistence.xml
Persistence.xmlファイルは次のとおりです。
<?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="Eclipselink_JPA"
transaction-type="RESOURCE_LOCAL">
<class>com.tutorialspoint.eclipselink.entity.Employee</class>
<class>com.tutorialspoint.eclipselink.entity.Department</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/jpadb"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password"
value="root"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.logging.level" value="FINE"/>
<property name="eclipselink.ddl-generation"
value="create-tables"/>
</properties>
</persistence-unit>
</persistence>サービスクラス
下にパッケージを作成します ‘src’ 名前の付いたパッケージ ‘com.tutorialspoint.eclipselink.service’。名前の付いたDAOクラスManyToMany.java指定されたパッケージの下に作成されます。DAOクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.service;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Clas;
import com.tutorialspoint.eclipselink.entity.Teacher;
public class ManyToMany
{
public static void main(String[] args)
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
entitymanager.getTransaction( ).begin( );
//Create Clas Entity
Clas clas1=new Clas(0,"1st",null);
Clas clas2=new Clas(0,"2nd",null);
Clas clas3=new Clas(0,"3rd",null);
//Store Clas
entitymanager.persist(clas1);
entitymanager.persist(clas2);
entitymanager.persist(clas3);
//Create Clas Set1
Set<Clas> classSet1 = new HashSet();
classSet1.add(clas1);
classSet1.add(clas2);
classSet1.add(clas3);
//Create Clas Set2
Set<Clas> classSet2 = new HashSet();
classSet2.add(clas3);
classSet2.add(clas1);
classSet2.add(clas2);
//Create Clas Set3
Set<Clas> classSet3 = new HashSet();
classSet3.add(clas2);
classSet3.add(clas3);
classSet3.add(clas1);
//Create Teacher Entity
Teacher teacher1 = new Teacher(0,
"Satish","Java",classSet1);
Teacher teacher2 = new Teacher(0,
"Krishna","Adv Java",classSet2);
Teacher teacher3 = new Teacher(0,
"Masthanvali","DB2",classSet3);
//Store Teacher
entitymanager.persist(teacher1);
entitymanager.persist(teacher2);
entitymanager.persist(teacher3);
entitymanager.getTransaction( ).commit( );
entitymanager.close( );
emfactory.close( );
}
}このサンプルプロジェクトでは、3つのテーブルが作成されます。MySQLインターフェースで次のクエリを渡すと、teacher_clasテーブルの結果が次のように表示されます。
Select * form teacher_clas| Teacher_tid | Classet_cid |
|---|---|
| 354 | 351 |
| 355 | 351 |
| 356 | 351 |
| 354 | 352 |
| 355 | 352 |
| 356 | 352 |
| 354 | 353 |
| 355 | 353 |
| 356 | 353 |
上記の表 teacher_tid は教師テーブルからの外部キーであり、 classet_cidクラステーブルからの外部キーです。したがって、異なる教師が異なるクラスに割り当てられます。
MySQLインターフェースで次のクエリを渡すと、教師テーブルの結果が次のように表示されます。
Select * from teacher| Tid | 件名 | Tname |
|---|---|---|
| 354 | Java | サティッシュ |
| 355 | Adv Java | クリシュナ |
| 356 | DB2 | マスタンバリ |
MySQLインターフェースで次のクエリとの結果を渡します clas 表は次のように表示されます。
Select * from clas| Cid | Cname |
|---|---|
| 351 | 1位 |
| 352 | 2位 |
| 353 | 3位 |
基準は、エンティティのクエリを定義するために使用される事前定義されたAPIです。これは、JPQLクエリを定義する別の方法です。これらのクエリはタイプセーフで移植性があり、構文を変更することで簡単に変更できます。JPQLと同様に、抽象スキーマ（スキーマの編集が簡単）と埋め込みオブジェクトに従います。メタデータAPIは、基準APIと混合されて、基準クエリの永続エンティティをモデル化します。
Criteria APIの主な利点は、コンパイル時の早い段階でエラーを検出できることです。文字列ベースのJPQLクエリとJPA基準ベースのクエリは、パフォーマンスと効率が同じです。
基準APIの履歴
基準はJPAのすべてのバージョンに含まれているため、基準の各ステップはJPAの仕様で通知されます。
- JPA 2.0では、基準クエリAPI、クエリの標準化が開発されています。
- JPA 2.1には、基準の更新と削除（一括更新と削除）が含まれています。
基準クエリ構造
CriteriaとJPQLは密接に関連しており、クエリで同様の演算子を使用して設計できます。続くjavax.persistence.criteriaクエリを設計するためのパッケージ。クエリ構造とは、構文基準クエリを意味します。
次の単純な基準クエリは、データソース内のエンティティクラスのすべてのインスタンスを返します。
EntityManager em = ...;
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Entity class> cq = cb.createQuery(Entity.class);
Root<Entity> from = cq.from(Entity.class);
cq.select(Entity);
TypedQuery<Entity> q = em.createQuery(cq);
List<Entity> allitems = q.getResultList();クエリは、基準を作成するための基本的な手順を示しています。
EntityManager インスタンスは、CriteriaBuilderオブジェクトを作成するために使用されます。
CriteriaQueryインスタンスは、クエリオブジェクトを作成するために使用されます。このクエリオブジェクトの属性は、クエリの詳細で変更されます。
CriteriaQuery.form メソッドは、クエリルートを設定するために呼び出されます。
CriteriaQuery.select 結果リストタイプを設定するために呼び出されます。
TypedQuery<T> インスタンスは、実行するクエリを準備し、クエリ結果のタイプを指定するために使用されます。
getResultListTypedQuery <T>オブジェクトのメソッドでクエリを実行します。このクエリはエンティティのコレクションを返し、結果はリストに保存されます。
基準APIの例
従業員データベースの例を考えてみましょう。jpadb.employeeテーブルに次のレコードが含まれていると仮定します。
Eid Ename Salary Deg
401 Gopal 40000 Technical Manager
402 Manisha 40000 Proof reader
403 Masthanvali 35000 Technical Writer
404 Satish 30000 Technical writer
405 Krishna 30000 Technical Writer
406 Kiran 35000 Proof reader名前の付いたEclipseIDEでJPAプロジェクトを作成します JPA_Eclipselink_Criteria。このプロジェクトのすべてのモジュールについて、以下で説明します。
エンティティの作成
名前の付いたパッケージを作成します com.tutorialspoint.eclipselink.entity 下 ‘src’
という名前のクラスを作成します Employee.java与えられたパッケージの下で。クラスEmployeeエンティティは次のように表示されます。
package com.tutorialspoint.eclipselink.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Employee
{
@Id
@GeneratedValue(strategy= GenerationType.AUTO)
private int eid;
private String ename;
private double salary;
private String deg;
public Employee(int eid, String ename, double salary, String deg)
{
super( );
this.eid = eid;
this.ename = ename;
this.salary = salary;
this.deg = deg;
}
public Employee( )
{
super();
}
public int getEid( )
{
return eid;
}
public void setEid(int eid)
{
this.eid = eid;
}
public String getEname( )
{
return ename;
}
public void setEname(String ename)
{
this.ename = ename;
}
public double getSalary( )
{
return salary;
}
public void setSalary(double salary)
{
this.salary = salary;
}
public String getDeg( )
{
return deg;
}
public void setDeg(String deg)
{
this.deg = deg;
}
@Override
public String toString() {
return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
+ salary + ", deg=" + deg + "]";
}
}Persistence.xml
Persistence.xmlファイルは次のとおりです。
<?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="Eclipselink_JPA"
transaction-type="RESOURCE_LOCAL">
<class>com.tutorialspoint.eclipselink.entity.Employee</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/jpadb"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password"
value="root"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.logging.level" value="FINE"/>
<property name="eclipselink.ddl-generation"
value="create-tables"/>
</properties>
</persistence-unit>
</persistence>サービスクラス
このモジュールには、MetaDataAPI初期化を使用してCriteriaクエリ部分を実装するサービスクラスが含まれています。名前の付いたパッケージを作成します‘com.tutorialspoint.eclipselink.service’。名前の付いたクラスCriteriaAPI.java指定されたパッケージの下に作成されます。DAOクラスは次のように表示されます。
package com.tutorialspoint.eclipselink.service;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import com.tutorialspoint.eclipselink.entity.Employee;
public class CriteriaApi
{
public static void main(String[] args)
{
EntityManagerFactory emfactory = Persistence.
createEntityManagerFactory( "Eclipselink_JPA" );
EntityManager entitymanager = emfactory.
createEntityManager( );
CriteriaBuilder criteriaBuilder = entitymanager
.getCriteriaBuilder();
CriteriaQuery<Object> criteriaQuery = criteriaBuilder
.createQuery();
Root<Employee> from = criteriaQuery.from(Employee.class);
//select all records
System.out.println(“Select all records”);
CriteriaQuery<Object> select =criteriaQuery.select(from);
TypedQuery<Object> typedQuery = entitymanager
.createQuery(select);
List<Object> resultlist= typedQuery.getResultList();
for(Object o:resultlist)
{
Employee e=(Employee)o;
System.out.println("EID : "+e.getEid()
+" Ename : "+e.getEname());
}
//Ordering the records
System.out.println(“Select all records by follow ordering”);
CriteriaQuery<Object> select1 = criteriaQuery.select(from);
select1.orderBy(criteriaBuilder.asc(from.get("ename")));
TypedQuery<Object> typedQuery1 = entitymanager
.createQuery(select);
List<Object> resultlist1= typedQuery1.getResultList();
for(Object o:resultlist1)
{
Employee e=(Employee)o;
System.out.println("EID : "+e.getEid()
+" Ename : "+e.getEname());
}
entitymanager.close( );
emfactory.close( );
}
}上記のプログラムをコンパイルして実行すると、EclipseIDEのコンソールパネルに次の出力が表示されます。
Select All records
EID : 401 Ename : Gopal
EID : 402 Ename : Manisha
EID : 403 Ename : Masthanvali
EID : 404 Ename : Satish
EID : 405 Ename : Krishna
EID : 406 Ename : Kiran
Select All records by follow Ordering
EID : 401 Ename : Gopal
EID : 406 Ename : Kiran
EID : 405 Ename : Krishna
EID : 402 Ename : Manisha
EID : 403 Ename : Masthanvali
EID : 404 Ename : Satish