简谈解决Hibernate懒加载的4种方式

Dieser Artikel zusammenfasst die vier Methoden, die ich während des Lernens von Hibernate verwendet habe, um das Lazy Loading-Problem zu lösen.

Lazy Loading (lazy) bedeutet verspätete Ladezeiten, verzögerte Ladezeiten.

Wann sollte man Lazy Loading verwenden? Ich kann nur antworten, dass man Lazy Loading verwenden sollte, wenn man es tun muss.

Warum verwenden wir Lazy Loading? Weil es bei zu großen Datenmengen, die wir abrufen möchten, offensichtlich nicht angebracht ist, auf den Cache zurückzugreifen, da der Speicherplatz begrenzt ist. Um die Anzahl der gleichzeitigen Verbindungen zu reduzieren und den Verbrauch der Systemressourcen zu verringern, laden wir die Daten nur dann, wenn sie benötigt werden, und verwenden in diesem Fall Lazy Loading.

例如，有一个对象是Employee，还有一个对象是Department。显然，对于Employee相对于Department来说，是多对一的关系；而对于Department相对于Employee来说，是一对多的关系。当我们查询Employee对象时，如果希望通过employee对象的属性department查询到对应的Department，那么会抛出异常。这是因为懒加载的存在，在session关闭之后，Hibernate又向数据库发出一次请求，结果就抛出异常了。

以下总结的是解决这个问题的四种方法：

1.显式初始化（在查询方法内部）

要查询某员工属于哪个部门时，需要对Department进行预先查询

使用语句

Hibernate.initialize(Department.class); 

2.修改对象关系文件，将lazy改写为lazy=false，即关闭懒加载

以上两种方法确实可以解决问题，但缺点是无论是否使用该对象，Hibernate都会向数据库发出SQL语句请求数据，造成不必要的性能浪费。

3.使用过滤器（web项目）

①获取session的方式必须使用getCurrentSession

②特殊的关闭session方式

public void doFilter(ServletRequest request, ServletResponse response, 
   FilterChain arg2) throws IOException, ServletException { 
  // TODO 自动-生成的方法存根 
  Session session = null; 
  Transaction tx = null; 
  try { 
   session = HibernateUtil.getCurrentSession(); 
   tx = session.beginTransaction(); 
   arg2.doFilter(request, response);//请求一直在进行 
   tx.commit(); 
  } catch (Exception e) { 
   // TODO: 处理异常 
   if (tx != null) { 
    tx.rollback(); 
   } 
  } finally { 
   //特殊关闭方式 
   HibernateUtil.closeCurrentSession(); 
  } 
 } 

4.In der SSH-Framework verwendet man den von Spring bereitgestellten openSessionView

Der Prinzip ist ähnlich wie die dritte Methode, nur dass dieser Filter von Spring bereitgestellt wird. Beim Verwenden müssen Sie nur wie folgt im web.xml-Datei konfigurieren:

<!-- Verwenden Sie Spring, um das Lazy Loading Problem zu lösen --> 
 <filter 
  <filter-name>OpenSessionInViewFilter</Filter-name> 
  <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</Filter-class> 
 </filter> 
 <filter-Mapping> 
  <filter-name>OpenSessionInViewFilter</Filter-name> 
  <url-Pattern>/*</url-Pattern> 
 </Filter-Mapping> 

und3und4Diese Methode kann auch das Lazy Loading Problem lösen, insbesondere die4Diese beiden Methoden werden auch häufig verwendet. Aber diese beiden Methoden haben auch Nachteile. Der Nachteil ist, dass die Zeit bis zum Schließen der Sitzung verlängert wird und das Leben der Sitzung verlängert wird. Bevor diese Methode verwendet wurde, wurde die Sitzung nach dem Abfragen der Daten geschlossen;而现在，das Schließen der Sitzung ist am Ende einer Web-Anfrage.

Zusammenfassung

Das ist das Ende dieses Artikels über eine kurze Diskussion über die Lösung von Hibernate-Lazy Loading4Dieser Artikel enthält den gesamten Inhalt dieser Methode und hofft, dass er allen hilft. Freunde, die interessiert sind, können weiterhin andere verwandte Themen dieser Website lesen. Bitte lassen Sie uns wissen, wenn es Fehler gibt. Vielen Dank für die Unterstützung der Freunde dieser Website!

Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet übernommen und gehört dem Urheberrechtsinhaber. Der Inhalt wurde von Internetnutzern freiwillig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht von Hand bearbeitet. Sie übernimmt auch keine rechtlichen Verantwortlichkeiten. Wenn Sie urheberrechtlich geschützte Inhalte entdecken, freuen wir uns über eine E-Mail an: notice#oldtoolbag.com (Bitte ersetzen Sie # durch @ beim Senden einer E-Mail zur Meldung von Missbrauch und stellen Sie relevante Beweise zur Verfügung. Bei nachgewiesener Täuschung wird diese Website die beanstandeten urheberrechtlichen Inhalte sofort löschen.)