JPA-はじめに

エンタープライズアプリケーションは、膨大な量のデータを保存および取得することでデータベース操作を実行します。ストレージ管理に利用可能なすべてのテクノロジーにもかかわらず、アプリケーション開発者は通常、データベース操作を効率的に実行するのに苦労しています。

一般に、Java開発者は大量のコードを使用するか、独自のフレームワークを使用してデータベースと対話しますが、JPAを使用すると、データベースと対話する負担が大幅に軽減されます。オブジェクトモデル（Javaプログラム）とリレーショナルモデル（データベースプログラム）の間のブリッジを形成します。

リレーショナルモデルとオブジェクトモデルの不一致

リレーショナルオブジェクトは表形式で表され、オブジェクトモデルは相互接続されたオブジェクト形式のグラフで表されます。リレーショナルデータベースからオブジェクトモデルを格納および取得する際に、次の理由により不一致が発生します。

粒度：オブジェクトモデルはリレーショナルモデルよりも粒度が高くなります。
サブタイプ：サブタイプ（継承を意味する）は、すべてのタイプのリレーショナルデータベースでサポートされているわけではありません。
同一性：オブジェクトモデルと同様に、リレーショナルモデルは同一性を記述している間は同一性を公開しません。
関連付け：リレーショナルモデルは、オブジェクトドメインモデルを調べている間、複数の関係を決定できません。
データナビゲーション：オブジェクトネットワーク内のオブジェクト間のデータナビゲーションは、両方のモデルで異なります。

JPAとは何ですか？

Java Persistence APIは、膨大な量のデータをOracle Corporationが提供するデータベースに永続的に保存するためのクラスとメソッドのコレクションです。

JPAを使用する場所

リレーショナルオブジェクト管理のコードを記述する負担を軽減するために、プログラマーは「JPAプロバイダー」フレームワークに従います。これにより、データベースインスタンスとのやり取りが容易になります。ここでは、必要なフレームワークがJPAに引き継がれます。

JPA

JPAの歴史

EJBの以前のバージョン、javax.ejb.EntityBean Interfaceを使用したビジネスロジックレイヤーと組み合わせた定義済み永続レイヤー。

EJB 3.0の導入中、永続層は分離され、JPA 1.0（Java Persistence API）として指定されました。このAPIの仕様は、JSR 220を使用して2006年5月11日にJAVA EE5の仕様とともにリリースされました。
JPA 2.0は、Java Community Process JSR 317の一部として、2009年12月10日にJAVA EE6の仕様とともにリリースされました。
JPA 2.1は、JSR 338を使用して2013年4月22日にJAVA EE7の仕様でリリースされました。

JPAプロバイダー

JPAはオープンソースAPIであるため、Oracle、Redhat、Eclipseなどのさまざまなエンタープライズベンダー JPA永続性フレーバーを追加して、新しい製品を提供します。これらの製品の一部は次のとおりです。

Hibernate、Eclipselink、Toplink、Spring Data JPAなど*

JPA-アーキテクチャ

Java Persistence APIは、ビジネスエンティティをリレーショナルエンティティとして保存するソースです。 PLAIN OLD JAVA OBJECT（POJO）をエンティティとして定義する方法と、関係を持つエンティティを管理する方法を示します。

クラスレベルのアーキテクチャ

次の図は、JPAのクラスレベルのアーキテクチャを示しています。 JPAのコアクラスとインターフェースを示しています。

JPAクラスレベルアーキテクチャ

次の表は、上記のアーキテクチャに示されている各ユニットについて説明しています。

Units	Description
EntityManagerFactory	This is a factory class of EntityManager. It creates and manages multiple EntityManager instances.
EntityManager	It is an Interface, it manages the persistence operations on objects. It works like factory for Query instance.
Entity	Entities are the persistence objects, stores as records in the database.
EntityTransaction	It has one-to-one relationship with EntityManager. For each EntityManager, operations are maintained by EntityTransaction class.
Persistence	This class contain static methods to obtain EntityManagerFactory instance.
Query	This interface is implemented by each JPA vendor to obtain relational objects that meet the criteria.

上記のクラスとインターフェースは、エンティティをレコードとしてデータベースに保存するために使用されます。データベースにデータを保存するためのコードを書く手間を減らして、クラスをデータベーステーブルにマッピングするためのコードを書くなど、より重要なアクティビティに集中できるようにすることで、プログラマを支援します。

JPAクラスの関係

上記のアーキテクチャでは、クラスとインターフェイスの関係はjavax.persistenceパッケージに属します。次の図は、それらの関係を示しています。

JPAクラス関係

EntityManagerFactoryとEntityManagerの関係は* 1対多*です。 EntityManagerインスタンスへのファクトリクラスです。
EntityManagerとEntityTransactionの関係は 1対1 です。 EntityManager操作ごとに、EntityTransactionインスタンスがあります。
EntityManagerとQueryの関係は* 1対多*です。 1つのEntityManagerインスタンスを使用して、多数のクエリを実行できます。
EntityManagerとEntityの関係は* 1対多*です。 1つのEntityManagerインスタンスで複数のエンティティを管理できます。

JPA-ORMコンポーネント

最新のアプリケーションのほとんどは、リレーショナルデータベースを使用してデータを保存します。最近、多くのベンダーがデータデータベースの負担を軽減するためにオブジェクトデータベースに切り替えました。これは、オブジェクトデータベースまたはオブジェクトリレーショナルテクノロジが、保存、取得、更新、およびメンテナンスを処理していることを意味します。このオブジェクトリレーショナルテクノロジーの中核部分は、orm.xmlファイルのマッピングです。 xmlはコンパイルを必要としないため、少ない管理で複数のデータソースを簡単に変更できます。

オブジェクトリレーショナルマッピング

オブジェクトリレーショナルマッピング（ORM）では、ORMとは何か、どのように機能するかについて簡単に説明します。 ORMは、オブジェクト型からリレーショナル型へ、またはその逆にデータを変換するプログラミング機能です。

ORMの主な機能は、データベース内のデータにオブジェクトをマッピングまたはバインドすることです。マッピング中に、データ、データのタイプ、および他のテーブルの自己エンティティまたはエンティティとの関係を考慮する必要があります。

高度な機能

慣用的な永続性：オブジェクト指向クラスを使用して永続性クラスを作成できます。
高性能：多くのフェッチ技術と期待できるロック技術があります。
信頼性：安定性が高く、優れています。多くの産業プログラマーが使用します。

ORMアーキテクチャ

ここでは、ORMアーキテクチャに従います。

オブジェクトリレーショナルマッピング

上記のアーキテクチャは、オブジェクトデータが3つのフェーズでリレーショナルデータベースに格納される方法を説明しています。

フェーズ1

*Object data* フェーズという名前の最初のフェーズには、POJOクラス、サービスインターフェイス、およびクラスが含まれます。 これは、ビジネスロジックの操作と属性を持つ主要なビジネスコンポーネントレイヤーです。

たとえば、従業員のデータベースをスキーマとして取り上げましょう。

従業員のPOJOクラスには、ID、名前、給与、指定などの属性が含まれます。そして、これらの属性のセッターおよびゲッターメソッドのようなメソッド。
Employee DAO/Serviceクラスには、従業員の作成、従業員の検索、従業員の削除などのサービスメソッドが含まれています。

フェーズ2

2番目のフェーズは、 mapping または persistence フェーズと呼ばれ、JPAプロバイダー、マッピングファイル（ORM.xml）、JPAローダー、およびオブジェクトグリッドが含まれます。

* JPAプロバイダー*：JPAフレーバー（javax.persistence）を含むベンダー製品。たとえば、Eclipselink、Toplink、Hibernateなど。
マッピングファイル：マッピングファイル（ORM.xml）には、POJOクラスのデータとリレーショナルデータベースのデータ間のマッピング構成が含まれています。
* JPAローダー*：JPAローダーはキャッシュメモリのように機能し、リレーショナルグリッドデータをロードできます。データベースのコピーのように機能し、POJOデータのサービスクラス（POJOクラスの属性）と対話します。
オブジェクトグリッド：オブジェクトグリッドは、リレーショナルデータのコピーを保存できる一時的な場所です。キャッシュメモリのような。データベースに対するすべてのクエリは、最初にオブジェクトグリッド内のデータに対して実行されます。コミットされて初めて、メインデータベースに影響を与えます。

フェーズ3

3番目のフェーズは、リレーショナルデータフェーズです。これには、ビジネスコンポーネントに論理的に接続されているリレーショナルデータが含まれています。上記で説明したように、ビジネスコンポーネントがデータをコミットする場合にのみ、データベースに物理的に保存されます。それまで、変更されたデータはグリッド形式としてキャッシュメモリに保存されます。データを取得するプロセスも同じです。

上記の3つのフェーズのプログラムによる相互作用のメカニズムは、オブジェクトリレーショナルマッピングと呼ばれます。

Mapping.xml

mapping.xmlファイルは、EntityクラスをデータベーステーブルにマッピングするようJPAベンダーに指示します。

4つの属性を含むEmployeeエンティティの例を見てみましょう。 Employee.java という名前のEmployeeエンティティのPOJOクラスは次のとおりです。

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クラスです。 eid、ename、salary、degの4つの属性が含まれています。これらの属性はデータベースのテーブルフィールドであり、eidはこのテーブルの主キーであると考えてください。次に、そのための休止状態マッピングファイルを設計する必要があります。 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> ：タグは、XMLファイルへのエンティティタグを許可するスキーマ定義を定義します。
<description> ：タグは、アプリケーションに関する説明を定義します。
<entity> ：タグは、データベースのテーブルに変換するエンティティクラスを定義します。属性クラスは、POJOエンティティクラス名を定義します。
<table> ：タグはテーブル名を定義します。クラス名をテーブル名として保持する場合、このタグは必要ありません。
<attributes> ：タグは属性（テーブル内のフィールド）を定義します。
<id> ：タグはテーブルの主キーを定義します。 <generated-value> タグは、Automatic、Manual、Sequenceから取得したプライマリキー値の割り当て方法を定義します。
<basic> ：タグは、テーブルの残りの属性を定義するために使用されます。
<column-name> ：タグは、ユーザー定義のテーブルフィールド名を定義するために使用されます。

アノテーション

一般に、Xmlファイルは特定のコンポーネントの構成、またはコンポーネントの2つの異なる仕様のマッピングに使用されます。この場合、xmlをフレームワークで個別に管理する必要があります。つまり、マッピングxmlファイルを作成するときに、POJOクラスの属性をmapping.xmlファイルのエンティティタグと比較する必要があります。

解決策は次のとおりです。クラス定義では、注釈を使用して構成部分を記述できます。注釈は、クラス、プロパティ、およびメソッドに使用されます。注釈は「@」記号で始まります。アノテーションは、クラス、プロパティ、またはメソッドが宣言される前に宣言されます。 JPAのすべての注釈は、javax.persistenceパッケージで定義されています。

例で使用されている注釈のリストを次に示します。

Annotation	Description
@Entity	This annotation specifies to declare the class as entity or a table.
@Table	This annotation specifies to declare table name.
@Basic	This annotation specifies non constraint fields explicitly.
@Embedded	This annotation specifies the properties of class or an entity whose value instance of an embeddable class.
@Id	This annotation specifies the property, use for identity (primary key of a table) of the class.
@GeneratedValue	This annotation specifies, how the identity attribute can be initialized such as Automatic, manual, or value taken from sequence table.
@Transient	This annotation specifies the property which in not persistent i.e. the value is never stored into database.
@Column	This annotation is used to specify column or attribute for persistence property.
@SequenceGenerator	This annotation is used to define the value for the property which is specified in @GeneratedValue annotation. It creates a sequence.
@TableGenerator	This annotation is used to specify the value generator for property specified in @GeneratedValue annotation. It creates a table for value generation.
@AccessType	This type of annotation is used to set the access type. If you set @AccessType(FIELD) then Field wise access will occur. If you set @AccessType(PROPERTY) then Property wise assess will occur.
@JoinColumn	This annotation is used to specify an entity association or entity collection. This is used in many- to-one and one-to-many associations.
@UniqueConstraint	This annotation is used to specify the field, unique constraint for primary or secondary table.
@ColumnResult	This annotation references the name of a column in the SQL query using select clause.
@ManyToMany	This annotation is used to define a many-to-many relationship between the join Tables.
@ManyToOne	This annotation is used to define a many-to-one relationship between the join Tables.
@OneToMany	This annotation is used to define a one-to-many relationship between the join Tables.
@OneToOne	This annotation is used to define a one-to-one relationship between the join Tables.
@NamedQueries	This annotation is used for specifying list of named queries.
@NamedQuery	This annotation is used for specifying a Query using static name.

Java Bean標準

Javaクラス。インスタンスの値と動作を単一のユニット呼び出しオブジェクトにカプセル化します。 Java Beanは、一時的なストレージおよび再利用可能なコンポーネントまたはオブジェクトです。これは、インスタンス属性を個別に初期化するためのデフォルトのコンストラクターとゲッターとセッターのメソッドを持つシリアル化可能なクラスです。

Beanの規則

Beanには、デフォルトのコンストラクターまたはシリアル化されたインスタンスを含むファイルが含まれます。したがって、BeanはBeanをインスタンス化できます。
Beanのプロパティは、ブールプロパティと非ブールプロパティに分離できます。
非ブールプロパティには、 getter および setter メソッドが含まれます。
ブール型プロパティには setter および is メソッドが含まれます。
プロパティの Getter メソッドは、小文字の「get」で始まり（javaメソッドの規則）、大文字で始まるフィールド名で続く必要があります。 E.g. フィールド名は「salary」です。したがって、このフィールドの取得メソッドは「getSalary（）」です。
プロパティの Setter メソッドは、小文字の「set」で始まり（javaメソッドの規則）、大文字で始まるフィールド名と、フィールドに設定する引数値が続く必要があります。 E.g. フィールド名は「salary」です。したがって、このフィールドの設定メソッドは「setSalary（double sal）」です。
ブールプロパティの場合、trueまたはfalseであるかどうかを確認するメソッドです。 E.g. ブール型プロパティ「空」、このフィールドのメソッドは「isEmpty（）」です。

JPA-インストール

この章では、WindowsおよびLinuxベースのシステムでJPAをセットアップするプロセスについて説明します。 JPAは、複雑なセットアップ手順なしで、いくつかの簡単な手順に従って簡単にインストールして、現在のJava環境に統合できます。インストール中にユーザー管理が必要です。

システム要求

JDK	Java SE 2 JDK 1.5 or above
Memory	1 GB RAM (recommended)
Disk Space	No minimum requirement
Operating System Version	Windows XP or above, Linux

JPAをインストールする手順に進みましょう。

ステップ1：Javaインストールの確認

まず、システムにJava Software Development Kit（SDK）をインストールする必要があります。これを確認するには、作業しているプラットフォームに応じて、次の2つのコマンドのいずれかを実行します。

Javaインストールが適切に行われている場合、Javaインストールの現在のバージョンと仕様が表示されます。サンプル出力を次の表に示します。

Platform

Command

Sample Output

Windows

Open command console and type:

\> java –version

a

Javaバージョン「1.7.0_60」

Java（TM）SEランタイム環境（ビルド1.7.0_60-b19）

Java Hotspot（TM）64ビットサーバーVM（ビルド24.60-b09、混合モード）

Linux

Open command terminal and type:

$ java –バージョン

a

Javaバージョン "1.7.0_25"

JDKランタイム環境を開く（rhel-2.3.10.4.el6_4-x86_64）

JDK 64ビットサーバーVMを開く（ビルド23.7-b01、混合モード）

このチュートリアルの読者は、システムにJava SDKバージョン1.7.0_60がインストールされていることを前提としています。
Java SDKがない場合は、http：//www.oracle.com/technetwork/java/javase/downloads/indexlから現在のバージョンをダウンロードし、インストールしてください。

ステップ2：Java環境を設定する

Javaがマシンにインストールされているベースディレクトリの場所を指すように、環境変数JAVA_HOMEを設定します。例えば、

Platform	Description
Windows	Set JAVA_HOME to C:\ProgramFiles\java\jdk1.7.0_60
Linux	Export JAVA_HOME=/usr/local/java-current

Javaコンパイラの場所の完全パスをシステムパスに追加します。

Platform	Description
Windows	Append the String "C:\Program Files\Java\jdk1.7.0_60\bin" to the end of the system variable PATH.
Linux	Export PATH=$PATH:$JAVA_HOME/bin/

上記で説明したように、コマンドプロンプトからコマンド java -version を実行します。

ステップ3：JPAのインストール

このチュートリアルのJPAプロバイダーを使用して、JPAのインストールを実行できます。 Eclipselink、Hibernate。 Eclipselinkを使用してJPAインストールをフォローしましょう。 JPAプログラミングでは、特定のフォルダーフレームワークに従う必要があるため、IDEを使用することをお勧めします。

リンクhttps://www.eclipse.org/downloads/に従ってEclipse IDEフォームをダウンロードします。EclipseのインディゴであるJavaEE開発者向けのEclipseIDEを選択します。

EclipseドライブのzipファイルをCドライブで解凍します。 Eclipse IDEを開きます。

JPAのインストール

Eclipselinkを使用したJPAのインストール

Eclipselinkはライブラリであるため、Eclipse IDEに直接追加することはできません。 Eclipselinkを使用してJPAをインストールするには、次の手順に従う必要があります。

次のようにEclipse IDEで*ファイル→新規→ JPA *プロジェクトを選択して、新しいJPAプロジェクトを作成します。 + 新しいJPA
New JPA Projectという名前のダイアログボックスが表示されます。プロジェクト名「finddevguides_JPA_Eclipselink」を入力し、 jre バージョンを確認して次をクリックします。 + ダイアログボックス
ユーザーライブラリセクションでライブラリのダウンロードをクリックします（ライブラリがない場合）。 + ライブラリをダウンロード
[ライブラリのダウンロード]ダイアログボックスでEclipselinkライブラリの最新バージョンを選択し、次のように[次へ]をクリックします。 + ライブラリのダウンロードダイアログボックス
ライセンス条項に同意し、次のようにダウンロードライブラリの[完了]をクリックします。 + ライセンス
ファイルをダウンロードするプロセスは次のとおりです。 + プロセス
ダウンロード後、ユーザーライブラリセクションでダウンロードしたライブラリを選択し、次のように[完了]をクリックします。 + ライブラリセクション
最後に、Eclipse IDEのパッケージエクスプローラーでプロジェクトファイルを取得します。すべてのファイルを抽出すると、次のようにフォルダーとファイル階層が取得されます。 + パッケージエクスプローラー

MySQLコネクタをプロジェクトに追加する

ここで説明するすべての例は、データベースと交流するために必須です。データベース操作用のMySQLデータベースを考えてみましょう。 javaプログラムと対話するには、mysql-connector jarが必要です。

手順に従って、データベースjarをプロジェクトに構成します。

[プロジェクトのプロパティ]→ [Javaビルドパス]を右クリックして移動します。次のダイアログボックスが表示されます。[外部瓶の追加]をクリックします。 + 外部ジャー
システムメモリのjarの場所に移動し、次のように選択して[開く]をクリックします。 + ジャーの場所
プロパティダイアログで[OK]をクリックします。 MySQLコネクタJarをプロジェクトに追加します。これで、MySQLを使用してデータベース操作を行うことができます。

JPA-エンティティマネージャー

この章では、JPAを使用した簡単な例を紹介します。例として従業員管理を考えてみましょう。これは、従業員管理が従業員を作成、更新、検索、削除していることを意味します。上記のように、データベース操作にMySQLデータベースを使用しています。

この例の主なモジュールは次のとおりです。

*モデルまたはPOJO * + Employee.java
永続性 + Persistence.xml
サービス + CreatingEmployee.java + UpdatingEmployee.java + FindingEmployee.java + EditingEmployee.java

Eclipselinkを使用したJPAインストールで使用したパッケージ階層を見てみましょう。次のように、この例の階層に従います。

パッケージ階層

エンティティの作成

エンティティはBeanまたはモデルに他なりません。この例では、エンティティとして Employee を使用します。 * eid、ename、salary、、および *deg は、このエンティティの属性です。これらの属性のデフォルトのコンストラクタ、セッター、およびゲッターメソッドが含まれています。

上記の階層で、 ‘src’ （ソース）パッケージの下に ‘com.finddevguides.eclipselink.entity’ という名前のパッケージを作成します。次のように、指定されたパッケージの下に Employee.java という名前のクラスを作成します。

package com.finddevguides.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ワークベンチを開き、次のようにクエリを入力します。

create database jpadb
use jpadb

Persistence.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.finddevguides.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 操作です。ビジネスコンポーネントでは、すべての永続化操作がサービスクラスに分類されます。

上記のパッケージ階層で、 ‘src’ （ソース）パッケージの下に ‘com.finddevguides.eclipselink.service’ という名前のパッケージを作成します。 CreateEmloyee.java、UpdateEmployee.java、FindEmployee.java、DeleteEmployee.javaという名前のすべてのサービスクラス。次のように、指定されたパッケージの下にあります。

従業員を作成

次のように、 CreateEmployee.java という名前のEmployeeクラスを作成します。

package com.finddevguides.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.finddevguides.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（）は、persistence.xmlファイルでpersistence-unitに指定したものと同じ一意の名前を提供することにより、永続性ユニットを作成します。 entitymanagerfactoryオブジェクトは、 createEntityManager（）*メソッドを使用してentitymangerインスタンスを作成します。 entitymanagerオブジェクトは、トランザクション管理用のentitytransactionインスタンスを作成します。 entitymanagerオブジェクトを使用することにより、エンティティをデータベースに永続化できます。

上記のプログラムをコンパイルして実行すると、Eclipse IDEのコンソールパネルにあるeclipselinkライブラリから通知を受け取ります。

結果として、MySQLワークベンチを開き、次のクエリを入力します。

use jpadb
select * from employee

*employee* という名前の影響を受けるデータベーステーブルは、次のように表形式で表示されます。

Eid	Ename	Salary	Deg
1201	Gopal	40000	Technical Manager

従業員を更新

従業員を更新するには、レコードフォームデータベースを取得し、変更を加えて、最終的にコミットする必要があります。 UpdateEmployee.java という名前のクラスは次のように表示されます。

package com.finddevguides.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.finddevguides.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();
   }
}

上記のプログラムをコンパイルして実行すると、Eclipse IDEのコンソールパネルのEclipselinkライブラリから通知を受け取ります。

結果として、MySQLワークベンチを開き、次のクエリを入力します。

use jpadb
select * from employee

*employee* という名前の影響を受けるデータベーステーブルは、次のように表形式で表示されます。

Eid	Ename	Salary	Deg
1201	Gopal	46000	Technical Manager

従業員の給与1201は46000に更新されます。

従業員を探す

従業員を見つけるには、データベースからレコードを取得して表示します。この操作では、EntityTransactionは関与せず、レコードの取得中にトランザクションは適用されません。

次のような FindEmployee.java という名前のクラス。

package com.finddevguides.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.finddevguides.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( ));
   }
}

上記のプログラムをコンパイルして実行すると、次のようにEclipse IDEのコンソールパネルにあるEclipselinkライブラリから出力が得られます。

employee ID = 1201
employee NAME = Gopal
employee SALARY = 46000.0
employee DESIGNATION = Technical Manager

従業員の削除

従業員を削除するには、最初にレコードを見つけてから削除します。ここで、EntityTransactionは重要な役割を果たします。

次のような DeleteEmployee.java という名前のクラス：

package com.finddevguides.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.finddevguides.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( );
   }
}

上記のプログラムをコンパイルして実行すると、Eclipse IDEのコンソールパネルのEclipselinkライブラリから通知を受け取ります。

結果として、MySQLワークベンチを開き、次のクエリを入力します。

use jpadb
select * from employee

*employee* という名前の影響を受けるデータベースには、nullレコードがあります。

この例のすべてのモジュールが完了すると、パッケージとファイルの階層が次のように表示されます。

モジュール

JPA-JPQL

この章では、JPQLと、それが永続性ユニットでどのように機能するかについて説明します。この章では、例は前の章で使用したものと同じパッケージ階層に従います。

JPA JPQL

Java Persistence Query言語

JPQLは、JPA仕様で定義されているJava Persistence Query Languageです。エンティティに対するクエリを作成して、リレーショナルデータベースに格納するために使用されます。 JPQLは、SQL構文に基づいて開発されています。ただし、データベースには直接影響しません。

JPQLは、SELECT句を使用して情報またはデータを取得でき、UPDATE句とDELETE句を使用して一括更新を実行できます。 EntityManager.createQuery（）APIは、言語のクエリをサポートします。

クエリ構造

JPQL構文は、SQLの構文に非常によく似ています。 SQLは単純な構造化照会言語であり、多くの開発者がアプリケーションで使用しているため、SQLのような構文を持つことは利点です。 SQLはリレーショナルデータベースのテーブル、レコード、およびフィールドに対して直接機能しますが、JPQLはJavaクラスおよびインスタンスに対して機能します。

たとえば、JPQLクエリは、SQLの場合のように、データベースからフィールド結果セットではなくエンティティオブジェクトを取得できます。 JPQLクエリ構造は次のとおりです。

SELECT ... FROM ...
[WHERE ...]
[GROUP BY ... [HAVING ...]]
[ORDER BY ...]

JPQLのDELETEおよびUPDATEクエリの構造は、次のように単純です。

DELETE FROM ... [WHERE ...]

UPDATE ... SET ... [WHERE ...]

スカラー関数と集計関数

スカラー関数は、入力値に基づいて結果値を返します。集計関数は、入力値を計算して結果の値を返します。

前の章で使用したのと同じ従業員管理の例に従ってください。ここでは、JPQLのスカラー関数と集計関数を使用してサービスクラスを調べます。

jpadb.employeeテーブルに次のレコードが含まれていると仮定しましょう。

Eid	Ename	Salary	Deg
1201	Gopal	40000	Technical Manager
1202	Manisha	40000	Proof Reader
1203	Masthanvali	40000	Technical Writer
1204	Satish	30000	Technical Writer
1205	Krishna	30000	Technical Writer
1206	Kiran	35000	Proof Reader

次のように、 com.finddevguides.eclipselink.service パッケージの下に ScalarandAggregateFunctions.java という名前のクラスを作成します。

package com.finddevguides.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);
   }
}

上記のプログラムをコンパイルして実行すると、次のようにEclipse IDEのコンソールパネルに出力が表示されます。

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、Likeキーワード

「間」、「そして」、「いいね」はJPQLの主要なキーワードです。これらのキーワードは、クエリのWhere句の後に使用されます。

次のように、 com.finddevguides.eclipselink.service パッケージの下に BetweenAndLikeFunctions.java という名前のクラスを作成します。

package com.finddevguides.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.finddevguides.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( ));
      }
   }
}

上記のプログラムをコンパイルして実行すると、次のようにEclipse IDEのコンソールパネルに出力が表示されます。

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でレコードを並べ替えるには、ORDER BY句を使用します。この句の使用法はSQLでの使用法と同じですが、エンティティを扱います。例による順序に従ってください。

次のように com.finddevguides.eclipselink.service パッケージの下にクラスOrdering.javaを作成します。

package com.finddevguides.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.finddevguides.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( ));
      }
   }
}

上記のプログラムをコンパイルして実行すると、次のようにEclipse IDEのコンソールパネルに出力が表示されます。

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から分離することにより、コード編成を改善できます。また、リテラルをクエリ文字列に動的に埋め込むのではなく、クエリパラメータを渡し、より効率的なクエリを実現します。

まず、次のように、* Name.Queryアノテーションを com.finddevguides.eclipselink.entity パッケージの Employee.java という名前のEmployeeエンティティクラスに追加します。

package com.finddevguides.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 + "]";
   }
}

次のように、 com.finddevguides.eclipselink.service パッケージの下に NamedQueries.java という名前のクラスを作成します。

package com.finddevguides.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.finddevguides.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( ));
      }
   }
}

上記のプログラムをコンパイルして実行すると、次のようにEclipse IDEのコンソールパネルに出力が表示されます。

Employee ID :1204    Employee Name :Satish

上記のすべてのクラスを追加すると、パッケージ階層は次のように表示されます。

パッケージ階層

熱心で遅延読み込み

JPAの主な概念は、キャッシュメモリにデータベースの複製コピーを作成することです。データベースとのトランザクション中、最初は重複データに影響し、エンティティマネージャーを使用してコミットされた場合にのみ、変更がデータベースに反映されます。

データベースからレコードを取得する方法には、熱心な取得と遅延取得の2つの方法があります。

熱心なフェッチ

主キーを使用してレコードを検索しながら、レコード全体を取得します。

遅延フェッチ

プライマリキーが存在する場合、通知の可用性をチェックします。その後、そのエンティティのgetterメソッドのいずれかを呼び出すと、全体が取得されます。

ただし、初めてレコードをフェッチしようとすると、遅延フェッチが可能です。これにより、レコード全体のコピーが既にキャッシュメモリに保存されます。パフォーマンスに関しては、遅延フェッチが望ましいです。

JPA-高度なマッピング

JPAは、Java仕様でリリースされたライブラリです。したがって、エンティティの永続性に関するすべてのオブジェクト指向の概念をサポートしています。ここまでで、オブジェクトリレーショナルマッピングの基本について説明しました。この章では、オブジェクトとリレーショナルエンティティ間の高度なマッピングについて説明します。

継承戦略

継承はオブジェクト指向言語の中心概念であるため、エンティティ間の継承関係または戦略を使用できます。 JPAは、SINGLE_TABLE、JOINED_TABLE、TABLE_PER_CONCRETE_CLASSなどの3種類の継承戦略をサポートしています。

次のように、Staff、TeachingStaff、NonTeachingStaffクラスとそれらの関係の例を考えてみましょう。

継承戦略

上記の図では、Staffはエンティティであり、TeachingStaffとNonTeachingStaffはStaffのサブエンティティです。ここでは、継承の3つの戦略すべてにおける上記の例を説明します。

単一テーブル戦略

単一テーブル戦略は、すべてのクラスフィールド（スーパークラスとサブクラスの両方）を取得し、SINGLE_TABLE戦略として知られる単一のテーブルにマップします。ここで、弁別子の値は、1つのテーブルの3つのエンティティの値を区別する上で重要な役割を果たします。

上記の例を考えてみましょう。TeachingStaffとNonTeachingStaffはStaffクラスのサブクラスです。継承の概念を思い出してください（サブクラスごとにスーパークラスのプロパティを継承するメカニズムです）。したがって、sid、snameはTeachingStaffとNonTeachingStaffの両方に属するフィールドです。 JPAプロジェクトを作成します。このプロジェクトのすべてのモジュールは次のとおりです。

エンティティの作成

*‘src’* パッケージの下に *‘com.finddevguides.eclipselink.entity’* という名前のパッケージを作成します。 指定されたパッケージの下に *Staff.java* という名前の新しいJavaクラスを作成します。 Staffエンティティクラスは次のように表示されます。

package com.finddevguides.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）フィールドを示しています。

*com.finddevguides.eclipselink.entity* パッケージの下に *TeachingStaff.java* という名前のStaffクラスのサブクラス（クラス）を作成します。 TeachingStaff Entityクラスは次のように表示されます。

package com.finddevguides.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;
   }
}

*com.finddevguides.eclipselink.entity* パッケージの下に *NonTeachingStaff.java* という名前のStaffクラスのサブクラス（クラス）を作成します。 NonTeachingStaff Entityクラスは次のとおりです。

package com.finddevguides.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.finddevguides.eclipselink.entity.Staff</class>
      <class>com.finddevguides.eclipselink.entity.NonTeachingStaff</class>
      <class>com.finddevguides.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>

サービスクラス

サービスクラスは、ビジネスコンポーネントの実装部分です。 ‘com.finddevguides.eclipselink.service’ という名前の ‘src’ パッケージの下にパッケージを作成します。

指定したパッケージの下にSaveClient.javaという名前のクラスを作成して、Staff、TeachingStaff、およびNonTeachingStaffクラスフィールドを格納します。 SaveClientクラスは次のように表示されます。

package com.finddevguides.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.finddevguides.eclipselink.entity.NonTeachingStaff;
import com.finddevguides.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();
   }
}

上記のプログラムをコンパイルして実行すると、Eclipse IDEのコンソールパネルに通知が表示されます。 MySQLワークベンチで出力を確認してください。表形式の出力は次のとおりです。

Sid	Type	Sname	Areaexpertise	Qualification	Subjectexpertise
1	TS	Gopal		MSC MED	Maths
2	TS	Manisha		BSC BED	English
3	NS	Satish	Accounts
4	NS	Krishna	Office Admin

最後に、3つのクラスのすべてのフィールドを含む単一のテーブルを取得します。このテーブルは、 'Type' （フィールド）という名前の識別列とは異なります。

結合テーブル戦略

結合テーブル戦略は、テーブルを結合してトランザクションを簡単にするための一意の値を含む参照列を共有することです。上記と同じ例を考えてみましょう。

JPAプロジェクトを作成します。以下に示すすべてのプロジェクトモジュール：

エンティティの作成

*‘src’* パッケージの下に *‘com.finddevguides.eclipselink.entity’* という名前のパッケージを作成します。 指定されたパッケージの下に *Staff.java* という名前の新しいJavaクラスを作成します。 Staffエンティティクラスは次のように表示されます。

package com.finddevguides.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;
   }
}

*com.finddevguides.eclipselink.entity* パッケージの下に *TeachingStaff.java* という名前のStaffクラスのサブクラス（クラス）を作成します。 TeachingStaff Entityクラスは次のように表示されます。

package com.finddevguides.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;
   }
}

*com.finddevguides.eclipselink.entity* パッケージの下に *NonTeachingStaff.java* という名前のStaffクラスのサブクラス（クラス）を作成します。 NonTeachingStaff Entityクラスは次のとおりです。

package com.finddevguides.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.finddevguides.eclipselink.entity.Staff</class>
      <class>com.finddevguides.eclipselink.entity.NonTeachingStaff</class>
      <class>com.finddevguides.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>

サービスクラス

サービスクラスは、ビジネスコンポーネントの実装部分です。 ‘com.finddevguides.eclipselink.service’ という名前の ‘src’ パッケージの下にパッケージを作成します。

指定したパッケージの下にSaveClient.javaという名前のクラスを作成して、Staff、TeachingStaff、およびNonTeachingStaffクラスフィールドを格納します。次に、次のようにSaveClientクラスを作成します。

package com.finddevguides.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.finddevguides.eclipselink.entity.NonTeachingStaff;
import com.finddevguides.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();
   }
}

上記のプログラムをコンパイルして実行すると、Eclipse IDEのコンソールパネルに通知が表示されます。出力については、次のようにMySQLワークベンチを確認します。

ここで3つのテーブルが作成され、表形式の staff テーブルの結果は次のように表示されます。

Sid	Dtype	Sname
1	TeachingStaff	Gopal
2	TeachingStaff	Manisha
3	NonTeachingStaff	Satish
4	NonTeachingStaff	Krishna

表形式の TeachingStaff テーブルの結果は次のとおりです。

Sid	Qualification	Subjectexpertise
1	MSC MED	Maths
2	BSC BED	English

上記の表で、sidは外部キー（staffテーブルの参照フィールドフォーム）です。表形式の NonTeachingStaff テーブルの結果は次のとおりです。

Sid	Areaexpertise
3	Accounts
4	Office Admin

最後に、それぞれのフィールドを使用して3つのテーブルが作成され、3つのテーブルすべてでSIDフィールドが共有されます。スタッフテーブルではSIDが主キーであり、残りの（TeachingStaffおよびNonTeachingStaff）テーブルではSIDは外部キーです。

クラスごとの戦略

クラスごとのテーブル戦略は、サブエンティティごとにテーブルを作成することです。スタッフテーブルが作成されますが、nullレコードが含まれます。 Staffテーブルのフィールド値は、TeachingStaffテーブルとNonTeachingStaffテーブルで共有する必要があります。

上記と同じ例を考えてみましょう。このプロジェクトのすべてのモジュールは次のとおりです。

エンティティの作成

*‘src’* パッケージの下に *‘com.finddevguides.eclipselink.entity’* という名前のパッケージを作成します。 指定されたパッケージの下に *Staff.java* という名前の新しいJavaクラスを作成します。 Staffエンティティクラスは次のように表示されます。

package com.finddevguides.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;
   }
}

*com.finddevguides.eclipselink.entity* パッケージの下に *TeachingStaff.java* という名前のStaffクラスのサブクラス（クラス）を作成します。 TeachingStaff Entityクラスは次のように表示されます。

package com.finddevguides.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;
   }
}

*com.finddevguides.eclipselink.entity* パッケージの下に *NonTeachingStaff.java* という名前のStaffクラスのサブクラス（クラス）を作成します。 NonTeachingStaff Entityクラスは次のとおりです。

package com.finddevguides.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.finddevguides.eclipselink.entity.Staff</class>
      <class>com.finddevguides.eclipselink.entity.NonTeachingStaff</class>
      <class>com.finddevguides.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>

サービスクラス

サービスクラスは、ビジネスコンポーネントの実装部分です。 ‘com.finddevguides.eclipselink.service’ という名前の ‘src’ パッケージの下にパッケージを作成します。

指定されたパッケージの下に SaveClient.java という名前のクラスを作成して、Staff、TeachingStaff、およびNonTeachingStaffクラスフィールドを格納します。 SaveClientクラスは次のように表示されます。

package com.finddevguides.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import com.finddevguides.eclipselink.entity.NonTeachingStaff;
import com.finddevguides.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();
   }
}

上記のプログラムをコンパイルして実行すると、Eclipse IDEのコンソールパネルに通知が表示されます。出力については、次のようにMySQLワークベンチを確認します。

ここでは、3つのテーブルが作成され、 Staff テーブルにはnullレコードが含まれています。

表形式の TeachingStaff の結果は次のとおりです。

Sid	Qualification	Sname	Subjectexpertise
1	MSC MED	Gopal	Maths
2	BSC BED	Manisha	English

上の表TeachingStaffには、StaffおよびTeachingStaffエンティティの両方のフィールドが含まれています。

表形式の NonTeachingStaff の結果は次のとおりです。

Sid	Areaexpertise	Sname
3	Accounts	Satish
4	Office Admin	Krishna

上記のテーブルNonTeachingStaffには、StaffおよびNonTeachingStaffエンティティの両方のフィールドが含まれています。

JPA-エンティティの関係

この章では、エンティティ間の関係について説明します。一般に、データベース内のテーブル間の関係はより効果的です。ここでは、エンティティクラスはリレーショナルテーブル（JPAの概念）として扱われるため、エンティティクラス間の関係は次のようになります。

@ManyToOneリレーション
@OneToMany関係
@OneToOneリレーション
@ManyToMany関係

@ManyToOneリレーション

エンティティ間の多対1の関係：1つのエンティティ（列または列のセット）が、一意の値を含む別のエンティティ（列または列のセット）で参照される場合。リレーショナルデータベースでは、これらの関係は、テーブル間で外部キー/主キーを使用することで適用できます。

EmployeeエンティティとDepartmentエンティティ間の関係の例を考えてみましょう。単方向、つまり従業員から部署へ、多対1の関係が適用されます。つまり、従業員の各レコードには1つの部門IDが含まれており、これはDepartmentテーブルのプライマリキーでなければなりません。ここで、Employeeテーブルでは、部門IDは外部キーです。

この図は、多対1の関係を次のように説明しています。

@ManyToOne Relation

*JPA_Eclipselink_MTO* という名前のEclipse IDEでJPAプロジェクトを作成します。 このプロジェクトのすべてのモジュールは次のとおりです。

エンティティの作成

上記の図に従ってエンティティを作成します。 ‘src’ パッケージの下に ’com.tutorialspoin.eclipselink.entity’ という名前のパッケージを作成します。指定されたパッケージの下に Department.java という名前のクラスを作成します。クラスDepartmentエンティティは次のように表示されます。

package com.finddevguides.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番目のエンティティを作成します- ‘com.finddevguides.eclipselink.entity’ パッケージの下に Employee.java という名前の従業員エンティティクラス。 Employeeエンティティクラスは次のように表示されます。

package com.finddevguides.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プロジェクトの作成中にEclipse IDEによって作成されます。構成の詳細はユーザー仕様です。 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.finddevguides.eclipselink.entity.Employee</class>
      <class>com.finddevguides.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>

サービスクラス

このモジュールには、属性の初期化を使用してリレーショナル部分を実装するサービスクラスが含まれています。 ‘com.finddevguides.eclipselink.service’ という名前の ‘src’ パッケージの下にパッケージを作成します。 ManyToOne.java という名前のDAOクラスが、指定されたパッケージの下に作成されます。 DAOクラスは次のように表示されます。

package com.finddevguideseclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import com.finddevguides.eclipselink.entity.Department;
import com.finddevguides.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();
   }
}

上記のプログラムをコンパイルして実行すると、Eclipse IDEのコンソールパネルに通知が表示されます。出力については、MySQLワークベンチを確認してください。この例では、2つのテーブルが作成されます。

MySQLインターフェイスで次のクエリを渡すと、 Department テーブルの結果が表形式でクエリに次のように表示されます。

Select * from department;

Id  Name
101 Development

MySQLインターフェイスで次のクエリを渡すと、 Employee テーブルの結果が表形式でクエリに次のように表示されます。

Select *from employee;

Eid Deg                 Ename           Salary  Department_Id
102 Technical Writer    Satish          45000   101
103 Technical Writer    Krishna         45000   101
104 Technical Writer    Masthan Wali    50000   101

上記の表で、Deparment_IdはDepartment表の外部キー（参照フィールド）です。

@OneToMany関係

この関係では、1つのエンティティの各行が、他のエンティティの多くの子レコードに参照されます。重要なことは、子レコードが複数の親を持つことはできないということです。テーブルAとテーブルBの1対多の関係では、テーブルAの各行は、テーブルBの0、1、または多くの行にリンクされます。

上記の例を考えてみましょう。* Employee と *Department が逆方向の場合、リレーションは多対1のリレーションです。 JPA_Eclipselink_OTM という名前のEclipse IDEでJPAプロジェクトを作成します。このプロジェクトのすべてのモジュールは次のとおりです。

エンティティの作成

上記の図に従ってエンティティを作成します。 ‘src’ パッケージの下に ’com.tutorialspoin.eclipselink.entity’ という名前のパッケージを作成します。指定されたパッケージの下に Department.java という名前のクラスを作成します。クラスDepartmentエンティティは次のように表示されます。

package com.finddevguides.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番目のエンティティを作成します。 ‘com.finddevguides.eclipselink.entity’ パッケージの下に Employee.java という名前の従業員エンティティクラスがあります。 Employeeエンティティクラスは次のように表示されます。

package com.finddevguides.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は、JPAプロジェクトの作成中にEclipse IDEによって作成されます。構成の詳細はユーザー仕様です。 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.finddevguides.eclipselink.entity.Employee</class>
      <class>com.finddevguides.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>

サービスクラス

このモジュールには、属性の初期化を使用してリレーショナル部分を実装するサービスクラスが含まれています。 ‘com.finddevguides.eclipselink.service’ という名前の ‘src’ パッケージの下にパッケージを作成します。 OneToMany.java という名前のDAOクラスが、指定されたパッケージの下に作成されます。 DAOクラスは次のように表示されます。

package com.finddevguideseclipselink.service;

import java.util.List;
import java.util.ArrayList;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import com.finddevguides.eclipselink.entity.Department;
import com.finddevguides.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();
   }
}

上記のプログラムをコンパイルして実行すると、Eclipse IDEのコンソールパネルに通知が表示されます。出力については、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  Name
254 Development

MySQLインターフェイスで次のクエリを渡すと、テーブル形式の従業員テーブルの結果がクエリで次のように表示されます。

Select *from employee;

Eid Deg                 Ename          Salary
251 Technical Writer    Satish         45000
252 Technical Writer    Krishna        45000
253 Technical Writer    Masthanvali    50000

@OneToOneリレーション

1対1の関係では、1つのアイテムは他の1つのアイテムにのみ属することができます。これは、1つのエンティティの各行が別のエンティティの1つの行のみを参照することを意味します。

上記の例を考えてみましょう。* 従業員*と*部門*は逆方向の単方向で、リレーションは1対1リレーションです。つまり、各従業員は1つの部門にのみ属します。 JPA_Eclipselink_OTO という名前のEclipse IDEでJPAプロジェクトを作成します。このプロジェクトのすべてのモジュールは次のとおりです。

エンティティの作成

上記の図に従ってエンティティを作成します。 ‘src’ パッケージの下に ’com.tutorialspoin.eclipselink.entity’ という名前のパッケージを作成します。指定されたパッケージの下に Department.java という名前のクラスを作成します。クラスDepartmentエンティティは次のように表示されます。

package com.finddevguides.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番目のエンティティを作成します。 ‘com.finddevguides.eclipselink.entity’ パッケージの下に Employee.java という名前の従業員エンティティクラスがあります。 Employeeエンティティクラスは次のように表示されます。

package com.finddevguides.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は、JPAプロジェクトの作成中にEclipse IDEによって作成されます。構成の詳細はユーザー仕様です。 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.finddevguides.eclipselink.entity.Employee</class>
      <class>com.finddevguides.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>

サービスクラス

このモジュールには、属性の初期化を使用してリレーショナル部分を実装するサービスクラスが含まれています。 ‘com.finddevguides.eclipselink.service’ という名前の ‘src’ パッケージの下にパッケージを作成します。 OneToOne.java という名前のDAOクラスが、指定されたパッケージの下に作成されます。 DAOクラスは次のように表示されます。

package com.finddevguideseclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import com.finddevguides.eclipselink.entity.Department;
import com.finddevguides.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();
   }
}

上記のプログラムをコンパイルして実行すると、Eclipse IDEのコンソールパネルに通知が表示されます。出力については、次のようにMySQLワークベンチを確認してください。上記の例では、2つのテーブルが作成されます。

MySQLインターフェイスで次のクエリを渡すと、 department テーブルの結果が表形式でクエリに次のように表示されます。

Select * from department

Id  Name
301 Development

MySQLインターフェイスで次のクエリを渡すと、表形式の employee テーブルの結果がクエリで次のように表示されます。

Select *from employee

Eid Deg                 Ename   Salary  Department_id
302 Technical Writer    Satish  45000   301

@ManyToMany関係

多対多の関係では、1つのエンティティの1つ以上の行が他のエンティティの複数の行に関連付けられます。

ClassエンティティとTeacherエンティティ間の関係の例を考えてみましょう。双方向の方法では、クラスと教師の両方が多対1の関係にあります。つまり、クラスの各レコードは教師セット（教師ID）によって参照されます。教師セットは教師テーブルの主キーであり、Teacher_Classテーブルに格納されている必要があります。ここでは、Teachers_Classテーブルに両方の外部キーフィールドが含まれています。* JPA_Eclipselink_MTM *という名前のEclipse IDEでJPAプロジェクトを作成します。このプロジェクトのすべてのモジュールは次のとおりです。

@ManyToOne Relation

エンティティの作成

上記の図に従ってエンティティを作成します。 ‘src’ パッケージの下に ’com.tutorialspoin.eclipselink.entity’ という名前のパッケージを作成します。指定されたパッケージの下に Clas.java という名前のクラスを作成します。クラスDepartmentエンティティは次のように表示されます。

package com.finddevguides.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番目のエンティティを作成します- ‘com.finddevguides.eclipselink.entity’ パッケージの下に Teacher.java という名前の従業員エンティティクラス。 Employeeエンティティクラスは次のように表示されます。

package com.finddevguides.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は、JPAプロジェクトのクレスト時にEclipse IDEによって作成されます。構成の詳細はユーザー仕様です。 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.finddevguides.eclipselink.entity.Employee</class>
      <class>com.finddevguides.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>

サービスクラス

このモジュールには、属性の初期化を使用してリレーショナル部分を実装するサービスクラスが含まれています。 ‘com.finddevguides.eclipselink.service’ という名前の ‘src’ パッケージの下にパッケージを作成します。 ManyToMany.java という名前のDAOクラスが、指定されたパッケージの下に作成されます。 DAOクラスは次のように表示されます。

package com.finddevguides.eclipselink.service;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import com.finddevguides.eclipselink.entity.Clas;
import com.finddevguides.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( );
   }
}

上記のプログラムをコンパイルして実行すると、Eclipse IDEのコンソールパネルに通知が表示されます。出力については、次のようにMySQLワークベンチを確認してください。このサンプルプロジェクトでは、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 Subject     Tname
354 Java        Satish
355 Adv Java    Krishna
356 DB2         Masthanvali

MySQLインターフェイスで次のクエリを渡すと、クエリで表形式の clas テーブルの結果が次のように表示されます。

Select * from clas;

cid Cname
351 1st
352 2nd
353 3rd

JPA-基準API

Criteria APIは、エンティティのクエリを定義するために使用される定義済みのAPIです。これは、JPQLクエリを定義する代替方法です。これらのクエリはタイプセーフで移植性があり、構文を変更することで簡単に変更できます。 JPQLと同様に、抽象スキーマ（スキーマの編集が簡単）および埋め込みオブジェクトに従います。メタデータAPIは基準APIと混合され、基準クエリの永続エンティティをモデル化します。

基準APIの主な利点は、コンパイル時にエラーを早期に検出できることです。文字列ベースのJPQLクエリとJPA基準ベースのクエリは、パフォーマンスと効率が同じです。

基準の歴史API

基準APIはJPAのすべてのバージョンに含まれているため、基準APIの各ステップはJPAの仕様で通知されます。

JPA 2.0（基準クエリAPI）では、クエリの標準化が開発されています。
JPA 2.1には、基準の更新と削除（一括更新と削除）が含まれています。

基準クエリ構造

Criteria APIと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.fromメソッドは、クエリルートを設定するために呼び出されます。
CriteriaQuery.selectを呼び出して、結果リストのタイプを設定します。
TypedQuery <T>インスタンスは、実行のためにクエリを準備し、クエリ結果のタイプを指定するために使用されます。
クエリを実行するTypedQuery <T>オブジェクトのgetResultListメソッド。このクエリはエンティティのコレクションを返し、結果はリストに保存されます。

基準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

*JPA_Eclipselink_Criteria* という名前のEclipse IDEでJPAプロジェクトを作成します。 このプロジェクトのすべてのモジュールは次のとおりです。

エンティティの作成

*‘src’* パッケージの下に *com.finddevguides.eclipselink.entity* という名前のパッケージを作成します。

指定されたパッケージの下に Employee.java という名前のクラスを作成します。クラスEmployeeエンティティは次のように表示されます。

package com.finddevguides.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ファイルが必要です。

Persistence.xmlは、JPAプロジェクトのクレスト時にEclipse IDEによって作成されます。構成の詳細はユーザー指定です。 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.finddevguides.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>

サービスクラス

このモジュールには、MetaData API初期化を使用してCriteriaクエリパーツを実装するサービスクラスが含まれています。 ‘com.finddevguides.eclipselink.service’ という名前のパッケージを作成します。 CriteriaAPI.java という名前のクラスが、指定されたパッケージの下に作成されます。 DAOクラスは次のように表示されます。

package com.finddevguides.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.finddevguides.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 = c riteriaQuery.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( );
   }
}

上記のプログラムをコンパイルして実行すると、次のようにEclipse IDEのコンソールパネルに出力が表示されます。

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

Jpa-quick-guide

JPA-はじめに

リレーショナルモデルとオブジェクトモデルの不一致

JPAとは何ですか？

JPAを使用する場所

JPAの歴史

JPAプロバイダー

JPA-アーキテクチャ

クラスレベルのアーキテクチャ

JPAクラスの関係

JPA-ORMコンポーネント

オブジェクトリレーショナルマッピング

高度な機能

ORMアーキテクチャ

フェーズ1

フェーズ2

フェーズ3

Mapping.xml

アノテーション

Java Bean標準

Beanの規則

JPA-インストール

システム要求

ステップ1：Javaインストールの確認

ステップ2：Java環境を設定する

ステップ3：JPAのインストール

Eclipselinkを使用したJPAのインストール

MySQLコネクタをプロジェクトに追加する

JPA-エンティティマネージャー

エンティティの作成

Persistence.xml

永続化操作

従業員を作成

従業員を更新

従業員を探す

従業員の削除

JPA-JPQL

Java Persistence Query言語

クエリ構造

スカラー関数と集計関数

Between、And、Likeキーワード

ご注文

名前付きクエリ

熱心で遅延読み込み

熱心なフェッチ

遅延フェッチ

JPA-高度なマッピング

継承戦略

単一テーブル戦略

エンティティの作成

Persistence.xml

サービスクラス

結合テーブル戦略

エンティティの作成

Persistence.xml

サービスクラス

クラスごとの戦略

エンティティの作成

Persistence.xml

サービスクラス

JPA-エンティティの関係

@ManyToOneリレーション

エンティティの作成

Persistence.xml

サービスクラス

@OneToMany関係

エンティティの作成

Persistence.xml

サービスクラス

@OneToOneリレーション

エンティティの作成

Persistence.xml

サービスクラス

@ManyToMany関係

エンティティの作成

Persistence.xml

サービスクラス

JPA-基準API

基準の歴史API

基準クエリ構造