休止状態 セッションとトランザクションの基礎

Habréの最初の記事では、セッションとトランザクションに関するHibernateとの連携に関するいくつかの考えと意見を共有したいと思います。 このトピックの開発の最初に生じるいくつかのニュアンスに焦点を当てました。 ジュニアプログラマー自身がHibernateを常時使用していなかったので、エラーが発生する可能性があります。これらに気づいた場合は、修正に感謝します。

Hibernateライブラリは、最も一般的なORMライブラリであり、Java Persistence APIの実装です。 多くの場合、通常のJavaアプリケーション、特にJBossアプリケーションサーバー（およびその子孫のWildFly）のサーブレットコンテナーでORMプロバイダーとして使用されます。

始めましょう。

1）。 エンティティオブジェクト

ユーザーと彼のタスクの2つのエンティティを考えます。

CREATE TABLE "user" ( user_id serial NOT NULL, login character varying(10), password character varying(10), role integer, name character varying(20) NOT NULL, CONSTRAINT user_pkey PRIMARY KEY (user_id) ) CREATE TABLE task ( task_id serial NOT NULL, user_id bigint, task_date date, name character varying(20), definition character varying(200), CONSTRAINT tasks_pkey PRIMARY KEY (task_id), CONSTRAINT fk_user FOREIGN KEY (user_id) REFERENCES "user" (user_id) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ) 

次に、これらのテーブルのエンティティクラスを示します。

 @Entity @Table(name = "user", schema = "public") public class User { private Long userId; private String name; private String login; private String password; private Integer role; private List<Task> tasks; @Id @SequenceGenerator(name = "user_seq", sequenceName = "user_user_id_seq", allocationSize = 0) @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_seq") @Column(name = "user_id") public Long getUserId() { return userId; } public void setUserId(Long userId) { this.userId = userId; } @OneToMany(fetch = FetchType.LAZY, mappedBy = "user", cascade = CascadeType.ALL) public List<Tasks> getTasks() { return tasks; } public void setTasks(List<Tasks> tasks) { this.tasks = tasks; } @Column(name = "name") public String getName() { return name; } public void setName(String name) { this.name = name; } @Column(name = "login") public String getLogin() { return login; } public void setLogin(String login) { this.login = login; } @Column(name = "password") public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } } @Entity @Table(name = "task", schema = "public") public class Task { private Long taskId; private User user; private Date taskDate; private String name; private String definition; private Priority priority; private Type type; @Id @SequenceGenerator(name = "tasks_seq", sequenceName = "tasks_task_id_seq", allocationSize = 0) @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "tasks_seq") @Column(name = "task_id", unique = true, nullable = false) public Long getTaskId() { return taskId; } public void setTaskId(Long taskId) { this.taskId = taskId; } @ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL) @JoinColumn(name = "user_id") public User getUser() { return user; } public void setUser(User user) { this.user = user; } @Column(name = "task_date") public Date getTaskDate() { return taskDate; } public void setTaskDate(Date taskDate) { this.taskDate = taskDate; } @Column(name = "name") public String getName() { return name; } public void setName(String name) { this.name = name; } @Column(name = "definition") public String getDefinition() { return definition; } public void setDefinition(String definition) { this.definition = definition; } } 

JPAアノテーションについてはこちらをご覧ください 。

2）。 セッションインターフェース

Hibernateでは、データベースの操作はorg.hibernate.Session型のオブジェクトを介して行われます。
ドキュメントからの抜粋：

JavaアプリケーションとHibernateの間のメインランタイムインターフェース。 これは、永続化サービスの概念を抽象化する中心的なAPIクラスです。
セッションのライフサイクルは、論理トランザクションの開始と終了によって制限されます。 （長いトランザクションは複数のデータベーストランザクションにまたがることがあります。）
セッションの主な機能は、マップされたエンティティクラスのインスタンスの作成、読み取り、削除操作を提供することです。

org.hibernate.Sessionインターフェースは、アプリケーションとHibernateの間のブリッジです。 セッションを使用して、 エンティティオブジェクトを使用したすべてのCRUD操作が実行されます。 Session型のオブジェクトは、 org.hibernate.SessionFactory型のインスタンスから取得されます。このインスタンスは、アプリケーションにシングルトンとして存在する必要があります。

3）。 オブジェクトの状態

エンティティオブジェクトは、次の3つの状態（ステータス）のいずれかになります。

• 一時的なオブジェクト 。 このステータスのオブジェクトは、エンティティクラスの塗りつぶされたインスタンスです。 データベースに保存できます。 セッションに接続されていません。 Idフィールドには入力しないでください。そうしないと、オブジェクトのステータスがデタッチされます。
• 永続オブジェクト 。 このステータスのオブジェクトは、特定のセッションにアタッチされるいわゆる保存されたエンティティです。 このステータスでのみ、オブジェクトはデータベースと対話します。 トランザクションでこのタイプのオブジェクトを操作する場合、オブジェクトに対するすべての変更はデータベースに記録されます。
• 分離オブジェクト 。 このステータスのオブジェクトは、セッションから切断されたオブジェクトであり、データベースに存在する場合と存在しない場合があります。

エンティティオブジェクトは、あるステータスから別のステータスに転送できます。 これを行うには、次のメソッドがSessionインターフェースに存在します。

• persist（オブジェクト） -オブジェクトをtransientからpersistentに変換します。つまり、セッションにアタッチしてデータベースに保存します。 ただし、オブジェクトのIdフィールドに値を割り当てると、 PersistentObjectExceptionが発生します。Hibernateは、 デタッチされたオブジェクト、つまりデータベースに存在すると見なします。 保存時に、 persist（）メソッドはselectを作成せずにすぐに挿入を実行します 。
• merge（オブジェクト） -オブジェクトを一時的または分離されたオブジェクトから永続 的なオブジェクトに変換します。 transientの場合、 persist（） （設定されていてもオブジェクトの新しいIDを生成する）と同様に動作し、 detachedの場合、データベースからオブジェクトをロードし、セッションにアタッチし、保存時に更新を実行します
• replicate（Object、ReplicationMode） -オブジェクトをデタッチから永続に変換しますが、オブジェクトには事前にIdを設定する必要があります。 このメソッドは、特定のIDを持つオブジェクトをデータベースに保存するように設計されていますが、 永続化（）およびマージ（）は許可しません。 このIDを持つオブジェクトがデータベースにすでに存在する場合、動作はorg.hibernate.ReplicationMode列挙からの規則に従って決定されます。
  ReplicationMode.IGNORE-データベースの変更はありません。
  ReplicationMode.OVERWRITE-オブジェクトは、既存のオブジェクトではなくデータベースに保存されます。
  ReplicationMode.LATEST_VERSION-最新バージョンのオブジェクトがデータベースに保存されます。
  ReplicationMode.EXCEPTION-例外をスローします。
• delete（オブジェクト） -データベースからオブジェクトを削除します。つまり、 persistentをtransientに変換します。 オブジェクトはどのような状態でもかまいません。主なことは、 IDが設定されていることです。
• save（オブジェクト） -オブジェクトをデータベースに保存し、インストールされていても新しいIdを生成します。 オブジェクトは一時的または切り離される可能性があります
• update（オブジェクト） -データベース内のオブジェクトを更新し、 永続 オブジェクトに変換します（ 分離状態のオブジェクト ）
• saveOrUpdate（オブジェクト）-save（ ）またはupdate（）を呼び出します
• refresh（オブジェクト） -データベースに対してselectを実行し、 永続オブジェクトに変換することにより、 デタッチされたオブジェクトを更新する
• get（Object.class、id） - 永続状態の特定のIDを持つデータベースからエンティティークラスのオブジェクトを取得します

Sessionオブジェクトは、ロードされたオブジェクトをキャッシュします。 データベースからオブジェクトをロードするとき、キャッシュが最初にチェックされます。 キャッシュからオブジェクトを削除してセッションから切断するには、 session.evict（Object）を使用します。 session.clear（）メソッドは、セッション内のすべてのオブジェクトにevict（）を適用します。

ここで、 エンティティクラスのアノテーション@OneToManyおよび@ManyToOneを見てみましょう。 @OneToManyのフェッチパラメーターは、子オブジェクトをいつ読み込むかを示します。 javax.persistence.FetchType列挙で指定された2つの値のいずれかを持つことができます。

FetchType.EAGER-親オブジェクトをロードするときに、子オブジェクトのコレクションをすぐにロードします。
FetchType.LAZY-最初のアクセス時に子オブジェクトのコレクションをロードします（ getを呼び出します ）-いわゆる遅延ロード。

カスケードパラメーターは、 セッションインターフェースのどのメソッドが関連するエンティティにカスケードされるかを示します。 たとえば、 タスクコレクションのUserエンティティクラスで、次を指定します。

 @OneToMany(fetch = FetchType.LAZY, mappedBy = "user", cascade = {CascadeType.PERSIST, CascadeType.MERGE}) public List<Tasks> getTasks() { return tasks; } public void setTasks(List<Tasks> tasks) { this.tasks = tasks; } 

次に、 session.persist（ユーザー）またはsession.merge（ユーザー）が実行されると、 タスクからのすべてのオブジェクトに永続化またはマージ操作が適用されます。 javax.persistence.CascadeType列挙の残りの操作についても同様です。 CascadeType.ALLは、列挙からのすべての操作を適用します。 データベースから不要な関連エンティティオブジェクトの束をロードしないように、 CascadeTypeを正しく構成する必要があります。

4）。 データベースからオブジェクトを抽出する

以下に簡単な例を示します。

  @Autowired private SessionFactory sessionFactory public void getTasks(Long userId) { ... Session session = sessionFactory.openSession(); User user = (User) session.load(User.class, userId); Session session = sessionFactory.openSession(); List<Task> tasksList = user.getTasks(); ... } 

session.get（）メソッドの代わりに、 session.load（）を使用できます。 session.load（）メソッドは、いわゆるproxy-objectを返します 。 プロキシオブジェクトは、データベース内の実際のオブジェクトとやり取りできる中間オブジェクトです。 エンティティオブジェクトの機能を拡張します。 プロキシオブジェクトとの相互作用は、エンティティオブジェクトとの相互作用に完全に似ています。 プロキシオブジェクトは、 プロキシオブジェクトを作成するときにデータベースクエリが実行されないという点でエンティティオブジェクトとは異なります。つまり、HibernateはこのIDを持つオブジェクトがデータベースに存在すると単純に信じています。 ただし、 proxy-objectの最初のgetまたはset呼び出しはすぐに選択要求を開始し、指定されたIDを持つオブジェクトがデータベースにない場合、 ObjectNotFoundExceptionを取得します 。 プロキシオブジェクトの主な目的は、遅延ロードを実装することです。

FetchType.LAZYは tasksの Userクラスで設定されているため、 user.getTasks（）呼び出しはデータベースからのユーザータスクのロードを開始します。

LazyInitializationException

FetchType.LAZYパラメーターには注意する必要があります。 関連するエンティティをロードするときに、 LazyInitializationExceptionをキャッチする場合があります。 上記のコードでは、 user.getTasks（）を呼び出すとき、 ユーザーは永続ステータスまたはプロキシステータスである必要があります。

また、 LazyInitializationExceptionにより、コードが若干変更される場合があります。

 public List<Task> getTasks(Long userId) { ... Session session = sessionFactory.openSession(); User user = (User) session.load(User.class, userId); List<Task> tasksList = user.getTasks(); session.close(); return tasksList; } 

ここではすべてが理論的に真実です。 ただし、 tasksListにアクセスしようとすると、 LazyInitializationExceptionが発生する可能性があります 。 しかし、デバッガーでは、このコードは正しく機能します。 なんで？ user.getTasks（）はコレクションへの参照のみを返すが、コレクションのロードを待機しないためです。 データの読み込みを待たずに、セッションを閉じました。 出力はトランザクションで実行されます、つまり：

  public List<Task> getTasks(Long userId) { ... User user = (User) session.load(User.class, userId); Session session = sessionFactory.openSession(); session.beginTransaction(); List<Task> tasksList = user.getTasks(); session.getTransaction().commit(); return tasksList; } 

条件付き選択

次に、条件付きのデータサンプリングの簡単な例をいくつか示します。 このため、タイプorg.hibernate.CriteriaのオブジェクトがHibernateで使用されます。

  public List<Task> getUser(String login) { ... Session session = sessionFactory.openSession(); Criteria userCriteria = session.createCriteria(User.class); userCriteria.add(Restrictions.eq("login", login)); user = (User) userCriteria.uniqueResult(); session.close(); ... } 

ここで、login = 'login'のユーザーからselect *を実行していることが明らかです。 addメソッドでは、特定の選択基準を表すタイプCriterionのオブジェクトを渡します。 org.hibernate.criterion.Restrictionsクラスは、さまざまな種類の基準を提供します。 「ログイン」パラメータは、データベーステーブルのフィールドではなく、エンティティクラスのプロパティの名前を示します。
さらにいくつかの例を示します。

a）。

  public List<Task> getTasksByName(String name) { ... session = sessionFactory.openSession(); Criteria criteria = session.createCriteria(Task.class); List<Task> tasks = criteria.add(Restrictions.like("name", name, MatchMode.ANYWHERE)).list(); ... } 

ここでは、 Taskエンティティクラスのnameプロパティのコンテンツを選択します。 MatchMode.ANYWHEREは、 「name」プロパティ内の任意の場所で部分文字列名を検索する必要があることを意味します。

b）
そして、ここではテーブルの20番目の数値から始めて50行を取得します。

  public List<Task> getTasks() { ... Session session = sessionFactory.openSession(); Criteria criteria = session.createCriteria(Task.class); List<Task> tasks = criteria.setFirstResult(20).setMaxResults(50).list(); ... } 

5）。 オブジェクトを保存する

エンティティオブジェクトをデータベースに保存するいくつかの方法を見てみましょう。

a）。 一時オブジェクトを作成し、データベースに保存します。

  @Autowired private UserDao userDao; @Autowired private SessionFactory sessionFactory; public void saveUser(String login) { User user = userDao.getUserByLogin(login); Session session = sessionFactory.openSession(); session.openTransaction(); Task task = new Task(); task.setName(" 1"); task.setDefinition(" 1"); task.setTaskDate(new Date()); task.setUser(user); session.saveOrUpdate(task); session.flush(); session.getTransaction().commit(); return task.getTaskId(); } 

いくつかのニュアンスに注意してください。 まず、データベースへの保存はトランザクションの一部としてのみ実行できます。 session.openTransaction（）を呼び出すと、このセッションの新しいトランザクションが開き、 session.getTransaction（）。Commit（）が実行します。 次に、 task.setUser（user）メソッドで、 ユーザーを分離状態で渡します 。 永続的なステータスで転送することもできます。

このコードは（ ユーザーの受信とは別に）2つのリクエストを実行します-nextval（ 'task_task_id_seq'）を選択 し、タスクに挿入します...
saveOrUpdate（）の代わりに、 save（） 、 persist（） 、 merge（）を実行できます-2つのクエリもあります。 session.flush（）呼び出しはすべての変更をデータベースに適用しますが、正直なところ、 commit（）自体はflush（）を呼び出すまでデータベースに何も保存されないため、この呼び出しはここでは役に立ちません。

データベースからロードされた永続 オブジェクトまたはプロキシオブジェクトステータスオブジェクトのトランザクション内で何かを変更すると、 更新リクエストが実行されることに注意してください。 タスクが新しいユーザーを参照する必要がある場合は、次を実行します。

  User user = new User(); //  <i>transient-object</i> user.setLogin("user"); user.setPassword("user"); ... task.setUser(user); session.saveOrUpdate(task); //  

注： ユーザーフィールドのTaskクラスでは、 CascadeType.PERSIST 、 CascadeType.MERGE、またはCascadeType.ALLを設定する必要があります。

データベースに存在するユーザーであるuserIdが手元にある場合、データベースからUserオブジェクトをロードする必要はなく、追加のselectを作成します 。 ユーザーIDをTaskクラスのプロパティに直接割り当てることはできないため、 userIdのみを入力してUserクラスのオブジェクトを作成する必要があります。 当然、これはtransient-objectにできないため、ここでは既知のプロキシオブジェクトを使用する必要があります。

 public void saveTask(Long userId, Task task) ... task.setUser((User) session.load(User.class, userId)); //       session.saveOrUpdate(task); ... 

b） オブジェクトを子オブジェクトのコレクションに追加します。

  public Long saveUser(String login) { Session session = sessionFactory.openSession(); session.openTransaction(); user = (User) session.load(User.class, userId); Task task = new Task(); task.setName(""); task.setUser(user); user.getTasks().add(task); session.getTransaction().commit(); return user.getUserId(); } 

Userでは、 tasksプロパティにCascadeType.ALLが必要です。 CascadeType.MERGEがインストールされている場合、 user.getTasks（）の後に追加（task） session.merge（user）を実行します 。 このコードは3つのクエリを実行します - ユーザーから*を 選択し、nextval（ 'task_task_id_seq'）を選択 してタスクに挿入します ...

6）。 オブジェクトを削除する

a）。 transient-objectを作成することで削除できます ：

  public void deleteTask(Long taskId) { Session session = sessionFactory.openSession(); session.openTransaction(); Tasks task = new Tasks(); task.setTaskId(taskId); session.delete(task); session.getTransaction().commit(); } 

このコードはタスクのみを削除します 。 ただし、 タスクがタイプproxy 、 persistentまたはdetachedのオブジェクトであり、 CascadeType.REMOVEがユーザーフィールドのTaskクラスで動作する場合 、関連するユーザーもデータベースから削除されます。 ユーザーを削除する必要がない場合は、どうしますか？ そう、 task.setUser（null）

b） この方法で削除できます：

  public void deleteTask(Long userId, Long taskId) { User user = (User) session.load(User.class, userId); user.getTasks().removeIf((Task task) -> { if (task.getTaskId() == taskId) { task.setUser(null); return true; } else return false; }); } 

このコードは、 タスクとユーザー間の接続を単に削除します 。 ここでは、newfangled lambda式を適用します。 タスクオブジェクトは、1つの条件下でデータベースから削除されます-Userエンティティクラスで何かを変更した場合：

  @OneToMany(fetch = FetchType.LAZY, mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true) public List<Tasks> getTasks() { return tasks; } public void setTasks(List<Tasks> tasks) { this.tasks = tasks; } 

orphanRemoval = trueパラメーターは、 ユーザーへのリンクを持たないすべてのTaskオブジェクトをデータベースから削除することを指定します。

7）。 宣言的なトランザクション管理

宣言的なトランザクション管理のために、 Spring Frameworkを使用します 。 トランザクション管理は、トランザクションマネージャを介して行われます。 session.openTransaction（）およびsession.commit（）を呼び出す代わりに、 @ Transactionalアノテーションが使用されます。 アプリケーション構成には次のものが必要です。

  <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"></property> </bean> <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <tx:annotation-driven transaction-manager="transactionManager"/> 

ここでは、 sessionFactory BeanがバインドされるtransactionManager Beanを定義しました。 HibernateTransactionManagerクラスは、HibernateライブラリのSessionFactory用の共通のorg.springframework.transaction.PlatformTransactionManagerインターフェースの実装です。 アノテーション駆動型は、トランザクションマネージャに@Transactionalアノテーションを処理するように指示します 。

-Chatterは無価値です。 コードを見せてください。 （ライナス・トーバルズ）

  @Transactional(propagation = Propagation.REQUIRED, rollbackFor = {ObjectNotFoundException.class, ConstraintViolationException.class}) public Long saveTask(Long userId) { Session session = sessionFactory.getCurrentSession(); Tasks task = new Tasks(); task.setName(" 1"); task.setDefinition(" 1"); task.setTaskDate(new Date()); task.setUser((User) session.load(User.class, userId)); session.saveOrUpdate(task); return task.getTaskId(); } 

@Transactional注釈は、メソッドをトランザクションで実行する必要があることを示します 。 トランザクションマネージャーは新しいトランザクションを開き、そのセッションのインスタンスを作成します。このインスタンスは、 sessionFactory.getCurrentSession（）を介して利用できます。 Sessionインスタンスはスレッド変数（ThreadLocal）であるため、このアノテーションを持つメソッドで呼び出されるすべてのメソッドもこのトランザクションにアクセスできます。 sessionFactory.openSession（）を呼び出すと、トランザクションに関連しない完全に異なるセッションが開きます。

rollbackForパラメーターは、トランザクションをロールバックするロールバックの例外を指定します。 逆パラメーター-noRollbackForがあります。これは、上記のすべての例外の結果、トランザクションがロールバックされることを示します。

伝播パラメータが最も興味深いです。 彼は取引の広がりの原則を示しています。 org.springframework.transaction.annotation.Propagation列挙から任意の値を取得できます。 以下に例を示します。

  @Autowired private SessionFactory sessionFactory; @Autowired private UserDao userDao; @Transactional(propagation = Propagation.REQUIRED, rollbackFor = {ConstraintViolationException.class}) public Long saveTask(Long userId) { Session session = sessionFactory.getCurrentSession(); User user = userDao.getUserByLogin("user1"); Tasks task = new Tasks(); task.setName(" 1"); ... task.setUser(user); session.saveOrUpdate(task); return task.getTaskId(); } 

UserDao.getUserByLogin（）メソッドは、 @ Transactionalアノテーションでタグ付けすることもできます 。 そして、ここで伝播パラメーターは、 saveTask（）メソッドトランザクションに関連するUserDao.getUserByLogin（）メソッドの動作を決定します。

• Propagation.REQUIRED-既存のトランザクションがある場合は実行し、存在しない場合は新しいトランザクションを作成します。
• Propagation.MANDATORY-既存のトランザクションで実行し、存在する場合は例外をスローします。
• Propagation.SUPPORTS-存在する場合は既存のトランザクションで実行し、存在しない場合はトランザクションの外部で実行します。
• Propagation.NOT_SUPPORTED-常にトランザクションの外部で実行されます。 既存のものがある場合は、停止します。
• Propagation.REQUIRES_NEW-常に新しい独立したトランザクションで実行されます。 既存のものがある場合、新しいトランザクションが完了するまで停止します。
• Propagation.NESTED-現在のトランザクションがある場合、新しい、いわゆるネストされたトランザクションで実行します。 ネストされたトランザクションがキャンセルされた場合、これは外部トランザクションに影響しません。 外部トランザクションがキャンセルされると、ネストされたトランザクションはキャンセルされます。 現在のトランザクションがない場合、新しいトランザクションが作成されます。
• Propagation.NEVER-常にトランザクションの外部で実行し、既存のトランザクションがある場合は例外をスローします。

トランザクションに関する良いもの 。 トランザクションを使用すると、パフォーマンスに追加のコストがかかることに注意してください。

要約すると

私の記事では、Hibernateでセッションとトランザクションを操作する最も基本的な原則を取り上げました。 この記事が、JavaプログラマーがHibernateライブラリ（おそらくすべての人ではない）のスーパークラスについて学習する際の最初のしきい値を克服するのに役立つことを願っています。 複雑で興味深いプログラミングアクティビティでの成功をお祈りします。

サンプルプロジェクト 。

ご清聴ありがとうございました！