JavaEE使い方メモ（JPA その２ - マッピング）

[環境構築](http://qiita.com/opengl-8080/items/aeda0d8bad42af3113bd)
[JPA の基本的な話](http://qiita.com/opengl-8080/items/e4840aa3e33b42ae0d6b)
[JPQL の話](http://qiita.com/opengl-8080/items/e074330b5f4862d9995f)
[Criteria API の話](http://qiita.com/opengl-8080/items/6e3e03e4c90cd3d5e211)

[コード](https://github.com/opengl8080-javaee-samples/jpa)

マッピング方法だけを確認しやすいようにした一覧を作成しました。
[JPA マッピングカタログ - Qiita](http://qiita.com/opengl-8080/items/5190ee953cfbab5ce3e9)


# はじめに
オブジェクト指向で考えられたドメインモデルと、正規化などを考慮して考えられたリレーショナルデータベースのテーブルでは、データの持たせ方に違いが生まれる。
この違いをインピーダンスミスマッチと言う。

インピーダンスミスマッチを解決するには、データベースから取得したレコードをオブジェクトにマッピングする処理が必要になる（さらに、永続化するときは逆変換が必要）。

オブジェクトとテーブルの構造が１対１で対応していれば、この変換はそこまで大変ではない。
しかし、そうでない場合、変換を自力で実装するのは非常に骨が折れる。

O/R マッパーはこの変換を自動でやってくれるフレームワークで、 JPA では、様々なマッピングをアノテーションで定義することができるようになっている。

ドメインモデルの実装に具体的な技術要素である JPA のアノテーションが設定されることに若干の拒絶反応が起こりそうになるが、そこはマッピングを自動化できることとのトレードオフとして目をつむるべきかなと個人的に思っている。

# 基本編
## 基本

**エンティティ**
![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/80753290-49b6-70bf-f4a6-abcdb8a830b4.jpeg)

```java:Reimu.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Reimu {
    @Id
    private Long id;

    @Override
    public String toString() {
        return "Reimu{" + "id=" + id + '}';
    }
}
```

**データベース**
![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/5a377398-77e0-9623-85e5-4327e342cdff.jpeg)


```sql:
CREATE TABLE `reimu` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

- デフォルトでは、エンティティは同じ名前のテーブルとマッピングされる。
    - エンティティの名前は、特に指定しなければクラス名と同じになる。
- エンティティには、必ず１つは `@Id` でアノテートされたフィールドが必要。
- エンティティは、 public または protected で、引数の無いコンストラクタが必要。
- フィールドは、可視性が private でもマッピングできる。
- デフォルトでは、フィールドは同じ名前のカラムとマッピングされる。

## テーブル名・カラム名を指定する

**エンティティ**
![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/5798af0d-1cb9-cb35-d9ba-7b85e3c3c250.jpeg)

```java:KirisameMarisa.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "kirisame_marisa")
public class KirisameMarisa {
    @Id
    @Column(name = "id_column")
    private Long id;

    @Override
    public String toString() {
        return "KirisameMarisa{" + "id=" + id + '}';
    }
}
```

**データベース**
![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/3716497e-76f2-1d56-db8f-7306496e90c9.jpeg)

```sql:
CREATE TABLE `kirisame_marisa` (
  `id_column` int(11) NOT NULL AUTO_INCREMENT,
  PRIMARY KEY (`id_column`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

- エンティティ名とテーブル名が異なる場合は、 `@Table` でクラスをアノテートし、 `name` 属性でテーブル名を指定する。
- フィールド名とカラム名が異なる場合は、 `@Column` でフィールドをアノテートし、 `name` 属性でカラム名を指定する。

## ID が自動生成されることを設定する
例えば、 MySQL の場合は AUTO_INCREMENT の仕組みを使って ID が採番される。
また、 Oracle の場合はシーケンスオブジェクトを使って ID を採番する。

ID がアプリケーション以外の仕組みによって生成されることを設定しておくと、 `persist()` するときにその仕組を利用して ID が自動生成される。
また、 ID が自動生成されることを設定しておくことで、 `persist()` した後に自動生成された ID を取得できるようになる（設定していないと、取得できない）。

### MySQL の AUTO_INCREMENT

**エンティティ**
![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/34e45fca-6c28-8792-eeb2-b2f4aa637028.jpeg)

```java:SinGyoku.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class SinGyoku {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String value;

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "SinGyoku{" + "id=" + id + ", value=" + value + '}';
    }
}
```

**データベース**
![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/1a48c7ce-3965-c43d-6d3f-ab6ac07149e9.jpeg)

```sql:
CREATE TABLE `singyoku` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `value` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
    SinGyoku sinGyoku = new SinGyoku();
    sinGyoku.setValue("test");
    
    this.em.persist(sinGyoku);
    
    System.out.println(sinGyoku);
    
    this.em.flush();
    
    System.out.println(sinGyoku);
```

```text:GlassFishコンソール出力
情報:   SinGyoku{id=null, value=test}
情報:   SinGyoku{id=1, value=test}
```

- `@GeneratedValue` でフィールドをアノテートすることで、そのフィールドが自動生成されることを設定できる。
- `strategy` 属性に、その項目がどのようにして生成されるかを指定する。
- MySQL の AUTO_INCREMENT では、 `GenerationType.IDENTITY` を指定する。
- MySQL の AUTO_INCREMENT は INSERT 文を発行するときに ID を採番する。よって `EntityManager#flush()` で明示的にコミットを実行しないと、自動生成された ID を取得できない。

### Oracle のシーケンスオブジェクト
※Oracle に接続するための JDBC Connection Pool と JDBC Resource を予め GlassFish に登録しておくこと（サンプル実装では、 `OracleUnit` という名前で永続ユニットを定義した）。

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/ddc3f119-23b0-960a-4689-9cd0179d7029.jpeg)

```java:
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name = "yuugen_magan")
public class YuugenMagan {
    
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "yuugen_magan_seq_gen")
    @SequenceGenerator(name = "yuugen_magan_seq_gen", sequenceName = "yuugen_magan_seq", allocationSize = 1)
    private Long id;
    private String value;

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "YuugenMagan{" + "id=" + id + ", value=" + value + '}';
    }
}
```

**データベース**

```sql:
CREATE TABLE yuugen_magan (
    ID NUMBER(10),
    VALUE VARCHAR2(128),
    PRIMARY KEY(ID)
);

CREATE SEQUENCE yuugen_magan_seq;
```

**動作確認**

```java:MappingEjb.java
    YuugenMagan yuugenMagan = new YuugenMagan();
    yuugenMagan.setValue("test");
    
    this.em.persist(yuugenMagan);
    System.out.println(yuugenMagan);
```

```text:GlassFishコンソール出力
情報:   YuugenMagan{id=1, value=test}
```

- シーケンスオブジェクトを使用する場合は、 `@GeneratedValue` の `strategy` に `GenerationType.SEQUENCE` を指定する。
    - `generator` 属性には、 ID を生成するジェネレータの名前を指定する。
    - ジェネレータの定義は、 `@SequenceGenerator` アノテーションで行う。
    - `name` 属性にジェネレータの名前を指定し、 `sequenceName` 属性でシーケンスオブジェクトの名前を指定する。
- シーケンスオブジェクトの場合は、コミット前でも EntityManager が次のシーケンス値を取得できるので、 `flush()` する前でも自動生成された ID を参照することができる。
- `allocationSize` はシーケンス値の増分（デフォルトは 50）。

### シーケンス生成用のテーブルを使用する

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/db9f9635-82dd-2ac5-892c-36ebc53dd86b.jpeg)

```java:Elis.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.TableGenerator;

@Entity
public class Elis {
    
    @Id
    @GeneratedValue(strategy = GenerationType.TABLE, generator = "elis_seq_generator")
    @TableGenerator(name = "elis_seq_generator",
                    table = "seq_generator",
                    pkColumnName = "table_name",
                    valueColumnName = "sequence_number",
                    pkColumnValue = "elis",
                    allocationSize = 1)
    private Long id;
    private String value;

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Elis{" + "id=" + id + ", value=" + value + '}';
    }
}
```

**データベース**
![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/d6d88f40-5ca3-0fcc-7cfc-e215ef2f386a.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/fbd7feda-3ec9-89fe-4b3a-6c3f5ad31e7d.jpeg)

```sql:
CREATE TABLE `elis` (
  `id` int(11) NOT NULL,
  `value` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `seq_generator` (
  `table_name` varchar(128) NOT NULL,
  `sequence_number` int(11) NOT NULL,
  PRIMARY KEY (`table_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```


**動作確認**

```java:MappingEjb.java
    Elis elis = new Elis();
    elis.setValue("test");
    
    this.em.persist(elis);
    System.out.println(elis);
```

```text:GlassFishコンソール出力
情報:   Elis{id=1, value=test}
```

- シーケンスを採番するための専用のテーブルを使用する場合、 `strategy` に `GenerationType.TABLE` を指定する。
- `generator` には、 `@TableGenerator` で定義した名前を指定する。
- `@TableGenerator` では、シーケンス採番用のテーブルの情報を定義する。

| 属性            | 説明                                                                                    |
| :--             | :--                                                                                     |
| name            | ジェネレータの名前                                                                      |
| table           | シーケンスを採番するテーブルの名前                                                      |
| pkColumnName    | シーケンス採番テーブルの行を特定するためのカラムの名前                                  |
| valueColumnName | シーケンス値を保存しておくカラムの名前                                                  |
| pkColumnValue   | このジェネレータが採番に用いる行を特定するための値。`pkColumnName` に保存されている値。 |
| allocationSize  | シーケンスの増分値（デフォルトは 50）                                                   |

## 複合主キーとマッピングする
### @EmbeddedId を使用したパターン

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/a979d39d-b033-6716-9c79-081c5b5eef42.jpeg)

```java:Sariel.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.EmbeddedId;
import javax.persistence.Entity;

@Entity
public class Sariel {
    
    @EmbeddedId
    private SarielKey key;
    private String value;

    public void setKey(SarielKey key) {
        this.key = key;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Sariel{" + "key=" + key + ", value=" + value + '}';
    }
}
```

```java:SarielKey.java
package sample.javaee.jpa.entity.mapping;

import java.io.Serializable;
import java.util.Objects;
import javax.persistence.Embeddable;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;

@Embeddable
public class SarielKey implements Serializable {
    
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long key1;
    private String key2;

    public void setKey2(String key2) {
        this.key2 = key2;
    }
    
    @Override
    public String toString() {
        return "SarielKey{" + "key1=" + key1 + ", key2=" + key2 + '}';
    }

    @Override
    public int hashCode() {
        // 省略
    }

    @Override
    public boolean equals(Object obj) {
        // 省略
    }
}
```

**データベース**
![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/a0fe335c-1e75-2ac0-fd3c-db2f20691662.jpeg)

```sql:
CREATE TABLE `sariel` (
  `key1` int(11) NOT NULL AUTO_INCREMENT,
  `key2` varchar(32) NOT NULL,
  `value` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`key1`,`key2`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
    SarielKey key = new SarielKey();
    key.setKey2("test");
    
    Sariel sariel = new Sariel();
    sariel.setKey(key);
    sariel.setValue("TEST");
    
    this.em.persist(sariel);
    
    this.em.flush();
    
    System.out.println(sariel);
```

```text:GlassFishコンソール出力
情報:   Sariel{key=SarielKey{key1=1, key2=test}, value=TEST}
```

- 複合主キーをマッピングする場合の１つの方法として、 `@EmbeddedId` アノテーションを使用した方法がある。
- 複合主キーに指定したカラムを持つ主キー用のクラス（`SarielKey`）を作成し、そのクラスを `@Embeddable` でアノテートする。
- メインのエンティティ側（`Sariel`）には、主キー用のクラスをフィールドに持たせ、 `@EmbeddedId` でアノテートする。
- 主キーの一意性を保証するため、 `equals()` と `hashCode()` をオーバーライドする（コードは NetBeans の機能で自動生成したもの）。

#### equals() と hashCode() をオーバーライドする理由
デフォルトの `equals()` メソッドは、インスタンスが同じかどうかを比較するようになっている。

つまり、キー項目に同じ値が設定されていても、インスタンスが異なれば `equals()` メソッドは false を返してしまう。
そうなると、同じキー項目をもつ異なるエンティティオブジェクトが生成される可能性が生まれ、主キーの一意性が保証されなくなる。

このため、キー項目を持つクラスは `equals()` メソッドをオーバーライドしなければならない。
そして、 `equals()` メソッドをオーバーライドするので、合わせて `hashCode()` もオーバーライドしなければならない（詳しくは Effective Java を参照）。

### @IdClass を使用したパターン

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/145aa4d7-20c2-fd31-660e-0bc9ede305f0.jpeg)

```java:Mima.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.IdClass;

@Entity
@IdClass(MimaKey.class)
public class Mima {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long key1;
    @Id
    private String key2;
    private String value;

    public void setKey2(String key2) {
        this.key2 = key2;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Mima{" + "key1=" + key1 + ", key2=" + key2 + ", value=" + value + '}';
    }
}
```

```java:MimaKey.java
package sample.javaee.jpa.entity.mapping;

import java.io.Serializable;
import java.util.Objects;

public class MimaKey implements Serializable {
    
    private Long key1;
    private String key2;

    @Override
    public int hashCode() {
        // 省略
    }

    @Override
    public boolean equals(Object obj) {
        // 省略
    }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/66769f3d-853a-3e2d-b607-4d3196f93e18.jpeg)

```sql:
CREATE TABLE `mima` (
  `key1` int(11) NOT NULL AUTO_INCREMENT,
  `key2` varchar(45) NOT NULL,
  `value` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`key1`,`key2`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:
    Mima mima = new Mima();
    
    mima.setKey2("key2");
    mima.setValue("test");
    
    this.em.persist(mima);
    
    this.em.flush();
    
    System.out.println(mima);
```

```text:GlassFishコンソール出力
情報:   Mima{key1=2, key2=key2, value=test}
```

- `@IdClass` を使うことで複合主キーをマッピングすることもできる。
- この場合、主キーの項目はメインとなるエンティティ側（`Hoge`）に定義し、 `@Id` でアノテートする。
- `@IdClass` に指定したクラスにはアノテーションを一切付与せずに複合主キーを指定できる。
    - つまり、複合主キーが既存のクラスで、自由にコードを書き変えられないときとかに使えるということか？
    - でも、 `equals()` と `hashCode()` が正しくオーバーライドされていないと、主キーの一意性が担保されなくなるので注意が必要そう。

## 日付項目をマッピングする

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/f94c877e-7c49-a2d0-23eb-620966b172bc.jpeg)

```java:Kikuri.java
package sample.javaee.jpa.entity.mapping;

import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
public class Kikuri {
    
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Temporal(TemporalType.DATE)
    private Date date;
    @Temporal(TemporalType.TIME)
    private Date time;
    @Temporal(TemporalType.TIMESTAMP)
    private Date datetime;
    
    public void setDate(Date date) {
        this.date = this.time = this.datetime = date;
    }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/ce23efb1-d6e4-a9c9-1335-1df69612f642.jpeg)


```sql:
CREATE TABLE `kikuri` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `date` date DEFAULT NULL,
  `time` time DEFAULT NULL,
  `datetime` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:
    Kikuri kikuri = new Kikuri();
    kikuri.setDate(new Date());
    
    this.em.persist(kikuri);
```

プログラム実行後のテーブルの状態。

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/91c2f2eb-7551-2c9a-6395-e276317c6653.jpeg)

- 日付項目をマッピングする場合は、 `@Temporal` でフィールドをアノテートする。
- `@Temporal` の値には、データベース上の詳細な型（`DATE`, `TIME`, `TIMESTAMP`）を指定する。
    - `DATE` は日付だけ。
    - `TIME` は時刻だけ。
    - `TIMESTAMP` は日付と時刻の両方。

### Java8 で追加された LocalTime とかは使える？
コンバーターを自作すれば使えるっぽい？

[Using the Java 8 DateTime Classes with JPA! | Java.net](https://weblogs.java.net/blog/montanajava/archive/2014/06/17/using-java-8-datetime-classes-jpa)

## 特定のフィールドを永続化の対象外にする

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/e67f4eaf-90f3-f295-a9a7-b0e0f5e92b1f.jpeg)

```java:Konngara.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Transient;

@Entity
public class Konngara {
    
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String value;
    @Transient
    private String ignore;

    public void setValue(String value) {
        this.value = value;
    }

    public void setIgnore(String ignore) {
        this.ignore = ignore;
    }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/9e3ce76e-8bf5-2b79-70e5-4476ed83f3d3.jpeg)

```sql:
CREATE TABLE `konngara` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `value` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

- `@Transient` でフィールドをアノテートすると、そのフィールドは永続化の対象外になり、マッピングでは無視される。

## 列挙型をマッピングする
### デフォルトの動き

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/03a9845a-30a6-640c-d55e-624e01a6e106.jpeg)

```java:Genji.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Genji {
    
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "enum_value")
    private GenjiEnum enumValue;

    public void setEnumValue(GenjiEnum enumValue) {
        this.enumValue = enumValue;
    }
}
```

```java:GenjiEnum.java
package sample.javaee.jpa.entity.mapping;

public enum GenjiEnum {
    HOGE, FUGA, PIYO;
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/f7dc5b4c-817d-feb0-21b7-a2338ac4bd6c.jpeg)

```sql:
CREATE TABLE `genji` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `enum_value` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
    Genji genji = new Genji();
    genji.setEnumValue(GenjiEnum.HOGE);
    
    this.em.persist(genji);
    
    genji = new Genji();
    genji.setEnumValue(GenjiEnum.FUGA);
    
    this.em.persist(genji);
```

プログラム実行後のテーブルの状態。

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/2e9c2c48-e5e5-b742-0604-9ff035ec40a9.jpeg)

- enum の項目は、デフォルトでは対応する序数が保存される。
- しかし、これだと列挙子の順番を入れ替えた途端にデータが正しくマッピングされなくなる。

### 文字列でマッピングする

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/fc5c5595-23c1-8874-886a-5a3c34673299.jpeg)

```java:Rika.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Rika {
    
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "enum_value")
    @Enumerated(EnumType.STRING)
    private RikaEnum enumValue;

    public void setEnumValue(RikaEnum enumValue) {
        this.enumValue = enumValue;
    }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/f83cb0e9-bad7-1af0-46d8-66ee29e6b05a.jpeg)

```sql:
CREATE TABLE `rika` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `enum_value` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
    Rika rika = new Rika();
    rika.setEnumValue(RikaEnum.HOGE);
    
    this.em.persist(rika);
    
    rika = new Rika();
    rika.setEnumValue(RikaEnum.FUGA);
    
    this.em.persist(rika);
```

プログラムを実行後のテーブルの様子.

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/3493d194-6093-deea-cd05-03d591fa213e.jpeg)

- `@Enumerated` でアノテートして、 `EnumType.STRING` を指定すると、序数ではなく文字列で enum の情報を記録できる。
- これなら、列挙子の順番を書き変えてもデータマッピングで不整合が起こることはない。

## 基本型のコレクションのマッピング

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/38783c66-46c8-de6e-ee88-6092f367d562.jpeg)

```java:Meira.java
package sample.javaee.jpa.entity.mapping;

import java.util.List;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OrderBy;

@Entity
public class Meira {
    
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ElementCollection(fetch = FetchType.EAGER)
    @CollectionTable(name = "meira_list_value")
    @Column(name = "value")
    @OrderBy("DESC")
    private List<String> list;

    @Override
    public String toString() {
        return "Meira{" + "id=" + id + ", list=" + list + '}';
    }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/0c535740-1987-d02e-d04f-36a50ea20745.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/542f0220-1141-d8e6-26da-dc79b28c59fa.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/7f623d84-3d9e-f7b5-c5c0-802d4c05b917.jpeg)

```sql:
CREATE TABLE `meira` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `meira_list_value` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `meira_id` int(11) NOT NULL,
  `value` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `meira_fk_idx` (`meira_id`),
  CONSTRAINT `meira_fk` FOREIGN KEY (`meira_id`) REFERENCES `meira` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
    Meira meira = this.em.find(Meira.class, 1L);
    System.out.println(meira);
```

```text:GlassFishコンソール出力
情報:   Meira{id=1, list=[zzz, yyy, xxx]}
```

- `@ElementCollection` でコレクション型のフィールドをアノテートすると、そのフィールドが基本型のコレクションであることを定義できる。
    - コレクション型の対象は、 `Collection`, `Set`, `List`。
    - 基本型とは、エンティティではない型のこと。プリミティブ型、 String 型、組み込み可能クラス（詳細後述）などのことを指す。
    - `fetch` 属性に `FetchType.EAGER` を指定することで、即時ロードさせることができる（詳細後述）。
- `@CollectionTable` アノテーションで、コレクションの各要素を取得するためのテーブルを指定する。
    - 省略した場合は、「エンティティ名_フィールド名（`meira_list`）」で解決される。
- `@Column` アノテーションで、どのカラムの値をコレクションの要素として取得するのかを指定する。
    - 省略した場合は、「フィールド名（`list`）」で解決される。
- ソート条件を指定したい場合は、 `@OrderBy` でフィールドをアノテートする。

### 結合に用いるカラム名の解決
デフォルトの場合、**エンティティ名_エンティティのキープロパティ名** で解決される。
つまり、前述のテーブルの場合は `Meira_id` で解決される。

`meira_list_value` テーブルと `meria` テーブルと結合するときのカラム名は、ちょうどこのデフォルト値と同じになっている（`meria_id`）。
そのため、特に指定なしで動作している。

もしデフォルト値と実際のカラム名が異なる場合（仮に `meria_table_id` とした場合）は、以下のように設定する。

```diff:
    @ElementCollection(fetch = FetchType.EAGER)
-   @CollectionTable(name = "meira_list_value")
+   @CollectionTable(
+       name = "meira_list_value",
+       joinColumns = @JoinColumn(name = "meria_table_id")    
+   )
    @Column(name = "value")
    @OrderBy("DESC")
    private List<String> list;
```

- `@CollectionTable` アノテーションの `joinColumns` 属性で設定する。

### 即時ロードと遅延ロード
エンティティが他のクラスをコレクション（`List` や `Set`）で持っている場合、デフォルトで遅延ロードが適用される。

遅延ロードの場合、エンティティが `EntityManager#find(Class, Object)` などで DB からロードされた時点では、まだその項目は DB から取得されていない。
値が取得されるのは、そのコレクションから実際に値を取得しようとしたときになる。

前述の `Meira` クラスに、 `lazyList` という遅延ロードするリストを追加して、動作を確認してみる。

```diff:Meira.java
package sample.javaee.jpa.entity.mapping;

import java.util.List;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OrderBy;

@Entity
public class Meira {
    
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ElementCollection(fetch = FetchType.EAGER)
    @CollectionTable(name = "meira_list_value")
    @Column(name = "value")
    @OrderBy("DESC")
    private List<String> list;
    
+   @ElementCollection
+   @CollectionTable(name = "meira_list_value")
+   @Column(name = "value")
+   public List<String> lazyList;

    @Override
    public String toString() {
-       return "Meira{" + "id=" + id + ", list=" + list}';
+       return "Meira{" + "id=" + id + ", list=" + list + ", lazyList=" + lazyList + '}';
    }
}
```

**動作確認**

```diff:MappingEjb.java
    Meira meira = this.em.find(Meira.class, 1L);
    System.out.println(meira);
    
+   for (String value : meira.lazyList) {
+       System.out.println(value);
+   }
```

```text:GlassFishコンソール出力
情報:   Meira{id=1, list=[zzz, yyy, xxx], lazyList={IndirectList: not instantiated}}
情報:   xxx
情報:   yyy
情報:   zzz
```

- 遅延ロードの場合、 `list` をただ `toString()` しただけでは、値が設定されていないのが分かる。
- しかし、拡張 for 文などを使って List から値を取得すると、実際の値が取れるようになる。

#### それぞれのメリットとデメリット
| -          | メリット                                   | デメリット                                                                   |
| :--        | :--                                        | :--                                                                          |
| 即時ロード | 検索に時間がかかる場合は、予めロードしておくことができる。                | 結局使用しなくても読み込んでしまう。 |
| 遅延ロード | DB とのアクセスを必要なときだけに限定できる。 | 予めロードしておけない。                                                |

基本は遅延ロード（デフォルト）で、実際に動かしてみたらパフォーマンスに影響があった場合は即時ロードにする、くらいの方針でよいかと。
よく言われているが、動かしてもないのにパフォーマンスを気にして無駄に設定やモデルをいじくりまわしてしまう、というのは避けた方がいい。

また、 JPA 2.1 (Java EE 7) では、 Entity Graph という仕組みが追加されている。これを利用すると、エンティティ間の関連をどこまで掘り下げて一度に読み込むかなどを定義することができる（詳細後述）。

### ソート用のカラムを使用する
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/ca6f56df-9ff8-658d-e315-ca2a62c1ab83.jpeg)

```java:Shinki.java
package sample.javaee.jpa.entity.mapping;

import java.util.List;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.OrderColumn;

@Entity
public class Shinki {
    @Id
    private Long id;
    
    @ElementCollection(fetch = FetchType.EAGER)
    @Column(name = "value")
    @OrderColumn(name = "order")
    private List<String> list;

    @Override
    public String toString() {
        return "Shinki{" + "id=" + id + ", list=" + list + '}';
    }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/459612ed-5747-5aac-7aa1-395d94da3aec.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/283a5a45-a92f-8724-dca9-205baaced33c.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/c9b780f7-0252-71b2-075f-1b64dda9e050.jpeg)

```sql:
CREATE TABLE `shinki` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `shinki_list` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `shinki_id` int(11) NOT NULL,
  `order` int(11) NOT NULL,
  `value` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `shinki_list_fk_idx` (`shinki_id`),
  CONSTRAINT `shinki_list_fk` FOREIGN KEY (`shinki_id`) REFERENCES `shinki` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 Shinki shinki = this.em.find(Shinki.class, 1L);
 System.out.println(shinki);
```

```text:GlassFishコンソール出力
情報: Shinki{id=1, list={[piyo, fuga, hoge]}}
```

- `@OrderColumn` アノテーションを使用することで、ソートのキーとなるカラムを指定することができる。

## Map にマッピングする

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/c308bb1e-4c8a-0a13-787b-9e66bd3cd744.jpeg)

```java:Eren.java
package sample.javaee.jpa.entity.mapping;

import java.util.Map;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MapKeyColumn;

@Entity
public class Eren {

 @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;

 @ElementCollection(fetch = FetchType.EAGER)
 @CollectionTable(name = "eren_map_value")
 @MapKeyColumn(name = "key")
 @Column(name = "value")
 private Map<String, String> map;

 @Override
 public String toString() {
 return "Eren{" + "id=" + id + ", map=" + map + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/a457c5da-96c1-b617-1308-800cb89f2bd8.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/d1388e02-c08a-74da-6402-83fc093ca8f8.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/9db10dfb-cf34-2c25-837f-5ac65e2e0967.jpeg)

```sql:
CREATE TABLE `eren` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `eren_map_value` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `eren_id` int(11) NOT NULL,
 `key` varchar(45) NOT NULL,
 `value` varchar(45) DEFAULT NULL,
 PRIMARY KEY (`id`),
 KEY `eren_map_velu_fk_idx` (`eren_id`),
 CONSTRAINT `eren_map_velu_fk` FOREIGN KEY (`eren_id`) REFERENCES `eren` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 Eren eren = this.em.find(Eren.class, 1L);

 System.out.println(eren);
```

```text:GlassFishコンソール
情報: Eren{id=1, map={fuga=FUGA, piyo=PIYO, hoge=HOGE}}
```

- `@MapKeyColumn` でアノテートすることで、 `Map` のキーバリューと DB の値をマッピングすることができる。
- `@MapKeyColumn` の `name` には、 `Map` のキーとなる値を持つカラム名を指定する。
- それ以外は、コレクションのときと同じ要領で設定する。
- `String` 以外にも、他のエンティティなどをキーやバリューに指定することもできる。

## 非エンティティクラスをマッピングする

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/cbdc4d33-e186-2c47-62f4-f13411cb4564.jpeg)

```java:Kotohime.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Kotohime {

 @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;
 private String value;
 @Embedded
 private EmbeddedKotohime embeddedKotohime;

 @Override
 public String toString() {
 return "Kotohime{" + "id=" + id + ", value=" + value + ", embeddedKotohime=" + embeddedKotohime + '}';
 }
}
```

```java:EmbeddedKotohime.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Column;
import javax.persistence.Embeddable;

@Embeddable
public class EmbeddedKotohime {

 @Column(name = "embedded_value")
 private String embeddedValue;

 @Override
 public String toString() {
 return "EmbeddedKotohime{" + "embeddedValue=" + embeddedValue + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/83e38292-92af-7abd-03d8-88d4915ce33b.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/d7460101-e072-9b3c-c1d8-1e79dc39f63d.jpeg)

```sql:
CREATE TABLE `kotohime` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `value` varchar(45) DEFAULT NULL,
 `embedded_value` varchar(45) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 Kotohime kotohime = this.em.find(Kotohime.class, 1L);

 System.out.println(kotohime);
```

```text:GlassFishコンソール
情報: Kotohime{id=1, value=hoge, embeddedKotohime=EmbeddedKotohime{embeddedValue=HOGE}}
```

- `@Embeddable` でクラスをアノテートすることで、非エンティティクラスをエンティティにマッピングすることができるようになる。
- `@Embeddable` でアノテートしたクラスを、 **組み込み可能クラス** と呼ぶ。
- 組み込み可能クラスは ID を持たない = 識別する必要がない、すなわち DDD の ValueObject に該当する。
- エンティティ側では、 `@Embedded` を使ってフィールドが組み込み可能クラスであることを指定する。

### 組み込み可能クラスの List をマッピングする
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/54bf64fc-baa1-c267-8fed-3450e03206b9.jpeg)

```java:KanaAnaberaru.java
package sample.javaee.jpa.entity.mapping;

import java.util.List;
import javax.persistence.CollectionTable;
import javax.persistence.ElementCollection;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.Table;

@Entity
@Table(name = "kana_anaberaru")
public class KanaAnaberaru {
 @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;

 @Embedded
 @ElementCollection(fetch = FetchType.EAGER)
 @CollectionTable(
 name = "kana_anaberaru_list_value",
 joinColumns = @JoinColumn(name = "kana_anaberaru_id")
 )
 private List<EmbeddedKanaAnaberaru> embeddedKanaAnaberaruList;

 @Override
 public String toString() {
 return "KanaAnaberaru{" + "id=" + id + ", embeddedKanaAnaberaruList=" + embeddedKanaAnaberaruList + '}';
 }
}
```

```java:EmbeddedKanaAnaberaru.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Column;
import javax.persistence.Embeddable;

@Embeddable
public class EmbeddedKanaAnaberaru {
 @Column(name = "embedded_value")
 private String embeddedValue;

 @Override
 public String toString() {
 return "EmbeddedKanaAnaberaru{" + "embeddedValue=" + embeddedValue + '}';
 }
}
```

**データーベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/5c24b1dc-9924-9f53-8e11-1af5aade9730.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/e2790973-9819-50a0-4244-1a013950de31.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/f0ff3ecd-b383-f1d7-559b-d2c2b0b89f80.jpeg)

```sql:
CREATE TABLE `kana_anaberaru` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `kana_anaberaru_list_value` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `kana_anaberaru_id` int(11) NOT NULL,
 `embedded_value` varchar(45) DEFAULT NULL,
 PRIMARY KEY (`id`),
 KEY `kana_anaberaru_list_value_fk_idx` (`kana_anaberaru_id`),
 CONSTRAINT `kana_anaberaru_list_value_fk` FOREIGN KEY (`kana_anaberaru_id`) REFERENCES `kana_anaberaru` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
```


**動作確認**

```java:MappingEjb.java
 KanaAnaberaru kotohime = this.em.find(KanaAnaberaru.class, 1L);

 System.out.println(kotohime);
```

```text:GlassFishコンソール出力
情報: KanaAnaberaru{id=1, embeddedKanaAnaberaruList=[EmbeddedKanaAnaberaru{embeddedValue=hoge}, EmbeddedKanaAnaberaru{embeddedValue=fuga}, EmbeddedKanaAnaberaru{embeddedValue=piyo}]}
```

- `@Embedded` アノテーションをフィールドに追加すれば、組み込み可能クラスを List でマッピングすることができる。

### 組み込み可能クラスを Map にマッピングする

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/23d0d75c-6361-a860-976d-eaf1ec2bc826.jpeg)

```java:AsakuraRikako.java
package sample.javaee.jpa.entity.mapping;

import java.util.Map;
import javax.persistence.CollectionTable;
import javax.persistence.ElementCollection;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.Table;

@Entity
@Table(name = "asakura_rikako")
public class AsakuraRikako {

 @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;

 @Embedded
 @ElementCollection(fetch = FetchType.EAGER)
 @CollectionTable(
 name = "asakura_rikako_map_values",
 joinColumns = @JoinColumn(name = "asakura_rikako_id")
 )
 private Map<AsakuraRikakoKey, AsakuraRikakoValue> map;

 @Override
 public String toString() {
 return "AsakuraRikako{" + "id=" + id + ", map=" + map + '}';
 }
}
```

```java:AsakuraRikakoKey.java
package sample.javaee.jpa.entity.mapping;

import java.util.Objects;
import javax.persistence.Column;
import javax.persistence.Embeddable;

@Embeddable
public class AsakuraRikakoKey {
 @Column(name = "embedded_key")
 private String key;

 @Override
 public String toString() {
 return "AsakuraRikakoKey{" + "key=" + key + '}';
 }

 @Override
 public int hashCode() {
 // NetBeans で自動生成
 }

 @Override
 public boolean equals(Object obj) {
 // NetBeans で自動生成
 }
}
```

```java:AsakuraRikakoValue.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Column;
import javax.persistence.Embeddable;

@Embeddable
public class AsakuraRikakoValue {
 @Column(name = "embedded_value")
 private String value;

 @Override
 public String toString() {
 return "AsakuraRikakoValue{" + "value=" + value + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/fbde618b-069e-6ed0-dfae-b454290ebe1f.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/ea58482e-b783-48c5-305e-2ab1c28a5df5.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/f62df319-612b-5cea-ffcf-8ec67bb658a3.jpeg)

```sql:
CREATE TABLE `asakura_rikako` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `asakura_rikako_map_values` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `asakura_rikako_id` int(11) NOT NULL,
 `embedded_key` varchar(45) NOT NULL,
 `embedded_value` varchar(45) DEFAULT NULL,
 PRIMARY KEY (`id`),
 KEY `asakura_rikako_map_values_fk_idx` (`asakura_rikako_id`),
 CONSTRAINT `asakura_rikako_map_values_fk` FOREIGN KEY (`asakura_rikako_id`) REFERENCES `asakura_rikako` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 AsakuraRikako asakuraRikako = this.em.find(AsakuraRikako.class, 1L);

 System.out.println(asakuraRikako);
```

```text:GlassFishコンソール出力
情報: AsakuraRikako{id=1, map={AsakuraRikakoKey{key=fuga}=AsakuraRikakoValue{value=FUGA}, AsakuraRikakoKey{key=piyo}=AsakuraRikakoValue{value=PIYO}, AsakuraRikakoKey{key=hoge}=AsakuraRikakoValue{value=HOGE}}}
```

- `@Embedded` をフィールドに追加することで、組み込み可能クラスを Map のキーやバリューとして使用することができる。

## Lob カラムをマッピングする
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/11952110-db93-1983-3091-e6705aa8d9d5.jpeg)

```java:PatchouliKnowledge.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Lob;
import javax.persistence.Table;

@Entity
@Table(name = "patchouli_knowledge")
public class PatchouliKnowledge {
 @Id
 private Long id;
 @Lob
 @Column(name = "blob_value")
 private byte[] blobValue;
 @Lob
 @Column(name = "clob_value")
 private String clobValue;

 public void setBlobValue(byte[] blobValue) {
 this.blobValue = blobValue;
 }

 public void setClobValue(String clobValue) {
 this.clobValue = clobValue;
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/55b01f1e-a0e7-6bab-1e6c-424accb7063e.jpeg)

```sql:
CREATE TABLE `patchouli_knowledge` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `blob_value` blob,
 `clob_value` longtext,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 PatchouliKnowledge patchouliKnowledge = new PatchouliKnowledge();
 patchouliKnowledge.setBlobValue("blob text".getBytes(Charset.forName("UTF-8")));
 patchouliKnowledge.setClobValue("clob text");

 this.em.persist(patchouliKnowledge);
```

実行後のデータベースの様子。

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/a634200e-dd34-ea5f-fcc9-6dc2e21d3bb4.jpeg)

- `@Lob` でフィールドをアノテートすると、 LOB 型のデータとしてマッピングできる。
- BLOB にマッピングされるか、 CLOB にマッピングされるかは、フィールドの型によって以下のように決定される。
 - `byte[]`、 `Byte[]`、 `Serializable` の場合は BLOB。
 - `char[]`、 `Character[]`、 `String` の場合は CLOB。

# リレーションのマッピング
複数のエンティティが関連を持つ場合の、 DB とのマッピング方法について。

## １対１
### 単方向
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/f494d44e-bae3-b24f-3d4a-15f9c30236f1.jpeg)

```java:KitashirakawaChiyuri.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.Table;

@Entity
@Table(name = "kitashirakawa_chiyuri")
public class KitashirakawaChiyuri {
 @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;
 @JoinColumn(name = "okazaki_yumemi_id")
 private OkazakiYumemi okazakiYumemi;

 @Override
 public String toString() {
 return "KitashirakawaChiyuri{" + "id=" + id + ", okazakiYumemi=" + okazakiYumemi + '}';
 }
}
```

```java:OkazakiYumemi.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "okazaki_yumemi")
public class OkazakiYumemi {
 @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;

 @Override
 public String toString() {
 return "OkazakiYumemi{" + "id=" + id + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/828b5e1c-93ab-01c1-2d1f-4e515e47680e.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/7c5243d7-6604-fcd7-1aeb-31ff54c6d8b8.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/516711ce-227d-99cc-0589-7e5580267ed2.jpeg)

```sql:
CREATE TABLE `kitashirakawa_chiyuri` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `okazaki_yumemi_id` int(11) NOT NULL,
 PRIMARY KEY (`id`),
 KEY `kitashirakawa_chiyuri_fk_idx` (`okazaki_yumemi_id`),
 CONSTRAINT `kitashirakawa_chiyuri_fk` FOREIGN KEY (`okazaki_yumemi_id`) REFERENCES `okazaki_yumemi` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `okazaki_yumemi` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 KitashirakawaChiyuri kitashirakawaChiyuri = this.em.find(KitashirakawaChiyuri.class, 1L);

 System.out.println(kitashirakawaChiyuri);
```

```text:GlassFishコンソール出力
情報: KitashirakawaChiyuri{id=1, okazakiYumemi=OkazakiYumemi{id=1}}
```

- エンティティ間の多重度が１対１で、関連の向きが単方向の場合は、特に何も指定することなくマッピングすることができる。
- ただし、結合に用いられるカラム名が、デフォルトでは **フィールド名_相手のキーカラム名** で解決される（`okazakiYumemi_id`）ので、 `@JoinColumn` アノテーションを使って結合に用いるカラム名を明示している。
- デフォルトのフェッチ方法は `EAGER` になる。これを変更したい場合は、 `@OneToOne(fetch = FetchType.LAZY)` の指定を追加する。

### 双方向
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/4170a1e9-f0c5-d9b8-8bfd-2f3f74744acb.jpeg)

```java:Orange.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Orange {
 @Id
 private Long id;

 private Kurumi kurumi;

 public Long getId() {
 return id;
 }

 @Override
 public String toString() {
 return "Orange{" + "id=" + id + ", kurumi.id=" + kurumi.getId() + '}';
 }
}
```

```java:Kurumi.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Kurumi {
 @Id
 private Long id;

 @OneToOne(mappedBy = "kurumi")
 private Orange orange;

 public Long getId() {
 return id;
 }

 @Override
 public String toString() {
 return "Kurumi{" + "id=" + id + ", orange.id=" + orange.getId() + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/007ac854-e51c-5f81-bc5d-0ecaf80506b8.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/1f5dd404-f99c-560b-f709-43b2cb1c65b4.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/681b25c6-29a7-5b6f-abf4-3ad0871da96c.jpeg)

```sql:
CREATE TABLE `kurumi` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `orange` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `kurumi_id` int(11) NOT NULL,
 PRIMARY KEY (`id`),
 KEY `orange_fk_idx` (`kurumi_id`),
 CONSTRAINT `orange_fk` FOREIGN KEY (`kurumi_id`) REFERENCES `kurumi` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 Orange orange = this.em.find(Orange.class, 1L);
 System.out.println(orange);

 Kurumi kurumi = this.em.find(Kurumi.class, 2L);
 System.out.println(kurumi);
```

```text:GlassFishコンソール出力
情報: Orange{id=1, kurumi.id=1}
情報: Kurumi{id=2, orange.id=2}
```

- DB のテーブル上で、関連するエンティティを識別するためのカラムを持っている方のエンティティを **所有者** と呼ぶ。
 - もしくは、エンティティ A がエンティティ B の参照を持っている場合、 A を所有者と呼ぶ。
- 逆側のエンティティを、 **被所有者** と呼ぶ。
 - 上記例でいうと、 `Orange` が所有者で、 `Kurumi` が被所有者となる。
- しかしエンティティが相互参照していると、それだけではどちらが所有者でどちらが被所有者なのか判断することができない。
- そこで、 `Kurumi` が被所有者であることを明示するために、 `@OneToOne` アノテーションの `mappedBy` 属性を使用する。
 - `mappedBy` には、所有者が持っている被所有者を指すプロパティ名を指定する（上記例の場合は、 `kurumi`）。

~~そもそも相互参照するようなクラス設計はダメじゃね？~~

## １対多
### 単方向
#### 結合テーブルを使用する
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/f1620846-4d6c-26e2-0186-66270d43a427.jpeg)

```java:Elliy.java
package sample.javaee.jpa.entity.mapping;

import java.util.List;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;

@Entity
public class Elliy {
 @Id
 private Long id;

 @OneToMany(fetch = FetchType.EAGER)
 @JoinTable(inverseJoinColumns = @JoinColumn(name = "yuuka_id"))
 private List<Yuuka> yuukaList;

 @Override
 public String toString() {
 return "Elliy{" + "id=" + id + ", yuukaList=" + yuukaList + '}';
 }
}
```

```java:Yuuka.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Yuuka {
 @Id
 private Long id;

 @Override
 public String toString() {
 return "Yuuka{" + "id=" + id + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/26222dad-4b2b-fb65-7aa8-9a3f9992cd34.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/a24d8b3e-c51c-8475-9c62-3c2f3fdf6f21.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/241c8520-f20f-3169-34b8-f03c12aff878.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/81dacee1-d569-43e8-5617-42ba512ff67e.jpeg)

```sql:
CREATE TABLE `elliy` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `yuuka` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

CREATE TABLE `elliy_yuuka` (
 `elliy_id` int(11) NOT NULL,
 `yuuka_id` int(11) NOT NULL,
 PRIMARY KEY (`elliy_id`,`yuuka_id`),
 KEY `elliy_yuuka_fk1_idx` (`elliy_id`),
 KEY `elliy_yuuka_fk2_idx` (`yuuka_id`),
 CONSTRAINT `elliy_yuuka_fk1` FOREIGN KEY (`elliy_id`) REFERENCES `elliy` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
 CONSTRAINT `elliy_yuuka_fk2` FOREIGN KEY (`yuuka_id`) REFERENCES `yuuka` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 Elliy elliy = this.em.find(Elliy.class, 1L);
 System.out.println(elliy);
```

```text:GlassFishコンソール出力
情報: Elliy{id=1, yuukaList=[Yuuka{id=1}, Yuuka{id=2}, Yuuka{id=3}, Yuuka{id=4}]}
```

- 関連テーブルを使って１対多のエンティティをマッピングするケース。
- デフォルトでは、以下のようにテーブル名やカラム名が解決される。

| 対象 | デフォルト設定で解決された場合 | 例 |
| :-- | :-- | :-- |
| 関連テーブル名 | 所有者エンティティ名_被所有者エンティティ名 | `Elliy_Yuuka` |
| 所有者を結合するためのカラム名 | 所有者エンティティ名_ID項目名 | `Elliy_id` |
| 被所有者を結合するためのカラム名 | プロパティ名_ID項目名 | `yuukaList_id` |

- 関連テーブルの名前と所有者側を結合するためのカラム名は、デフォルトのままでも問題ない。
- しかし、被所有者側を結合するためのカラム名が、デフォルトのままだと問題がある。
- そこで、 `@JoinTable` アノテーションの `inverseJoinColumns` 属性を使ってカラム名を明示的に指定している。
- 今回は必要なかったが、関連テーブル名や所有者を結合するためのカラム名を指定する場合は、以下のようにする。

```java:
 @JoinTable(
 name = "relation_table_name",
 joinColumns = @JoinColumn(name = "join_column")
 )
 private List<Yuuka> yuukaList;
```

- `name` 属性で、関連テーブルの名前を指定する。
- `joinColumns` 属性で、所有者側を結合するためのカラム名を指定する。

#### 結合テーブルを使用しない
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/e9b3b083-8139-1f1c-b3e9-4a2916884ca0.jpeg)

```java:Mugetsu.java
package sample.javaee.jpa.entity.mapping;

import java.util.List;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;

@Entity
public class Mugetsu {
 @Id
 private Long id;

 @OneToMany(fetch = FetchType.EAGER)
 @JoinColumn(name = "mugetsu_id")
 private List<Gengetsu> gengetsuList;

 @Override
 public String toString() {
 return "Mugetsu{" + "id=" + id + ", gengetsuList=" + gengetsuList + '}';
 }
}
```

```java:Gengetsu.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Gengetsu {
 @Id
 private Long id;

 @Override
 public String toString() {
 return "Gengetsu{" + "id=" + id + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/6b5aa59a-abad-1245-f5b2-d9ff74ffc42d.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/852662cb-ac17-6a91-0ede-19a70f2b6730.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/c211f75d-80f5-59a6-d21b-b3dfec66ed26.jpeg)

```sql:
CREATE TABLE `mugetsu` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `gengetsu` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `mugetsu_id` int(11) NOT NULL,
 PRIMARY KEY (`id`),
 KEY `gengetsu_fk_idx` (`mugetsu_id`),
 CONSTRAINT `gengetsu_fk` FOREIGN KEY (`mugetsu_id`) REFERENCES `mugetsu` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 Mugetsu mugetsu = this.em.find(Mugetsu.class, 1L);
 System.out.println(mugetsu);
```

```text:GlassFishコンソール出力
情報: Mugetsu{id=1, gengetsuList=[Gengetsu{id=1}, Gengetsu{id=2}, Gengetsu{id=3}]}
```

- 関連テーブルを使わない単純なケース。
- １対多の関連を解決する場合、 JPA は、デフォルトだと関連テーブルを使った方法を想定して関連の解決を行おうとする。
- そうではなく、上記のように単純な方法で１対多のデータを格納している場合は、所有者側に `@JoinColumn` アノテーションを設定する。
 - 結合条件となるカラムの名前は、デフォルトだと `プロパティ名_IDカラム名` で解決される（上述の例の場合は `gengetsuList_id`）。
 - これを上書きする場合は、 `name` 属性を指定する。

### 双方向
#### 結合テーブルを使用する
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/b98f0f6b-bcde-a126-512b-2562c8b344ca.jpeg)

```java:Sara.java
package sample.javaee.jpa.entity.mapping;

import java.util.List;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;

@Entity
public class Sara {
 @Id
 private Long id;

 @OneToMany(fetch = FetchType.EAGER)
 @JoinTable(
 inverseJoinColumns = @JoinColumn(name = "luize_id")
 )
 private List<Luize> luizeList;

 public Long getId() {
 return id;
 }

 @Override
 public String toString() {
 return "Sara{" + "id=" + id + ", luizeList=" + luizeList + '}';
 }
}
```

```java:Luize.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinTable;

@Entity
public class Luize {
 @Id
 private Long id;

 @JoinTable(name="sara_luize")
 private Sara sara;

 @Override
 public String toString() {
 return "Luize{" + "id=" + id + ", sara.id=" + sara.getId() + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/5a152c5c-c00b-e07d-4351-44eecb8f9183.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/6160b027-4b1b-f596-3485-ecffaa61f0c8.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/ec8b755e-7515-727c-220f-59377356f63d.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/832fcdfe-7151-0716-72a6-7f5cf0fa1381.jpeg)

```sql:
CREATE TABLE `sara` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `luize` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

CREATE TABLE `sara_luize` (
 `sara_id` int(11) NOT NULL,
 `luize_id` int(11) NOT NULL,
 PRIMARY KEY (`sara_id`,`luize_id`),
 KEY `sara_luize_fk1_idx` (`sara_id`),
 KEY `sara_luize_fk2_idx` (`luize_id`),
 CONSTRAINT `sara_luize_fk1` FOREIGN KEY (`sara_id`) REFERENCES `sara` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
 CONSTRAINT `sara_luize_fk2` FOREIGN KEY (`luize_id`) REFERENCES `luize` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 Sara sara = this.em.find(Sara.class, 1L);
 System.out.println(sara);

 Luize luize = this.em.find(Luize.class, 1L);
 System.out.println(luize);
```

```text:GlassFishコンソール出力
情報: Sara{id=1, luizeList=[Luize{id=1, sara.id=1}, Luize{id=2, sara.id=1}, Luize{id=3, sara.id=1}]}
情報: Luize{id=1, sara.id=1}
```

- 多の方のエンティティ（`Luize` クラス）が持つフィールド（`sara`）を、 `@JoinTable` アノテートしてテーブル名を明示する。
- これをしないと、関連テーブルが `luize_sara` で解決されてしまう。
- `Luize` クラスの `sara` フィールドのフェッチを変更したい場合は、 `@ManyToOne` アノテーションを使用する。

#### 結合テーブルを使用しない
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/18e6f0c0-dd7d-bf89-5a3c-1ed1f844df03.jpeg)


```java:Yuki.java
package sample.javaee.jpa.entity.mapping;

import java.util.List;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;

@Entity
public class Yuki {
 @Id
 private Long id;

 @OneToMany(fetch = FetchType.EAGER)
 @JoinColumn(name = "yuki_id")
 private List<Mai> maiList;

 public Long getId() {
 return id;
 }

 @Override
 public String toString() {
 return "Yuki{" + "id=" + id + ", maiList=" + maiList + '}';
 }
}
```

```java:Mai.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Mai {
 @Id
 private Long id;

 private Yuki yuki;

 @Override
 public String toString() {
 return "Mai{" + "id=" + id + ", yuki.id=" + yuki.getId() + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/88a62b75-5b30-7db6-0671-f6bd962260e2.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/e3f81b0b-1e37-f2a9-2606-112aad7f8a7c.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/447a7b62-77a4-abdf-840a-30898489a849.jpeg)

```sql:
CREATE TABLE `yuki` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `mai` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `yuki_id` int(11) NOT NULL,
 PRIMARY KEY (`id`),
 KEY `mai_fk_idx` (`yuki_id`),
 CONSTRAINT `mai_fk` FOREIGN KEY (`yuki_id`) REFERENCES `yuki` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 Yuki yuki = this.em.find(Yuki.class, 1L);
 System.out.println(yuki);

 Mai mai = this.em.find(Mai.class, 1L);
 System.out.println(mai);
```

```text:GlassFishコンソール出力
情報: Yuki{id=1, maiList=[Mai{id=1, yuki.id=1}, Mai{id=2, yuki.id=1}, Mai{id=3, yuki.id=1}]}
情報: Mai{id=1, yuki.id=1}
```

- 多（`Mai`）から１（`Yuki`）側を結合するときのカラム名は、１対１のときと同じ方法で解決される。
- 明示したい場合は、 `@JoinColumn` を使う。

## 多対多
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/7d24dcca-d4c9-b0e5-fa6f-51645d85a8d2.jpeg)

```java:Alice.java
package sample.javaee.jpa.entity.mapping;

import java.util.ArrayList;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;

@Entity
public class Alice {
 @Id
 private Long id;

 @ManyToMany(fetch = FetchType.EAGER)
 @JoinTable(
 joinColumns = @JoinColumn(name = "alice_id"),
 inverseJoinColumns = @JoinColumn(name = "yumeko_id")
 )
 private List<Yumeko> yumekoList;

 public Long getId() {
 return id;
 }

 @Override
 public String toString() {
 List<String> ids = new ArrayList<>();

 for (Yumeko yumeko : this.yumekoList) {
 ids.add(String.valueOf(yumeko.getId()));
 }

 return "Alice{" + "id=" + id + ", yumekoList=" + String.join(", ", ids) + '}';
 }
}
```

```java:Yumeko.java
package sample.javaee.jpa.entity.mapping;

import java.util.ArrayList;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Yumeko {
 @Id
 private Long id;

 @ManyToMany(fetch = FetchType.EAGER, mappedBy = "yumekoList")
 private List<Alice> aliceList;

 public Long getId() {
 return id;
 }

 @Override
 public String toString() {
 List<String> ids = new ArrayList<>();

 for (Alice alice : this.aliceList) {
 ids.add(String.valueOf(alice.getId()));
 }

 return "Yumeko{" + "id=" + id + ", aliceList=" + String.join(", ", ids) + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/7f2978f7-d6a5-213b-ddf0-500b6e7645cb.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/09ad4d6d-1a2b-2c36-b857-474823ae4434.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/78349b0f-71cb-5227-8657-c993d930a2e2.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/436a5965-86f2-431c-f38a-614cb702c33e.jpeg)

```sql:
CREATE TABLE `alice` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `yumeko` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `alice_yumeko` (
 `alice_id` int(11) NOT NULL,
 `yumeko_id` int(11) NOT NULL,
 PRIMARY KEY (`alice_id`,`yumeko_id`),
 KEY `alice_yumeko_fk1_idx` (`alice_id`),
 KEY `alice_yumeko_fk2_idx` (`yumeko_id`),
 CONSTRAINT `alice_yumeko_fk1` FOREIGN KEY (`alice_id`) REFERENCES `alice` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
 CONSTRAINT `alice_yumeko_fk2` FOREIGN KEY (`yumeko_id`) REFERENCES `yumeko` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 Alice alice = this.em.find(Alice.class, 1L);
 System.out.println(alice);

 Yumeko yumeko = this.em.find(Yumeko.class, 1L);
 System.out.println(yumeko);
```

```text:GlassFishコンソール出力
情報: Alice{id=1, yumekoList=1, 2, 3}
情報: Yumeko{id=1, aliceList=1, 2}
```

- 双方向の多対多をマッピングする場合は、 `@ManyToMany` アノテーションを使う。
- どちらか一方を所有者に決めて、そちらに `@JoinTable` アノテーションで結合の条件を設定する。
- 被所有者側は、 `@ManyToMany` アノテーションの `mappedBy` 属性で、所有者側のどのフィールドを紐付いているのかだけを指定すればいい。
- 実装してて気づいたけど、 `toString()` メソッド内で Stream API を使うと、アプリケーションロード時にエラーになるっぽい。原因はよくわからない。仕方ないので、 for 文を使って文字列を整形している。

# 継承のマッピング
## クラス階層に属するエンティティを１つのテーブルにマッピングする
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/e25376f1-4431-1f07-b30c-6dca4ecd774d.jpeg)

```java:ParentRumia.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "rumia")
public class ParentRumia {
 @Id
 protected Long id;

 protected String name;

 public void setName(String name) {
 this.name = name;
 }

 @Override
 public String toString() {
 return "ParentRumia{" + "id=" + id + ", name=" + name + '}';
 }
}
```

```java:ChildRumia.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;

@Entity
public class ChildRumia extends ParentRumia {

 private String value;

 public void setValue(String value) {
 this.value = value;
 }

 @Override
 public String toString() {
 return "ChildRumia{id=" + id + ", name=" + name + ", value=" + value + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/2707de69-c4a2-2db0-401d-9fd4982cf673.jpeg)

```sql:
CREATE TABLE `rumia` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `dtype` varchar(45) NOT NULL,
 `name` varchar(45) DEFAULT NULL,
 `value` varchar(45) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 ParentRumia parentRumia = new ParentRumia();
 parentRumia.setName("parent name");

 this.em.persist(parentRumia);

 ChildRumia childRumia = new ChildRumia();
 childRumia.setName("child name");
 childRumia.setValue("child value");

 this.em.persist(childRumia);
```

実行後のデータベースの様子。

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/f48dcc2d-091e-5954-135b-1ea97864be8b.jpeg)

- 特に指定が無い場合、１つのクラス階層に属するエンティティは、１つのテーブルにマッピングされる。
- マッピングされるテーブルの名前は、デフォルトでは階層のルートとなるエンティティ名で解決される。
- テーブルには `dtype` という名前の文字列型のカラムを用意しておく。
 - このカラムに、そのレコードがどのクラスのデータなのかを識別するための値が格納される。
 - デフォルトでは、エンティティの名前が格納される。
- テーブルには、クラス階層の各エンティティが持つ全てのプロパティに対応するカラムを用意しなければならない。

### メリット
- データの持ち方が単純で理解しやすい。
- 検索時にテーブルの JOIN が必要ない。

### デメリット
- 階層にクラスが追加されると、テーブルのカラムも変更しなければならない。
- 項目に NOT NULL 制約を設けることができない。
 - 子クラスで定義されたカラムには、親クラスのレコードでは NULL 値が設定されるため。

### エンティティ名を保存するカラムの名前や値を変更する
デフォルトでは `DTYPE` という文字列型のカラムにエンティティ名が保存される。
これは、 `@DiscriminatorColumn` と `@DiscriminatorValue` アノテーションで変更することができる。

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/4444b7cf-d931-38ff-10aa-828df0b870ff.jpeg)

```java:ParentDaiyousei.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "daiyousei")
@DiscriminatorColumn(name = "entity_type", discriminatorType = DiscriminatorType.INTEGER)
@DiscriminatorValue("1")
public class ParentDaiyousei {
 @Id
 private Long id;
 private String value;

 public void setValue(String value) {
 this.value = value;
 }
}
```

```java:ChildDaiyousei.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue("2")
public class ChildDaiyousei extends ParentDaiyousei {
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/a70d5310-37cd-7ac4-475b-d7eee7df12d2.jpeg)

```sql:
CREATE TABLE `daiyousei` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `entity_type` int(11) NOT NULL,
 `value` varchar(45) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 ParentDaiyousei parentDaiyousei = new ParentDaiyousei();
 parentDaiyousei.setValue("parent value");

 this.em.persist(parentDaiyousei);

 ChildDaiyousei childDaiyousei = new ChildDaiyousei();
 childDaiyousei.setValue("child value");

 this.em.persist(childDaiyousei);
```

実行後のデータベースの様子。

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/22ea4cc8-62e3-8b44-536b-1201e5678792.jpeg)

- ルートのエンティティを `@DiscriminatorColumn` でアノテートして、 `name` 属性でカラムの名前を指定できる。
- `discriminatorType` 属性で型を指定することができる。
- 各エンティティでなんという値を設定するかは、 `@DiscriminatorValue` アノテーションで指定する。

## サブクラスごとにテーブルをマッピングする
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/e5524e8c-91b0-374f-a6e8-b0024fa7791f.jpeg)

```java:ParentCirno.java
package sample.javaee.jpa.entity.mapping;

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(name = "parent_cirno")
@Inheritance(strategy = InheritanceType.JOINED)
public class ParentCirno {
 @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
 protected Long id;

 protected String name;

 public void setName(String name) {
 this.name = name;
 }

 @Override
 public String toString() {
 return "ParentCirno{" + "id=" + id + ", name=" + name + '}';
 }
}
```

```java:ChildCirno.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Table;

@Entity
@Table(name = "child_cirno")
public class ChildCirno extends ParentCirno {

 private String value;

 public void setValue(String value) {
 this.value = value;
 }

 @Override
 public String toString() {
 return "ChildCirno{" + "id=" + id + ", name=" + name + ", value=" + value + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/e6b80e1d-a000-f75a-f9a4-3b8d3c4d2ff4.jpeg)

```sql:
CREATE TABLE `parent_cirno` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(45) DEFAULT NULL,
 `dtype` varchar(45) NOT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

CREATE TABLE `child_cirno` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `value` varchar(45) DEFAULT NULL,
 PRIMARY KEY (`id`),
 KEY `child_cirno_fk_idx` (`id`),
 CONSTRAINT `child_cirno_fk` FOREIGN KEY (`id`) REFERENCES `parent_cirno` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 ParentCirno parentCirno = new ParentCirno();
 parentCirno.setName("parent name");

 this.em.persist(parentCirno);

 ChildCirno childCirno = new ChildCirno();
 childCirno.setName("child name");
 childCirno.setValue("child value");

 this.em.persist(childCirno);
```

実行後のデータベースの様子。

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/549978f8-4cad-cdea-8a70-98e0ad1e303e.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/4133f4dd-b65c-9f87-c6d2-cce4aa497bbc.jpeg)

- ルートのエンティティを `@Inheritance` でアノテートし、 `strategy` に `InheritanceType.JOINED` を指定する。
 - デフォルトは、 `InheritanceType.SINGLE_TABLE` を指定したのと同じになる。
- すると、クラス階層上の各エンティティを、それぞれ個別のテーブルにマッピングすることができる。
- 各テーブルは、 PK を外部参照制約で紐付ける。
- ルートのテーブルには、クラスを特定するための `dtype` カラムを定義する。
 - こちらも `@DiscriminatorColumn` アノテーションを使って変更することができる。

### メリット
- 項目に NOT NULL 制約を設けることができる（`SINGLE_TABLE` と比べた場合の話）。
- データが正規化される。

### デメリット
- サブクラスのエンティティを取得するには、テーブルの結合が必要になる。

## エンティティごとに独立したテーブルにマッピングする
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/551d60da-2aa4-04e1-698f-a206a96a9863.jpeg)

```java:ParentHongMeiling.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;

@Entity
@Table(name = "parent_hong_meiling")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class ParentHongMeiling {
 @Id
 private Long id;

 private String name;

 public void setName(String name) {
 this.name = name;
 }
}
```

```java:ChildHongMeiling.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Table;

@Entity
@Table(name = "child_hong_meiling")
public class ChildHongMeiling extends ParentHongMeiling {
 private String value;

 public void setValue(String value) {
 this.value = value;
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/d6361fd0-79d1-10ea-cce4-acf164adefeb.jpeg)

```sql:
CREATE TABLE `parent_hong_meiling` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(45) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

CREATE TABLE `child_hong_meiling` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(45) DEFAULT NULL,
 `value` varchar(45) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 ParentHongMeiling parentHongMeiling = new ParentHongMeiling();
 parentHongMeiling.setName("parent name");

 this.em.persist(parentHongMeiling);

 ChildHongMeiling childHongMeiling = new ChildHongMeiling();
 childHongMeiling.setName("child name");
 childHongMeiling.setValue("child value");

 this.em.persist(childHongMeiling);
```

実行後のデータベースの状態。

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/071b379f-09fd-7931-0eab-dfecdb526401.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/727aa0ca-2dc0-0188-d685-56c9618fdef9.jpeg)

- `@Inheritance` で `InheritanceType.TABLE_PER_CLASS` を指定することで、各エンティティをそれぞれ独立したテーブルにマッピングできる。

### メリット
- `SINGLE_TABLE` と同様で、単一のエンティティの検索でテーブルの JOIN が発生することはない。

### デメリット
- データが正規化されていない。
- 多態を利用したフィールドがあった場合、データの読み込みで複数回のデータベースアクセスが発生する可能性がある。
 - 例えば、 `List<ParentHongMeiling>` という型のフィールドがあった場合、リストの中身は実は `ParentHongMeiling` と `ChildHongMeiling` のインスタンスが入り乱れて入っている可能性があり得る。
 - その場合、 `parent_hong_meiling` と `child_hong_meiling` のテーブルにそれぞれ検索しにいかなければならない。
 - `UNION` が使えればいいが、サポートしていないデータベースも存在する。
- このマッピング方法は、オプションらしい（実装されていなくても JPA の仕様的にはかまわない）。

# その他
## マッピングのためだけのスーパークラスを定義する
**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/98849656-2247-8458-4a75-a4294c629c9c.jpeg)

```java:MappedKoakuma.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Id;
import javax.persistence.MappedSuperclass;

@MappedSuperclass
public class MappedKoakuma {
 @Id
 private Long id;

 private String name;

 public void setName(String name) {
 this.name = name;
 }
}
```

```java:Koakuma.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;

@Entity
public class Koakuma extends MappedKoakuma {

 private String value;

 public void setValue(String value) {
 this.value = value;
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/e0719886-dc23-5aa9-5934-4549ffc70322.jpeg)

```sql:
CREATE TABLE `koakuma` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(45) DEFAULT NULL,
 `value` varchar(45) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 Koakuma koakuma = new Koakuma();
 koakuma.setName("name");
 koakuma.setValue("value");

 this.em.persist(koakuma);
```

実行後のデータベースの様子。

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/38642d66-b23a-4d95-cffb-ae2916c8aa8c.jpeg)

- `@MappedSuperclass` でクラスをアノテートすると、そのクラスはエンティティとしては扱われず、マッピングの定義だけが有効になる。
- 既存の実装で共通項目が親クラスに定義されているけど、そのクラスは永続化する必要がない、という場合に使えると思われる。
- 新規に作るのであれば、共通項目は継承関係で解決するよりも組み込み可能クラスを利用して依存関係で解決した方がいいと思う。


## Entity Graph で関連するエンティティの読み込みを制御する
関連するエンティティをどのタイミングでロードするかどうかは、これまではフィールド単位に静的にしか指定できなかった（即時ロードと遅延ロード）。
つまり、ある検索のときは即時ロードしたいけど、別の検索のときは遅延ロードにしたい、という細かい制御はできなかった。

しかし、 JPA 2.1 で追加された Entity Graph を使えば、この制御ができるようになる。

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/200872e6-6824-8366-993d-b93456b9e21b.jpeg)

```java:IzayoiSakuya.java
package sample.javaee.jpa.entity.mapping;

import java.util.List;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.NamedAttributeNode;
import javax.persistence.NamedEntityGraph;
import javax.persistence.Table;

@Entity
@Table(name = "izayoi_sakuya")
@NamedEntityGraph(
 name = "IzayoiSakuya.remiliaScarletList",
 attributeNodes = @NamedAttributeNode("remiliaScarletList")
)
public class IzayoiSakuya {
 @Id
 private Long id;
 @JoinColumn(name = "izayoi_sakuya_id")
 private List<RemiliaScarlet> remiliaScarletList;
 @JoinColumn(name = "izayoi_sakuya_id")
 private List<FrandreScarlet> frandreScarletList;

 @Override
 public String toString() {
 return "IzayoiSakuya{" + "id=" + id + ", remiliaScarletList=" + remiliaScarletList + ", frandreScarletList=" + frandreScarletList + '}';
 }
}
```

```java:RemiliaScarlet.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "remilia_scarlet")
public class RemiliaScarlet {
 @Id
 private Long id;

 @Override
 public String toString() {
 return "RemiliaScarlet{" + "id=" + id + '}';
 }
}
```

```java:FrandreScarlet.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "frandre_scarlet")
public class FrandreScarlet {
 @Id
 private Long id;

 @Override
 public String toString() {
 return "FrandreScarlet{" + "id=" + id + '}';
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/db232921-d5d4-843e-d11a-56ee2eab277f.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/dc889ee9-bfae-3668-be89-7796aa37b4cd.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/0c3d56c8-2e99-3bda-66e7-3ef3b38f3482.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/6421ca04-b540-535d-27fb-5cd48ca47130.jpeg)

```sql:
CREATE TABLE `izayoi_sakuya` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `frandre_scarlet` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `izayoi_sakuya_id` int(11) NOT NULL,
 PRIMARY KEY (`id`),
 KEY `frandre_scarlet_fk_idx` (`izayoi_sakuya_id`),
 CONSTRAINT `frandre_scarlet_fk` FOREIGN KEY (`izayoi_sakuya_id`) REFERENCES `izayoi_sakuya` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

CREATE TABLE `remilia_scarlet` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `izayoi_sakuya_id` int(11) NOT NULL,
 PRIMARY KEY (`id`),
 KEY `remilia_scarlet_fk_idx` (`izayoi_sakuya_id`),
 CONSTRAINT `remilia_scarlet_fk` FOREIGN KEY (`izayoi_sakuya_id`) REFERENCES `izayoi_sakuya` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 // デフォルト
 IzayoiSakuya izayoiSakuya = this.em.find(IzayoiSakuya.class, 1L);
 System.out.println(izayoiSakuya);

 // Entity Graph を指定
 EntityGraph graph = this.em.getEntityGraph("IzayoiSakuya.remiliaScarletList");

 Map<String, Object> hint = new HashMap<>();
 hint.put("javax.persistence.fetchgraph", graph);

 izayoiSakuya = this.em.find(IzayoiSakuya.class, 2L, hint);
 System.out.println(izayoiSakuya);
```

```text:GlassFishコンソール出力
情報: IzayoiSakuya{id=1, remiliaScarletList={IndirectList: not instantiated}, frandreScarletList={IndirectList: not instantiated}}
情報: IzayoiSakuya{id=2, remiliaScarletList={[RemiliaScarlet{id=4}, RemiliaScarlet{id=5}]}, frandreScarletList={IndirectList: not instantiated}}
```

- `@NamedEntityGraph` アノテーションをエンティティに設定することで、 Entity Graph を静的に定義できる。
- `name` 属性で Entity Graph の名前を、 `attributeNodes` 属性で即時ロードするフィールドを指定する。
- Entity Graph を使うかどうかは、 `EntityManager.find()` の最後に Map を渡すことで指定できる。
 - Entity Graph は、 `EntityManager#getEntityGraph(String)` を使って取得できる。
 - キーに `javax.persistence.fetchgraph` を、値に Entity Graph を設定した Map を、 `find()` メソッドに渡す。
 - `javax.persistence.loadgraph` っていうのも指定できるみたいだけど、 `fetchgraph` との違いがよく分からなかった。。。
- Entity Graph を指定したときだけ、 `attributeNodes` で設定したフィールドが即時ロードされる。
- `subgraphs` 属性を指定すれば、さらに掘り下げて読み込み方を指定することができる。

### Entity Graph を動的に作成する
```java:MappingEjb.java
 EntityGraph dynamicGraph = this.em.createEntityGraph(IzayoiSakuya.class);
 dynamicGraph.addAttributeNodes("frandreScarletList");

 hint = new HashMap<>();
 hint.put("javax.persistence.fetchgraph", dynamicGraph);

 izayoiSakuya = this.em.find(IzayoiSakuya.class, 3L, hint);
 System.out.println(izayoiSakuya);
```

```text:GlassFishコンソール出力
情報: IzayoiSakuya{id=3, remiliaScarletList={IndirectList: not instantiated}, frandreScarletList={[FrandreScarlet{id=6}, FrandreScarlet{id=7}]}}
```

- `EntityManager#createEntityGraph(Class)` で、 Entity Graph を動的に作成することができる。

## コンバーターを使用する
JPA 2.1 で、コンバーターという仕組みが追加された。

コンバーターを使えば、データベースとのマッピングを自由に実装することができる。

**エンティティ**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/e345a298-dbcd-ad8d-e984-dc020318f04f.jpeg)

```java:LettyWhiterock.java
package sample.javaee.jpa.entity.mapping;

import javax.persistence.Convert;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import sample.javaee.jpa.converter.LettyWhiterockConverter;

@Entity
@Table(name = "letty_whiterock")
public class LettyWhiterock {
 @Id
 private Long id;

 @Convert(converter = LettyWhiterockConverter.class)
 private String value;

 @Override
 public String toString() {
 return "LettyWhiterock{" + "id=" + id + ", value=" + value + '}';
 }
}
```

**コンバーター**

```java:LettyWhiterockConverter.java
package sample.javaee.jpa.converter;

import java.util.Objects;
import javax.persistence.AttributeConverter;
import javax.persistence.Converter;

@Converter
public class LettyWhiterockConverter implements AttributeConverter<String, Integer>{

 @Override
 public Integer convertToDatabaseColumn(String attribute) {
 return "hoge".equals(attribute) ? 1 : 0;
 }

 @Override
 public String convertToEntityAttribute(Integer dbData) {
 return Objects.equals(dbData, 1) ? "hoge" : "fuga";
 }
}
```

**データベース**

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/d3531aa5-e7ec-c9d8-a19a-4dfdf608fc31.jpeg)

![javaee-jpa.JPG](https://qiita-image-store.s3.amazonaws.com/0/28302/e4f25629-ed8c-1d86-3338-301cb0f0efe7.jpeg)

```sql:
CREATE TABLE `letty_whiterock` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `value` int(11) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
```

**動作確認**

```java:MappingEjb.java
 LettyWhiterock lettyWhiterock = this.em.find(LettyWhiterock.class, 1L);
 System.out.println(lettyWhiterock);
```

```text:GlassFishコンソール出力
情報: LettyWhiterock{id=1, value=hoge}
```

- `AttributeConverter` インターフェースを実装することで、コンバーターを作成することができる。
 - `convertToDatabaseColumn()` メソッドで「Java → データベース」の変換を実装する。
 - `convertToEntityAttribute()` メソッドで「データベース → Java」の変換を実装する。
- `@Converter` でアノテートすることで、 JavaEE サーバーが自動でそのクラスをコンバーターとして認識してくれる。
- コンバーターを使用するときは、フィールドを `@Convert` でアノテートして、 `converter` 属性でコンバーターの Class を指定する。
- `@Converter` アノテーションの `autoApply` 属性に `true` を設定すると、 `@Convet` でアノテートしなくてもフィールドの型から推測して自動でコンバーターが適用されるようになる（`Integer` など基本的な型にも適用されるので、独自の型以外では使わない方がいい）。


# 参考
- [Amazon.co.jp： Beginning Java EE 6 GlassFish 3で始めるエンタープライズJava (Programmer’s SELECTION): Antonio Goncalves, 日本オラクル株式会社, 株式会社プロシステムエルオーシー: 本][]
- [Amazon.co.jp： Enterprise JavaBeans 3.1 第6版: Andrew Lee Rubinger, Bill Burke, 佐藤 直生, 木下 哲也: 本][]
- [Java Persistence/ElementCollection - Wikibooks, open books for an open world][]
- [web用語辞典 - インピーダンス・ミスマッチ][]
- [東方Projectの登場人物 - Wikipedia][]
- [Forward Everyday: JPA 2.1: Entity Graph][]
- [Thoughts on Java: JPA 2.1 Entity Graph - Part 1: Named entity graphs][]
- [Get current JTA transaction status from CMT EJB « Piotr Nowicki's Homepage](http://piotrnowicki.com/2011/09/get-current-jta-transaction-status-from-cmt-ejb/)
- [Java Persistence/What is new in JPA 2.1? - Wikibooks, open books for an open world][]
- [JavaEE 7 JPA 2.1の新機能コンバータ - しんさんの出張所　はてな編][]

[JavaEE 7 JPA 2.1の新機能コンバータ - しんさんの出張所　はてな編]: http://d.hatena.ne.jp/shin/20130627/p1
[Java Persistence/What is new in JPA 2.1? - Wikibooks, open books for an open world]: http://en.wikibooks.org/wiki/Java_Persistence/What_is_new_in_JPA_2.1%3F
[Thoughts on Java: JPA 2.1 Entity Graph - Part 1: Named entity graphs]: http://www.thoughts-on-java.org/2014/03/jpa-21-entity-graph-part-1-named-entity.html
[Forward Everyday: JPA 2.1: Entity Graph]: http://hantsy.blogspot.jp/2013/12/jpa-21-entity-graph.html
[Amazon.co.jp： Enterprise JavaBeans 3.1 第6版: Andrew Lee Rubinger, Bill Burke, 佐藤 直生, 木下 哲也: 本]: http://www.amazon.co.jp/Enterprise-JavaBeans-3-1-Andrew-Rubinger/dp/4873115086/ref=sr_1_1?s=books&ie=UTF8&qid=1423309914&sr=1-1&keywords=enterprise+javabeans+3.1
[Amazon.co.jp： Beginning Java EE 6 GlassFish 3で始めるエンタープライズJava (Programmer’s SELECTION): Antonio Goncalves, 日本オラクル株式会社, 株式会社プロシステムエルオーシー: 本]: http://www.amazon.co.jp/Beginning-GlassFish-3%E3%81%A7%E5%A7%8B%E3%82%81%E3%82%8B%E3%82%A8%E3%83%B3%E3%82%BF%E3%83%BC%E3%83%97%E3%83%A9%E3%82%A4%E3%82%BAJava-Programmer%E2%80%99s-SELECTION/dp/4798124605
[東方Projectの登場人物 - Wikipedia]: http://ja.wikipedia.org/wiki/%E6%9D%B1%E6%96%B9Project%E3%81%AE%E7%99%BB%E5%A0%B4%E4%BA%BA%E7%89%A9
[web用語辞典 - インピーダンス・ミスマッチ]: http://www23.atwiki.jp/sevenlives/pages/903.html
[Java Persistence/ElementCollection - Wikibooks, open books for an open world]: http://en.wikibooks.org/wiki/Java_Persistence/ElementCollection