JPAのデザインパターンとライフサイクル



# はじめに

最近、「JPAの事実と誤解」という講義を聴講し、その内容を自分なりに整理しております。

- 機械翻訳を通じて作成しているため、誤字脱字があるかもしれません


# JPAの基盤となる3つのパターン

前回の記事では、JPAがどのような場合に適切な選択肢であり、どのような設計を持っているのかを簡単に見てまいりました。

改めてこれを簡単に整理しながら、JPAがどのように構成されているのかを確認いたします。

以下の例では、JPAの実装体としてHibernateを使用いたします。


https://qiita.com/haroya01/items/fbb47ffe91f30431e29a

### Data Mapper Pattern

- ドメインオブジェクトとデータベース間のデータを変換し、送信する役割を果たします

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/ba537bd9-609e-43d9-ba94-d6a14a9dfcbb.png)

これはJPAにおけるRepository層（Repository Layer）を通して実装されます。

https://docs.spring.io/spring-framework/docs/6.1.0/javadoc-api/org/springframework/stereotype/Repository.html

Springでは特に`@Repository`というアノテーションを提供しており、その背景についても説明されています。

> Indicates that an annotated class is a "Repository", originally defined by Domain-Driven Design (Evans, 2003) as "a mechanism for encapsulating storage, retrieval, and search behavior which emulates a collection of objects".

- この概念はDomain-Driven Design（DDD）を通じて登場しました
- オブジェクトのコレクション（Collection）を模倣する保存、取得、および検索動作をカプセル化するメカニズムを提供いたします
    - カプセル化とは、保存、取得、検索などの内部動作を隠蔽し、Javaのメモリ上で管理することを意味します（例：List、Setなど）

通常、Springでは次のように`@Repository`を通じて該当部分を定義いたします。


```java
@Entity
public class User {
    @Id
    private Long id;
    private String name;
```
次のようにUserがある場合

```java
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // 名前でユーザーを検索するカスタムメソッド
    List<User> findByName(String name);
}
```
次のように定義いたします。

データベース（DB）にどのようにアクセスするのか、どのようなSQL文（SQL statement）を作成したのか、また、データベースから取得したデータをJavaのメモリ上のオブジェクトにどのようにマッピングするのか、全く知りません。

全てがカプセル化されているためです。

ここまでが、Data Mapper PatternがJPAに適用された例でございました。

:::note info
### DAO vs Repository
この2つの違いは混同される可能性があります。  
コメントでは次のように説明されています。

> Teams implementing traditional Jakarta EE patterns such as "Data Access Object" may also apply this stereotype to DAO classes, though care should be taken to understand the distinction between Data Access Object and DDD-style repositories before doing so. This annotation is a general-purpose stereotype and individual teams may narrow their semantics and use as appropriate.

- 従来のJakarta EEパターン（例：Data Access Object, DAO）を使用する場合でも、`@Repository`を付与しても問題ありません

- しかし、DAOとドメイン駆動設計（DDD）スタイルのリポジトリ（Repository）は概念上の違いがございますので、これらを十分に区別した上で使用する必要がございます

### Repository
- Repositoryはドメインモデルの観点から保存、取得、検索機能を抽象化し、アプリケーションアーキテクチャにおける役割を明確にいたします

```java
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByName(String name);
}
```
以前に説明した通り、すべてがカプセル化されております。

### DAO
- DAOは、データベースとの具体的な技術的相互作用（SQLなど）に焦点を合わせます

```java
@Commpont
public class UserDao {

    private final JdbcTemplate jdbcTemplate;

    public UserDao(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public List<User> findByName(String name) {
        String sql = "SELECT id, name FROM users WHERE name = ?";
        return jdbcTemplate.query(sql, new Object[]{name}, new RowMapper<User>() {
            @Override
            public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                User user = new User();
                user.setId(rs.getLong("id"));
                user.setName(rs.getString("name"));
                return user;
            }
        });
    }
}
```
DBへのアクセスから呼び出し、Javaのメモリ（オブジェクト）へのマッピングまで、すべてが露出しております。

これがDAOとRepositoryの違いと言えます。
:::

### Identity Map

- これは、同一のデータベース内のデータが重複してロードされるのを防ぐという概念です

データベース上では同じデータでも、  
Javaのメモリ上では異なるオブジェクトとなります。

例えば、DBのuser_id = 1でuser_name = "haroya"というデータがあったとしても

```java
User user1 = userDao.findById(1);  // DBから取得（新しいオブジェクトを生成）
User user2 = userDao.findById(1);  // 再びDBから取得（また別のオブジェクトを生成）
assert user1 != user2;  // 異なるオブジェクトインスタンス
```
Javaのメモリ上では別々のオブジェクトとして扱われます。

しかし、JPAはIdentity Map（アイデンティティマップ）を適用することにより、基本的に同一のデータは同一のオブジェクトとして扱うことを保証しております。

```java
User user1 = userMapper.findById(1);  // DBから取得
User user2 = userMapper.findById(1);  // DBを照会せず、キャッシュされたオブジェクトを返す
assert user1 == user2;  // 同一のオブジェクトインスタンス
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/68dba905-5453-4106-949e-30c9e4496b3b.png)

下記のように一次キャッシュ（First-Level Cache）で管理されると説明されており、実装体は

`package org.hibernate.engine.internal.StatefulPersistenceContext`に定義されております。


![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/fae7edc0-1668-42e0-9b1c-846dcb9f6b75.png)

以下のようにキーに基づいて定義されます。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/c5df5544-2303-435d-af91-d5a1eb183123.png)

そして、そのキーはエンティティのIDそのものです。

```java
@Entity
public class User {
    @Id
    private Long id;
    private String name;
```
もしUserオブジェクトが以前のように存在しており、  
IDが1であれば、それは同一のオブジェクトとして扱われます。  
そして、もしそれが一次キャッシュ（保存されたマップ、正確には永続性コンテキスト）に存在している場合、該当するオブジェクトが返されるということです。

非常に簡単に図示すると、

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/4a48fcc3-ef4e-4e3f-96cd-4ebc08d1d6ad.png)

次のようにEntityKeyにより、どのオブジェクトかを管理します。

:::note info
### Identity Map (Map<EntityKey, EntityHolderImpl>)の構成 

#### Key: EntityKey(User, 1)
  - Type: User
  - Identifier: 1

#### Value: EntityHolderImpl
  - entityKey: EntityKey(User, 1)
  - descriptor: EntityPersister（Userのマッピング情報）
  - entity: 実際のUserインスタンス
  - proxy: プロキシオブジェクト（遅延読み込み時）
  - entityEntry: エンティティの状態およびメタデータ
  - entityInitializer: 遅延読み込み初期化用オブジェクト
  - state: EntityHolderState（例：MANAGED）

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/92e4f089-4a9f-48c5-93ea-57a9553a46f5.png)
:::


#### 1次キャッシュのフロー

次のように、findByIdでUserオブジェクトを取得するように呼び出した場合

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/b40c7509-177f-4aeb-ad67-ea8d3201f195.png)

まず、Identity Mapを確認し、存在しなければDBに問い合わせを行います。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/3dc71329-ef00-4677-a547-4b38d63bb39d.png)

その後、次のように返却されます。

以降、同一セッション内でリクエストが発生した場合は、Identity Mapにキャッシュされたデータが返却されます。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/b62e3839-6695-480f-bd7a-f708a9cd5cdc.png)

これにより、以下のような利点が得られます。

- **DB呼び出しの最小化**: 同一エンティティを再度取得する際にキャッシュ済みのオブジェクトを利用することで、不要なデータベースクエリを削減します
- **データ整合性の維持**: 同一エンティティに対して同一のインスタンスを再利用することで、データ状態の一貫性が保証されます
- **パフォーマンスの向上**: DBアクセスの回数を減らすことで、アプリケーション全体のパフォーマンスが向上します

:::note warn
Identity Mapの詳細な構造は、以降の図面では省略いたします。
:::


### Unit of Work

- アプリケーション内でドメインオブジェクトの変更履歴を追跡いたします

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/062e5ffd-532c-4172-9d6c-ec919179cf5c.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/fbd8b4d4-0103-4eaf-ac1c-c78f41de6e41.png)

新しいオブジェクトが検出されると、元のコピー（snapshotオブジェクト）を作成いたします。

図で表すと、次のようになります。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/11ef9a2a-1c15-43af-ad3c-4b48627c548f.png)

以下のようにコピーされます。  
たとえ内部の値が変更されたとしても、

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/64a5f36e-0600-477c-8c39-934f578c96f7.png)

もし`flush();`で変更内容をDBに反映しようとする場合、

IDを通じて同じデータであるかを確認し、最適化されたクエリによりDBに反映いたします。  
これは`org.hibernate.internal.SessionImpl`で確認することが可能です。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/951cd23e-d90d-47eb-becc-e4a223acc251.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/12673088-95e0-41c2-9a23-dbb589aec345.png)

このメカニズムに関する詳細な説明は、以前の記事にてご参照いただければと存じます。

https://qiita.com/haroya01/items/e2fbb38a90a686855b06

### transactionとUnit of Work（作業単位）

一般的にJPA（またはHibernate）を使用する際は、トランザクションの範囲の設定が非常に重要です。  
JPAで言う**「作業単位 (Unit of Work)」**とは、エンティティの生成、修正、削除といった一連の操作を一つの論理的なグループとしてまとめて処理することを意味いたします。

この作業単位は通常、データベーストランザクションと同じ範囲に設定する必要があり、これによりデータの整合性と一貫性が維持されます。

```java
 @Transactional
    public Student registerStudent(String name) {
        Student student = new Student();
        student.setName(name);
        studentRepository.save(student); 
        return student;
    }
```

- Springでは、`@Transactional`アノテーションを用いて作業単位を定義し、データベースのライフサイクルとJPAのエンティティライフサイクル（Transient、Managed、Detached、Removed）を一致させることが可能です

# JPAの4つの状態（ライフサイクル）

先ほどの内容を通じて、Persistence Context（永続性コンテキスト）がどのように構成されているかを把握いたしました。

今回は、オブジェクトの4つの状態について整理してまいります。

大まかな流れは以下の通りです。


![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/fcd05bd5-3bcf-46d3-9918-e2ac2381291e.png)

テストに使用するStudentエンティティは、次の通りです。

```java
@Entity
public class Student {

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

    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

```
:::note info
### Jpaのエンティティとは？ DDDのエンティティと同じでしょうか？
- 結論として、同じではありません
- `@Entity`がValue Objectのように使われる場合もあれば、エンティティとして使われる場合もあります
- 単に`@Entity`は、データベースのテーブルやカラムにどのオブジェクトをマッピングするかを定義する技術的な部分に過ぎません
:::

## Transient

- 非永続状態（Transient）は、`new`キーワードで生成されたオブジェクトを指します

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/6026a7c0-2df3-40ac-9ad6-7fa42cf054e2.png)

以下のように考えることができます。  
用語が付いているだけで、通常定義しているJavaオブジェクト（Object）です。  
これらは後にヒープメモリが解放されると、ガベージコレクターによって回収されるオブジェクトとなります。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/04d18f4e-7a9a-49c4-b84d-f000725f4fa0.png)

非永続オブジェクトは、永続性コンテキストが管理する永続状態（Persistent）を作り出すことが可能です。


## Persistence

- 永続状態（Persistent）とは、Identity MapにオブジェクトのIDを登録し、永続性コンテキスト（Persistence Context）が管理する状態を指します

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/2aa04b6f-2605-452f-9aed-3f8b0c8f8015.png)

大きく2種類ございます。

1. Transient（非永続状態）のオブジェクトを永続状態に登録する
2. `find();`を使用して一次キャッシュやDBからデータを取得する

### Transient（非永続状態）のオブジェクトを永続状態に登録する

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/7d8a08ce-d830-48d4-8ccb-c335fb305b8c.png)

`new`で生成した非永続オブジェクトを永続状態（永続性コンテキストで管理）に登録する方法がございます。

テストコードは以下のようになっております。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/a2af0ecb-6c68-4415-88b3-d0564bfcb688.png)

ところで、該当のテストコードのログを確認すると、以下のようになっております。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/5589b2b1-a191-4907-a246-2e9dc2bfd07d.png)

あれ？なぜクエリが発生したのでしょうか？  
それは、永続性コンテキストに登録する（Identity Mapに格納する）ためには必ずIDが必要となるからです。


## 永続状態で管理するためには必ず識別子 @ID が必要です

永続性コンテキストがエンティティを管理するためには、必ず識別子（@Id）の値が必要となります。

したがって、
`@GeneratedValue(strategy = GenerationType.IDENTITY)` の戦略の場合、次のようにクエリが発生します。

### IDENTITY戦略のクエリ発生 
```java
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id
```
IDENTITY戦略は、基本的にデータベースにIDの生成を委譲するため、INSERTクエリが発生いたします。

```markdown
[永続性コンテキスト]
┌───────────────────────────────────────────────┐
│                                               │
│  [1次キャッシュ]                                │
│  ┌─────────────────┐                          │
│  │                 │                          │
│  │  @Id | Entity   │                          │
│  │  (空)          │                          │
│  │                 │                          │
│  └─────────────────┘                          │
│                                               │                     
│                                               │
└───────────────────────────────────────────────┘
```

次のように1次キャッシュが空の場合、

```markdown
[永続性コンテキスト]
┌───────────────────────────────────────────────┐
│                                               │
│  [1次キャッシュ]                              │
│  ┌─────────────────┐                         │
│  │                 │                         │
│  │  @Id | Entity   │                         │
│  │   1  | User     │ ← DBから取得したIDが割り当てられる │
│  │                 │                         │
│  └─────────────────┘                         │
│                                               │
│  [書き込み遅延SQLストア]                      │
│  ┌─────────────────┐                         │
│  │                 │                         │
│  │  INSERT SQL     │                         │
│  │  即時実行       │ ← すぐにDBにSQLが実行される       │
│  │                 │                         │
│  └─────────────────┘                         │
│                                               │
└───────────────────────────────────────────────┘
```

データベースにINSERTクエリが発生し、直ちに該当のIDをキーとして使用いたします。

これに関して、公式ドキュメントには以下のように記載されております。

:::note warn
### IDENTITY 戦略の注意点 
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/31fc77a6-4ca5-427d-9ea1-10dfd2a98245.png)

- **問題点 1: Extended Persistence Context の問題**

  IDENTITY カラムは、エンティティが実際にデータベースに挿入されるまで識別子の値が決定されません。  
  そのため、長期間にわたって複数のエンティティを管理する Extended Persistence Context（拡張永続性コンテキスト）の場合、挿入タイミングに制約が生じ、状態管理に問題が発生する可能性がございます。

- **問題点 2: バッチ INSERT 処理が不可能**

  IDENTITY 戦略を使用すると、各エンティティの挿入ごとに識別子生成が必要となるため、Hibernateは複数のINSERT文を一度にバッチ処理することができません。  
  その結果、大量のエンティティを一括挿入する際、パフォーマンス向上の効果を得にくくなります。
:::


それでは、他の生成戦略はどうでしょうか？

### GenerationTypeの戦略種類

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/a416af3e-9b3a-488e-b2bd-2d112d774597.png)

基本的には、以下のような戦略がございます。

#### 識別子生成戦略別のSQL実行タイミング

各識別子生成戦略ごとのSQL実行タイミングは以下の通りです。


| 生成戦略   | 識別子生成クエリ          | 識別子生成時点      | INSERTクエリ        | 書き込み遅延サポート |
|------------|---------------------------|---------------------|---------------------|----------------------|
| IDENTITY   | INSERT                    | persist() 即時      | persist() 即時      | ❌                   |
| SEQUENCE   | SELECT NEXT VALUE         | persist() 即時      | commit 時点         | ⭕                   |
| TABLE      | SELECT & UPDATE           | persist() 即時      | commit 時点         | ⭕                   |
| UUID       | なし（アプリケーション）  | persist() 即時      | commit 時点         | ⭕                   |
| AUTO       | 方言により決定            | 方言により決定      | 方言により決定      | -                    |



### SEQUENCE 戦略のクエリ発生

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/f20efb0b-7ab0-4e10-bfe2-819f8a94c0bc.png)

このようにシーケンス戦略を設定し、テストを実行すると、

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/f39dd455-9344-45ca-8f17-8e600a9d7e73.png)

以下のようになります。

```sql
 next value for student_seq
 ```
 クエリが発生することを確認できます。

1. 永続性コンテキストは、Studentエンティティを管理するために識別子が必要です。
2. @SequenceGeneratorに指定された "STUDENT_SEQ" から次の値を取得します。  
   -> SQL: `select next value for STUDENT_SEQ`
3. 取得した識別子の値をStudentエンティティに割り当てます。
4. Studentエンティティを永続性コンテキストの1次キャッシュに保存します。
5. INSERT SQLは書き込み遅延ストアに保持されます。

### UUID 戦略のクエリ発生
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/8f7c1bef-c0c4-4c45-842d-3fd8ae77cdeb.png)
 
このようにUUID戦略を使用する場合、どのタイミングでクエリが発生するでしょうか？

そのいかなるクエリも発生しません。  
なぜなら、識別子（@Id）はUUIDとしてアプリケーション側で生成されるためです。

### Table 戦略のクエリ発生


![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/52d28446-ae86-4e16-bf5f-23801ab52e94.png)

以下のように記述し、テストを実行すると、

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/6a4a211d-d015-48c5-ab62-cf1f32540d6c.png)

以下のようなクエリが発生することが確認できます。


```sql
select tbl.GEN_VAL 
from id_gen tbl 
where tbl.GEN_NAME=? for update
```
1. id_gen テーブルから、特定の GEN_NAME を持つ行の現在の識別子値（GEN_VAL）を読み込みます。  
   同時に、`for update` を使用してこの行に対してロックをかけます。

```sql
update id_gen 
set GEN_VAL=?  
where GEN_VAL=? 
  and GEN_NAME=?
```
2. 先に読み込んだ値を元に、新しい識別子値へ更新します。

#### Table 戦略の問題点

ここで、Table 戦略の問題点を把握することができます。

直接値を読み込み、更新する過程でロックが使用されます。  
そのため、同時実行性が高い環境ではロック競合および追加のデータベース呼び出しが発生し、パフォーマンス低下につながる可能性がございます。

公式ドキュメントにも、以下のように説明されています。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/dd40a9e2-0f26-4584-a539-a36a1d7b3652.png)

- TABLE ジェネレータは、複数のデータベースで同一に使用できるという利点（移植性）がありますが、実際には識別子値を生成するために別のテーブルを使用します
- この別テーブルから次の識別子値を取得するために、別のトランザクションを実行し、そのテーブルの特定の行に対して **行レベルロック（row-level lock）** をかける必要があります

これらの理由から、Table 戦略は十分に注意して使用する必要がございます。

### では、直接IDを指定するとどうなるでしょうか？

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/00e961de-41b3-4dbb-b922-a2262e46497b.png)

このように、何らかの方法で`@Id`（識別子）を付与するだけで、

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/0155aad8-dd0c-4a03-9a64-bb1638ee502b.png)

どのようなクエリも発生しません。

:::note info
### 生成戦略によるクエリ発生の整理 
- 永続状態にするためには、Identity Mapで識別するための`@Id`（識別子）が必要です
- 識別子がデータベース依存の方式であれば、DBにクエリが発生し、
- アプリケーション依存の方式であれば、クエリは発生しません
:::


### Id (キー)生成戦略 

#### 代理キー (Surrogate Key) vs 自然キー (Natural Key)
- **代理キー (Surrogate Key)** : ビジネス上の意味を持たない識別子  
    - 下記のテーブル構造において、`id` は学生の意味とは全く関係がありません
    
    ```java
    @Entity
    public class Student {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY) 
        private Long id;
        
        private String name;
    }
    ```

- **自然キー (Natural Key)** : ビジネス上の意味を持つ識別子  
    - 下記のテーブル構造において、`studentNumber` はビジネス上の意味を持っています

```java
```java
@Entity
public class Student {

    @Id
    @NaturalId  // Hibernateでは自然キーとして認識
    @Column(name = "student_number", nullable = false, unique = true)
    private Long studentNumber;
```
:::note info
### 代理キーを使用すべき理由
- ビジネス（ドメイン）は常に変化しうるためです
- もし自然キーが複雑な場合、インデックス作成などデータベース側の問題に柔軟に対応できなくなります

このような理由から、代理キーを使用することが望ましいと考えられます。
:::

#### 単純キー (Simple Key) と複合キー (Compound Key)
- **単純キー (Simple Key)**: 識別子が1つの場合
```java
@Entity
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    private Long id;
```
- **複合キー (Compound Key)**: 識別子が複数の場合

```java
@Entity
@IdClass(StudentId.class)
public class Student {

    @Id
    private String department;    // 例: 学科コード

    @Id
    private String studentNumber;   // 例: 学籍番号
```
:::note info
### 単純キーを複合キーより好む理由
- ビジネス（ドメイン）は常に変更される可能性があります
- エンティティ間の関係設定の観点でも、単純キーの方が一貫性があり、直感的に管理できます

このような理由から、単純キーを好むと考えられます。
:::

#### 生成キー (Generated Key) vs 割り当てキー (Assigned Key)
- **生成キー (Generated Key)**: JPAまたはDBが生成するキー  
  ```java
  @Entity
  public class Student {

      // データベースが自動的に生成するキー（例：auto-increment）
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
  }
```
- **割り当てキー (Assigned Key)**: アプリケーションまたはドメインロジックにより直接割り当てられるキー

```java
@Entity
public class Student {
    // アプリケーションで直接割り当てるキー（例: 学籍番号）
    @Id
    @NaturalId // Hibernateでは自然キーとしても使用
    @Column(name = "student_number", nullable = false, unique = true)
    private Long studentNumber;
```

:::note info
### 生成キーを好む理由
- 管理や安定性の観点から、生成キー方式は直感的です
- ビジネス（ドメイン）は常に変更される可能性があるためです

このような理由から、生成キー方式が優れていると考えられます。
:::


### find(); を使用して 1次キャッシュとDBからデータを取得する

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/91fc7dca-56cc-4816-8de7-56733aeee19b.png)

`find();` を使用して、DBからデータを取得し、1次キャッシュに保持する方法があります。

動作は次の通りです。

1. 1次キャッシュ（Identity Map）に対象のオブジェクトが存在するかを確認します

   ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/9328b4f1-bc7d-4c2d-9c88-89575ecf0b46.png)
   
   存在すれば、そのオブジェクトを返却します。

   :::note info
   1次キャッシュのこの動作により、作業範囲（トランザクション）内では識別子の同一性に応じて同一のオブジェクトが返却されることが保証されます。  
   また、1次キャッシュにオブジェクトが既に存在する場合、SELECTクエリは発生しません。
   :::

2. もし存在しなければ、データベースに対してSELECTクエリを発行し、データを取得してJavaオブジェクトにマッピングした後、永続性コンテキストに登録し、返却します。

   ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/70772c1d-0357-4d2b-be24-894721c290f6.png)
   
   ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/8512b24b-25d4-4ce1-aa95-be78c0cabbd1.png)
   
   ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/a8feea77-40bf-492f-bd5c-092c29d2b6b1.png)

もしDBにも存在しなければ、nullが返されます。


## Removed 状態

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/4075a530-67ed-4845-bf0c-17d8d8d23f5f.png)

`remove();` メソッドを通じ、永続状態のエンティティを削除対象としてマークすることができます。

- 次に `flush();` を呼び出すと、データベースに対して DELETE クエリが発行され、実際に削除されます
- `remove();` は永続状態にあるエンティティを削除対象に変更するだけであり、依然として永続性コンテキストで管理されるオブジェクトです。
- つまり、永続状態でないオブジェクトには `remove();` を使用することはできません

:::note info
つまり、JPAで削除を実行するためには、必ず識別子（@Id）を用いてエンティティを永続状態に登録する必要があるため、ほとんどの場合 `find();` を通じたSELECTクエリが発生します。
:::

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/d08e21e6-c86e-45b4-ab99-2c91081d9628.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/d0ba874b-aea2-44f3-bb77-e1136d90119e.png)
`package org.hibernate.event.internal.EntityStatus` を確認すると、動作構造を詳しく把握することができます。

以下は、永続状態のエンティティを削除する際の動作を示しています。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/7f904cb1-106e-4285-9510-ddeeab212375.png)

次のようなテストコードがあります。

```java
Student findStudent = entityManager.find(Student.class, 1L);
entityManager.remove(findStudent);
```
これにより、エンティティが Removed 状態に変更されます。
その後、以下のように Removed 状態に設定されたエンティティを取得しようとすると、

```java
Student removedStudent = entityManager.find(Student.class, student.getId());
assertNull(removedStudent);
```
永続性コンテキスト（1次キャッシュ）からも値は見つかりません。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/0f432236-211f-424e-9a9d-0bb57ed6e812.png)

しかしながら、これはあくまで永続性コンテキスト上で管理されているオブジェクトであり、flush() を呼び出さない限り、データベース上からは削除されません。
該当テストコードのログを確認すると、以下のように DELETE クエリは発生していません。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/6725d7ac-f907-4743-9903-143bf7d77d33.png)


### Removed 状態のオブジェクトを再び永続化する

通常、Removed 状態になったオブジェクトを再び永続状態に戻すことはほとんどありませんが、理解を深めるために、以下のような状況を考えてみましょう。

ポイントは、永続性コンテキスト（Identity Map）に登録されているか否かです。  
次のようなコードは、

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/545f6f81-afcc-453e-844f-404b72f5bcec.png)

```java
entityManager.remove(student);
```
状態遷移: **Managed → Removed**  
`remove()` を呼び出すと、エンティティの状態は Removed に変更され、削除対象としてマークされます。  
（ただし、まだ `flush()` を呼び出していないため、データベース上では実際には削除されていません。）

```java
entityManager.detach(student);
```
状態遷移: **Removed → Detached**  
`detach()` を呼び出すと、永続性コンテキストから該当エンティティが分離され、Detached 状態になります。  
この時点で、削除予約（Removed 状態）はキャンセルされます。

```java
Student reattachedStudent = entityManager.merge(student);
```
状態遷移: **Detached → Managed**  
`merge()` を呼び出すと、Detached 状態のエンティティが再び永続性コンテキストにマージされ、新たな Managed インスタンス（reattachedStudent）が返されます。  
この際、同一の識別子（ID）の値が保持されます。

## Destached

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/cc276dd4-462e-49a7-9ca4-088352b3409e.png)

以前のテストコードで使用したように、
```java
entityManager.detach(student);
```
というメソッドを使用しますが、これは永続性コンテキストにおいて該当オブジェクトの管理を中止することを意味いたします。

つまり、Identity Map（1次キャッシュ）からそのオブジェクトが除外されます。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/fb20196f-48b6-4b5b-9429-8ded3e57a783.png)
この後、以下のようなリクエストが発生すると、

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/0d330cbb-a56a-4497-99d6-07e48fd947f0.png)


永続性コンテキスト内から対象オブジェクトが除外された状態となります。

```java
entityManager.clear();
```
다음과 같은 메서드를 쓴다면 영속성 컨텍스트에서 관리되는 모든 객체를 영속성 컨텍스트에서 제거한다.


次のようなメソッドを使用すると、永続性コンテキストで管理されているすべてのオブジェクトが永続性コンテキストから除外されます。

:::note info
**非永続状態 (Transient) と 準永続状態 (Detached) の違い**  
最も大きな違いは、準永続状態では識別子 (id) が存在するため、再登録時に INSERT クエリが発生しないという点です。
:::

## flush() メソッド 

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3815412/21e2bbc5-56bc-4478-a1ef-eead54184ba5.png)

- 永続性コンテキストには、元の状態のスナップショットと該当エンティティが保存されています
- `flush()` を呼び出すと、メモリ上の変更点を比較し、実際のデータベースに反映するためのクエリが実行されます

簡単に言えば、これまでの変更内容をデータベースと同期させる作業であると言えます。


次回の記事では、永続性の伝播 (Cascade) について整理いたします。