LazyInitializationException: 在Hibernate中从与原始会话不同的会话中加载延迟属性

huangapple
go评论115阅读模式
英文:

LazyInitializationException: load lazy attribute from a session different from the original one in Hibernate

问题

  1. 我是初学者，正在学习 Hibernate，并尝试了解急加载和懒加载。
  3. 我知道如果 Hibernate 会话已关闭，然后我尝试检索懒加载数据，那么 Hibernate 将抛出异常。
  5. 现在，我尝试在第一个会话中加载主实体（Instructor），然后在一个***新的独立会话***中加载从属实体（Course）：
  7. **主类（测试类）**
  9. ```java
  10. public class EagerLazyDemo {
  11.     public static void main(String[] args) {
  13.         SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
  14.                 .addAnnotatedClass(Instructor.class)
  15.                 .addAnnotatedClass(InstructorDetail.class)
  16.                 .addAnnotatedClass(Course.class)
  17.                 .buildSessionFactory();
  19.         Session session = factory.getCurrentSession();
  21.         // 开始事务
  22.         session.beginTransaction();
  24.         // 从数据库获取讲师信息
  25.         Instructor theInstructor = session.get(Instructor.class, 1);
  27.         // 提交事务
  28.         session.getTransaction().commit();
  30.         session.close();
  32.         //------
  34.         // 新会话
  35.         session = factory.getCurrentSession();
  36.         session.beginTransaction();
  38.         // 获取并显示讲师的课程
  39.         List<Course> courses = theInstructor.getCourses();
  40.         printCourses(courses);
  42.         session.getTransaction().commit();
  43.         session.close();
  45.     }
  47.     private static void printCourses(List<Course> courses) {
  48.         for (Course c : courses) {
  49.             System.out.println(c);
  50.         }
  51.     }
  52. }

但是 Hibernate 抛出了以下异常：

错误：

  1. Exception in thread "main" org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.mehdisarf.hibernate.demo.entity.Instructor.courses, could not initialize proxy - no Session
  2.     at org.hibernate.collection.internal.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:606)
  3.     at org.hibernate.collection.internal.AbstractPersistentCollection.withTemporarySessionIfNeeded(AbstractPersistentCollection.java:218)
  4.     at org.hibernate.collection.internal.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:585)
  5.     at org.hibernate.collection.internal.AbstractPersistentCollection.read(AbstractPersistentCollection.java:149)
  6.     at org.hibernate.collection.internal.PersistentBag.iterator(PersistentBag.java:387)
  7.     at com.mehdisarf.hibernate.demo.EagerLazyDemo.printCourses(EagerLazyDemo.java:55)
  8.     at com.mehdisarf.hibernate.demo.EagerLazyDemo.main(EagerLazyDemo.java:42)

它表示：

> 无法初始化代理 - 没有会话

尽管我已经为加载从属实体创建了一个会话

以下是我的实体类：

讲师类（主实体）

  1. @Entity
  2. @Table(name = "instructor")
  3. public class Instructor {
  5.     // ... （省略其他代码）
  7.     @OneToMany(fetch = FetchType.LAZY,
  8.             mappedBy = "instructor",
  9.             cascade = {CascadeType.DETACH, CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
  10.     private List<Course> courses;
  12.     // ... （省略其他代码）
  13. }

课程类（从属实体）

  1. @Entity
  2. @Table(name = "course")
  3. public class Course {
  5.     // ... （省略其他代码）
  7.     @ManyToOne(cascade = {CascadeType.DETACH, CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
  8.     @JoinColumn(name = "instructor_id")
  9.     private Instructor instructor;
  11.     // ... （省略其他代码）
  12. }
  2. <details>
  3. <summary>英文:</summary>
  4. I&#39;m beginner at hibernate and try to learn eager and lazy loading
  5. I know that if the hibernate session is closed and then I try to retrieve lazy data, then Hibernate will throw an exception. 
  6. Now, I&#39;ve tried to load main entity(Instructor) in first session and then load dependent entity(Course) in a ***new separate session***: 
  7. **Main Class(Test Class)**
  8. public class EagerLazyDemo {
  9. public static void main(String[] args) {
  10. SessionFactory factory = new Configuration().configure(&quot;hibernate.cfg.xml&quot;)
  11. .addAnnotatedClass(Instructor.class)
  12. .addAnnotatedClass(InstructorDetail.class)
  13. .addAnnotatedClass(Course.class)
  14. .buildSessionFactory();
  15. Session session = factory.getCurrentSession();
  16. // Begin A Transaction
  17. session.beginTransaction();
  18. // Get The Instructor From DB
  19. Instructor theInstructor = session.get(Instructor.class, 1);
  20. // Commit Transaction
  21. session.getTransaction().commit();
  22. session.close();
  23. //------
  24. //new session
  25. session = factory.getCurrentSession();
  26. session.beginTransaction();
  27. //Get And Display Courses For The Instructor
  28. List&lt;Course&gt; courses = theInstructor.getCourses();
  29. printCourses(courses);
  30. session.getTransaction().commit();
  31. session.close();
  32. }
  33. private static void printCourses(List&lt;Course&gt; courses) {
  34. for (Course c : courses) {
  35. System.out.println(c);
  36. }
  37. }
  38. }
  39. but hibernate throw this exception:  
  40. **Error:**
  41. Exception in thread &quot;main&quot; org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.mehdisarf.hibernate.demo.entity.Instructor.courses, could not initialize proxy - no Session
  42. at org.hibernate.collection.internal.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:606)
  43. at org.hibernate.collection.internal.AbstractPersistentCollection.withTemporarySessionIfNeeded(AbstractPersistentCollection.java:218)
  44. at org.hibernate.collection.internal.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:585)
  45. at org.hibernate.collection.internal.AbstractPersistentCollection.read(AbstractPersistentCollection.java:149)
  46. at org.hibernate.collection.internal.PersistentBag.iterator(PersistentBag.java:387)
  47. at com.mehdisarf.hibernate.demo.EagerLazyDemo.printCourses(EagerLazyDemo.java:55)
  48. at com.mehdisarf.hibernate.demo.EagerLazyDemo.main(EagerLazyDemo.java:42)
  49. **it says:**
  50. &gt; could not initialize proxy - no Session
  51. Although I have a session for loading dependent entity
  52. **These Are My Entity Classes:**
  53. **Instructor Class (main entity)**
  54. @Entity
  55. @Table(name = &quot;instructor&quot;)
  56. public class Instructor {
  57. @Id
  58. @GeneratedValue(strategy = GenerationType.IDENTITY)
  59. @Column(name = &quot;id&quot;)
  60. private int id;
  61. @Column(name = &quot;first_name&quot;)
  62. private String firstName;
  63. @Column(name = &quot;last_name&quot;)
  64. private String lastName;
  65. @Column(name = &quot;email&quot;)
  66. private String email;
  67. @OneToOne(cascade = CascadeType.ALL)
  68. @JoinColumn(name = &quot;instructor_detail_id&quot;)
  69. private InstructorDetail instructorDetail;
  70. @OneToMany(fetch = FetchType.LAZY,
  71. mappedBy = &quot;instructor&quot;,
  72. cascade = {CascadeType.DETACH, CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
  73. private List&lt;Course&gt; courses;
  74. public Instructor() {
  75. }
  76. public Instructor(String firstName, String lastName, String email) {
  77. this.firstName = firstName;
  78. this.lastName = lastName;
  79. this.email = email;
  80. }
  81. public void addCourse(Course theCourse) {
  82. if (courses == null) {
  83. courses = new ArrayList&lt;&gt;();
  84. }
  85. this.courses.add(theCourse);
  86. theCourse.setInstructor(this);
  87. }
  88. public int getId() {
  89. return id;
  90. }
  91. public void setId(int id) {
  92. this.id = id;
  93. }
  94. public String getFirstName() {
  95. return firstName;
  96. }
  97. public void setFirstName(String firstName) {
  98. this.firstName = firstName;
  99. }
  100. public String getLastName() {
  101. return lastName;
  102. }
  103. public void setLastName(String lastName) {
  104. this.lastName = lastName;
  105. }
  106. public String getEmail() {
  107. return email;
  108. }
  109. public void setEmail(String email) {
  110. this.email = email;
  111. }
  112. public InstructorDetail getInstructorDetail() {
  113. return instructorDetail;
  114. }
  115. public void setInstructorDetail(InstructorDetail instructorDetail) {
  116. this.instructorDetail = instructorDetail;
  117. }
  118. public List&lt;Course&gt; getCourses() {
  119. return courses;
  120. }
  121. public void setCourses(List&lt;Course&gt; courses) {
  122. this.courses = courses;
  123. }
  124. @Override
  125. public String toString() {
  126. return id + &quot;&quot; + firstName + &quot;&quot; + lastName + &quot;&quot; + email + &quot;  (Detail:&quot; + instructorDetail+&quot;)&quot;;
  127. }
  128. }
  129. **Course Class (dependent entity)**
  130. @Entity
  131. @Table(name = &quot;course&quot;)
  132. public class Course {
  133. @Id
  134. @GeneratedValue(strategy = GenerationType.IDENTITY)
  135. @Column(name = &quot;id&quot;)
  136. private int id;
  137. @Column(name = &quot;title&quot;)
  138. private String title;
  139. @ManyToOne(cascade = {CascadeType.DETACH, CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
  140. @JoinColumn(name = &quot;instructor_id&quot;)
  141. private Instructor instructor;
  142. public Course() {
  143. }
  144. public Course(String title) {
  145. this.title = title;
  146. }
  147. public int getId() {
  148. return id;
  149. }
  150. public void setId(int id) {
  151. this.id = id;
  152. }
  153. public String getTitle() {
  154. return title;
  155. }
  156. public void setTitle(String title) {
  157. this.title = title;
  158. }
  159. public Instructor getInstructor() {
  160. return instructor;
  161. }
  162. public void setInstructor(Instructor instructor) {
  163. this.instructor = instructor;
  164. }
  165. @Override
  166. public String toString() {
  167. return id + &quot;|&quot; + title + &quot;|&quot;;
  168. }
  169. }
  170. </details>
  171. # 答案1
  172. **得分**: 2
  173. 你的对象theInstructor仍然与之前的会话关联。为了检索你的对象，在打开新会话后，你需要进行另一个调用：
  174. theInstructor = session.get(Instructor.class, 1);
  175. <details>
  176. <summary>英文:</summary>
  177. Your object theInstructor is still linked to the former session. In order to retrieve your object you have to make another call after opening the new session :
  178. theInstructor = session.get(Instructor.class, 1);
  179. </details>
  180. # 答案2
  181. **得分**: 1
  182. "theInstructor"在进行"theInstructor.getCourses()"调用时，并未连接到任何会话，这导致了异常。
  183. 当对象通过get方法返回时，它处于持久状态。
  184. > 任何由get()或load()方法返回的实例都是持久的。[会话文档][1]
  185. 当会话关闭时，"theInstructor"对象进入脱离状态。
  186. > 脱离状态 - 脱离的实例是指已经持久化，但其会话已关闭的对象。[Hibernate对象状态文档][2]
  187. 调用`session = factory.getCurrentSession();`返回新的会话对象，但"theInstructor"对象并未连接到新会话。因此，尝试惰性加载课程时会失败。
  188. [1]: https://docs.jboss.org/hibernate/orm/3.5/api/org/hibernate/Session.html#get(java.lang.Class,%20java.io.Serializable)
  189. [2]: https://docs.jboss.org/hibernate/core/3.5/reference/en/html/objectstate.html
  190. <details>
  191. <summary>英文:</summary>
  192. &quot;theInstructor&quot; is not attached to any session while &quot;theInstructor.getCourses()&quot; call is made, this results in exception.
  193. When object is returned by the get method it is in the Persistent state.
  194. &gt; Any instance returned by a get() or load() method is persistent
  195. [Session Documentation][1]
  196. When session is closed &quot;theInstructor&quot; object goes into the Detached state.
  197. &gt; Detached - a detached instance is an object that has been persistent, but its Session has been closed. [Hibernate object states documentation][2]
  198. Call made to `session = factory.getCurrentSession();` returns new session object, but `theInstructor` object is not attached to the new session. Hence an attempt to lazily load the courses fails.
  199. [1]: https://docs.jboss.org/hibernate/orm/3.5/api/org/hibernate/Session.html#get(java.lang.Class,%20java.io.Serializable)
  200. [2]: https://docs.jboss.org/hibernate/core/3.5/reference/en/html/objectstate.html
  201. </details>

huangapple
  • 本文由 发表于 2020年5月5日 05:20:43
  • 转载请务必保留本文链接：https://go.coder-hub.com/61601826.html
  • hibernate
  • java
  • jpa
  • mysql
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定