Wir haben gesehen, wie wir HQL und Native SQL Query in Hibernate verwenden können. Wenn es viele Abfragen gibt, verursachen sie ein Chaos im Code, da alle Abfragen über das gesamte Projekt verstreut sind. Deshalb bietet Hibernate Named Queries, die an einem zentralen Ort definiert und überall im Code verwendet werden können. Wir können Named Queries sowohl für HQL als auch für Native SQL erstellen.
Hibernate Named Query
Hibernate Named Query, @NamedQueryHibernate Named Query kann in Hibernate-Mapping-Dateien oder durch die Verwendung von JPA-Annotationen @NamedQuery und @NamedNativeQuery definiert werden. Heute werfen wir einen Blick auf beide und darauf, wie man Hibernate Named Query in einer einfachen Anwendung verwendet. Wir verwenden dieselben Datenbanktabellen wie im HQL-Beispiel, sodass Sie diesen Beitrag für das Setup-SQL-Skript der Datenbank überprüfen können. Für unser Hibernate Named Query Beispielprojekt verwenden wir Annotationen für das Hibernate-Mapping. Allerdings erstellen wir einige Named Queries sowohl in Mapping-Dateien als auch in Entity-Bean-Klassen. Unsere endgültige Projektstruktur sieht wie folgt aus, wir konzentrieren uns hauptsächlich auf die Komponenten, die mit Hibernate Named Query zusammenhängen.
Hibernate Konfigurations-XML
hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration SYSTEM "https://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.password">pankaj123</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
<property name="hibernate.connection.username">pankaj</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.current_session_context_class">thread</property>
<property name="hibernate.show_sql">true</property>
<mapping />
<mapping />
<mapping resource="named-queries.hbm.xml" />
</session-factory>
</hibernate-configuration>Hibernate Named Query XML
Wir haben eine Hibernate-Mapping-Datei, die nur HQL-Named-Queries und Native-SQL-Named-Queries enthält.
named-queries.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<query name="HQL_GET_ALL_EMPLOYEE">from Employee</query>
<query name="HQL_GET_EMPLOYEE_BY_ID">
<![CDATA[from Employee where emp_id = :id]]>
</query>
<query name="HQL_GET_EMPLOYEE_BY_SALARY">
<![CDATA[from Employee where emp_salary > :salary]]>
</query>
<sql-query name="SQL_GET_ALL_EMPLOYEE">
<![CDATA[select emp_id, emp_name, emp_salary from Employee]]>
</sql-query>
<sql-query name="SQL_GET_ALL_EMP_ADDRESS">
<![CDATA[select {e.*}, {a.*} from Employee e join Address a ON e.emp_id=a.emp_id]]>
<return alias="e" />
<return-join alias="a" property="e.address"></return-join>
</sql-query>
</hibernate-mapping>Das query-Element wird für HQL-Named-Queries verwendet und das sql-query-Element für Native-SQL-Named-Queries. Wir können das return-Element verwenden, um die Entität zu deklarieren, der das Resultset zugeordnet wird. Das return-join wird verwendet, wenn wir einen Join von mehreren Tabellen haben. Wir sollten CDATA verwenden, um unsere Hibernate-Named-Query zu deklarieren, um sicherzustellen, dass sie als Daten behandelt wird, da andernfalls < und >-Zeichen unsere Mapping-XML-Datei durcheinander bringen.
Hibernate Named Query @NamedQuery Annotation
Wir haben zwei Modellklassen - Employee und Address. Wir haben Named Queries in der Address-Klasse wie folgt definiert.
package com.journaldev.hibernate.model;
package com.journaldev.hibernate.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.NamedNativeQueries;
import javax.persistence.NamedNativeQuery;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;
@Entity
@Table(name = "ADDRESS")
@NamedQueries({ @NamedQuery(name = "@HQL_GET_ALL_ADDRESS",
query = "from Address") })
@NamedNativeQueries({ @NamedNativeQuery(name = "@SQL_GET_ALL_ADDRESS",
query = "select emp_id, address_line1, city, zipcode from Address") })
public class Address {
@Id
@Column(name = "emp_id", unique = true, nullable = false)
@GeneratedValue(generator = "gen")
@GenericGenerator(name = "gen", strategy = "foreign", parameters = { @Parameter(name = "property", value = "employee") })
private long id;
@Column(name = "address_line1")
private String addressLine1;
@Column(name = "zipcode")
private String zipcode;
@Column(name = "city")
private String city;
@OneToOne
@PrimaryKeyJoinColumn
private Employee employee;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getAddressLine1() {
return addressLine1;
}
public void setAddressLine1(String addressLine1) {
this.addressLine1 = addressLine1;
}
public String getZipcode() {
return zipcode;
}
public void setZipcode(String zipcode) {
this.zipcode = zipcode;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public Employee getEmployee() {
return employee;
}
public void setEmployee(Employee employee) {
this.employee = employee;
}
@Override
public String toString() {
return "AddressLine1= " + addressLine1 + ", City=" + city
+ ", Zipcode=" + zipcode;
}
}Hibernate Named Query Testprogramm
Schreiben wir ein Testprogramm, um alle oben definierten Hibernate Named Queries zu verwenden.
package com.journaldev.hibernate.main;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.journaldev.hibernate.model.Address;
import com.journaldev.hibernate.model.Employee;
import com.journaldev.hibernate.util.HibernateUtil;
public class HibernateNamedQueryExample {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
// Prep work
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.getCurrentSession();
Transaction tx = session.beginTransaction();
//HQL Named Query Example
Query query = session.getNamedQuery("HQL_GET_ALL_EMPLOYEE");
List empList = query.list();
for (Employee emp : empList) {
System.out.println("List of Employees::" + emp.getId() + ","
+ emp.getAddress().getCity());
}
query = session.getNamedQuery("HQL_GET_EMPLOYEE_BY_ID");
query.setInteger("id", 2);
Employee emp = (Employee) query.uniqueResult();
System.out.println("Employee Name=" + emp.getName() + ", City="
+ emp.getAddress().getCity());
query = session.getNamedQuery("HQL_GET_EMPLOYEE_BY_SALARY");
query.setInteger("salary", 200);
empList = query.list();
for (Employee emp1 : empList) {
System.out.println("List of Employees::" + emp1.getId() + ","
+ emp1.getSalary());
}
query = session.getNamedQuery("@HQL_GET_ALL_ADDRESS");
List
addressList = query.list(); for (Address addr : addressList) { System.out.println("List of Address::" + addr.getId() + "::" + addr.getZipcode() + "::" + addr.getEmployee().getName()); } //Native SQL Named Query Example query = session.getNamedQuery("@SQL_GET_ALL_ADDRESS"); List<Object[]> addressObjArray = query.list(); for(Object[] row : addressObjArray){ for(Object obj : row){ System.out.print(obj + "::"); } System.out.println("\n"); } query = session.getNamedQuery("SQL_GET_ALL_EMP_ADDRESS"); addressObjArray = query.list(); for(Object[] row : addressObjArray){ Employee e = (Employee) row[0]; System.out.println("Employee Info::"+e); Address a = (Address) row[1]; System.out.println("Address Info::"+a); } // rolling back to save the test data tx.commit(); // closing hibernate resources sessionFactory.close(); } }Wenn wir das obige Programm mit unseren Testdaten ausführen, ergibt sich folgende Ausgabe:
package com.journaldev.hibernate.main;
Hibernate: select employee0_.emp_id as emp_id1_1_, employee0_.emp_name as emp_name2_1_, employee0_.emp_salary as emp_sala3_1_ from EMPLOYEE employee0_
Hibernate: select address0_.emp_id as emp_id1_0_0_, address0_.address_line1 as address_2_0_0_, address0_.city as city3_0_0_, address0_.zipcode as zipcode4_0_0_, employee1_.emp_id as emp_id1_1_1_, employee1_.emp_name as emp_name2_1_1_, employee1_.emp_salary as emp_sala3_1_1_ from ADDRESS address0_ left outer join EMPLOYEE employee1_ on address0_.emp_id=employee1_.emp_id where address0_.emp_id=?
Hibernate: select address0_.emp_id as emp_id1_0_0_, address0_.address_line1 as address_2_0_0_, address0_.city as city3_0_0_, address0_.zipcode as zipcode4_0_0_, employee1_.emp_id as emp_id1_1_1_, employee1_.emp_name as emp_name2_1_1_, employee1_.emp_salary as emp_sala3_1_1_ from ADDRESS address0_ left outer join EMPLOYEE employee1_ on address0_.emp_id=employee1_.emp_id where address0_.emp_id=?
Hibernate: select address0_.emp_id as emp_id1_0_0_, address0_.address_line1 as address_2_0_0_, address0_.city as city3_0_0_, address0_.zipcode as zipcode4_0_0_, employee1_.emp_id as emp_id1_1_1_, employee1_.emp_name as emp_name2_1_1_, employee1_.emp_salary as emp_sala3_1_1_ from ADDRESS address0_ left outer join EMPLOYEE employee1_ on address0_.emp_id=employee1_.emp_id where address0_.emp_id=?
Hibernate: select address0_.emp_id as emp_id1_0_0_, address0_.address_line1 as address_2_0_0_, address0_.city as city3_0_0_, address0_.zipcode as zipcode4_0_0_, employee1_.emp_id as emp_id1_1_1_, employee1_.emp_name as emp_name2_1_1_, employee1_.emp_salary as emp_sala3_1_1_ from ADDRESS address0_ left outer join EMPLOYEE employee1_ on address0_.emp_id=employee1_.emp_id where address0_.emp_id=?
List of Employees::1,San Jose
List of Employees::2,Santa Clara
List of Employees::3,Bangalore
List of Employees::4,New Delhi
Hibernate: select employee0_.emp_id as emp_id1_1_, employee0_.emp_name as emp_name2_1_, employee0_.emp_salary as emp_sala3_1_ from EMPLOYEE employee0_ where emp_id=?
Employee Name=David, City=Santa Clara
Hibernate: select employee0_.emp_id as emp_id1_1_, employee0_.emp_name as emp_name2_1_, employee0_.emp_salary as emp_sala3_1_ from EMPLOYEE employee0_ where emp_salary>?
List of Employees::3,300.0
List of Employees::4,400.0
Hibernate: select address0_.emp_id as emp_id1_0_, address0_.address_line1 as address_2_0_, address0_.city as city3_0_, address0_.zipcode as zipcode4_0_ from ADDRESS address0_
List of Address::1::95129::Pankaj
List of Address::2::95051::David
List of Address::3::560100::Lisa
List of Address::4::100100::Jack
Hibernate: select emp_id, address_line1, city, zipcode from Address
1::Albany Dr::San Jose::95129::
2::Arques Ave::Santa Clara::95051::
3::BTM 1st Stage::Bangalore::560100::
4::City Centre::New Delhi::100100::
Hibernate: select e.emp_id as emp_id1_1_0_, e.emp_name as emp_name2_1_0_, e.emp_salary as emp_sala3_1_0_, a.emp_id as emp_id1_0_1_, a.address_line1 as address_2_0_1_, a.city as city3_0_1_, a.zipcode as zipcode4_0_1_ from Employee e join Address a ON e.emp_id=a.emp_id
Employee Info::Id= 1, Name= Pankaj, Salary= 100.0, {Address= AddressLine1= Albany Dr, City=San Jose, Zipcode=95129}
Address Info::AddressLine1= Albany Dr, City=San Jose, Zipcode=95129
Employee Info::Id= 2, Name= David, Salary= 200.0, {Address= AddressLine1= Arques Ave, City=Santa Clara, Zipcode=95051}
Address Info::AddressLine1= Arques Ave, City=Santa Clara, Zipcode=95051
Employee Info::Id= 3, Name= Lisa, Salary= 300.0, {Address= AddressLine1= BTM 1st Stage, City=Bangalore, Zipcode=560100}
Address Info::AddressLine1= BTM 1st Stage, City=Bangalore, Zipcode=560100
Employee Info::Id= 4, Name= Jack, Salary= 400.0, {Address= AddressLine1= City Centre, City=New Delhi, Zipcode=100100}
Address Info::AddressLine1= City Centre, City=New Delhi, Zipcode=100100Wichtige Punkte zu Hibernate Named Query
Einige wichtige Punkte zu Hibernate Named Query sind:
- Hibernate Named Query hilft uns, Abfragen an einem zentralen Ort zu gruppieren, anstatt sie über den gesamten Code zu verstreuen.
- Die Syntax von Hibernate Named Query wird überprüft, wenn die Hibernate Session Factory erstellt wird, was dazu führt, dass Fehler in den Named Queries frühzeitig erkannt werden.
- Hibernate Named Query ist global, das heißt, einmal definiert, kann sie in der gesamten Anwendung verwendet werden.
- Ein großer Nachteil von Named Queries ist, dass sie schwer zu debuggen sind, da man den Ort finden muss, an dem sie definiert sind.
Passende Infrastruktur bei centron
Node-Anwendungen wollen deployt werden: ccloud³ VMs mit vollem Root-Zugriff ab 3,12 € im Monat – oder gleich als Managed Server, wenn der Betrieb nicht bei Ihnen liegen soll. Cloud Server mieten →
Fazit
Hibernate Named Queries bieten eine leistungsstarke Möglichkeit, HQL- und SQL-Abfragen zu zentralisieren und zu verwalten, was zu saubererem und wartbarerem Code führt. Durch die Definition von Abfragen in Annotationen oder Mapping-Dateien profitieren Anwendungen von einer schnelleren Fehlererkennung und einer verbesserten Organisation. Allerdings kann das Debuggen von Named Queries eine Herausforderung darstellen, was eine sorgfältige Berücksichtigung des Ortes ihrer Definition erfordert.
Testen Sie Ihr Setup auf ccloud³
Registrieren Sie sich in der ccloud³ und erhalten Sie 200 € Startguthaben für Ihr Projekt – z. B. für eine PostgreSQL-VM mit automatischen Backups.