Hibernate Interview Fragen und Antworten

Hibernate ist eines der am weitesten verbreiteten ORM-Tools für Java-Anwendungen. Es findet häufig Verwendung in Unternehmens für Datenbankoperationen. Daher habe ich beschlossen, einen Beitrag über Interviewfragen zu schreiben, um Ihr Wissen vor einem Vorstellungsgespräch aufzufrischen. Egal, ob Sie Anfänger oder erfahrener Entwickler sind – gute Kenntnisse des Hibernate ORM-Tools helfen Ihnen, Interviews erfolgreich zu bestehen. Hier stelle ich wichtige Interviewfragen zum Thema mit Antworten bereit, um Ihr Wissen aufzufrischen und Ihren Interviewer zu beeindrucken. Wie bei anderen Beiträgen über Interviewfragen besteht die Möglichkeit, dass ich in Zukunft weitere Fragen zu dieser Liste hinzufüge. Sie sollten diesen Beitrag also vielleicht für die Zukunft speichern.

Interview Fragen

Was ist das Hibernate Framework?

Object-Relational Mapping (ORM) ist eine Programmiertechnik, um Objekte des Anwendungsdomänenmodells mit relationalen Datenbanktabellen zu verknüpfen. Hibernate ist ein Java-basiertes ORM-Tool, das ein Framework für die Abbildung von Anwendungsdomänenobjekten auf relationale Datenbanktabellen und umgekehrt bereitstellt. Es bietet eine Referenzimplementierung der Java Persistence API, was es zu einer großartigen Wahl als ORM-Tool mit Vorteilen wie loser Kopplung macht. Wir können die Hibernate-Persistence-API für CRUD-Operationen verwenden. Das H.-Framework bietet die Möglichkeit, einfache alte Java-Objekte mit traditionellen Datenbanktabellen zu verknüpfen, durch Verwendung von entweder JPA-Annotationen oder XML-basierte Konfiguration. Ebenso sind H.-Konfigurationen flexibel und können sowohl aus XML-Konfigurationsdateien als auch programmatisch erfolgen.

Was ist die Java Persistence API (JPA)?

Die Java Persistence API (JPA) bietet eine Spezifikation für die Verwaltung relationaler Daten in Anwendungen. Die aktuelle JPA-Version 2.1 wurde im Juli 2011 als JSR 338 gestartet. JPA 2.1 wurde am 22. Mai 2013 als final genehmigt. JPA-Spezifikationen sind mit Annotationen im Paket javax.persistence definiert. Die Verwendung von JPA-Annotationen hilft uns, implementierungsunabhängigen Code zu schreiben.

Was sind die wichtigsten Vorteile der Verwendung des Hibernate Frameworks?

Einige der wichtigsten Vorteile der Verwendung des Frameworks sind:

• Hibernate eliminiert den gesamten Boilerplate-Code, der mit JDBC einhergeht, und kümmert sich um die Verwaltung von Ressourcen, sodass wir uns auf die Geschäftslogik konzentrieren können.
• Das Hibernate Framework bietet Unterstützung für XML sowie JPA-Annotationen, was unseren Code implementierungsunabhängig macht.
• Hibernate bietet eine leistungsstarke Abfragesprache (HQL), die SQL ähnelt. HQL ist jedoch vollständig objektorientiert und versteht Konzepte wie Vererbung, Polymorphismus und Assoziation.
• Hibernate ist ein Open-Source-Projekt der Red Hat Community und wird weltweit eingesetzt. Dies macht es zu einer besseren Wahl als andere, da die Lernkurve gering ist und es eine Vielzahl von Online-Dokumentationen und Hilfe in Foren gibt.
• Hibernate ist einfach in andere Java-EE-Frameworks zu integrieren. Es ist so beliebt, dass das Spring Framework integrierte Unterstützung für die Integration von Hibernate in Spring-Anwendungen bietet.
• Hibernate unterstützt Lazy-Initialization mithilfe von Proxy-Objekten und führt tatsächliche Datenbankabfragen nur dann aus, wenn es erforderlich ist.
• Hibernate-Cache hilft uns, eine bessere Leistung zu erzielen.
• Für datenbankspezifische Funktionen ist Hibernate geeignet, da wir auch native SQL-Abfragen ausführen können. Insgesamt ist Hibernate in der aktuellen Marktlage die beste Wahl für ORM-Tools, da es alle Funktionen enthält, die in einem ORM-Tool nötig sind.

Was sind die Vorteile von Hibernate gegenüber JDBC?

Einige der wichtigsten Vorteile des Hibernate Frameworks gegenüber JDBC sind:

• Hibernate entfernt viel Boilerplate-Code, der mit der JDBC-API einhergeht, und der Code sieht sauberer und lesbarer aus.
• Hibernate unterstützt Vererbung, Assoziationen und Sammlungen. Diese Funktionen sind in der JDBC-API nicht vorhanden.
• Hibernate bietet implizit eine Transaktionsverwaltung. Tatsächlich funktionieren die meisten Abfragen außerhalb von Transaktionen nicht. In der JDBC-API müssen wir Code für die Transaktionsverwaltung mit Commit und Rollback schreiben.
• Die JDBC-API wirft SQLException, eine Checked-Exception. Daher müssen wir viele Try-Catch-Block-Codes schreiben. Hibernate kapselt JDBC-Ausnahmen und wirft HibernateException als Unchecked-Exception, sodass wir keinen Code zum Behandeln schreiben müssen.
• Hibernate Query Language (HQL) ist objektorientierter und näher an der Java-Programmiersprache. Für JDBC müssen wir native SQL-Abfragen schreiben.
• Hibernate unterstützt Caching, was für die Leistung besser ist. JDBC-Abfragen werden nicht zwischengespeichert, daher ist die Leistung geringer.

Nennen Sie einige wichtige Schnittstellen des Hibernate Frameworks?

Einige der wichtigen Schnittstellen des Hibernate-Frameworks sind:

1. SessionFactory (org.hibernate.SessionFactory): Die SessionFactory ist ein unveränderlicher, threadsicherer Cache von kompilierten Mappings für eine einzelne Datenbank. Wir müssen die SessionFactory einmal initialisieren und können sie dann zwischenspeichern und wiederverwenden. Eine SessionFactory-Instanz ist für den Erhalt von Session-Objekte für Datenbankoperationen.
2. Session (org.hibernate.Session): Die Session ist ein einzel-threaded, kurzlebiges Objekt, das eine Sitzung zwischen der Anwendung und dem persistenten Speicher darstellt. Sie kapselt JDBC java.sql.Connection und dient als Factory für org.hibernate.Transaction. Eine Sitzung ist nur bei Bedarf zu öffnen und so bald wie möglich wieder zu schließen. Das Session-Objekt ist die Schnittstelle zwischen Java-Anwendungscode und Hibernate-Framework und bietet Methoden für CRUD-Operationen.
3. Transaction (org.hibernate.Transaction): Die Transaktion ist ein von der Anwendung verwendetes einzel-threaded, kurzlebiges Objekt, um atomare Arbeitseinheiten zu spezifizieren. Sie abstrahiert die Anwendung von der zugrunde liegenden JDBC- oder JTA-Transaktion. Eine org.hibernate.Session kann in einigen Fällen mehrere org.hibernate.Transaction umfassen.

SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
transaction.commit();
session.close();

Was ist die Hibernate-Konfigurationsdatei?

Die Konfigurationsdatei enthält datenbankspezifische Konfigurationen und ist für die Initialisierung der SessionFactory. Wir geben Datenbankanmeldeinformationen oder JNDI-Ressourceninformationen in der Hibernate-Konfigurations-XML-Datei an. Andere wichtige Teile der Hibernate-Konfigurationsdatei sind Dialektinformationen, sodass Hibernate den Datenbanktyp und die Mapping-Dateien oder Klassendetails kennt.

Was ist die Hibernate-Mapping-Datei?

Die Hibernate-Mapping-Datei gibt es, um die Felder der Entitäts-Bean und die Spalten der Datenbanktabelle zu definieren. Wir wissen, dass JPA-Annotationen für das Mapping nützlich sind, aber manchmal sind XML-Mapping-Dateien praktisch, wenn wir Drittanbieterklassen verwenden und keine Annotationen nutzen können.

Nennen Sie einige wichtige Annotationen, die für Hibernate-Mapping sind?

Hibernate unterstützt JPA-Annotationen und verfügt über zusätzliche Annotationen im Paket org.hibernate.annotations. Einige der wichtigsten Annotationen sind:

• javax.persistence.Entity: ist zum deklarieren einer Klasse als Entity-Bean.
• javax.persistence.Table: ist um den Tabellennamen in der Datenbank zu spezifizieren, der der Entity-Bean entspricht.
• javax.persistence.Access: findet Verwendung, um den Zugriffstyp zu definieren, entweder Feld oder Eigenschaft. Der Standardwert ist Feld. Wenn Hibernate die Getter-/Setter-Methoden verwenden soll, muss der Wert auf Eigenschaft gesetzt sein.
• javax.persistence.Column: Gibt die Spalte in der Datenbanktabelle an, die einem Feld oder einer Eigenschaft in der Entity-Bean zugeordnet ist.
• javax.persistence.Id: Kennzeichnet den Primärschlüssel der Entity-Bean.
• javax.persistence.EmbeddedId: ist für die Definition eines zusammengesetzten Primärschlüssel in der Entity-Bean.
• javax.persistence.GeneratedValue: Gibt die Generierungsstrategie für den Primärschlüssel an, in Verbindung mit javax.persistence.GenerationType.
• javax.persistence.OneToOne: Definiert eine Eins-zu-Eins-Beziehung zwischen zwei Entity-Beans.
• javax.persistence.OneToMany: Definiert eine Eins-zu-Viele-Beziehung zwischen zwei Entity-Beans.
• javax.persistence.ManyToOne: Definiert eine Viele-zu-Eins-Beziehung zwischen zwei Entity-Beans.
• javax.persistence.ManyToMany: Definiert eine Viele-zu-Viele-Beziehung zwischen zwei Entity-Beans.
• org.hibernate.annotations.Cascade: findet Nutzen, um das Kaskadenverhalten für Operationen wie Speichern, Aktualisieren, Löschen usw. zu definieren.
• javax.persistence.PrimaryKeyJoinColumn: ist, um die Eigenschaft für den Fremdschlüssel zu definieren. Verwendung erfolgt mit org.hibernate.annotations.GenericGenerator und org.hibernate.annotations.Parameter.

package com.journaldev.hibernate.model;

import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import org.hibernate.annotations.Cascade;

@Entity
@Table(name = "EMPLOYEE")
@Access(value=AccessType.FIELD)
public class Employee {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "emp_id")
	private long id;

	@Column(name = "emp_name")
	private String name;

	@OneToOne(mappedBy = "employee")
	@Cascade(value = org.hibernate.annotations.CascadeType.ALL)
	private Address address;

	//getter setter methods
}

Was ist Hibernate SessionFactory und wie konfiguriert man sie?

Die SessionFactory ist die Factory-Klasse, um Session-Objekte zu erstellen. Die SessionFactory ist für das Lesen der Hibernate-Konfigurationsparameter, die Verbindung zur Datenbank und die Bereitstellung von Session-Objekten verantwortlich. Eine Anwendung hat normalerweise eine einzelne SessionFactory-Instanz, und Threads, die Client-Anfragen bedienen, erhalten Sitzungen von dieser Factory. Der interne Zustand einer SessionFactory ist unveränderlich. Dieser interne Zustand umfasst alle Metadaten zur Objekt-/Relation-Mapping.

Ist SessionFactory threadsicher?

Ja, der interne Zustand der SessionFactory ist unveränderlich, daher ist sie threadsicher. Mehrere Threads können gleichzeitig darauf zugreifen, um Sitzungsinstanzen zu erhalten.

Was ist Hibernate Session und wie wird sie abgerufen?

Hibernate Session ist die Hauptschnittstelle zwischen der Java-Anwendung und der Datenbank. Es ist ein leichtgewichtiges, nicht threadsicheres Objekt, um CRUD-Operationen durchzuführen. Eine Sitzung kann mit den Methoden openSession() oder getCurrentSession() von der SessionFactory abgerufen werden.

Ist die Session threadsicher?

Nein, das Session-Objekt ist nicht threadsicher. Jeder Thread sollte seine eigene Session-Instanz erhalten und sie schließen, wenn die Arbeit abgeschlossen ist.

Was ist der Unterschied zwischen openSession und getCurrentSession?

openSession: Öffnet immer eine neue Sitzung. Der Entwickler ist dafür verantwortlich, die Sitzung nach der Verwendung explizit zu schließen.

getCurrentSession: Gibt eine Sitzung zurück, die an den aktuellen Kontext gebunden ist. Sie erfordert keine explizite Schließung, da Hibernate sie automatisch schließt, wenn die Transaktion endet. Diese Methode erfordert eine Konfiguration im Hibernate-Konfigurationsfile:

 


<property name="hibernate.current_session_context_class">thread</property>

Was ist der Unterschied zwischen Session get() und load() Methode?

Hibernate-Session bietet verschiedene Methoden, um Daten aus der Datenbank zu laden. get() und load() sind die am häufigsten verwendeten Methoden. Auf den ersten Blick scheinen sie ähnlich, aber es gibt einige Unterschiede:

• get() lädt die Daten, sobald es aufgerufen wird, wohingegen load() ein Proxy-Objekt zurückgibt und die Daten erst lädt, wenn sie tatsächlich benötigt werden. Daher ist load() besser, da es Lazy Loading unterstützt.
• Da load() eine Ausnahme auslöst, wenn keine Daten gefunden werden, sollten wir es nur verwenden, wenn wir sicher sind, dass die Daten existieren.
• Wir sollten get() verwenden, wenn wir sicherstellen wollen, dass die Daten in der Datenbank vorhanden sind.

Was ist Hibernate Caching und der First-Level Cache?

Wie der Name schon sagt, speichert Hibernate Abfragedaten im Cache, um unsere Anwendung schneller zu machen. Der Hibernate-Cache kann sehr nützlich sein, um die Anwendungsleistung zu verbessern bei korrekter Verwendung. Die Idee hinter dem Cache besteht darin, die Anzahl der Datenbankabfragen zu reduzieren und somit die Durchlaufzeit der Anwendung zu verkürzen. Der Hibernate-First-Level-Cache ist mit dem Session-Objekt verbunden. Der Hibernate-First-Level-Cache ist standardmäßig aktiviert und ist nicht deaktivierbar. Hibernate bietet jedoch Methoden, mit denen wir ausgewählte Objekte aus dem Cache löschen oder den Cache vollständig leeren können. Objekte, die in einer Session zwischengespeichert ist, sind für andere Sessions nicht sichtbar, und wenn die Session geschlossen ist, gehen alle zwischengespeicherten Objekte ebenfalls verloren.

Wie konfiguriert man den Second-Level Cache mit EHCache?

 
EHCache ist die beste Wahl, um den Second-Level-Cache von Hibernate zu nutzen. Folgende Schritte sind erforderlich, um EHCache in einer Hibernate-Anwendung zu aktivieren:
 
 
 
 



Fügen Sie die hibernate-ehcache-Abhängigkeit zu Ihrem Maven-Projekt hinzu. Wenn es kein Maven-Projekt ist, fügen Sie die entsprechenden JAR-Dateien hinzu.



 
 
 
 
 
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-ehcache</artifactId>
    <version>4.3.5.Final</version>
</dependency>


Fügen Sie die folgenden Eigenschaften in die Hibernate-Konfigurationsdatei ein:

<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

<!-- Für Singleton-Factory -->
<!-- <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory</property> -->

<!-- Aktivieren Sie Second-Level-Cache und Abfrage-Cache -->
<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.use_query_cache">true</property>
<property name="net.sf.ehcache.configurationResourceName">/myehcache.xml</property>


Erstellen Sie eine EHCache-Konfigurationsdatei. Eine Beispieldatei myehcache.xml könnte wie folgt aussehen:

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="true"
    monitoring="autodetect" dynamicConfig="true">

    <diskStore path="java.io.tmpdir/ehcache" />

    <defaultCache maxEntriesLocalHeap="10000" eternal="false"
        timeToIdleSeconds="120" timeToLiveSeconds="120" diskSpoolBufferSizeMB="30"
        maxEntriesLocalDisk="10000000" diskExpiryThreadIntervalSeconds="120"
        memoryStoreEvictionPolicy="LRU" statistics="true">
        <persistence strategy="localTempSwap" />
    </defaultCache>

    <cache name="employee" maxEntriesLocalHeap="10000" eternal="false"
        timeToIdleSeconds="5" timeToLiveSeconds="10">
        <persistence strategy="localTempSwap" />
    </cache>

    <cache name="org.hibernate.cache.internal.StandardQueryCache"
        maxEntriesLocalHeap="5" eternal="false" timeToLiveSeconds="120">
        <persistence strategy="localTempSwap" />
    </cache>

    <cache name="org.hibernate.cache.spi.UpdateTimestampsCache"
        maxEntriesLocalHeap="5000" eternal="true">
        <persistence strategy="localTempSwap" />
    </cache>
</ehcache>


Annotieren Sie Entitätsklassen mit der Annotation @Cache und geben Sie die zu verwendende Cache-Strategie an. Zum Beispiel:

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;

@Entity
@Table(name = "ADDRESS")
@Cache(usage=CacheConcurrencyStrategy.READ_ONLY, region="employee")
public class Address {

}

Das war’s! Hibernate wird den EHCache für den Second-Level-Cache verwenden. Lesen Sie den Hibernate EHCache-Beispiel für ein vollständiges Beispiel mit Erklärung.

Welche Zustände kann eine Entitäts-Bean haben?

Eine Entitäts-Bean kann in einem von drei Zuständen existieren:

• Transient: Die Entität ist nicht mit einer Sitzung oder einem Datenbankeintrag verbunden. Sie existiert nur im Speicher.
• Persistent: Die Entität ist mit einer Sitzung verbunden und entspricht einem Eintrag in der Datenbank.
• Detached: Die Entität war zuvor persistent, ist aber nicht mehr mit einer Sitzung verbunden.

Was ist der Nutzen des Hibernate Session merge() Aufrufs?

Die Methode merge() wird verwendet, um den Zustand einer getrennten Entität in die aktuelle Sitzung zu übernehmen. Im Gegensatz zu update(), das die Entität direkt mit der Sitzung verbindet, erstellt merge() eine neue Instanz im persistenten Kontext und lässt das ursprüngliche getrennte Objekt unverändert.

Was ist der Unterschied zwischen Hibernate save(), saveOrUpdate() und persist() Methoden?

• save(): Speichert ein Transienten-Objekt in der Datenbank. Wenn das Objekt bereits existiert, löst es einen Fehler aus.
• saveOrUpdate(): Speichert ein Transienten-Objekt oder aktualisiert ein vorhandenes Objekt basierend auf seinem Zustand.
• persist(): Ähnlich wie save(), gibt jedoch keine generierte ID zurück und erfordert eine aktive Transaktion.

Was passiert, wenn eine Entitäts-Bean keinen No-Args-Konstruktor hat?

Hibernate verwendet die Reflection API, um Instanzen von Entitäts-Beans zu erstellen. Der No-Args-Konstruktor ist erforderlich, da Hibernate die Methode Class.newInstance() verwendet. Fehlt ein solcher Konstruktor, wird eine HibernateException ausgelöst.

Was ist der Unterschied zwischen einer sortierten und einer geordneten Sammlung, und welche ist besser?

Wenn wir die Sortieralgorithmen der Collection-API verwenden, um eine Collection zu sortieren, spricht man von einer sortierten Liste. Für kleine Collections ist das kein großer Aufwand, aber für größere Collections kann es zu einer langsamen Performance und OutOfMemory-Fehlern führen. Außerdem müssen die Entitätsklassen die Schnittstellen Comparable oder Comparator implementieren, damit es funktioniert. Lesen Sie mehr dazu unter java object list sorting. Wenn wir das Hibernate-Framework verwenden, um Daten aus der Datenbank zu laden, können wir die Criteria-API verwenden, um mit der Klausel „order by“ eine geordnete Liste zu erhalten. Der folgende Codeausschnitt zeigt, wie das funktioniert:

 
List empList = session.createCriteria(Employee.class)
						.addOrder(Order.desc("id")).list();

Eine geordnete Liste ist besser als eine sortierte Liste, weil das eigentliche Sortieren auf Datenbankebene erfolgt. Das ist schneller und verursacht keine Speicherprobleme.

Wie implementiert man Joins in Hibernate?

Joins sind in Hibernate auf folgende Weise zu implementieren:

• Mit HQL und dem JOIN-Schlüsselwort, z. B.: FROM Employee e JOIN e.department d WHERE d.name = 'HR'.
• Mit Kriterienabfragen und der Methode createAlias(), um Joins programmatisch zu definieren.
• Mit nativen SQL-Abfragen und der Methode addEntity(), um die Ergebnisse auf Entitäten abzubilden.

Warum sollte man keine finale Entitätsklasse verwenden?

Hibernate verwendet Proxy-Klassen, um Funktionen wie Lazy Loading zu unterstützen. Proxy-Klassen erweitern die ursprüngliche Entitätsklasse. Wenn eine Entitätsklasse als final deklariert ist, kann Hibernate keine Proxys erstellen, was Lazy Loading deaktiviert und die Leistung beeinträchtigen kann.

Was ist HQL und welche Vorteile bietet es?

Hibernate Query Language (HQL) ist eine objektorientierte Abfragesprache, die von Hibernate bereitgestellt sind. Sie ähnelt SQL, arbeitet jedoch auf Hibernate-Entitäten anstelle von Datenbanktabellen. HQL unterstützt Polymorphie, Vererbung und Assoziationen, was sie leistungsfähiger und einfacher zu verwenden macht.

Vorteile von HQL:

• Es ist datenbankunabhängig, da Abfragen in Bezug auf das Entitätsmodell und nicht auf das Datenbankschema geschrieben sind.
• Unterstützt objektorientierte Konzepte wie Vererbung und Polymorphie.
• Bietet bessere Lesbarkeit und Wartbarkeit im Vergleich zu nativen SQL-Abfragen.

Was ist Query Cache in Hibernate?

Der Query Cache ist ein Caching-Mechanismus in Hibernate, der die Ergebnisse von HQL-Abfragen zwischenspeichert. Er funktioniert in Verbindung mit dem Second-Level Cache und ist nützlich für häufig ausgeführte Abfragen mit denselben Parametern. Der Query Cache kann in der Hibernate-Konfigurationsdatei aktiviert sind:

<property name="hibernate.cache.use_query_cache">true</property>

In der Code-Basis können Sie den Query Cache wie folgt aktivieren:

Query query = session.createQuery("from Employee");
query.setCacheable(true);

Können wir native SQL-Abfragen in Hibernate ausführen?

Ja, Hibernate ermöglicht die Ausführung nativer SQL-Abfragen mit der Methode createSQLQuery(). Native SQL-Abfragen sind nützlich für datenbankspezifische Operationen, bei denen es nicht zur Ausführung mit HQL kommen kann.

Beispiel:

SQLQuery query = session.createSQLQuery("SELECT * FROM EMPLOYEE");
query.addEntity(Employee.class);
List employees = query.list();

Was ist der Nutzen von nativer SQL-Abfrageunterstützung in Hibernate?

Die Unterstützung nativer SQL-Abfragen ist hilfreich, wenn datenbankspezifische Funktionen wie Query Hints oder proprietäre SQL-Funktionen erforderlich sind, die von HQL nicht unterstützt werden.

Was ist Named SQL Query?

Named SQL Queries sind vordefinierte Abfragen, die in der gesamten Anwendung Wiederverwendung finden. Sie werden entweder mit den Annotationen @NamedQuery oder @NamedNativeQuery oder in der Hibernate-Mapping-Datei definiert.

Welche Vorteile bietet Named SQL Query?

• Zentralisiert Abfragedefinitionen, was deren Verwaltung und Debugging erleichtert.
• Bietet bessere Leistung, da Abfragen beim Start der Anwendung vorkompiliert sind.
• Fördert die Wiederverwendbarkeit, indem häufig verwendete Abfragen an einem einzigen Ort definiert sind.

Was ist der Nutzen der Hibernate Criteria API?

Hibernate provides Criteria API that is more object oriented for querying the database and getting results. We can’t use Criteria to run update or delete queries or any DDL statements. It’s only used to fetch the results from the database using more object oriented approach. Some of the common usage of Criteria API are:

-   Criteria API provides Projection that we can use for aggregate functions such as sum(), min(), max() etc.
-   Criteria API can be used with ProjectionList to fetch selected columns only.
-   Criteria API can be used for join queries by joining multiple tables, useful methods are createAlias(), setFetchMode() and setProjection()
-   Criteria API can be used for fetching results with conditions, useful methods are add() where we can add Restrictions.
-   Criteria API provides addOrder() method that we can use for ordering the results.

Wie loggt man von Hibernate generierte SQL-Abfragen in Log-Dateien?

We can set below property for hibernate configuration to log SQL queries.

```
        true
```

However we should use it only in Development or Testing environment and turn it off in production environment.

Was ist Hibernate Proxy und wie hilft es beim Lazy Loading?

Hibernate verwendet Proxy-Objekte, um Lazy Loading zu implementieren. Ein Proxy ist eine Unterklasse der tatsächlichen Entitätsklasse, die Methoden überschreibt, um Daten erst dann abzurufen, wenn sie benötigt werden. Dies verbessert die Leistung, da Datenbankabfragen verzögert werden, bis die Daten tatsächlich benötigt werden.

Lazy Loading kann mit der fetch-Eigenschaft in Mapping-Dateien oder Annotationen aktiviert werden:

@OneToMany(fetch = FetchType.LAZY)
private List
 
addresses;

Wie implementiert man Beziehungen in Hibernate?

Beziehungen in Hibernate können mit Annotationen oder XML-Mappings implementiert werden. Zu den gängigen Beziehungstypen gehören:

• Eins-zu-Eins: Verwenden Sie die Annotation @OneToOne mit dem Attribut mappedBy für bidirektionales Mapping.
• Eins-zu-Viele: Verwenden Sie die Annotation @OneToMany und einen Sammlungstyp wie List.
• Viele-zu-Viele: Verwenden Sie die Annotation @ManyToMany mit einer Verbindungstabelle.

Wie funktioniert die Transaktionsverwaltung in Hibernate?

Das Transaktionsmanagement ist in Hibernate sehr einfach, da die meisten Operationen außerhalb einer Transaktion nicht erlaubt sind. Nachdem wir die Session aus der SessionFactory erhalten haben, können wir mit session.beginTransaction() die Transaktion starten. Diese Methode gibt eine Referenz auf die Transaktion zurück, die wir später verwenden können, um die Transaktion entweder zu committen oder zurückzurollen. Insgesamt ist das Transaktionsmanagement von Hibernate besser als das von JDBC, da wir nicht auf Ausnahmen für ein Rollback angewiesen sind. Jede von Session-Methoden ausgelöste Ausnahme führt automatisch zu einem Rollback der Transaktion.

Was ist Kaskadierung und welche Typen gibt es?

When we have relationship between entities, then we need to define how the different operations will affect the other entity. This is done by cascading and there are different types of it. Here is a simple example of applying cascading between primary and secondary entities.

```
import org.hibernate.annotations.Cascade;

@Entity
@Table(name = "EMPLOYEE")
public class Employee {

@OneToOne(mappedBy = "employee")
@Cascade(value = org.hibernate.annotations.CascadeType.ALL)
private Address address;

}
```

Note that Hibernate CascadeType enum constants are little bit different from JPA `javax.persistence.CascadeType`, so we need to use the Hibernate CascadeType and Cascade annotations for mappings, as shown in above example. Commonly used cascading types as defined in CascadeType enum are:
1.  None: No Cascading, it's not a type but when we don't define any cascading then no operations in parent affects the child.
2.  ALL: Cascades save, delete, update, evict, lock, replicate, merge, persist. Basically everything
3.  SAVE\_UPDATE: Cascades save and update, available only in hibernate.
4.  DELETE: Corresponds to the Hibernate native DELETE action, only in hibernate.
5.  DETATCH, MERGE, PERSIST, REFRESH and REMOVE - for similar operations
6.  LOCK: Corresponds to the Hibernate native LOCK action.
7.  REPLICATE: Corresponds to the Hibernate native REPLICATE action.

Wie integriert man Log4j-Logging in Hibernate?

Log4j kann mit Hibernate integriert werden, um besseres Logging und Debugging zu ermöglichen. Die Konfiguration umfasst folgende Schritte:

1. Fügen Sie die Log4j-Abhängigkeit oder die JAR-Datei zu Ihrem Projekt hinzu.
2. Erstellen Sie eine log4j.properties-Datei oder log4j.xml-Datei mit den entsprechenden Logging-Konfigurationen:

log4j.rootLogger=INFO, stdout
log4j.logger.org.hibernate=DEBUG

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

Platzieren Sie die Konfigurationsdatei im Klassenpfad, und Hibernate-Protokolle erscheinen in der Konsole oder der angegebenen Ausgabe.

Wie verwendet man den JNDI DataSource mit Hibernate Framework?

In Unternehmensanwendungen ist es empfehlenswert, einen vom Anwendungsserver verwalteten DataSource-Pool zu verwenden. Hibernate kann einfach mit JNDI DataSources integriert werden.

Schritte zur Verwendung von JNDI DataSource:

1. Definieren Sie eine JNDI DataSource in Ihrem Anwendungsserver (z. B. Tomcat, WildFly).
2. Konfigurieren Sie Hibernate, um die JNDI DataSource in der hibernate.cfg.xml zu verwenden:

java:comp/env/jdbc/MyDataSource

Wie integriert man Hibernate und Spring Frameworks?

Spring ist eines der am häufigsten verwendeten Java-EE-Frameworks, und Hibernate ist das beliebteste ORM-Framework. Deshalb wird die Kombination von Spring und Hibernate häufig in Unternehmensanwendungen genutzt. Der größte Vorteil bei der Verwendung von Spring ist, dass es mit dem Modul Spring ORM eine sofort einsatzbereite Unterstützung für Hibernate-Integration bietet. Die folgenden Schritte sind erforderlich, um Spring und Hibernate zusammen zu integrieren:

1. Fügen Sie die Abhängigkeiten hibernate-entitymanager, hibernate-core und spring-orm hinzu.
2. Erstellen Sie Model-Klassen und entsprechende DAO-Implementierungen für Datenbankoperationen. Beachten Sie, dass DAO-Klassen die SessionFactory verwenden, die durch die Spring-Bean-Konfiguration injiziert wird.
3. Wenn Sie Hibernate 3 verwenden, müssen Sie org.springframework.orm.hibernate3.LocalSessionFactoryBean oder org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean in der Spring-Bean-Konfigurationsdatei konfigurieren. Für Hibernate 4 gibt es nur eine Klasse: org.springframework.orm.hibernate4.LocalSessionFactoryBean.
4. Beachten Sie, dass wir die Hibernate-Transaktionsverwaltung nicht verwenden müssen. Wir können die deklarative Transaktionsverwaltung von Spring mithilfe der Annotation @Transactional nutzen.

Was ist die HibernateTemplate-Klasse?

Als die Integration von Spring und Hibernate begann, stellte Spring ORM zwei Hilfsklassen bereit – HibernateDaoSupport und HibernateTemplate. Der Grund für deren Verwendung war es, die Session zu erhalten und von der Transaktionsverwaltung von Spring zu profitieren. Ab Hibernate 3.0.1 können wir jedoch die Methode SessionFactory.getCurrentSession() verwenden, um die aktuelle Sitzung zu erhalten und die Vorteile der Spring-Transaktionsverwaltung zu nutzen. Wie in den obigen Beispielen gezeigt, ist dies sehr einfach, weshalb wir diese Klassen nicht mehr verwenden sollten. Ein weiterer Vorteil von HibernateTemplate war die Übersetzung von Ausnahmen, dies kann jedoch leicht durch die Verwendung der Annotation @Repository mit Service-Klassen erreicht werden.

Wie integriert man Hibernate mit Servlet- oder Struts2-Webanwendungen?

Die Integration von Hibernate mit Servlets oder Struts2 muss mithilfe eines ServletContextListener erfolgen. Der Listener initialisiert die SessionFactory, sodass sie während der gesamten Anwendungslebensdauer verfügbar ist.

Welche Designmuster werden im Hibernate-Framework verwendet?

Hibernate verwendet mehrere Designmuster, um seine Funktionalität zu implementieren:

• Domain Model Pattern: Repräsentiert die Daten und das Verhalten der Anwendung als Objekte.
• Data Mapper Pattern: Mapped Domänenobjekte auf Datenbanktabellen und umgekehrt.
• Proxy Pattern: Wird für Lazy Loading von assoziierten Objekten verwendet.
• Factory Pattern: Wird bei der Erstellung der SessionFactory verwendet.

Welche Best Practices sollten mit dem Hibernate Framework befolgt werden?

Einige der Best Practices für die Arbeit mit Hibernate sind:

• Überprüfen Sie immer den Zugriff auf Primärschlüsselfelder. Wenn der Primärschlüssel auf Datenbankebene generiert wird, sollte kein Setter dafür vorhanden sein.
• Standardmäßig setzt Hibernate die Feldwerte direkt, ohne Setter zu verwenden. Wenn Sie möchten, dass Hibernate Setter verwendet, stellen Sie sicher, dass der Zugriff als @Access(value=AccessType.PROPERTY) definiert ist.
• Verwenden Sie native SQL-Abfragen nur, wenn sie mit HQL nicht durchgeführt werden können, z. B. bei datenbankspezifischen Funktionen.
• Wenn Sie eine Sammlung sortieren müssen, verwenden Sie eine geordnete Liste, anstatt die Sortierung mithilfe der Collection-API vorzunehmen.
• Verwenden Sie benannte Abfragen klug, und halten Sie sie an einem einzigen Ort für einfaches Debugging. Verwenden Sie sie nur für häufig verwendete Abfragen.
• Vermeiden Sie Many-to-Many-Beziehungen. Diese können einfach mithilfe von bidirektionalen One-to-Many- und Many-to-One-Beziehungen implementiert werden.
• Für Sammlungen sollten Sie Listen, Maps und Sets verwenden. Vermeiden Sie Arrays, da sie keine Vorteile durch Lazy Loading bieten.
• Behandeln Sie Ausnahmen nicht als wiederherstellbar, führen Sie ein Rollback der Transaktion durch und schließen Sie die Sitzung. Andernfalls kann Hibernate nicht garantieren, dass der Speicherzustand den persistierten Zustand genau widerspiegelt.

Was ist das Hibernate Validator Framework?

Datenvalidierung ist ein integraler Bestandteil jeder Anwendung. Sie finden Datenvalidierung auf der Präsentationsebene mithilfe von JavaScript, dann im Servercode vor der Verarbeitung. Außerdem erfolgt die Datenvalidierung vor der Persistierung, um sicherzustellen, dass sie das richtige Format hat. Die Validierung ist eine Querschnittsaufgabe, daher sollten wir versuchen, sie von unserer Geschäftslogik zu trennen. JSR303 und JSR349 bieten Spezifikationen zur Validierung einer Bean durch Annotationen. Hibernate Validator stellt die Referenzimplementierung für beide Spezifikationen bereit.

Was ist der Vorteil des Tools Eclipse Plugins?

Das Hibernate Tools Plugin für Eclipse hilft uns, Hibernate-Konfigurations- und Mapping-Dateien einfach zu schreiben. Der größte Vorteil ist die Unterstützung von Vorschlägen für Eigenschaften oder XML-Tags. Es validiert diese auch gegen die Hibernate-DTD-Dateien, sodass wir Fehler im Voraus erkennen können.

Fazit

Hibernate ist ein mächtiges ORM-Framework, das in der Java-Welt weit verbreitet ist. Es vereinfacht den Umgang mit Datenbanken durch seine intuitive API und seine umfangreiche Unterstützung für Funktionen wie Caching, HQL und Lazy Loading. Die Integration mit anderen Frameworks wie Spring macht es noch leistungsfähiger und flexibler. Mit den oben aufgeführten Best Practices und Konzepten können Sie Ihre Kenntnisse verbessern und effektivere, skalierbare Anwendungen erstellen. Ob für Interviews oder den praktischen Einsatz – ein solides Verständnis von Hibernate ist eine wertvolle Fähigkeit für jeden Java-Entwickler.