Hibernate 查询结果的展现
Hibernate 查询结果的展现,Hibernate是通过对象包含对象这样的方式来维护关系的,那么当我们需要查询关联对象的时候,先通过Hib
我们使用hibernate(以下简称h)来管理数据库表的关联关系,基本的原理其实是很简单的,就是将数据库中表之间的关联转移到了实体bean的类之间,配置好了以后h就可以帮我们维持这种关联关系了。这的确带来了很大的方便,我们可以在我们的程序中以hql来面向对象的获取或保存数据了,例如以前我们要查询一个班级里面的学生的信息,自己写sql的话需要关联2张表,而且还要自己手动的将查询到的数据一个一个的取出来,然后封装到我们的bean里面去最后才能字啊jsp中显示出来,这个过程是很繁琐的,有了h,我们就可以不用在sql显式的写这种关联关系了,我们选择将这种关联关系写到h的映射文件中去,这样一来h就帮我们维护这种关系了,我们需要查询班级里面的学生的信息的时候,只要通过hql: from Class as c where c.id=:id;就可以得到具体的一个班级的实体对象(假设是c),接着Set
通过上面我们知道,Hibernate是通过对象包含对象这样的方式来维护关系的,那么当我们需要查询关联对象的时候,先通过Hibernate得到主对象,再调用主对象的get×得到关联对象,就可以获取关联信息了,然后组装数据到jsp上去显示。 我们可以简单的写成:hql=“select new map(c.id as id ,c.name as name,c.students[0].name as studentname) from Class as c where c.id=:id”; 这样就同时完成了数据的查询和组装。将查询到的数据组装到一个map中,as 后面的就是 map的key,map的值就是查询出来的数据了。这种数据组装方式比:
while (it.hasNext()) {
10 Object[] tuple = (Object[]) it.next();
11 Members members = (Members) tuple[ 0 ];
12 String className = (String) tuple[ 1 ];
要简洁很多。
当然,我们也可以定义自己的实体类来容纳查询出的数据:
selectnew NewMembers(members, classInfo.className) " +
3 " from Members members, ClassInfo classInfo " +
4 " where members.level = classInfo.classCode "
也可以 使用hibernateapi 函数 setResultTransformer 将查询结果存放到我们自定义的bo对象中去:
Query q = factory.getCurrentSession().createSQLQuery(sql).setResultTransformer(Transformers.aliasToBean(PostVO.class));关于数据组装,有很多方法,不一而论。我们下面要讨论的是,h在涉及到3张或3张以上的表的复杂的查询的时候,如何使用的问题。我们知道2张或者一张表的情形使用我们上面介绍的方式就足够了,但是对3张以上的表关联的复杂查询,我们则要比较2中方式的好坏了:一种方式是仍然将表关系通过配置映射文件交给h来管理,,这样一来我们不仅仅要在配置文件里配置多个关系,而且在对应的实体类里面也要加入关联属性,在查询的时候得到主实体对象以后还有多次调用其属性来获取关联表的信息,这样不是不可以,但是是比较繁琐的,稍微不注意就容易出现错误。如果要查询的表多于5张,最好的建议就是使用native sql来做,也就是通过直接执行sql语句来查询,表间的关联关系直接在sql语句里面写明,不要h来管理,这样一来少了h的配置,二来不需要定义每个表对应的实体类,也算省了很多事情,在使用native sql的时候有一些需要注意的地方: Session s = sessionFactory.openSession(); String sql="select book.bookname,borr.borrowTime,borr.backTime,pub.pubname,bs.name bookcasename,book.price from " +"(select * from tb_borrow where ifback=0) " +"as borr left join tb_bookinfo book on borr.bookid=book.id join tb_publishing pub " +"on book.isbn=pub.isbn join tb_bookcase bs " +" on book.bookcase=bs.id join tb_reader r on borr.readerid=r.id where r.barcode=?"; Query query=s.createSQLQuery(sql).addScalar("bookname", Hibernate.STRING) .addScalar("borrowTime", Hibernate.STRING). addScalar("backTime", Hibernate.STRING).addScalar("pubname", Hibernate.STRING). addScalar("bookcasename", Hibernate.STRING).addScalar("price", Hibernate.STRING); query.setParameter(0, barCode); List list=null; try{ list=query.list(); s.close(); } catch (Exception e) { e.printStackTrace(); } return list; 1. Session session = sessionFactory.openSession();session.createSQLQuery(sql);通过这种方式获得查询对象query。2. list=query.list();得到的是一个数组列表(ArrayList),其中列表的每个元素都是object类型的数组,代表查询结果的一条记录,也就是说h会将sql查询出来的其中的每个字段都强制转换成Object类型,然后组成一个数组方到list里面去。3.单纯使用s.createSQLQuery(sql)往往会报“找不到列”的错误,其实这是h对native sql支持的原因,因为Hibernate是通过使用ResultSetMetadata来判定返回的标量值的实际顺序和类型的,假若某个指定的类型没有被映射,或者不是你所预期的类型那么就会出现上述错误了,所以通过addScalar()明确指出返回什么列以及每个列的类型就可以避免上述错误了。最好你根据实际的类型将得到的object转换成实际的类型,就可以得到这些类型中保存的信息了。

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen



Hibernate in das SpringBoot-Projekt integrieren Vorwort Hibernate ist ein beliebtes ORM-Framework (Object Relational Mapping), das Java-Objekte Datenbanktabellen zuordnen kann, um Persistenzvorgänge zu erleichtern. Im SpringBoot-Projekt kann uns die Integration von Hibernate dabei helfen, Datenbankoperationen einfacher durchzuführen. In diesem Artikel wird die Integration von Hibernate in das SpringBoot-Projekt vorgestellt und entsprechende Beispiele bereitgestellt. 1.Abhängigkeiten einführenFügen Sie die folgenden Abhängigkeiten in die Datei pom.xml ein: org.springframework.bootspring-boot-starter-data-jpam

Java ist eine objektorientierte Programmiersprache, die im Bereich der Softwareentwicklung weit verbreitet ist. Hibernate ist ein beliebtes Java-Persistenz-Framework, das eine einfache und effiziente Möglichkeit bietet, die Persistenz von Java-Objekten zu verwalten. Während des Entwicklungsprozesses treten jedoch häufig Hibernate-Fehler auf, die dazu führen können, dass das Programm abnormal beendet wird oder instabil wird. Der Umgang mit und die Vermeidung von Hibernate-Fehlern ist zu einer Fähigkeit geworden, die Java-Entwickler beherrschen müssen. In diesem Artikel werden einige gängige Hib vorgestellt

Die Unterschiede zwischen Hibernate und Mybatis: 1. Implementierungsmethode; 3. Vergleich der Objektverwaltung; Detaillierte Einführung: 1. Implementierungsmethode: Hibernate ist eine vollständige Objekt-/Relational-Mapping-Lösung, die Objekte Datenbanktabellen zuordnet, während MyBatis von Entwicklern das manuelle Schreiben von SQL-Anweisungen und ResultMap erfordert. 2. Leistung: Hibernate ist in Bezug auf die Entwicklungsgeschwindigkeit schneller MyBatis, weil Hibernate die DAO-Ebene usw. vereinfacht.

Hibernate ist ein hervorragendes ORM-Framework, das den Datenzugriff zwischen Java-Anwendungen und relationalen Datenbanken vereinfacht. In Hibernate können wir Eins-zu-Viele- und Viele-zu-Viele-Beziehungen verwenden, um komplexe Datenmodelle zu verarbeiten. Die Eins-zu-Viele-Beziehung von Hibernate In Hibernate bedeutet eine Eins-zu-Viele-Beziehung, dass eine Entitätsklasse mehreren anderen Entitätsklassen entspricht. Beispielsweise kann eine Bestellung mehreren Bestellpositionen (OrderItem) entsprechen, und ein Benutzer (User) kann mehreren Bestellungen (Order) entsprechen. Um eine Eins-zu-Viele-Beziehung in Hibernate zu implementieren, müssen Sie in der zu speichernden Entitätsklasse ein Sammlungsattribut definieren

Hibernate ist ein Open-Source-ORM-Framework, das die Datenzuordnung zwischen relationalen Datenbanken und Java-Programmen miteinander verbindet und so Entwicklern den Zugriff auf Daten in der Datenbank erleichtert. Die Verwendung des Hibernate-Frameworks kann den Aufwand beim Schreiben von SQL-Anweisungen erheblich reduzieren und die Entwicklungseffizienz und Wiederverwendbarkeit von Anwendungen verbessern. Lassen Sie uns das Hibernate-Framework unter folgenden Gesichtspunkten vorstellen. 1. Vorteile des Hibernate-Frameworks: objektrelationale Zuordnung, Ausblenden von Datenbankzugriffsdetails, Ermöglichen der Entwicklung

In diesem Artikel erfahren Sie, wie Sie Masseneinfügungen/-aktualisierungen im Ruhezustand durchführen. Wann immer wir eine SQL-Anweisung ausführen, führen wir dies durch einen Netzwerkaufruf an die Datenbank durch. Wenn wir nun 10 Einträge in die Datenbanktabelle einfügen müssen, müssen wir 10 Netzwerkaufrufe durchführen. Stattdessen können wir Netzwerkaufrufe mithilfe der Stapelverarbeitung optimieren. Durch die Stapelverarbeitung können wir eine Reihe von SQL-Anweisungen in einem einzigen Netzwerkaufruf ausführen. Um dies zu verstehen und umzusetzen, definieren wir unsere Entität: @EntitypublicclassParent{@Id@GeneratedValue(strategy=GenerationType.AUTO)

Caching trägt dazu bei, Datenbanknetzwerkaufrufe beim Ausführen von Abfragen zu reduzieren. Cache- und Sitzungsverknüpfung der Ebene 1. Es wird implizit implementiert. Der Cache der ersten Ebene existiert, bis das Sitzungsobjekt existiert. Sobald das Sitzungsobjekt beendet/geschlossen ist, sind keine zwischengespeicherten Objekte mehr vorhanden. Der Cache der zweiten Ebene funktioniert für mehrere Sitzungsobjekte. Es ist mit der Session Factory verknüpft. Cache-Objekte der zweiten Ebene stehen allen Sitzungen über eine einzige Sitzungsfabrik zur Verfügung. Diese Cache-Objekte werden beendet, wenn eine bestimmte Sitzungsfabrik geschlossen wird. Um den Second-Level-Cache zu implementieren, müssen wir die folgenden Abhängigkeiten hinzufügen, um den Second-Level-Cache zu verwenden. <!--https://mvnrepository.com/artifact/net.sf.ehcache/ehcache--><de

Java-Framework-Technologie-Stack: Einführung häufig verwendeter Java-Frameworks wie SpringMVC, Hibernate, MyBatis usw. Mit der kontinuierlichen Entwicklung von Java wurden immer mehr Frameworks entwickelt, um den Entwicklungsprozess zu vereinfachen. Unter ihnen sind SpringMVC, Hibernate, MyBatis usw. eines der am häufigsten verwendeten Frameworks in der Java-Entwicklung. In diesem Artikel werden die grundlegenden Konzepte und die Verwendung dieser Frameworks vorgestellt, um den Lesern zu helfen, diese Frameworks besser zu verstehen und anzuwenden. Lassen Sie uns zunächst Sp vorstellen
