Hibernate.org Community Documentation

- 前のページ
- 次のページ

## 第11章 オブジェクトを扱う

Hibernate は完全なオブジェクト/リレーショナルマッピングソリューションであり、データベース管理システムの詳細を開発者から隠蔽するだけでなく、オブジェクトの 状態管理 も行います。これは、 JDBC/SQL 永続層と同じような SQL `statements` の管理とは異なり、 Java アプリケーションにおける永続化に対する、とても自然なオブジェクト指向の考え方を提供します。

言いかえれば、 Hibernate を用いるアプリケーション開発者は、オブジェクトの 状態 については常に意識すべきであり、 SQL 文の実行については必ずしもそうではありません。この部分は、通常、 Hibernate が処理し、システムのパフォーマンスをチューニングするときにだけ、問題になってきます。

## 11.1. Hibernate におけるオブジェクトの状態

Hibernate は次のようなオブジェクトの状態を定義し、サポートしています:

- Transient - `new` 演算子を使ってインスタンス化されただけで、 Hibernate の `Session` に関連付けられていないオブジェクトは、 transient です。それは、データベースに永続的な表現を持たず、識別子となる値は割り当てられていません。 Transient インスタンスは、アプリケーションがその参照をどこにも保持しない場合に、ガベージコレクタによって破棄されます。オブジェクトを永続的 (persistent) な状態にするためには、 Hibernate の `Session` を使いましょう（この状態遷移に必要となる SQL 文の発行は、 Hibernate に任せましょう）。

- 永続的 (Persistent) - 永続的なインスタンスはデータベースに永続的な表現を持ち、識別子となる値を持っています。それは、セーブされたり、ロードされたりするかもしれませんが、定義上は、 `Session` のスコープの中に存在しています。 Hibernate は、作業単位（Unit of Work）が完了したときに、永続状態のオブジェクトに加えられた変更を検出し、オブジェクトの状態とデータベースを同期します。オブジェクトを transient にするときは、開発者は、手作業で `UPDATE` 文や `DELETE` 文を実行しません。

- Detached - detached インスタンスとは、永続化されているが、それと関連付いていた `Session` がクローズされているオブジェクトのことです。そのオブジェクトへの参照は、依然として有効です。そして、もちろん、detached インスタンスはこの状態に修正することさえできます。 detached インスタンスは、もう一度永続化したい（そして、すべての変更を永続化したい）ときに、新しい `Session` に再追加できます。この機能は、ユーザーが考える時間を必要とするような、長期間に及ぶ作業単位に対するプログラミングモデルを可能にします。我々は、これを アプリケーションのトランザクション（application transactions） と呼んでいます。すなわち、ユーザーから見た作業単位だということです。

これから、状態と状態遷移（そして、遷移のきっかけとなる Hibernate のメソッド）について、詳細に述べます。

## 11.2. オブジェクトを永続状態にする

Newly instantiated instances of a persistent class are considered transient by Hibernate. We can make a transient instance persistent by associating it with a session:

    DomesticCat fritz = new DomesticCat();

    fritz.setColor(Color.GINGER);

    fritz.setSex('M');

    fritz.setName("Fritz");

    Long generatedId = (Long) sess.save(fritz);

`Cat` クラスの識別子が自動生成されるのであれば、 `save()` が呼ばれるときに、識別子が生成され、 `cat` インスタンスに割り当てられます。 `Cat` の識別子が `assigned` 識別子を持つか、複合キーであるなら、 `save()` を呼び出す前に、識別子を `cat` インスタンスを割り当てなければなりません。 `save()` の代わりに、 EJB3 の初期ドラフトで定義された `persist()` を使うことも可能です。

- `persist()` makes a transient instance persistent. However, it does not guarantee that the identifier value will be assigned to the persistent instance immediately, the assignment might happen at flush time. `persist()` also guarantees that it will not execute an `INSERT` statement if it is called outside of transaction boundaries. This is useful in long-running conversations with an extended Session/persistence context.

- `save()` does guarantee to return an identifier. If an INSERT has to be executed to get the identifier ( e.g. "identity" generator, not "sequence"), this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is problematic in a long-running conversation with an extended Session/persistence context.

Alternatively, you can assign the identifier using an overloaded version of `save()`.

    DomesticCat pk = new DomesticCat();

    pk.setColor(Color.TABBY);

    pk.setSex('F');

    pk.setName("PK");

    pk.setKittens( new HashSet() );

    pk.addKitten(fritz);

    sess.save( pk, new Long(1234) );

永続化するオブジェクトが関連オブジェクトを持っている場合 （例えば、前の例における `kittens` コレクションのように）、外部キーカラムに、 `NOT NULL` 制約をつけない限りは、これらの一連のオブジェクトをどんな順番で永続化してもかまいません。外部キー制約を違反する恐れはありません。しかし、 `NOT NULL` 制約がある場合、間違った順番でオブジェクトを `save()` してしまうと、制約に違反するかもしれません。

関連するオブジェクトを自動的に保存する、 Hibernate の 遷移的な永続化 (transitive persistence) 機能を使うつもりならば、そのような詳細を気にする必要はありません。そして、 `NOT NULL` 制約の違反すら起こりません。 Hibernate がすべて面倒をみてくれます。遷移的な永続化は、この章の後半に書かれています。

## 11.3. オブジェクトのロード

永続化されたインスタンスの識別子があらかじめ分かっているなら、 `Session` の `load()` メソッドを使って、復元できます。 `load()` は、 Class オブジェクトを引数にとり、そのクラスのインスタンスを新たに生成し、状態をロードします。そのインスタンスの状態は、永続 (persistent) 状態です。

    Cat fritz = (Cat) sess.load(Cat.class, generatedId);

    // you need to wrap primitive identifiers

    long id = 1234;

    DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) );

あるいは、以下のように、既存のインスタンスに状態をロードすることもできます:

    Cat cat = new DomesticCat();

    // load pk's state into cat

    sess.load( cat, new Long(pkId) );

    Set kittens = cat.getKittens();

DB に該当する行が無い場合、 `load()` は回復不可能な例外を投げることに注意しましょう。そのクラスがプロキシを使ってマッピングされている場合、 `load()` は初期化されていないプロキシを返し、プロキシのメソッドが呼ばれるまで実際にはデータベースにアクセスしません。もし、実際にデータベースからロードせずに、オブジェクトに対する関連を作りたい場合、この振る舞いはとても役立ちます。 `batch-size` がクラスマッピングに定義されているならば、複数のインスタンスを一括でロードすることが可能です。

該当する行が存在することを確信できない場合は、 `get()` メソッドを使うべきです。それは、データベースにすぐにアクセスし、該当する行が無い場合は null を返します。

    Cat cat = (Cat) sess.get(Cat.class, id);

    if (cat==null) {

        cat = new Cat();

        sess.save(cat, id);

    }

    return cat;

`LockMode` を使えば、 `SELECT ... FOR UPDATE` という SQL を使ってオブジェクトをロードすることができます。詳細な情報は、 API ドキュメントを参照してください。

    Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);

関連に対するカスケード方法として `lock` や `all` を指定しない限り、関連するインスタンスや含まれるコレクションは `FOR UPDATE` で復元 されない ことに注意しましょう。

`refresh()` メソッドを使うことで、どんなときでも、オブジェクトやそのコレクションをリロードすることができます。データベースのトリガがテーブルを更新した際に、そのテーブルに対応するオブジェクトのプロパティを同期する場合、このメソッドが役に立ちます。

    sess.save(cat);

    sess.flush(); //force the SQL INSERT

    sess.refresh(cat); //re-read the state (after the trigger executes)

How much does Hibernate load from the database and how many SQL `SELECT`s will it use? This depends on the fetching strategy. This is explained in 「フェッチ戦略」.

## 11.4. クエリ

探したいオブジェクトの識別子が分からない場合は、クエリが必要になります。 Hibernate は使いやすくて強力なオブジェクト指向のクエリ言語 (HQL) をサポートしています。プログラムによってクエリが作成できるように、 Hibernate は洗練された Criteria と Example クエリ機能 (QBC と QBE） をサポートしています。 ResultSet をオブジェクトに変換する Hibernate のオプション機能を使うことで、データベースのネイティブな SQL でクエリを表現することもできます。

### 11.4.1. クエリの実行

HQL やネイティブな SQL クエリは、 `org.hibernate.Query` のインスタンスとして表現されます。このインタフェースは、パラメータバインディングや ResultSet のハンドリングやクエリの実行を行うメソッドを用意しています。通常、 `Query` は、以下に示すように、その時点の `Session` を使って取得します。

    List cats = session.createQuery(

        "from Cat as cat where cat.birthdate < ?")

        .setDate(0, date)

        .list();

    List mothers = session.createQuery(

        "select mother from Cat as cat join cat.mother as mother where cat.name = ?")

        .setString(0, name)

        .list();

    List kittens = session.createQuery(

        "from Cat as cat where cat.mother = ?")

        .setEntity(0, pk)

        .list();

    Cat mother = (Cat) session.createQuery(

        "select cat.mother from Cat as cat where cat = ?")

        .setEntity(0, izi)

        .uniqueResult();]]

    Query mothersWithKittens = (Cat) session.createQuery(

        "select mother from Cat as mother left join fetch mother.kittens");

    Set uniqueMothers = new HashSet(mothersWithKittens.list());

クエリは、普通、 `list()` を呼び出すことによって実行されます。クエリの結果は、メモリ上にあるコレクションにすべてロードされます。クエリによって復元されたエンティティのインスタンスは、永続状態です。もし、クエリがたった1個のインスタンスを返すと分かっているなら、 `uniqueResult()` メソッドが手っ取り早い方法です。即時フェッチを利用したクエリの場合、ふつう、得られたコレクションには、ルートのオブジェクトが重複して含まれています（しかし、ルートが持つコレクションは初期化 (ロード）されています）。この重複は `Set` を使って取り除くことができます。

#### 11.4.1.1. 結果をイテレートする

時々、 `iterate()` メソッドを使ってクエリを実行することで、より良いパフォーマンスを得ることができます。これは、通常、クエリによって得られた実際のエンティティのインスタンスが、すでにセッションまたは二次キャッシュに存在することが期待できる場合だけです。それらが、まだキャッシュされていないなら、 `iterate()` は、 `list()` よりも遅く、簡単なクエリに対しても多くのデータベースアクセスを必要とします。そのアクセスとは、識別子だけを取得するための最初の select １回 と、実際のインスタンスを初期化するために後から行う n回 の select のことです。

    // fetch ids

    Iterator iter = sess.createQuery("from eg.Qux q order by q.likeliness").iterate();

    while ( iter.hasNext() ) {

        Qux qux = (Qux) iter.next();  // fetch the object

        // something we couldnt express in the query

        if ( qux.calculateComplicatedAlgorithm() ) {

            // delete the current instance

            iter.remove();

            // dont need to process the rest

            break;

        }

    }

#### 11.4.1.2. オブジェクトの組（tuple）を返すクエリ

Hibernate のクエリでは、時々、オブジェクトの組を返すことがあります。その場合は、各タプルは配列として返されます:

    Iterator kittensAndMothers = sess.createQuery(

                "select kitten, mother from Cat kitten join kitten.mother mother")

                .list()

                .iterator();

    while ( kittensAndMothers.hasNext() ) {

        Object[] tuple = (Object[]) kittensAndMothers.next();

        Cat kitten = (Cat) tuple[0];

        Cat mother = (Cat) tuple[1];

        ....

    }

#### 11.4.1.3. スカラーの結果

クエリでは、 `select` 節でクラスのプロパティを指定できます。 SQL の集合関数を呼ぶこともできます。プロパティや集合関数は、（永続状態のエンティティではなく）「スカラー値」であると見なされます。

    Iterator results = sess.createQuery(

            "select cat.color, min(cat.birthdate), count(cat) from Cat cat " +

            "group by cat.color")

            .list()

            .iterator();

    while ( results.hasNext() ) {

        Object[] row = (Object[]) results.next();

        Color type = (Color) row[0];

        Date oldest = (Date) row[1];

        Integer count = (Integer) row[2];

        .....

    }

#### 11.4.1.4. パラメータのバインド

`Query` は、名前付きのパラメータや JDBC スタイルの `?` パラメータに値をバインドするためのメソッドを持っています。 JDBC とは違い、 Hibernate はパラメータにゼロから番号を振っていきます。名前付きのパラメータとは、クエリ文字列のなかにある `:name` 形式の識別子です。名前付きパラメータの利点は次の通りです。

- 名前付きパラメータは、クエリ文字列に登場する順番と無関係です

- 同じクエリ内に複数回登場することができます

- 自分自身を説明します

    //named parameter (preferred)

    Query q = sess.createQuery("from DomesticCat cat where cat.name = :name");

    q.setString("name", "Fritz");

    Iterator cats = q.iterate();

    //positional parameter

    Query q = sess.createQuery("from DomesticCat cat where cat.name = ?");

    q.setString(0, "Izi");

    Iterator cats = q.iterate();

    //named parameter list

    List names = new ArrayList();

    names.add("Izi");

    names.add("Fritz");

    Query q = sess.createQuery("from DomesticCat cat where cat.name in (:namesList)");

    q.setParameterList("namesList", names);

    List cats = q.list();

#### 11.4.1.5. ページ分け

ResultSet に制限（復元したい最大行数や復元したい最初の行）を加える必要があれば、以下のように、 `Query` インターフェースのメソッドを使います。

    Query q = sess.createQuery("from DomesticCat cat");

    q.setFirstResult(20);

    q.setMaxResults(10);

    List cats = q.list();

制限付きのクエリを DBMS のネイティブな SQL に変換する方法を、 Hibernate は知っています。

#### 11.4.1.6. スクロール可能なイテレーション

JDBC ドライバがスクロール可能な `ResultSet` をサポートしていれば、 `Query` インターフェースを使って、 `ScrollableResults` オブジェクトを取得できます。それを使うと、クエリの結果に対して柔軟にナビゲーションできます。

    Query q = sess.createQuery("select cat.name, cat from DomesticCat cat " +

                                "order by cat.name");

    ScrollableResults cats = q.scroll();

    if ( cats.first() ) {

        // find the first name on each page of an alphabetical list of cats by name

        firstNamesOfPages = new ArrayList();

        do {

            String name = cats.getString(0);

            firstNamesOfPages.add(name);

        }

        while ( cats.scroll(PAGE_SIZE) );

        // Now get the first page of cats

        pageOfCats = new ArrayList();

        cats.beforeFirst();

        int i=0;

        while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );

    }

    cats.close()

この機能にはオープン状態のデータベースコネクションが必要であることに注意してください。もし、オフラインのページ分け機能が必要であれば、 `setMaxResult()` / `setFirstResult()` を使いましょう。

#### 11.4.1.7. 名前付きクエリの外出し

Queries can also be configured as so called named queries using annotations or Hibernate mapping documents. `@NamedQuery` and `@NamedQueries` can be defined at the class level as seen in 例11.1「Defining a named query using @NamedQuery」 . However their definitions are global to the session factory/entity manager factory scope. A named query is defined by its name and the actual query string.

例11.1 Defining a named query using `@NamedQuery`

    @Entity

    @NamedQuery(name="night.moreRecentThan", query="select n from Night n where n.date >= :date")

    public class Night {

        ...

    }

    public class MyDao {

        doStuff() {

            Query q = s.getNamedQuery("night.moreRecentThan");

            q.setDate( "date", aMonthAgo );

            List results = q.list();

            ...

        }

        ...

    }

Using a mapping document can be configured using the `<query>` node. Remember to use a `CDATA` section if your query contains characters that could be interpreted as markup.

例11.2 Defining a named query using `<query>`

    <query name="ByNameAndMaximumWeight"><![CDATA[

        from eg.DomesticCat as cat

            where cat.name = ?

            and cat.weight > ?

    ] ]></query>

Parameter binding and executing is done programatically as seen in 例11.3「Parameter binding of a named query」.

例11.3 Parameter binding of a named query

    Query q = sess.getNamedQuery("ByNameAndMaximumWeight");

    q.setString(0, name);

    q.setInt(1, minWeight);

    List cats = q.list();

実際のプログラムコードは、使われるクエリ言語に依存していないことに注意しましょう。メタデータには、ネイティブ SQL クエリを定義することもできます。また、既存のクエリをマッピングファイルに移すことで、 Hibernate に移行することもできます。

`<hibernate-mapping>` 要素の中のクエリ定義は、クエリに対するユニークな名前が必要なことにも注意してください。それに対して、 `<class>` 要素の中のクエリ定義は、クラスの完全限定名が前に付けられるので、自動的にユニークな名前になります。例： `eg.Cat.ByNameAndMaximumWeight`

### 11.4.2. フィルタリングコレクション

コレクション フィルタ は、永続化されているコレクションや配列に適用される特殊なタイプのクエリです。そのクエリ文字列では、コレクションのその時点での要素を意味する `this` を使います。

    Collection blackKittens = session.createFilter(

        pk.getKittens(),

        "where this.color = ?")

        .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )

        .list()

    );

返されるコレクションは Bag とみなされます。そして、それはもとのコレクションのコピーになります。元のコレクションは修正されません（これは、 "filter" という名前の意味とは異なりますが、期待される動きとは一致しています）。

フィルタには `from` 節が不要であることに気づくでしょう（必要なら、持つことも可能ですが）。フィルタは、コレクションの要素自体を返して構いません。

    Collection blackKittenMates = session.createFilter(

        pk.getKittens(),

        "select this.mate where this.color = eg.Color.BLACK.intValue")

        .list();

クエリを含まないフィルタも役に立ちます。例えば、非常に大きなコレクションの部分集合をロードするために使えます。

    Collection tenKittens = session.createFilter(

        mother.getKittens(), "")

        .setFirstResult(0).setMaxResults(10)

        .list();

### 11.4.3. クライテリアのクエリ

HQL は非常に強力ですが、クエリ文字列を作るよりも、オブジェクト指向の API を使って動的にクエリを作る方を好む開発者もいます。こういった場合のために、 Hibernate は直感的な `Criteria` クエリ API を提供しています。

    Criteria crit = session.createCriteria(Cat.class);

    crit.add( Restrictions.eq( "color", eg.Color.BLACK ) );

    crit.setMaxResults(10);

    List cats = crit.list();

The `Criteria` and the associated `Example` API are discussed in more detail in 17章Criteria クエリ.

### 11.4.4. ネイティブ SQL のクエリ

`createSQLQuery()` を使って、 SQL でクエリを表現することもできます。そして、 Hibernate に、 ResultSet からオブジェクトへのマッピングをまかせます。 `session.connection()` を呼べばどんなときでも、直接、 JDBC `Connection` を使用できることを覚えておきましょう。もし、 Hibernate API を使うのであれば、下記のように SQL の別名を括弧でくくらなければなりません。

    List cats = session.createSQLQuery("SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10")

        .addEntity("cat", Cat.class)

    .list();

    List cats = session.createSQLQuery(

        "SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, " +

               "{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... " +

        "FROM CAT {cat} WHERE ROWNUM<10")

        .addEntity("cat", Cat.class)

    .list()

SQL queries can contain named and positional parameters, just like Hibernate queries. More information about native SQL queries in Hibernate can be found in 18章ネイティブ SQL.

## 11.5. 永続オブジェクトの修正

処理中の永続インスタンス （例： `Session` によって、ロード、セーブ、作成、クエリされたオブジェクト）は、アプリケーションに操作されます。その際に変更された永続状態は、 `Session` が フラッシュ されるときに、永続化されます（これは、この章の後半で述べています）。変更を永続化するために、特殊なメソッド（ `update()` のようなもの。これは、別の目的で使用します）を呼ぶ必要はありません。オブジェクトの状態を更新する一番簡単な方法は、オブジェクトを `load()` し、 `Session` をオープンにしている間に、直接操作することです。

    DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );

    cat.setName("PK");

    sess.flush();  // changes to cat are automatically detected and persisted

（オブジェクトをロードするための） SQL の `SELECT` と（更新された状態を永続化するための） SQL の `UPDATE` が同じセッションで必要となるので、このプログラミングモデルは、効率が悪くなる場合があります。そのため、 Hibernate は別の方法を用意しています。それは、 detached インスタンスを使用する方法です。

## 11.6. detached オブジェクトの修正

多くのアプリケーションでは次のことが必要になります。それは、あるトランザクションでオブジェクトを復元し、操作するためにそれを UI 層に送り、その後に、新しいトランザクションで変更をセーブするといったことです。並行性の高い環境で、このタイプのアプローチを使うアプリケーションでは、「期間の長い」作業単位の隔離性を保証するために、バージョンデータが通常使われます。

Hibernate は、 `Session.update()` や `Session.merge()` メソッドを使って、 detached インスタンスを再追加することで、このモデルに対応します。

    // in the first session

    Cat cat = (Cat) firstSession.load(Cat.class, catId);

    Cat potentialMate = new Cat();

    firstSession.save(potentialMate);

    // in a higher layer of the application

    cat.setMate(potentialMate);

    // later, in a new session

    secondSession.update(cat);  // update cat

    secondSession.update(mate); // update mate

識別子 `catId` を持つ `Cat` が、既に `secondSession` でロードされていた場合は、再追加しようとしたときに、例外が投げられます。

同じ識別子を持つ永続インスタンスをセッションが既に保持していないことを確信できるなら `update()` を使います。そして、セッションの状態を考えずに、どんな場合でも変更をマージしたい場合は、 `merge()` を使います。すなわち、 detached インスタンスの再追加操作が、最初に実行されることを確実にするために、通常は `update()` が新しいセッションのなかで最初に呼ばれるメソッドになります。

The application should individually `update()` detached instances that are reachable from the given detached instance only if it wants their state to be updated. This can be automated using transitive persistence. See 「連鎖的な永続化」 for more information.

`lock()` メソッドでもまた、新しいセッションにオブジェクトを再関連付けできます。しかし、 detached インスタンスは無修正でなければなりません。

    //just reassociate:

    sess.lock(fritz, LockMode.NONE);

    //do a version check, then reassociate:

    sess.lock(izi, LockMode.READ);

    //do a version check, using SELECT ... FOR UPDATE, then reassociate:

    sess.lock(pk, LockMode.UPGRADE);

`lock()` は、さまざまな `LockMode` とともに使うことができます。詳細は、 API ドキュメントとトランザクション処理の章を参照してください。再追加のときにだけ、 `lock()` が使われるわけではありません。

Other models for long units of work are discussed in 「楽観的同時実行制御」.

## 11.7. 自動的な状態検出

Hibernate のユーザーは次の2つのケースのどちらにも使える汎用的なメソッドを要求していました。それは、新しい識別子を生成して transient インスタンスをセーブすることと、その時点の識別子と関連づいている detached インスタンスを更新/再追加することのできるメソッドです。 `saveOrUpdate()` はこのような機能を実現したメソッドです。

    // in the first session

    Cat cat = (Cat) firstSession.load(Cat.class, catID);

    // in a higher tier of the application

    Cat mate = new Cat();

    cat.setMate(mate);

    // later, in a new session

    secondSession.saveOrUpdate(cat);   // update existing state (cat has a non-null id)

    secondSession.saveOrUpdate(mate);  // save the new instance (mate has a null id)

`saveOrUpdate()` の使用方法と意味は、新しいユーザーにとって混乱を招くかもしれません。まず第一に、あるセッションで使用したインスタンスを別の新しいセッションで使おうとしない限り、 `update()` や `saveOrUpdate()` や `merge()` を使う必要はありません。アプリケーション全体を通じて、これらのメソッドを全く使わないこともあります。

通常、 `update()` や `saveOrUpdate()` は次のシナリオで使われます:

- アプリケーションが最初のセッションでオブジェクトをロードします。

- オブジェクトが UI 層に送られます。

- オブジェクトに対して変更が加えられます。

- オブジェクトがビジネスロジック層に送られます。

- アプリケーションは、2番目のセッションで `update()` を呼ぶことで、これらの変更を永続化します。

`saveOrUpdate()` は以下のことを行います:

- オブジェクトがこのセッションで、すでに永続化されていれば、何もしません。

- そのセッションに関連づいている別のオブジェクトが同じ識別子を持っているなら、例外を投げます。

- オブジェクトの識別子が値を持たないならば、 `save()` します。

- オブジェクトの識別子が値を持ち、その値が新たにインスタンス化されたオブジェクトのための値である場合、そのオブジェクトを `save()` します。

- オブジェクトが（ `<version>` や `<timestamp>` によって）バージョンづけされていて、バージョンのプロパティが値を持ち、その値が新しくインスタンス化されたオブジェクトのための値である場合、そのオブジェクトを `save()` します。

- そうでない場合は、そのオブジェクトを `update()` します。

そして、 `merge()` は以下のように非常に異なります:

- 同じ識別子を持つ永続化インスタンスがその時点でセッションと関連付いているならば、引数で受け取ったオブジェクトの状態を永続化インスタンスにコピーします。

- 永続化インスタンスがその時点でセッションに関連付いていないなら、データベースからそれをロードするか、あるいは、新しい永続化インスタンスを作成します。

- 永続化インスタンスが返されます。

- 引数として与えたインスタンスはセッションと関連を持ちません。それは、分離状態のままです。

## 11.8. 永続オブジェクトの削除

`Session.delete()` はオブジェクトの状態をデータベースから削除します。もちろん、削除したオブジェクトをアプリケーションが保持したままでもよいです。そのため、 `delete()` は永続インスタンスを transient にするものと考えるのが一番です。

    sess.delete(cat);

外部キー制約に違反するリスクもなく、好きな順番でオブジェクトを削除することができます。ただし、間違った順番でオブジェクトを削除すると、外部キーカラムの `NOT NULL` 制約に違反する可能性があります。例えば、親オブジェクトを削除したときに、子供オブジェクトを削除し忘れた場合です。

## 11.9. 異なる二つのデータストア間でのオブジェクトのレプリケーション

永続インスタンスのグラフを別のデータストアに永続化する場合に、識別子の値を再生成せずにすむと便利な場合があります。

    //retrieve a cat from one database

    Session session1 = factory1.openSession();

    Transaction tx1 = session1.beginTransaction();

    Cat cat = session1.get(Cat.class, catId);

    tx1.commit();

    session1.close();

    //reconcile with a second database

    Session session2 = factory2.openSession();

    Transaction tx2 = session2.beginTransaction();

    session2.replicate(cat, ReplicationMode.LATEST_VERSION);

    tx2.commit();

    session2.close();

レプリケーション先のデータベースに行が既にある場合、 `replicate()` が衝突をどのように扱うかを `ReplicationMode` で指定します。

- `ReplicationMode.IGNORE` - 同じ識別子を持つ行がデータベースに存在するなら、そのオブジェクトを無視します。

- `ReplicationMode.OVERWRITE` - 同じ識別子を持つ既存の行をすべて上書きします。

- `ReplicationMode.EXCEPTION` - 同じ識別子を持つ行がデータベースに存在するなら、例外を投げます。

- `ReplicationMode.LATEST_VERSION` - 行に保存されているバージョン番号が、引数のオブジェクトのバージョン番号より古いならば、その行を上書きします。

次のようなケースで、この機能を使用します。異なるデータベースインスタンスに入れられたデータの同期、製品更新時におけるシステム設定情報の更新、非 ACID トランザクションのなかで加えられた変更のロールバックなどです。

## 11.10. セッションのフラッシュ

JDBC コネクションの状態とメモリ上のオブジェクトの状態を同期させるために必要な SQL 文を `Session` が実行することがときどきあります。この処理 flush は、デフォルトでは次のときに起こります。

- クエリを実行する前

- `org.hibernate.Transaction.commit()` を実行したとき

- `Session.flush()` を実行したとき

SQL 文は以下の順番で発行されます。

1. すべてのエンティティの挿入。これは、 `Session.save()` を使ってセーブしたオブジェクトの順に実行していきます。

2. すべてのエンティティの更新

3. すべてのコレクションの削除

4. すべてのコレクションの要素に対する削除、更新、挿入

5. すべてのコレクションの挿入

6. すべてのエンティティの削除。これは、 `Session.delete()` を使って削除したオブジェクトの順に実行していきます。

(１つ例外があります。 `native` ID 生成を使ったオブジェクトは、それらがセーブされたときに挿入されます。）

明示的に `flush()` するときを除いて、 いつ `Session` が JDBC をコールするのかについて絶対的な保証はありません。ただし、それらが実行される 順番 だけは保証されます。また、 Hibernate は、 `Query.list(..)` が古いデータや間違ったデータ返さないことを保証しています。

It is possible to change the default behavior so that flush occurs less frequently. The `FlushMode` class defines three different modes: only flush at commit time when the Hibernate `Transaction` API is used, flush automatically using the explained routine, or never flush unless `flush()` is called explicitly. The last mode is useful for long running units of work, where a `Session` is kept open and disconnected for a long time (see 「拡張セッションと自動バージョニング」).

    sess = sf.openSession();

    Transaction tx = sess.beginTransaction();

    sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state

    Cat izi = (Cat) sess.load(Cat.class, id);

    izi.setName(iznizi);

    // might return stale data

    sess.find("from Cat as cat left outer join cat.kittens kitten");

    // change to izi is not flushed!

    ...

    tx.commit(); // flush occurs

    sess.close();

During flush, an exception might occur (e.g. if a DML operation violates a constraint). Since handling exceptions involves some understanding of Hibernate's transactional behavior, we discuss it in 13章Transactions and Concurrency.

## 11.11. 連鎖的な永続化

個々のオブジェクトをセーブしたり、削除したり、再追加したりすることはかなり面倒です。特に、関連するオブジェクトを扱うような場合には際立ちます。よくあるのは、親子関係を扱うケースです。以下の例を考えてみましょう:

もし、親子関係の子が値型なら（例えば、住所や文字列のコレクション）、それらのライフサイクルは親に依存しており、便利な状態変化の「カスケード」を使うために、追加の作業は必要はありません。親がセーブされたとき、値型の子オブジェクトも同じようにセーブされますし、親が削除されたときは、子も削除されます。その他の操作も同じです。コレクションから1つの子を削除するような操作でもうまくいきます。すなわち、 Hibernate はこの削除操作を検出すると、値型のオブジェクトは参照を共有できないので、データベースからその子供を削除します。

ここで、親と子が値型でなくエンティティであるとして同じシナリオを考えてみましょう。（例えば、カテゴリーと品目の関係や親と子の猫の関係です。）エンティティは、それ自身がライフサイクルを持ち、参照の共有をサポートします。（そのため、コレクションからエンティティを削除することは、エンティティ自身の削除を意味しません。）また、エンティティは、デフォルトでは、関連する他のエンティティへ状態をカスケードすることはありません。 Hibernate は 到達可能性による永続化 をデフォルトでは実行しません。

Hibernate の Session の基本操作（ `persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()` が含まれます）に対して、それぞれに対応するカスケードスタイルがあります。それぞれのカスケードスタイルには、 `create, merge, save-update, delete, lock, refresh, evict, replicate` という名前がついています。もし、関連に沿ってカスケードさせたい操作があるなら、マッピングファイルにそう指定しなければなりません。例えば、以下のようにします:

    <one-to-one name="person" cascade="persist"/>

カスケードスタイルは、組み合わせることができます:

    <one-to-one name="person" cascade="persist,delete,lock"/>

すべての 操作を関連に沿ってカスケードするよう指定するときは、 `cascade="all"` を使います。デフォルトの `cascade="none"` は、どの操作もカスケードしないことを意味します。

In case you are using annotatons you probably have noticed the `cascade` attribute taking an array of `CascadeType` as a value. The cascade concept in JPA is very is similar to the transitive persistence and cascading of operations as described above, but with slightly different semantics and cascading types:

- `CascadeType.PERSIST`: cascades the persist (create) operation to associated entities persist() is called or if the entity is managed

- `CascadeType.MERGE`: cascades the merge operation to associated entities if merge() is called or if the entity is managed

- `CascadeType.REMOVE`: cascades the remove operation to associated entities if delete() is called

- `CascadeType.REFRESH:` cascades the refresh operation to associated entities if refresh() is called

- `CascadeType.DETACH:` cascades the detach operation to associated entities if detach() is called

- `CascadeType.ALL`: all of the above

## 注意

CascadeType.ALL also covers Hibernate specific operations like save-update, lock etc...

A special cascade style, `delete-orphan`, applies only to one-to-many associations, and indicates that the `delete()` operation should be applied to any child object that is removed from the association. Using annotations there is no `CascadeType.DELETE-ORPHAN` equivalent. Instead you can use the attribute `orphanRemoval as seen in` 例11.4「@OneToMany with orphanRemoval」. If an entity is removed from a `@OneToMany` collection or an associated entity is dereferenced from a `@OneToOne` association, this associated entity can be marked for deletion if `orphanRemoval` is set to true.

例11.4 `@OneToMany` with `orphanRemoval`

    @Entity

    public class Customer {

       private Set<Order> orders;

       @OneToMany(cascade=CascadeType.ALL, orphanRemoval=true)

       public Set<Order> getOrders() { return orders; }

       public void setOrders(Set<Order> orders) { this.orders = orders; }

       [...]

    }

    @Entity

    public class Order { ... }

    Customer customer = em.find(Customer.class, 1l);

    Order order = em.find(Order.class, 1l);

    customer.getOrders().remove(order); //order will be deleted by cascade

おすすめ：

- It does not usually make sense to enable cascade on a many-to-one or many-to-many association. In fact the `@ManyToOne` and `@ManyToMany` don't even offer a `orphanRemoval` attribute. Cascading is often useful for one-to-one and one-to-many associations.

- If the child object's lifespan is bounded by the lifespan of the parent object, make it a life cycle object by specifying `cascade="all,delete-orphan"(`@OneToMany(cascade=CascadeType.ALL, orphanRemoval=true)`)`.

- それ以外の場合は、カスケードはほとんど必要ないでしょう。しかし、同じトランザクションのなかで親と子が一緒に動作することが多いと思い、いくらかのコードを書く手間を省きたいのであれば、 `cascade="persist,merge,save-update"` を使うことを考えましょう。

`cascade="all"` でマッピングした関連（単値関連やコレクション）は、 親子 スタイルの関連とマークされます。それは、親のセーブ/更新/削除が、子のセーブ/更新/削除を引き起こす関係のことです。

Furthermore, a mere reference to a child from a persistent parent will result in save/update of the child. This metaphor is incomplete, however. A child which becomes unreferenced by its parent is not automatically deleted, except in the case of a one-to-many association mapped with `cascade="delete-orphan"`. The precise semantics of cascading operations for a parent/child relationship are as follows:

- 親が `persist()` に渡されたならば、すべての子は `persist()` に渡されます。

- `merge()` に渡されたならば、すべての子は `merge()` に渡されます。

- 親が `save()` 、 `update()` 、 `saveOrUpdate()` に渡されたならば、すべての子は `saveOrUpdate()` に渡されます。

- transient または detached の子が、永続化された親に参照されたならば、 `saveOrUpdate()` に渡されます。

- 親が削除されたならば、すべての子は、 `delete()` に渡されます。

- 子が永続化された親から参照されなくなったときは、 特に何も起こりません 。よって、アプリケーションが必要であれば、明示的に削除する必要があります。ただし、 `cascade="delete-orphan"` の場合を除きます。この場合、「親のない」子は削除されます。

最後に、操作のカスケードがオブジェクトグラフに適用されるのは、 コールした時 あるいは、 flushした時 であることに注意してください。すべての操作は、その操作が実行されたときに、到達可能な関連するエンティティに対してカスケードが可能ならカスケードします。しかし、 `save-upate` と `delete-orphan` は、 `Session` が flush している間に、すべての到達可能な関連するエンティティに伝播します。

## 11.12. メタデータの使用

Hibernate は、すべてのエンティティと値型の非常にリッチなメタレベルのモデルを必要とします。ときどき、このモデルはアプリケーションにとってとても役に立ちます。例えば、アプリケーションは、 Hibernate のメタデータを使って、「賢い」ディープコピーアルゴリズムを実装できるかもしません。そのアルゴリズムとは、どのオブジェクトがコピーされるべきか（例：可変の値型）やどのオブジェクトはコピーされないべきか（例：不変な値型や可能なら関連するエンティティ）を判断できるものです。

Hibernate は `ClassMetadata` と `CollectionMetadata` インタフェースと `Type` 階層を通してメタデータを公開します。メタデータインターフェースのインスタンスは、 `SessionFactory` から得られます。

    Cat fritz = ......;

    ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);

    Object[] propertyValues = catMeta.getPropertyValues(fritz);

    String[] propertyNames = catMeta.getPropertyNames();

    Type[] propertyTypes = catMeta.getPropertyTypes();

    // get a Map of all properties which are not collections or associations

    Map namedValues = new HashMap();

    for ( int i=0; i<propertyNames.length; i++ ) {

        if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {

            namedValues.put( propertyNames[i], propertyValues[i] );

        }

    }

製作著作 © 2004 Red Hat, Inc.

- 前のページ第10章 継承マッピング
- 上に戻る
- ホーム
- 次のページ第12章 Read-only entities