Hibernate.orgCommunity Documentation
Hibernate は完全なオブジェクト/リレーショナルマッピングソリューションであり、データベース管理システムの詳細を開発者から隠蔽するだけでなく、オブジェクトの 状態管理 も行います。これは、 JDBC/SQL 永続層と同じような SQL statements
の管理とは異なり、 Java アプリケーションにおける永続化に対する、とても自然なオブジェクト指向の考え方を提供します。
言いかえれば、 Hibernate を用いるアプリケーション開発者は、オブジェクトの 状態 については常に意識すべきであり、 SQL 文の実行については必ずしもそうではありません。この部分は、通常、 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 のメソッド)について、詳細に述べます。
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 がすべて面倒をみてくれます。遷移的な永続化は、この章の後半に書かれています。
永続化されたインスタンスの識別子があらかじめ分かっているなら、 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 「フェッチ戦略」.
探したいオブジェクトの識別子が分からない場合は、クエリが必要になります。 Hibernate は使いやすくて強力なオブジェクト指向のクエリ言語 (HQL) をサポートしています。プログラムによってクエリが作成できるように、 Hibernate は洗練された Criteria と Example クエリ機能 (QBC と QBE) をサポートしています。 ResultSet をオブジェクトに変換する Hibernate のオプション機能を使うことで、データベースのネイティブな SQL でクエリを表現することもできます。
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
を使って取り除くことができます。
時々、 iterate()
メソッドを使ってクエリを実行することで、より良いパフォーマンスを得ることができます。これは、通常、クエリによって得られた実際のエンティティのインスタンスが、すでにセッションまたは二次キャッシュに存在することが期待できる場合だけです。それらが、まだキャッシュされていないなら、 iterate()
は、 list()
よりも遅く、簡単なクエリに対しても多くのデータベースアクセスを必要とします。そのアクセスとは、識別子だけを取得するための最初の select 1回 と、実際のインスタンスを初期化するために後から行う 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;
}
}
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];
....
}
クエリでは、 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];
.....
}
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();
ResultSet に制限(復元したい最大行数や復元したい最初の行)を加える必要があれば、以下のように、 Query
インターフェースのメソッドを使います。
Query q = sess.createQuery("from DomesticCat cat");
q.setFirstResult(20);
q.setMaxResults(10);
List cats = q.list();
制限付きのクエリを DBMS のネイティブな SQL に変換する方法を、 Hibernate は知っています。
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()
を使いましょう。
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
コレクション フィルタ は、永続化されているコレクションや配列に適用される特殊なタイプのクエリです。そのクエリ文字列では、コレクションのその時点での要素を意味する 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();
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 クエリ.
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.
処理中の永続インスタンス (例: 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 インスタンスを使用する方法です。
多くのアプリケーションでは次のことが必要になります。それは、あるトランザクションでオブジェクトを復元し、操作するためにそれを 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 「楽観的同時実行制御」.
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()
は以下のように非常に異なります:
同じ識別子を持つ永続化インスタンスがその時点でセッションと関連付いているならば、引数で受け取ったオブジェクトの状態を永続化インスタンスにコピーします。
永続化インスタンスがその時点でセッションに関連付いていないなら、データベースからそれをロードするか、あるいは、新しい永続化インスタンスを作成します。
永続化インスタンスが返されます。
引数として与えたインスタンスはセッションと関連を持ちません。それは、分離状態のままです。
Session.delete()
はオブジェクトの状態をデータベースから削除します。もちろん、削除したオブジェクトをアプリケーションが保持したままでもよいです。そのため、 delete()
は永続インスタンスを transient にするものと考えるのが一番です。
sess.delete(cat);
外部キー制約に違反するリスクもなく、好きな順番でオブジェクトを削除することができます。ただし、間違った順番でオブジェクトを削除すると、外部キーカラムの NOT NULL
制約に違反する可能性があります。例えば、親オブジェクトを削除したときに、子供オブジェクトを削除し忘れた場合です。
永続インスタンスのグラフを別のデータストアに永続化する場合に、識別子の値を再生成せずにすむと便利な場合があります。
//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 トランザクションのなかで加えられた変更のロールバックなどです。
JDBC コネクションの状態とメモリ上のオブジェクトの状態を同期させるために必要な SQL 文を Session
が実行することがときどきあります。この処理 flush は、デフォルトでは次のときに起こります。
クエリを実行する前
org.hibernate.Transaction.commit()
を実行したとき
Session.flush()
を実行したとき
SQL 文は以下の順番で発行されます。
すべてのエンティティの挿入。これは、 Session.save()
を使ってセーブしたオブジェクトの順に実行していきます。
すべてのエンティティの更新
すべてのコレクションの削除
すべてのコレクションの要素に対する削除、更新、挿入
すべてのコレクションの挿入
すべてのエンティティの削除。これは、 Session.delete()
を使って削除したオブジェクトの順に実行していきます。
(1つ例外があります。 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.
個々のオブジェクトをセーブしたり、削除したり、再追加したりすることはかなり面倒です。特に、関連するオブジェクトを扱うような場合には際立ちます。よくあるのは、親子関係を扱うケースです。以下の例を考えてみましょう:
もし、親子関係の子が値型なら(例えば、住所や文字列のコレクション)、それらのライフサイクルは親に依存しており、便利な状態変化の「カスケード」を使うために、追加の作業は必要はありません。親がセーブされたとき、値型の子オブジェクトも同じようにセーブされますし、親が削除されたときは、子も削除されます。その他の操作も同じです。コレクションから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 している間に、すべての到達可能な関連するエンティティに伝播します。
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.