Beispiel-Tutorial zur Integration von Spring Hibernate (Spring 4 + Hibernate 3 und Hibernate 4)

Tutorials
Hibernate Spring

Spring ist eines der am häufigsten verwendeten Java EE Frameworks und Hibernate ist das beliebteste ORM-Framework. Deshalb wird die Kombination von Spring Hibernate in Unternehmensanwendungen häufig verwendet. Vor kurzem habe ich viel über das Spring Tutorial und das Hibernate Tutorial geschrieben, daher war ein Beitrag zur Spring Hibernate Integration schon lange überfällig.

Spring Hibernate

Heute in diesem Tutorial werden wir Spring 4 verwenden und es mit Hibernate 3 integrieren und dann dasselbe Projekt aktualisieren, um Hibernate 4 zu verwenden. Da es viele Versionen für Spring und Hibernate gibt und das Spring ORM-Artefakt sowohl Hibernate 3 als auch Hibernate 4 unterstützt, ist es gut, dass ich alle Abhängigkeiten aufliste, die ich in meinem Projekt verwendet habe. Beachten Sie, dass ich festgestellt habe, dass nicht alle Spring- und Hibernate-Versionen kompatibel sind. Die unten aufgeführten Versionen haben für mich funktioniert, daher denke ich, dass sie kompatibel sind. Wenn Sie andere Versionen verwenden und den Fehler „java.lang.NoClassDefFoundError“ erhalten, bedeutet dies, dass sie nicht kompatibel sind. Meistens liegt es daran, dass Hibernate-Klassen von einem Paket in ein anderes verschoben werden und dadurch dieser Fehler auftritt. Zum Beispiel wurde die Klasse „org.hibernate.engine.FilterDefinition“ in neueren Hibernate-Versionen zu „org.hibernate.engine.spi.FilterDefinition“ verschoben.

  • Spring Framework-Version: 4.0.3.RELEASE
  • Hibernate Core und Hibernate EntityManager-Version: 3.6.9.Final und 4.3.5.Final
  • Spring ORM-Version: 4.0.3.RELEASE

Database Setup

I am using MySQL database for my project, so below setup.sql script will create the necessary table for this example.

CREATE TABLE `Person` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL DEFAULT '',
  `country` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
commit;

Beispielprojektstruktur für die Integration von Spring und Hibernate

Das folgende Bild zeigt die endgültige Projektstruktur. Wir werden uns nacheinander mit den einzelnen Komponenten beschäftigen.

Maven-Abhängigkeiten

Wir werden zuerst unsere pom.xml-Datei für alle erforderlichen Abhängigkeiten und deren Versionen überprüfen.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.springframework.samples</groupId>
	<artifactId>SpringHibernateExample</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>

		<!-- Generic properties -->
		<java.version>1.6</java.version>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

		<!-- Spring -->
		<spring-framework.version>4.0.3.RELEASE</spring-framework.version>

		<!-- Hibernate / JPA -->
		<!-- <hibernate.version>4.3.5.Final</hibernate.version> -->
		<hibernate.version>3.6.9.Final</hibernate.version>

		<!-- Logging -->
		<logback.version>1.0.13</logback.version>
		<slf4j.version>1.7.5</slf4j.version>

	</properties>

	<dependencies>
		<!-- Spring and Transactions -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>

		<!-- Spring ORM support -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>

		<!-- Logging with SLF4J & LogBack -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>${logback.version}</version>
			<scope>runtime</scope>
		</dependency>

		<!-- Hibernate -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>${hibernate.version}</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.9</version>
		</dependency>
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.4</version>
		</dependency>
	</dependencies>
</project>

Wichtige Abhängigkeiten für das Spring- und Hibernate-Integrationsprojekt sind:

  • spring-context und spring-tx für die Kernfunktionalitäten von Spring. Beachten Sie, dass ich die Version 4.0.3.RELEASE verwende.
  • spring-orm-Abhängigkeit für die Spring-ORM-Unterstützung, sie wird für die Hibernate-Integration in unserem Spring-Projekt benötigt.
  • hibernate-entitymanager und hibernate-core-Abhängigkeiten für das Hibernate-Framework. Beachten Sie, dass die Version 3.6.9.Final ist. Um Hibernate 4 zu verwenden, müssen wir sie einfach auf 4.3.5.Final ändern, wie im obigen pom.xml-Datei kommentiert.
  • mysql-connector-java für den MySQL-Treiber zur Datenbankverbindung.

Model-Klasse oder Entity Bean

Wir können Hibernate XML-basiertes Mapping sowie JPA-annotationsbasiertes Mapping verwenden. Hier verwende ich JPA-Annotationen für das Mapping, da Hibernate eine JPA-Implementierung bereitstellt.

package com.journaldev.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * Entity bean with JPA annotations
 * Hibernate provides JPA implementation
 * @author pankaj
 *
 */
@Entity
@Table(name="Person")
public class Person {

	@Id
	@Column(name="id")
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private int id;
	
	private String name;
	
	private String country;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getCountry() {
		return country;
	}

	public void setCountry(String country) {
		this.country = country;
	}
	
	@Override
	public String toString(){
		return "id="+id+", name="+name+", country="+country;
	}
}

DAO-Klassen

Wir implementieren zwei Methoden in unseren DAO-Klassen: eine Methode, um das Person-Objekt in die Tabelle zu speichern, und eine andere Methode, die alle Datensätze aus der Tabelle abruft und eine Liste von Personen zurückgibt.

package com.journaldev.dao;

import java.util.List;

import com.journaldev.model.Person;

public interface PersonDAO {

	public void save(Person p);
	
	public List<Person> list();
	
}

Die Implementierung der oben genannten DAO-Klasse würde wie folgt aussehen.

package com.journaldev.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import com.journaldev.model.Person;

public class PersonDAOImpl implements PersonDAO {

	private SessionFactory sessionFactory;

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
    
	@Override
	public void save(Person p) {
		Session session = this.sessionFactory.openSession();
		Transaction tx = session.beginTransaction();
		session.persist(p);
		tx.commit();
		session.close();
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<Person> list() {
		Session session = this.sessionFactory.openSession();
		List<Person> personList = session.createQuery("from Person").list();
		session.close();
		return personList;
	}

}

Beachten Sie, dass dies der einzige Ort ist, an dem wir Hibernate-bezogene Klassen verwenden. Dieses Muster macht unsere Implementierung flexibel und einfach von einer Technologie auf eine andere migrierbar. Wenn wir zum Beispiel das iBatis-ORM-Framework verwenden möchten, müssen wir nur eine DAO-Implementierung für iBatis bereitstellen und dann die Spring-Bean-Konfigurationsdatei ändern. In obigem Beispiel verwende ich das Hibernate-Sitzungstransaktionsmanagement. Wir können jedoch auch das deklarative Transaktionsmanagement von Spring unter Verwendung der @Transactional-Annotation verwenden. Weitere Informationen finden Sie unter Spring Transaction Management.

Spring Bean-Konfigurationsdatei für die Integration von Hibernate 3

Lassen Sie uns zunächst die Spring-Bean-Konfigurationen betrachten, die wir für die Integration von Hibernate 3 benötigen. Wir werden später ins Detail gehen.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:aop="https://www.springframework.org/schema/aop"
	xmlns:tx="https://www.springframework.org/schema/tx"
	xsi:schemaLocation="https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		https://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		https://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/TestDB" />
		<property name="username" value="pankaj" />
		<property name="password" value="pankaj123" />
	</bean>

<!-- Hibernate 3 XML SessionFactory Bean definition-->
<!-- 	<bean id="hibernate3SessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="mappingResources">
			<list>
				<value>person.hbm.xml</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<value>
				hibernate.dialect=org.hibernate.dialect.MySQLDialect
			</value>
		</property>
	</bean> -->

<!-- Hibernate 3 Annotation SessionFactory Bean definition-->
	<bean id="hibernate3AnnotatedSessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="annotatedClasses">
			<list>
				<value>com.journaldev.model.Person</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="hibernate.current_session_context_class">thread</prop>
				<prop key="hibernate.show_sql">false</prop>
			</props>
		</property>
	</bean>
	
	<bean id="personDAO" class="com.journaldev.dao.PersonDAOImpl">
		<property name="sessionFactory" ref="hibernate3AnnotatedSessionFactory" />
	</bean>
</beans>

Es gibt zwei Möglichkeiten, die Datenbankverbindungsdetails an Hibernate zu übergeben: erstens, indem wir alles in hibernateProperties angeben, und zweitens, indem wir eine DataSource erstellen und sie dann an Hibernate übergeben. Ich bevorzuge den zweiten Ansatz, deshalb haben wir die Apache Commons DBCP-Abhängigkeit, um eine BasicDataSource zu erstellen, indem wir die Datenbankverbindungseigenschaften setzen. Für die Integration von Spring und Hibernate 3 stellt Spring ORM zwei Klassen zur Verfügung – org.springframework.orm.hibernate3.LocalSessionFactoryBean, wenn die Hibernate-Mappings XML-basiert sind, und org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean für Annotations-basiertes Mapping. Ich habe eine einfache Bean-Konfiguration von LocalSessionFactoryBean in den Kommentaren bereitgestellt, wenn Sie XML-basierte Mappings verwenden. AnnotationSessionFactoryBean erweitert die Klasse LocalSessionFactoryBean, daher verfügt sie über alle grundlegenden Eigenschaften für die Hibernate-Integration. Die Eigenschaften sind selbsterklärend und größtenteils mit Hibernate zusammenhängend, daher gehe ich nicht weiter auf sie ein. Aber wenn Sie sich fragen, woher die hibernateProperties, annotatedClasses kommen, müssen Sie sich den Quellcode der Bean-Klasse ansehen. Beachten Sie die Bean-Definition von personDAO, wie ich bereits sagte, wenn wir zu einem anderen ORM-Framework wechseln müssen, müssen wir hier die Implementierungsklasse ändern und alle anderen Eigenschaften setzen, die wir benötigen.

Spring 4 Hibernate 3 Testprogramm

Unsere Einrichtung ist jetzt bereit, lassen Sie uns ein einfaches Programm schreiben, um unsere Anwendung zu testen.

package com.journaldev.main;

import java.util.List;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.journaldev.dao.PersonDAO;
import com.journaldev.model.Person;

public class SpringHibernateMain {

	public static void main(String[] args) {

		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
		
		PersonDAO personDAO = context.getBean(PersonDAO.class);
		
		Person person = new Person();
		person.setName("Pankaj"); person.setCountry("India");
		
		personDAO.save(person);
		
		System.out.println("Person::"+person);
		
		List list = personDAO.list();
		
		for(Person p : list){
			System.out.println("Person List::"+p);
		}
		// Ressourcen schließen
		context.close();	
	}
}

Wenn wir das obige Programm ausführen, erhalten wir eine Menge Ausgabe, die mit Hibernate zusammenhängt, weil ich das Protokollieren nicht ordnungsgemäß eingerichtet habe, aber das ist nicht Gegenstand dieses Tutorials. Wir erhalten jedoch folgende Ausgabe, die von unserem Programm generiert wurde.

Person::id=3, name=Pankaj, country=India
Person List::id=1, name=Pankaj, country=India
Person List::id=2, name=Pankaj, country=India
Person List::id=3, name=Pankaj, country=India

Spring 4 Hibernate 4 Integrationsänderungen

Jetzt ändern wir unsere Anwendung, um Hibernate 4 anstelle von Hibernate 3 zu verwenden. Für diese Migration müssen wir nur folgende Konfigurationsänderungen vornehmen.

  1. Ändern Sie die Hibernate-Version in der pom.xml-Datei auf 4.3.5.Final, wie oben in den Kommentaren gezeigt.

  2. Ändern Sie die Spring-Bean-Konfigurationsdatei, bis jetzt sollten Sie erkannt haben, dass die Spring-Bean-Konfigurationsdatei der Schlüssel für die Integration des Spring- und Hibernate-Frameworks ist. Die folgende Spring-Bean-Konfigurationsdatei funktioniert für die Versionen Spring 4 und Hibernate 4.

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:aop="https://www.springframework.org/schema/aop"
	xmlns:tx="https://www.springframework.org/schema/tx"
	xsi:schemaLocation="https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		https://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		https://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/TestDB" />
		<property name="username" value="pankaj" />
		<property name="password" value="pankaj123" />
	</bean>


<!-- Hibernate 4 SessionFactory Bean-Definition -->
<bean id="hibernate4AnnotatedSessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="annotatedClasses">
			<list>
				<value>com.journaldev.model.Person</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="hibernate.current_session_context_class">thread</prop>
				<prop key="hibernate.show_sql">false</prop>
			</props>
		</property>
	</bean>

	
	<bean id="personDAO" class="com.journaldev.dao.PersonDAOImpl">
		<property name="sessionFactory" ref="hibernate4AnnotatedSessionFactory" />
	</bean>
</beans>

    Für Hibernate 4 müssen wir org.springframework.orm.hibernate4.LocalSessionFactoryBean für das SessionFactory-Bean verwenden. Spring ORM hat beide Klassen für Hibernate 3 zusammengeführt und es gibt jetzt eine einzige Klasse, was gut ist, um Verwirrung zu vermeiden. Alle anderen Konfigurationen sind wie zuvor.

Das war’s, unser Projekt wurde erfolgreich auf Hibernate 4 migriert, nicht wahr? Ändern Sie einfach die Klasse SpringHibernateMain, um spring4.xml für die Bean-Konfiguration zu verwenden, und es funktioniert einwandfrei. Sie erhalten das gleiche Ergebnis wie zuvor. Sie können das endgültige Projekt über den unten stehenden Link herunterladen und mit weiteren Konfigurationen herumspielen, um mehr zu lernen.

Spring Hibernate Integrationsprojekt herunterladen

Source:
https://www.digitalocean.com/community/tutorials/spring-hibernate-integration-example-tutorial