Spring mit JPA und Hibernate (Tutorial)

In Ihrem Browser ist JavaScript deaktiviert.
Das kann zu Darstellungsproblemen auf meiner Seite führen.

span.toggle_icon { display: none; } .tab_inner_content { left: 0; }

Dieser Beitrag ist Teil einer (Tutorial-) Serie über die Einführung in das Spring Framework und beschreibt den Einsatz von JPA (Datenbankzugriff) und Hibernate (OR-Mapper) mit dem Spring Framework.

Die Struktur des Projektes

Dieses Beispiel baut auf dem vorherigem Beispiel Spring an einem einfachem Beispiel in der Version 2.0.x auf. Die verwendeten Frameworks und Werkzeuge sind hier beschrieben. Dieses Beispiel ist eine Konsolenanwendung, die eine Fahrerverwaltung umsetzt. In diesem Beispiel werden die folgenden Technologien des Spring Frameworks vorgestellt:

Die Definition und die Verwendung von abstrakten und generischen Datenzugriffsobjekten (DAO).
Die Spezialisierung von Datenzugriffsobjekten für JPA.
Die Definition von Entitäten mit Relationen, Named Queries und Sequenzen.
Die Berücksichtigen von Besonderheiten bei Entitäten.
Das Erstellen einer XML Konfiguration für JPA.
Das Deklarieren eines Datenzugriffsobjekt im Spring Framework.
Ein Service im Spring Framework mit Transaktionen versehen.
Die Datenbank-spezifische Konfiguration für das Spring Framework erzeugen.
Einen JUnit-Test für Datenbankoperationen mit dem Spring Framework erstellen.

Die folgende Bibliotheken werden benötigt:

Die benötigten Bibliotheken - Dependencies (© Frank Rahn)

Die Literaturempfehlungen für dieses Beispiel

Das abstrakte und generische Datenzugriffsobjekt

Ein DAO (Data Access Object) dient zur Abstrahierung von der konkreten Persistenz-Technologie und entkoppelt die Geschäftslogik vom Datenbankzugriff. Die folgende Schnittstelle eines Datenzugriffsobjektes (DAO) ist noch unabhängig von einer konkreten Zugriffstechnologie.

Diese Schnittstelle definiert die elementarsten Methoden (CRUD) für den Datenzugriff. Als generische Parametern wird die Klasse der Entität und des primären Schlüssels (Primary Key) definiert.

package de.rahn.db.dao;

import java.io.Serializable;

/**
 * Ein generische DAO-Schnittstelle für eine Entität mit einem primären Key.
 * @author Frank W. Rahn
 * @param <Entity> Die Klasse der Entität
 * @param <PrimaryKey> Die Klasse des primären Key
 */
public interface GenericDAO<Entity, PrimaryKey extends Serializable> {

/**
	 * Liefere den primären Key für das angegebene Objekt.
	 * @param persistentObject das persistente Objekt
	 * @return den primären Key
	 */
	PrimaryKey getPrimaryKey(Entity persistentObject);

/**
	 * Speichere das neue Objekt in der Datenbank.
	 * @param newPersistentObject das neue persistente Objekt
	 * @return den primären Key
	 */
	PrimaryKey create(Entity newPersistentObject);

/**
	 * Aktualisiere das geänderte Objekt in der Datenbank.
	 * @param persistentObject das persistente Objekt
	 */
	void save(Entity persistentObject);

/**
	 * Lösche das persistente Objekt aus der Datenbank.
	 * @param persistentObject das persistente Objekt
	 */
	void remove(Entity persistentObject);

/**
	 * Lösche das persistente Objekt aus der Datenbank.
	 * @param key der primäre Key
	 */
	void remove(PrimaryKey key);

/**
	 * Finde das persistente Objekt an Hand seines primären Keys.
	 * @param key der primäre Key
	 * @return das persistente Objekt
	 */
	Entity findByPrimaryKey(PrimaryKey key);

}

package de.rahn.db.dao;

import java.io.Serializable;

/**

* Ein generische DAO-Schnittstelle für eine Entität mit einem primären Key.

* @author Frank W. Rahn

* @param <Entity> Die Klasse der Entität

* @param <PrimaryKey> Die Klasse des primären Key

public interface GenericDAO<Entity, PrimaryKey extends Serializable> {

/**

* Liefere den primären Key für das angegebene Objekt.

* @param persistentObject das persistente Objekt

* @return den primären Key

PrimaryKey getPrimaryKey(Entity persistentObject);

/**

* Speichere das neue Objekt in der Datenbank.

* @param newPersistentObject das neue persistente Objekt

* @return den primären Key

PrimaryKey create(Entity newPersistentObject);

/**

* Aktualisiere das geänderte Objekt in der Datenbank.

* @param persistentObject das persistente Objekt

void save(Entity persistentObject);

/**

* Lösche das persistente Objekt aus der Datenbank.

* @param persistentObject das persistente Objekt

void remove(Entity persistentObject);

/**

* Lösche das persistente Objekt aus der Datenbank.

* @param key der primäre Key

void remove(PrimaryKey key);

/**

* Finde das persistente Objekt an Hand seines primären Keys.

* @param key der primäre Key

* @return das persistente Objekt

Entity findByPrimaryKey(PrimaryKey key);

}

Nun folgt eine abstrakte Implementierung dieser Schnittstelle. In dieser Implementierung wurde …

in Zeile 21 der Logger definiert und
in Zeile 30 bis 41 im Object-Initializer die Ermittlung der konkreten Klassen der Entität und des primären Schlüssels durchgeführt.

package de.rahn.db.dao;

import static org.slf4j.LoggerFactory.getLogger;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import org.slf4j.Logger;

/**
 * Eine abstrakte Implementierung der Schnittstelle {@link GenericDAO}.
 * @author Frank W. Rahn
 * @param <Entity> Die Klasse der Entität
 * @param <PrimaryKey> Die Klasse des primären Key
 */
public abstract class AbstractGenericDAO<Entity, PrimaryKey extends Serializable>
	implements GenericDAO<Entity, PrimaryKey> {

/** Der zentrale Logger für die DAO's. */
	protected final static Logger logger = getLogger(GenericDAO.class);

/** Die Klasse der Entität. */
	protected final Class<Entity> entityClass;

/** Die Klasse des primären Key. */
	protected final Class<PrimaryKey> primaryKeyClass;

{
		ParameterizedType type =
			(ParameterizedType) getClass().getGenericSuperclass();
		Type[] actualTypeArguments = type.getActualTypeArguments();

@SuppressWarnings("unchecked")
		Class<Entity> entityClass = (Class<Entity>) actualTypeArguments[0];
		this.entityClass = entityClass;

@SuppressWarnings("unchecked")
		Class<PrimaryKey> primaryKey =
			(Class<PrimaryKey>) actualTypeArguments[1];
		this.primaryKeyClass = primaryKey;
	}

/**
	 * {@inheritDoc}
	 * @see GenericDAO#remove(java.io.Serializable)
	 */
	@Override
	public void remove(PrimaryKey key) {
		remove(findByPrimaryKey(key));
	}

}

package de.rahn.db.dao;

import static org.slf4j.LoggerFactory.getLogger;

import java.io.Serializable;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import org.slf4j.Logger;

/**

* Eine abstrakte Implementierung der Schnittstelle {@link GenericDAO}.

* @author Frank W. Rahn

* @param <Entity> Die Klasse der Entität

* @param <PrimaryKey> Die Klasse des primären Key

public abstract class AbstractGenericDAO<Entity, PrimaryKey extends Serializable>

implements GenericDAO<Entity, PrimaryKey> {

/** Der zentrale Logger für die DAO's. */

protected final static Logger logger = getLogger(GenericDAO.class);

/** Die Klasse der Entität. */

protected final Class<Entity> entityClass;

/** Die Klasse des primären Key. */

protected final Class<PrimaryKey> primaryKeyClass;

{

ParameterizedType type =

(ParameterizedType) getClass().getGenericSuperclass();

Type[] actualTypeArguments = type.getActualTypeArguments();

@SuppressWarnings("unchecked")

Class<Entity> entityClass = (Class<Entity>) actualTypeArguments[0];

this.entityClass = entityClass;

@SuppressWarnings("unchecked")

Class<PrimaryKey> primaryKey =

(Class<PrimaryKey>) actualTypeArguments[1];

this.primaryKeyClass = primaryKey;

}

/**

* {@inheritDoc}

* @see GenericDAO#remove(java.io.Serializable)

@Override

public void remove(PrimaryKey key) {

remove(findByPrimaryKey(key));

}

Die Spezialisierung des Data Access Objects für JPA

Die grundlegende Schnittstelle eines Datenzugriffsobjektes diesmal abhängig von der Zugriffstechnologie Java Persistence API (JPA).

package de.rahn.db.jpa.dao;

import java.io.Serializable;

import de.rahn.db.dao.GenericDAO;

/**

* Eine Erweiterung der Schnittstelle {@link GenericDAO} für JPA.

* @author Frank W. Rahn

* @param <Entity> Die Klasse der Entität

* @param <PrimaryKey> Die Klasse des primären Key

* @see de.rahn.db.dao.GenericDAO

public interface GenericJpaDAO<Entity, PrimaryKey extends Serializable> extends

GenericDAO<Entity, PrimaryKey> {

// Noch keine spezielle Definitionen.

}

In der folgenden abstrakten Implementierung dieser Schnittstelle wird die JPA Annotationen @PersistenceContext verwendet. Der EntityManager wird dadurch durch das Spring Framework injiziert.

package de.rahn.db.jpa.dao;

import java.io.Serializable;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import de.rahn.db.dao.AbstractGenericDAO;
import de.rahn.db.dao.GenericDAO;

/**
 * Eine Implementierung der Schnittstelle {@link GenericJpaDAO} für JPA.
 * @author Frank W. Rahn
 * @param <Entity> Die Klasse der Entität
 * @param <PrimaryKey> Die Klasse des primären Key
 * @see de.rahn.db.dao.AbstractGenericDAO
 */
public abstract class AbstractGenericJpaDAO<Entity, PrimaryKey extends Serializable>
	extends AbstractGenericDAO<Entity, PrimaryKey>
	implements GenericJpaDAO<Entity, PrimaryKey> {

@PersistenceContext
	private EntityManager entityManager;

/**
	 * @return Liefert den {@link #entityManager}
	 */
	protected final EntityManager getEntityManager() {
		return entityManager;
	}

/**
	 * {@inheritDoc}
	 * @see GenericDAO#create(java.lang.Object)
	 */
	@Override
	public PrimaryKey create(Entity newPersistentObject) {
		entityManager.persist(newPersistentObject);
		return getPrimaryKey(newPersistentObject);
	}

/**
	 * {@inheritDoc}
	 * @see GenericDAO#save(java.lang.Object)
	 */
	@Override
	public void save(Entity persistentObject) {
		entityManager.merge(persistentObject);
	}

/**
	 * {@inheritDoc}
	 * @see GenericDAO#remove(java.lang.Object)
	 */
	@Override
	public void remove(Entity persistentObject) {
		entityManager.remove(persistentObject);
	}

/**
	 * {@inheritDoc}
	 * @see GenericDAO#findByPrimaryKey(java.io.Serializable)
	 */
	@Override
	public Entity findByPrimaryKey(PrimaryKey key) {
		return entityManager.find(entityClass, key);
	}

}

package de.rahn.db.jpa.dao;

import java.io.Serializable;

import javax.persistence.EntityManager;

import javax.persistence.PersistenceContext;

import de.rahn.db.dao.AbstractGenericDAO;

import de.rahn.db.dao.GenericDAO;

/**

* Eine Implementierung der Schnittstelle {@link GenericJpaDAO} für JPA.

* @author Frank W. Rahn

* @param <Entity> Die Klasse der Entität

* @param <PrimaryKey> Die Klasse des primären Key

* @see de.rahn.db.dao.AbstractGenericDAO

public abstract class AbstractGenericJpaDAO<Entity, PrimaryKey extends Serializable>

extends AbstractGenericDAO<Entity, PrimaryKey>

implements GenericJpaDAO<Entity, PrimaryKey> {

@PersistenceContext

private EntityManager entityManager;

/**

* @return Liefert den {@link #entityManager}

protected final EntityManager getEntityManager() {

return entityManager;

}

/**

* {@inheritDoc}

* @see GenericDAO#create(java.lang.Object)

@Override

public PrimaryKey create(Entity newPersistentObject) {

entityManager.persist(newPersistentObject);

return getPrimaryKey(newPersistentObject);

}

/**

* {@inheritDoc}

* @see GenericDAO#save(java.lang.Object)

@Override

public void save(Entity persistentObject) {

entityManager.merge(persistentObject);

}

/**

* {@inheritDoc}

* @see GenericDAO#remove(java.lang.Object)

@Override

public void remove(Entity persistentObject) {

entityManager.remove(persistentObject);

}

/**

* {@inheritDoc}

* @see GenericDAO#findByPrimaryKey(java.io.Serializable)

@Override

public Entity findByPrimaryKey(PrimaryKey key) {

return entityManager.find(entityClass, key);

}

Im folgendem Klassendiagramm ist der Sachverhalt der abstrakten generischen JPA Datenzugriffsobjekte grafisch per UML dargestellt.

Abstrakte generische Datenzugriffsobjekte für JPA (© Frank Rahn)

Die Definition des Service der Fahrerverwaltung

Zunächst wird die Schnittstelle dieses Services definiert. Auch dieses Beispiel ist relativ einfach gehalten.

package de.rahn.services.drivers;

import java.util.List;

import de.rahn.services.drivers.entity.Car;
import de.rahn.services.drivers.entity.Driver;

/**
 * Das Interface zum Service Drivers.
 * @author Frank W. Rahn
 */
public interface Drivers {

/**
	 * Hole alle Fahrer.
	 * @return die Liste der Fahrer
	 */
	List<Driver> getDrivers();

/**
	 * Hole einen Fahrer.
	 * @param id die Id eines Fahrers
	 * @return der Fahrer
	 */
	Driver getDriver(Long id);

/**
	 * Lege einen Fahrer an.
	 * @param name der Name des Fahrers
	 * @param firstname der Vorname des Fahrers
	 * @return die Id des Fahrers
	 */
	Long createDriver(String name, String firstname);

/**
	 * Lege einen Fahrer an.
	 * @param driver der Fahrer
	 * @return die Id des Fahrers
	 */
	Long create(Driver driver);

/**
	 * Speichere den Fahrer.
	 * @param driver der Fahrer
	 */
	Driver save(Driver driver);

/**
	 * Füge ein Auto zum Fahrer hinzu.
	 * @param id die Id des Fahrers
	 * @param car das Auto
	 * @return der komplette Fahrer
	 */
	Driver addCarToDriver(Long id, Car car);

}

package de.rahn.services.drivers;

import java.util.List;

import de.rahn.services.drivers.entity.Car;

import de.rahn.services.drivers.entity.Driver;

/**

* Das Interface zum Service Drivers.

* @author Frank W. Rahn

public interface Drivers {

/**

* Hole alle Fahrer.

* @return die Liste der Fahrer

List<Driver> getDrivers();

/**

* Hole einen Fahrer.

* @param id die Id eines Fahrers

* @return der Fahrer

Driver getDriver(Long id);

/**

* Lege einen Fahrer an.

* @param name der Name des Fahrers

* @param firstname der Vorname des Fahrers

* @return die Id des Fahrers

Long createDriver(String name, String firstname);

/**

* Lege einen Fahrer an.

* @param driver der Fahrer

* @return die Id des Fahrers

Long create(Driver driver);

/**

* Speichere den Fahrer.

* @param driver der Fahrer

Driver save(Driver driver);

/**

* Füge ein Auto zum Fahrer hinzu.

* @param id die Id des Fahrers

* @param car das Auto

* @return der komplette Fahrer

Driver addCarToDriver(Long id, Car car);

}

Die XML Konfiguration für dieses Modul.

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd

Dieses ist die zentrale Konfiguration für den Service Drivers.

</description>

<context:component-scan base-package="de.rahn.services.drivers" />

</beans>

Die Entitäten des Services Fahrerverwaltung

Unsere Fahrerverwaltung besteht aus Fahrern mit ihren Autos. Hier werden nun eine Reihe von Annotationen von JPA verwendet, um das Datenmodell zu definieren.

In den Zeilen 27 bis 29 wird diese Klasse als Entität mit Zugriff auf Attribut-Ebene definiert. Zusätzlich wird das Datenbankschema angegeben. Der Tabellenname rahn.Driver wird aus dem Klassennamen generiert.
In der Zeile 30 wird eine statische und benannte Abfrage mit JPQL definiert. Mit dieser Abfrage können alle Fahrer selektiert werden. Damit wird sogenanntes SQL-Injection ausgeschlossen, da für diese Abfragen ausschließlich PreparedStatement verwendet werden.
In den Zeilen 37 bis 41 wird der primäre Schlüssel für diese Klasse definiert. Dabei wird dieser Identifizierer über eine DB-Sequenz automatisch vergeben.
In der Zeile 54 wird eine gerichtete Relation (1-zu-n) mit weiterreichen der CRUD-Operationen (Cascade) zum Auto definiert.
In der Zeile 55 wird die Spalte driver-id in der Tabelle des Autos definiert. Dieses ist notwendig, da die Klasse Auto den Fahrer nicht kennt – also kein Attribut des Fahrers besitzt. Wenn in der Klasse Auto das Attribut public Driver driver; definiert worden wäre, hatte folgende Anweisung für die Relation ausgereicht:
@OneToMany(cascade = CascadeType.ALL, mappedBy = "driver") .

package de.rahn.services.drivers.entity;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Persistence;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

/**
 * Die Klasse eines Fahrers.
 * @author Frank W. Rahn
 */
@Entity
@Table(schema = "rahn")
@Access(AccessType.FIELD)
@NamedQueries(@NamedQuery(name = Driver.FIND_ALL, query = "from Driver d"))
public class Driver {

/** Konstante für die NamedQuery. */
	public static final String FIND_ALL = "Driver.findAll";

/** Der Identifizierer des Fahrers. */
	@Id
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "DriverSEQ")
	@SequenceGenerator(name = "DriverSEQ", sequenceName = "DriverSEQ",
		schema = "rahn")
	@Basic(optional = false)
	private Long id;

/** Der Name des Fahrers. */
	@Basic(optional = false)
	@Column(nullable = false)
	private String name;

/** Der Vorname des Fahrers. */
	@Basic
	private String firstname;

/** Die Autos die der Fahrer fährt. */
	@OneToMany(cascade = CascadeType.ALL)
	@JoinColumn(name = "driver_id", nullable = false)
	private Set<Car> cars = new HashSet<>();
...

package de.rahn.services.drivers.entity;

import java.util.HashSet;

import java.util.Set;

import javax.persistence.Access;

import javax.persistence.AccessType;

import javax.persistence.Basic;

import javax.persistence.CascadeType;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.JoinColumn;

import javax.persistence.NamedQueries;

import javax.persistence.NamedQuery;

import javax.persistence.OneToMany;

import javax.persistence.Persistence;

import javax.persistence.SequenceGenerator;

import javax.persistence.Table;

/**

* Die Klasse eines Fahrers.

* @author Frank W. Rahn

@Entity

@Table(schema = "rahn")

@Access(AccessType.FIELD)

@NamedQueries(@NamedQuery(name = Driver.FIND_ALL, query = "from Driver d"))

public class Driver {

/** Konstante für die NamedQuery. */

public static final String FIND_ALL = "Driver.findAll";

/** Der Identifizierer des Fahrers. */

@Id

@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "DriverSEQ")

@SequenceGenerator(name = "DriverSEQ", sequenceName = "DriverSEQ",

schema = "rahn")

@Basic(optional = false)

private Long id;

/** Der Name des Fahrers. */

@Basic(optional = false)

@Column(nullable = false)

private String name;

/** Der Vorname des Fahrers. */

@Basic

private String firstname;

/** Die Autos die der Fahrer fährt. */

@OneToMany(cascade = CascadeType.ALL)

@JoinColumn(name = "driver_id", nullable = false)

private Set<Car> cars = new HashSet<>();

...

Im folgendem Abschnitt werden die von Eclipse IDE generierten Methoden für hashCode() und equals() dargestellt. Diese Methoden müssen überladen werden, da eine Entität eine eindeutige Identität besitzt, die über die beiden Methoden bestimmt werden muss.

Zwei eigentlich gleiche Entitäten werden als ungleich bewertet, wenn …

die Entitäten von unterschiedlichen EntityManager gelesen wurden oder
die eine Entität per Eager Loading (direkt beim Ausführen des Selects) und die andere Entität per Lazy Loading (durch einen Proxy beim Zugriff auf das Feld) geladen wurden.

Der automatische erzeugte Schlüssel ( id) wird erst beim Speichern der Entitäten gesetzt. Die beiden Methoden hashCode() und equals() müssen von denselben signifikanten Attributen abhängen.

In der Zeile 67 und 99 wird mit Persistence.getPersistenceUtil().isLoaded(cars) geprüft, ob die Autos schon geladen wurden. Wenn nicht würden die Entitäten des Autos geladen oder einen Fehler auslösen, wenn der EntityManager schon geschlossen wurde.

...
	// Ab hier von Eclipse generierte Methoden hashCode(), equals(), toString()

/**
	 * @see java.lang.Object#hashCode()
	 */
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		if (cars != null && Persistence.getPersistenceUtil().isLoaded(cars)) {
			result = prime * result + cars.hashCode();
		} else {
			result = prime * result;
		}
		result =
			prime * result + (firstname == null ? 0 : firstname.hashCode());
		result = prime * result + (id == null ? 0 : id.hashCode());
		result = prime * result + (name == null ? 0 : name.hashCode());
		return result;
	}

/**
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj == null) {
			return false;
		}
		if (!(obj instanceof Driver)) {
			return false;
		}
		Driver other = (Driver) obj;
		if (cars == null) {
			if (other.cars != null) {
				return false;
			}
		} else {
			if (Persistence.getPersistenceUtil().isLoaded(cars)
				&& Persistence.getPersistenceUtil().isLoaded(other.cars)) {
				if (!cars.equals(other.cars)) {
					return false;
				}
			}
		}
		if (firstname == null) {
			if (other.firstname != null) {
				return false;
			}
		} else if (!firstname.equals(other.firstname)) {
			return false;
		}
		if (id == null) {
			if (other.id != null) {
				return false;
			}
		} else if (!id.equals(other.id)) {
			return false;
		}
		if (name == null) {
			if (other.name != null) {
				return false;
			}
		} else if (!name.equals(other.name)) {
			return false;
		}
		return true;
	}

/**
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return new StringBuilder().append("Driver [id=").append(id)
			.append(", name=").append(name).append(", firstname=")
			.append(firstname).append("]").toString();
	}

// Ab hier von Eclipse generierte Setter und Getter
...

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

...

// Ab hier von Eclipse generierte Methoden hashCode(), equals(), toString()

/**

* @see java.lang.Object#hashCode()

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

if (cars != null && Persistence.getPersistenceUtil().isLoaded(cars)) {

result = prime * result + cars.hashCode();

} else {

result = prime * result;

}

result =

prime * result + (firstname == null ? 0 : firstname.hashCode());

result = prime * result + (id == null ? 0 : id.hashCode());

result = prime * result + (name == null ? 0 : name.hashCode());

return result;

}

/**

* @see java.lang.Object#equals(java.lang.Object)

@Override

public boolean equals(Object obj) {

if (this == obj) {

return true;

}

if (obj == null) {

return false;

}

if (!(obj instanceof Driver)) {

return false;

}

Driver other = (Driver) obj;

if (cars == null) {

if (other.cars != null) {

return false;

}

} else {

if (Persistence.getPersistenceUtil().isLoaded(cars)

&& Persistence.getPersistenceUtil().isLoaded(other.cars)) {

if (!cars.equals(other.cars)) {

return false;

}

if (firstname == null) {

if (other.firstname != null) {

return false;

}

} else if (!firstname.equals(other.firstname)) {

return false;

}

if (id == null) {

if (other.id != null) {

return false;

}

} else if (!id.equals(other.id)) {

return false;

}

if (name == null) {

if (other.name != null) {

return false;

}

} else if (!name.equals(other.name)) {

return false;

}

return true;

}

/**

* @see java.lang.Object#toString()

@Override

public String toString() {

return new StringBuilder().append("Driver [id=").append(id)

.append(", name=").append(name).append(", firstname=")

.append(firstname).append("]").toString();

}

// Ab hier von Eclipse generierte Setter und Getter

...

Als nächstes folgt die Klasse für die Autos. Das Auto kennt seinen Fahrer nicht, daher gibt es auch kein Attribut für den Fahrer in der Klasse.

Der primäre Schlüssel in Zeile 22 wird von Außen vorgegeben (Kennzeichen).

package de.rahn.services.drivers.entity;

import javax.persistence.Access;

import javax.persistence.AccessType;

import javax.persistence.Basic;

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Table;

/**

* Die Klasse eines Autos.

* @author Frank W. Rahn

@Entity

@Table(schema = "rahn")

@Access(AccessType.FIELD)

public class Car {

/** Die Identität eines angemeldeten Autos. */

@Id

@Basic(optional = false)

private String id;

/** Der Typ des Autos. */

@Basic(optional = false)

private String type;

// Ab hier von Eclipse generierte Methoden hashCode(), equals(), toString(),

// Setter und Getter

...

Es fehlt noch die XML Konfiguration für die Persistenz, die nicht sehr umfangreich ist.

In der Zeile 11 wird angegeben, dass die Anwendung die Transaktionen der Datenbank verwenden soll:
EntityTransaction etx = entityManager.getTransaction();
Im Gegensatz zu der Angabe JTA, wo der Transaktionsmanager des Java EE Containers verwendet würde:
UserTransaction utx = (UserTransaction) (new InitialContext()).lookup("java:comp/UserTransaction");

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

http://java.sun.com/xml/ns/persistence

http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd

<persistence-unit

name="test-spring-drivers" transaction-type="RESOURCE_LOCAL" />

</persistence>

Das Data Access Object für die Fahrerverwaltung

Die Definition des konkreten Datenzugriffsobjekt für den Service der Fahrerverwaltung.

In Zeile 16 wird die Annotation @Repository verwendet. Durch diese Annotation wird diese Klasse zu einem Spring Bean mit einer Behandlung für Ausnahmen der Persistenzschicht. Diese Ausnahmen werden in eine Unterklasse von org.springframework.dao.DataAccessException übersetzt.
Ab der Zeile 32 wird eine Methode findAll() implementiert, die per @NamedQuery definierten Abfrage alle Instanzen dieser Klasse lädt.

package de.rahn.services.drivers.dao;

import java.util.List;

import org.springframework.stereotype.Repository;

import de.rahn.db.jpa.dao.AbstractGenericJpaDAO;

import de.rahn.services.drivers.entity.Driver;

/**

* Ein DAO für den Fahrer.

* @author Frank W. Rahn

* @param <Entity> Die Klasse der Entität

* @param <PrimaryKey> Die Klasse des primären Key

@Repository

public class DriverDAO extends AbstractGenericJpaDAO<Driver, Long> {

/**

* {@inheritDoc}

* @see GenericDAO#getPrimaryKey(java.lang.Object)

@Override

public Long getPrimaryKey(Driver persistentObject) {

return persistentObject.getId();

}

/**

* Suche alle Fahrer.

* @return alle Fahrer

public List<Driver> findAll() {

return getEntityManager().createNamedQuery(Driver.FIND_ALL,

Driver.class).getResultList();

}

Die Implementierung des Services der Fahrerverwaltung

Die Standard-Implementierung der Fahrerverwaltung.

Durch die Annotation @Service("drivers") in Zeile 19 wird diese Implementierung als Spring Bean mit dem Namen drivers definiert.
In der Zeile 24 wird das Datenzugriffsobjekt DriverDAO verwendet.
In der Zeile 20 wird definiert, dass alle Methoden in einer Transaktion ausgeführt werden.
In Zeile 31 und 41 wird durch die Annotation angegeben, dass diese Methoden eine existierende Transaktion unterstützen, aber keine eigene Transaktion benötigen.

package de.rahn.services.drivers.standard;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import de.rahn.services.drivers.Drivers;
import de.rahn.services.drivers.dao.DriverDAO;
import de.rahn.services.drivers.entity.Car;
import de.rahn.services.drivers.entity.Driver;

/**
 * Die Standard-Implementierung des Services {@link Drivers}.
 * @author Frank W. Rahn
 */
@Service("drivers")
@Transactional
public class StandardDrivers implements Drivers {

@Autowired
	private DriverDAO driverDAO;

/**
	 * {@inheritDoc}
	 * @see Drivers#getDrivers()
	 */
	@Override
	@Transactional(propagation = Propagation.SUPPORTS)
	public List<Driver> getDrivers() {
		return driverDAO.findAll();
	}

/**
	 * {@inheritDoc}
	 * @see Drivers#getDriver(Long)
	 */
	@Override
	@Transactional(propagation = Propagation.SUPPORTS)
	public Driver getDriver(Long id) {
		return driverDAO.findByPrimaryKey(id);
	}

/**
	 * {@inheritDoc}
	 * @see Drivers#createDriver(String, String)
	 */
	@Override
	public Long createDriver(String name, String firstname) {
		Driver driver = new Driver();
		driver.setName(name);
		driver.setFirstname(firstname);

return create(driver);
	}

/**
	 * {@inheritDoc}
	 * @see Drivers#create(Driver)
	 */
	@Override
	public Long create(Driver driver) {
		return driverDAO.create(driver);
	}

/**
	 * {@inheritDoc}
	 * @see Drivers#save(Driver)
	 */
	@Override
	public Driver save(Driver driver) {
		driverDAO.save(driver);
		return driver;
	}

/**
	 * {@inheritDoc}
	 * @see Drivers#addCarToDriver(Long, Car)
	 */
	@Override
	public Driver addCarToDriver(Long id, Car car) {
		Driver driver = driverDAO.findByPrimaryKey(id);
		driver.getCars().add(car);

return save(driver);
	}

}

package de.rahn.services.drivers.standard;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import de.rahn.services.drivers.Drivers;

import de.rahn.services.drivers.dao.DriverDAO;

import de.rahn.services.drivers.entity.Car;

import de.rahn.services.drivers.entity.Driver;

/**

* Die Standard-Implementierung des Services {@link Drivers}.

* @author Frank W. Rahn

@Service("drivers")

@Transactional

public class StandardDrivers implements Drivers {

@Autowired

private DriverDAO driverDAO;

/**

* {@inheritDoc}

* @see Drivers#getDrivers()

@Override

@Transactional(propagation = Propagation.SUPPORTS)

public List<Driver> getDrivers() {

return driverDAO.findAll();

}

/**

* {@inheritDoc}

* @see Drivers#getDriver(Long)

@Override

@Transactional(propagation = Propagation.SUPPORTS)

public Driver getDriver(Long id) {

return driverDAO.findByPrimaryKey(id);

}

/**

* {@inheritDoc}

* @see Drivers#createDriver(String, String)

@Override

public Long createDriver(String name, String firstname) {

Driver driver = new Driver();

driver.setName(name);

driver.setFirstname(firstname);

return create(driver);

}

/**

* {@inheritDoc}

* @see Drivers#create(Driver)

@Override

public Long create(Driver driver) {

return driverDAO.create(driver);

}

/**

* {@inheritDoc}

* @see Drivers#save(Driver)

@Override

public Driver save(Driver driver) {

driverDAO.save(driver);

return driver;

}

/**

* {@inheritDoc}

* @see Drivers#addCarToDriver(Long, Car)

@Override

public Driver addCarToDriver(Long id, Car car) {

Driver driver = driverDAO.findByPrimaryKey(id);

driver.getCars().add(car);

return save(driver);

}

Im folgenden Bild wird der vollständige Service in einem UML-Klassendiagramm dargestellt.

Spring mit JPA und Hibernate (© Frank Rahn)

Die Anwendung mit Logging

Sie ist wie in dem Beispiel Spring an einem einfachem Beispiel aufgebaut. Es ändert sich nur die Anwendung, die XML Konfiguration de/rahn/app/application.xml und der Starter bleiben gleich. Die Änderung an der Application sind hier dargestellt.

package de.rahn.app;

import static org.slf4j.LoggerFactory.getLogger;

import java.util.List;

import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import de.rahn.services.drivers.Drivers;
import de.rahn.services.drivers.entity.Car;
import de.rahn.services.drivers.entity.Driver;

/**
 * Die Anwendung zum Aufrufen der Fahrerverwaltung.
 * @author Frank W. Rahn
 */
@Component
public class Application implements Runnable {

private static final Logger logger = getLogger(Application.class);

@Autowired(required = true)
	private Drivers drivers;

/**
	 * {@inheritDoc}
	 * @see Runnable#run()
	 */
	@Override
	public void run() {
		// Lege einen Fahrer an
		Long id = drivers.createDriver("Rahn", "Frank");
		logger.info("Einen Fahrer mit der Id '{}' angelegt", id);

// Hole den Fahrer wieder
		Driver driver = drivers.getDriver(id);
		logger.info("Den Fahrer mit der Id '{}' geholt: {}", id, driver);

// Lege ein Auto an
		Car car = new Car();
		car.setId("K-XX 4711");
		car.setType("Audi A6");
		driver = drivers.addCarToDriver(id, car);
		logger.info("Den Fahrer mit der Id '{}' geändert: {}", id, driver);

// Alle Fahrer selektieren
		List<Driver> listDrivers = drivers.getDrivers();
		for (Driver driver2 : listDrivers) {
			logger.info(
				"Fahrer: Id '{}' Name: {} {}",
				new Object[] { driver2.getId(), driver2.getFirstname(),
					driver2.getName() });
		}
	}

}

package de.rahn.app;

import static org.slf4j.LoggerFactory.getLogger;

import java.util.List;

import org.slf4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import de.rahn.services.drivers.Drivers;

import de.rahn.services.drivers.entity.Car;

import de.rahn.services.drivers.entity.Driver;

/**

* Die Anwendung zum Aufrufen der Fahrerverwaltung.

* @author Frank W. Rahn

@Component

public class Application implements Runnable {

private static final Logger logger = getLogger(Application.class);

@Autowired(required = true)

private Drivers drivers;

/**

* {@inheritDoc}

* @see Runnable#run()

@Override

public void run() {

// Lege einen Fahrer an

Long id = drivers.createDriver("Rahn", "Frank");

logger.info("Einen Fahrer mit der Id '{}' angelegt", id);

// Hole den Fahrer wieder

Driver driver = drivers.getDriver(id);

logger.info("Den Fahrer mit der Id '{}' geholt: {}", id, driver);

// Lege ein Auto an

Car car = new Car();

car.setId("K-XX 4711");

car.setType("Audi A6");

driver = drivers.addCarToDriver(id, car);

logger.info("Den Fahrer mit der Id '{}' geändert: {}", id, driver);

// Alle Fahrer selektieren

List<Driver> listDrivers = drivers.getDrivers();

for (Driver driver2 : listDrivers) {

logger.info(

"Fahrer: Id '{}' Name: {} {}",

new Object[] { driver2.getId(), driver2.getFirstname(),

driver2.getName() });

}

Die XML Konfiguration zum Einstieg in die Anwendung muß um die Datenbank- und die Transaktionsdefinitionen erweitert werden.

In der Zeile 27 wird auf die Konfiguration mit den Datenbank- und die Transaktionsdefinitionen im gleichen Verzeichnis verwiesen.

<?xml version="1.0" encoding="UTF-8"?>

<description>
		Dieses ist die zentrale Konfiguration für die Anwendungen.
	</description>

<aop:aspectj-autoproxy proxy-target-class="true" />

<context:annotation-config />

<import resource="db.xml" />
	<import resource="classpath:/de/rahn/services/drivers/drivers.xml" />
	<import resource="classpath:/de/rahn/app/application.xml" />

</beans>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd

Dieses ist die zentrale Konfiguration für die Anwendungen.

</description>

<aop:aspectj-autoproxy proxy-target-class="true" />

<context:annotation-config />

</beans>

In der folgenden XML Konfiguration werden die Datenbank- und die Transaktionsdefinitionen vorgenommen. Hier wird erstmalig der p-Namesraum für das Setzen von Properties verwendet.

Die Syntax lautet dabei:
p:<Property-Name>="<Property-Wert>" oder p:<Property-Name>-ref="<Name der referenzierten Bean>"

Die Definitionen für den Datenbankzugriff ( EntityManagerFactory) in den Zeilen 27 bis 34 und die Behandlung der Transaktionen in den Zeilen 37 bis 42.
In den Zeilen 22 bis 24 wird eine Datenbank gestartet und durch das angegebene Skript init.sql initialisiert.

<?xml version="1.0" encoding="UTF-8"?>

<description>
		Dieses ist die zentrale Konfiguration für die Datenbank.
	</description>

<jdbc:embedded-database id="dataSource" type="HSQL">
		<jdbc:script location="classpath:/META-INF/spring/init.sql" />
	</jdbc:embedded-database>

<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
		p:dataSource-ref="dataSource" p:persistenceUnitName="test-spring-drivers">
		<property name="jpaVendorAdapter">
			<1bean p:generateDdl="true"
				class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
		</property>
	</bean>

<bean id="transactionManager"
		class="org.springframework.orm.jpa.JpaTransactionManager"
		p:entityManagerFactory-ref="entityManagerFactory" />

<tx:annotation-driven proxy-target-class="true" />

</beans>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:p="http://www.springframework.org/schema/p"

xmlns:jdbc="http://www.springframework.org/schema/jdbc"

xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/jdbc

http://www.springframework.org/schema/jdbc/spring-jdbc.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx.xsd

Dieses ist die zentrale Konfiguration für die Datenbank.

</description>

<jdbc:embedded-database id="dataSource" type="HSQL">

<jdbc:script location="classpath:/META-INF/spring/init.sql" />

</jdbc:embedded-database>

<bean id="entityManagerFactory"

class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"

p:dataSource-ref="dataSource" p:persistenceUnitName="test-spring-drivers">

<1bean p:generateDdl="true"

class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />

</property>

</bean>

<bean id="transactionManager"

class="org.springframework.orm.jpa.JpaTransactionManager"

p:entityManagerFactory-ref="entityManagerFactory" />

<tx:annotation-driven proxy-target-class="true" />

</beans>

Im folgendem Kasten wird das Skript init.sql dargestellt. Der SQL Dialekt ist HSQL (HyperSQL Database). HSQLDB ist eine vollständig in Java geschrieben relationale Datenbank.

create SCHEMA rahn;

create sequence DriverSEQ;

create table rahn.Driver (

id bigint not null,

firstname varchar(255),

name varchar(255) not null,

primary key (id));

create table rahn.Car (

id varchar(255) not null,

type varchar(255) not null,

driver_id bigint not null,

primary key (id));

alter table rahn.Car

add constraint FK107B45ADEE2FE foreign key (driver_id)

references rahn.Driver;

insert into rahn.Driver (firstname, name, id)

values ('Martin', 'Rahn', next value for DriverSEQ);

Der Unit Test

Zunächst erstellen wir einen Test für die Klasse DriverDAO.

In der Zeile 25 wird auf die benötigten XML Konfigurationen von Spring verwiesen. Das ist eine spezielle XML Konfiguration für den Test /META-INF/spring/context-test.xml, sie beinhaltet die Konfigurationen für den Datenbankzugriff, und die Konfiguration für die Fahrerverwaltung ../drivers.xml.

package de.rahn.services.drivers.dao;

import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.sameInstance;
import static org.junit.Assert.assertThat;

import java.io.Serializable;
import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import de.rahn.services.drivers.entity.Driver;

/**
 * Die Testklasse für {@link DriverDAO}.
 * @author Frank W. Rahn
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "/META-INF/spring/context-test.xml",
	"../drivers.xml" })
@Transactional
public class DriverDAOTest {

@Autowired
	private DriverDAO driverDAO;

/**
	 * Test method for {@link DriverDAO#getPrimaryKey(Driver)}.
	 */
	@Test
	public void testGetPrimaryKey() {
		Driver driver = new Driver();
		driver.setId(new Long(4711));

Long id = driverDAO.getPrimaryKey(driver);
		assertThat("Primärer Key unterschiedlich", driver.getId(), is(id));
	}

/**
	 * Test method for {@link DriverDAO#findAll()}.
	 */
	@Test
	public void testFindAll() {
		List<Driver> drivers = driverDAO.findAll();
		assertThat("kein Ergebnis geliefert", drivers, notNullValue());
		assertThat("Anzahl der Treffer ungleich", drivers.size(), is(1));

Driver driver = drivers.get(0);
		assertThat("id ungleich", driver.getId(), is(0L));
		assertThat("firstname ungleich", driver.getFirstname(), is("Martin"));
		assertThat("name ungleich", driver.getName(), is("Rahn"));
	}

/**
	 * Test method for 
	 * {@link de.rahn.db.jpa.dao.AbstractGenericJpaDAO#create(Object)}.
	 */
	@Test
	public void testCreate() {
		Driver driver = new Driver();
		driver.setName("Rahn");
		driver.setFirstname("Frank");

Long id = driverDAO.create(driver);
		assertThat("keine id geliefert", id, notNullValue());
		assertThat("ungleiche id", driver.getId(), is(id));

Driver driver2 = driverDAO.findByPrimaryKey(id);
		assertThat("doch nicht gespeichert", driver2, notNullValue());
		assertThat("ungleicher Fahrer", driver2, sameInstance(driver));
	}

/**
	 * Test method for
	 * {@link de.rahn.db.jpa.dao.AbstractGenericJpaDAO#save(Object)}.
	 */
	@Test
	public void testSave() {
		Driver driver = driverDAO.findByPrimaryKey(0L);
		assertThat("kein Fahrer gefunden", driver, notNullValue());

driver.setFirstname("Peter");
		driverDAO.save(driver);

Driver driver2 = driverDAO.findByPrimaryKey(0L);
		assertThat("kein Fahrer gefunden", driver2, notNullValue());
		assertThat("ungleicher Fahrer", driver2, sameInstance(driver));
	}

/**
	 * Test method for
	 * {@link de.rahn.db.jpa.dao.AbstractGenericJpaDAO#remove(Object)}.
	 */
	@Test
	public void testRemoveEntity() {
		List<Driver> drivers = driverDAO.findAll();
		assertThat("Anzahl der Treffer ungleich", drivers.size(), is(1));
		Driver driver = drivers.get(0);

driverDAO.remove(driver);

drivers = driverDAO.findAll();
		assertThat("Anzahl der Treffer ungleich", drivers.size(), is(0));
	}

/**
	 * Test method for
	 * {@link de.rahn.db.jpa.dao.AbstractGenericJpaDAO#findByPrimaryKey(Serializable)}
	 * .
	 */
	@Test
	public void testFindByPrimaryKey() {
		Driver driver = driverDAO.findByPrimaryKey(0L);
		assertThat("kein Ergebnis geliefert", driver, notNullValue());
		assertThat("id ungleich", driver.getId(), is(0L));
		assertThat("firstname ungleich", driver.getFirstname(), is("Martin"));
		assertThat("name ungleich", driver.getName(), is("Rahn"));
	}

/**
	 * Test method for
	 * {@link de.rahn.db.dao.AbstractGenericDAO#remove(Serializable)}.
	 */
	@Test
	public void testRemovePrimaryKey() {
		driverDAO.remove(0L);

List<Driver> drivers = driverDAO.findAll();
		assertThat("kein Ergebnis geliefert", drivers, notNullValue());
		assertThat("Anzahl der Treffer ungleich", drivers.size(), is(0));
	}

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

package de.rahn.services.drivers.dao;

import static org.hamcrest.Matchers.is;

import static org.hamcrest.Matchers.notNullValue;

import static org.hamcrest.Matchers.sameInstance;

import static org.junit.Assert.assertThat;

import java.io.Serializable;

import java.util.List;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import org.springframework.transaction.annotation.Transactional;

import de.rahn.services.drivers.entity.Driver;

/**

* Die Testklasse für {@link DriverDAO}.

* @author Frank W. Rahn

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations = { "/META-INF/spring/context-test.xml",

"../drivers.xml" })

@Transactional

public class DriverDAOTest {

@Autowired

private DriverDAO driverDAO;

/**

* Test method for {@link DriverDAO#getPrimaryKey(Driver)}.

@Test

public void testGetPrimaryKey() {

Driver driver = new Driver();

driver.setId(new Long(4711));

Long id = driverDAO.getPrimaryKey(driver);

assertThat("Primärer Key unterschiedlich", driver.getId(), is(id));

}

/**

* Test method for {@link DriverDAO#findAll()}.

@Test

public void testFindAll() {

List<Driver> drivers = driverDAO.findAll();

assertThat("kein Ergebnis geliefert", drivers, notNullValue());

assertThat("Anzahl der Treffer ungleich", drivers.size(), is(1));

Driver driver = drivers.get(0);

assertThat("id ungleich", driver.getId(), is(0L));

assertThat("firstname ungleich", driver.getFirstname(), is("Martin"));

assertThat("name ungleich", driver.getName(), is("Rahn"));

}

/**

* Test method for

* {@link de.rahn.db.jpa.dao.AbstractGenericJpaDAO#create(Object)}.

@Test

public void testCreate() {

Driver driver = new Driver();

driver.setName("Rahn");

driver.setFirstname("Frank");

Long id = driverDAO.create(driver);

assertThat("keine id geliefert", id, notNullValue());

assertThat("ungleiche id", driver.getId(), is(id));

Driver driver2 = driverDAO.findByPrimaryKey(id);

assertThat("doch nicht gespeichert", driver2, notNullValue());

assertThat("ungleicher Fahrer", driver2, sameInstance(driver));

}

/**

* Test method for

* {@link de.rahn.db.jpa.dao.AbstractGenericJpaDAO#save(Object)}.

@Test

public void testSave() {

Driver driver = driverDAO.findByPrimaryKey(0L);

assertThat("kein Fahrer gefunden", driver, notNullValue());

driver.setFirstname("Peter");

driverDAO.save(driver);

Driver driver2 = driverDAO.findByPrimaryKey(0L);

assertThat("kein Fahrer gefunden", driver2, notNullValue());

assertThat("ungleicher Fahrer", driver2, sameInstance(driver));

}

/**

* Test method for

* {@link de.rahn.db.jpa.dao.AbstractGenericJpaDAO#remove(Object)}.

@Test

public void testRemoveEntity() {

List<Driver> drivers = driverDAO.findAll();

assertThat("Anzahl der Treffer ungleich", drivers.size(), is(1));

Driver driver = drivers.get(0);

driverDAO.remove(driver);

drivers = driverDAO.findAll();

assertThat("Anzahl der Treffer ungleich", drivers.size(), is(0));

}

/**

* Test method for

* {@link de.rahn.db.jpa.dao.AbstractGenericJpaDAO#findByPrimaryKey(Serializable)}

* .

@Test

public void testFindByPrimaryKey() {

Driver driver = driverDAO.findByPrimaryKey(0L);

assertThat("kein Ergebnis geliefert", driver, notNullValue());

assertThat("id ungleich", driver.getId(), is(0L));

assertThat("firstname ungleich", driver.getFirstname(), is("Martin"));

assertThat("name ungleich", driver.getName(), is("Rahn"));

}

/**

* Test method for

* {@link de.rahn.db.dao.AbstractGenericDAO#remove(Serializable)}.

@Test

public void testRemovePrimaryKey() {

driverDAO.remove(0L);

List<Driver> drivers = driverDAO.findAll();

assertThat("kein Ergebnis geliefert", drivers, notNullValue());

assertThat("Anzahl der Treffer ungleich", drivers.size(), is(0));

}

Für die allgemeinen Spring Beans wurde eine spezielle XML Konfiguration /META-INF/spring/context-test.xml erstellt. Sie lädt nur die Konfigurationen für den Datenbankzugriff.

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd

Dieses ist die zentrale Konfiguration für die Tests.

</description>

<context:annotation-config />

</beans>

Jetzt fehlt nur noch der Unit Test für den Service der Fahrerverwaltung StandardDriver.

package de.rahn.services.drivers.standard;

import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.Assert.assertThat;

import de.rahn.services.drivers.Drivers;
import de.rahn.services.drivers.entity.Car;
import de.rahn.services.drivers.entity.Driver;

/**
 * Die Testklasse für {@link StandardDrivers}.
 * @author Frank W. Rahn
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "/META-INF/spring/context-test.xml",
	"../drivers.xml" })
@Transactional
public class StandardDriversTest {

/** CAR_TYPE */
	private static final String CAR_TYPE = "Audi A6";

/** CAR_ID */
	private static final String CAR_ID = "K-XX 4711";

@Autowired
	private Drivers drivers;

/**
	 * Test method for {@link StandardDrivers#getDriver(Long)}.
	 */
	@Test
	public void testGetDriver() {
		Driver driver = drivers.getDriver(0L);
		assertThat("kein Fahrer geliefert", driver, notNullValue());
		assertThat("id ungleich", driver.getId(), is(0L));
		assertThat("firstname ungleich", driver.getFirstname(), is("Martin"));
		assertThat("name ungleich", driver.getName(), is("Rahn"));
	}

/**
	 * Test method for {@link StandardDrivers#createDriver(String, String)}.
	 */
	@Test
	public void testCreateDriver() {
		Long id = drivers.createDriver("Rahn", "Frank");
		assertThat("keine id geliefert", id, notNullValue());

Driver driver = drivers.getDriver(id);
		assertThat("doch nicht gespeichert", driver, notNullValue());
		assertThat("ungleiche id", driver.getId(), is(id));
		assertThat("firstname ungleich", driver.getFirstname(), is("Frank"));
		assertThat("name ungleich", driver.getName(), is("Rahn"));
	}

/**
	 * Test method for {@link StandardDrivers#addCarToDriver(Long, Car)}.
	 */
	@Test
	public void testAddCarToDriver() {
		Car car = new Car();
		car.setId(CAR_ID);
		car.setType(CAR_TYPE);
		Driver driver = drivers.addCarToDriver(0L, car);
		assertThat("doch nicht gespeichert", driver, notNullValue());
		assertThat("id ungleich", driver.getId(), is(0L));
		assertThat("firstname ungleich", driver.getFirstname(), is("Martin"));
		assertThat("name ungleich", driver.getName(), is("Rahn"));
		assertThat("anzahl Autos ungleich", driver.getCars().isEmpty(),
			not(true));
		car = driver.getCars().iterator().next();
		assertThat("id ungleich", car.getId(), is(CAR_ID));
		assertThat("type ungleich", car.getType(), is(CAR_TYPE));
	}

}

package de.rahn.services.drivers.standard;

import static org.hamcrest.Matchers.is;

import static org.hamcrest.Matchers.not;

import static org.hamcrest.Matchers.notNullValue;

import static org.junit.Assert.assertThat;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import org.springframework.transaction.annotation.Transactional;

import de.rahn.services.drivers.Drivers;

import de.rahn.services.drivers.entity.Car;

import de.rahn.services.drivers.entity.Driver;

/**

* Die Testklasse für {@link StandardDrivers}.

* @author Frank W. Rahn

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations = { "/META-INF/spring/context-test.xml",

"../drivers.xml" })

@Transactional

public class StandardDriversTest {

/** CAR_TYPE */

private static final String CAR_TYPE = "Audi A6";

/** CAR_ID */

private static final String CAR_ID = "K-XX 4711";

@Autowired

private Drivers drivers;

/**

* Test method for {@link StandardDrivers#getDriver(Long)}.

@Test

public void testGetDriver() {

Driver driver = drivers.getDriver(0L);

assertThat("kein Fahrer geliefert", driver, notNullValue());

assertThat("id ungleich", driver.getId(), is(0L));

assertThat("firstname ungleich", driver.getFirstname(), is("Martin"));

assertThat("name ungleich", driver.getName(), is("Rahn"));

}

/**

* Test method for {@link StandardDrivers#createDriver(String, String)}.

@Test

public void testCreateDriver() {

Long id = drivers.createDriver("Rahn", "Frank");

assertThat("keine id geliefert", id, notNullValue());

Driver driver = drivers.getDriver(id);

assertThat("doch nicht gespeichert", driver, notNullValue());

assertThat("ungleiche id", driver.getId(), is(id));

assertThat("firstname ungleich", driver.getFirstname(), is("Frank"));

assertThat("name ungleich", driver.getName(), is("Rahn"));

}

/**

* Test method for {@link StandardDrivers#addCarToDriver(Long, Car)}.

@Test

public void testAddCarToDriver() {

Car car = new Car();

car.setId(CAR_ID);

car.setType(CAR_TYPE);

Driver driver = drivers.addCarToDriver(0L, car);

assertThat("doch nicht gespeichert", driver, notNullValue());

assertThat("id ungleich", driver.getId(), is(0L));

assertThat("firstname ungleich", driver.getFirstname(), is("Martin"));

assertThat("name ungleich", driver.getName(), is("Rahn"));

assertThat("anzahl Autos ungleich", driver.getCars().isEmpty(),

not(true));

car = driver.getCars().iterator().next();

assertThat("id ungleich", car.getId(), is(CAR_ID));

assertThat("type ungleich", car.getType(), is(CAR_TYPE));

}

Hier noch die entsprechende Erfolgsmeldung.

Der Quellcode und Download des Beispiels

Quellcode ansehen bei GitHub:
Spring mit JPA und Hibernate

Download einer ZIP-Datei von GitHub:
Spring mit JPA und Hibernate

Die Maven Befehl

Eclipse Konfiguration neu erzeugen: $ mvn eclipse:clean eclipse:eclipse

Anwendung bauen: $ mvn clean install

Anwendung ausführen: $ mvn initialize exec:exec

Update: Criteria API

Es wurde in der pom.xml ein Maven-Plugin für die Generierung des Metamodels der Criteria API aufgenommen. Dieses Metamodel wird in das Verzeichnis target/generated-sources/apt generiert. Mit der Criteria API können Datenbankabfragen objektorientiert im Quellcode programiert werden.

Nachfolgenden ist die Maven Konfiguration für die Erzeugung der Criteria API mit dem JPA 2 Metamodel Generator von Hibernate dargestellt.

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

...

<groupId>org.bsc.maven</groupId>

<artifactId>maven-processor-plugin</artifactId>

<goals>

<goal>process</goal>

</goals>

</execution>

</executions>

</optionMap>

<processor>org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor</processor>

</processors>

</configuration>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-jpamodelgen</artifactId>

<version>${hibernate-jpamodelgen-version}</version>

</dependency>

</dependencies>

</plugin>

...

Zusätzlich wurde ein Template, nach dem Muster von Spring, erzeugt. Dadurch kann das abstrakte und generische JPA-Datenzugriffsobjekt die Erzeugung der Factory-Klassen übernehmen.

package de.rahn.db.jpa.dao;

import javax.persistence.criteria.CriteriaBuilder;

import javax.persistence.criteria.CriteriaQuery;

import javax.persistence.criteria.Root;

/**

* Ein typisches Spring-Template, dass die Erzeugung einiger notwendigen Factory

* Klassen zur Erzeugung von Queries auf Basis der Criteria API an das

* {@link AbstractGenericJpaDAO} deligiert.

* @author Frank W. Rahn

* @param <Entity> Die Klasse der Entität

* @see AbstractGenericJpaDAO

public interface CriteriaQueryTemplate<Entity> {

/**

* Diese Methode wird durch das {@link AbstractGenericJpaDAO} ausgeführt und

* stellt einige Standardkomponenten der Criteria API zu Verfügung.

* @param builder der {@link CriteriaBuilder}

* @param query die an die Entität gebundene Abfrage

* @param rootEntity die Projektionsvariable der FROM-Klausel

void doBuild(CriteriaBuilder builder, CriteriaQuery<Entity> query,

Root<Entity> rootEntity);

}

Das abstrakte und generische JPA-Datenzugriffsobjekt AbstractGenericJpaDAO, wird um die Methode buildQuery() erweitert.

...

/**

* Erzeuge über die Criteria API eine JPA Query.

* @param template der Builder

* @return eine ausführbare JPA Query

protected TypedQuery<Entity> buildQuery(

CriteriaQueryTemplate<Entity> template) {

// Erzeuge eine Builder

CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();

// Erzeuge die Query

CriteriaQuery<Entity> criteriaQuery =

criteriaBuilder.createQuery(entityClass);

// Erzeuge die Referenz zur Hauptentität

Root<Entity> rootEntity = criteriaQuery.from(entityClass);

// Führe den Build durch

template.doBuild(criteriaBuilder, criteriaQuery, rootEntity);

// Erzeuge eine ausführbare JPA Query

return entityManager.createQuery(criteriaQuery);

}

...

Das Datenzugriffsobjekt der Fahrer stellt die Methode findByName() bereit.

...

/**

* Suche alle Fahrer mit dem Namen.

* @param name der Name des Fahrers

* @return die gefundenen Fahrer

public List<Driver> findByName(final String name) {

return buildQuery(new CriteriaQueryTemplate<Driver>() {

@Override

public void doBuild(CriteriaBuilder builder,

CriteriaQuery<Driver> query, Root<Driver> rootEntity) {

// Erzeuge eine logische Ausdruck

Predicate predicate =

builder.equal(rootEntity.get(Driver_.name), name);

// Definiere die Abfrage

query.select(rootEntity).where(predicate).distinct(true);

}

}).getResultList();

}

...

Zum Abschluss darf natürlich der Test nicht fehlen.

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

...

/**

* Test der Criteria API.

@Test

public void testCriteriaAPI() {

List<Driver> drivers = driverDAO.findByName("Rahn");

assertThat("keine Ergebnis geliefert", drivers, notNullValue());

assertThat("Anzahl der Treffer ungleich", drivers.size(), is(1));

Driver driver = drivers.get(0);

assertThat("id ungleich", driver.getId(), is(0L));

assertThat("firstname ungleich", driver.getFirstname(), is("Martin"));

assertThat("name ungleich", driver.getName(), is("Rahn"));

}

...

Update am 28.09.2012

Es wurden folgende Änderungen an allen Projekten vorgenommen.

Die Projekte wurden aus meinem lokalen Apache Subversion Repository in meine öffentlichen GitHub Repositories verschoben.
- Projekt test-spring-simple
- Projekt test-spring-jpa
- Projekt test-spring-web
Die folgenden typischen Anpassungen an Git wurden an allen Projekten durchgeführt.
- .directory gelöscht
- .gitignore hinzugefügt
- README.md hinzugefügt
- COPYRIGHT.md hinzugefügt
- In jedem Repository wurde für jeden Beitrag der Serie ein Branch angelegt.
  - develop-spring-an-einem-einfachen-beispiel
  - develop-spring-mit-aop
  - develop-spring-mit-jpa-und-hibernate
  - develop-spring-mit-einer-einfachen-webanwendung
  - develop-spring-mit-einer-webanwendung-mit-jpa-und-validierung
  - develop-spring-security-mit-einer-webanwendung
  - develop-spring-mit-restful-webservice

Updates von 06.10.2012 bis zum 14.10.2012

Es wurden folgende Änderungen an allen Projekten vorgenommen.

Aktualisierung des OpenJDK auf die Version 1.7.0.
Aktualisierung der Entwicklungsumgebung Eclipse auf die Version 4.2.1.
Die benötigten Plugins aus dem Eclipse Marketplace:
- EGit – Git Team Provider, Version 2.1.0
- ~~GitHub Mylyn Connector, Version 2.0~~
- Maven Integration for Eclipse, Version 1.2
- Spring IDE, Version 3.0.0.RELEASE
- AspectJ Development Tools (AJDT), Version 2.2.0
- Markdown Text Editor, Version 0.9.0
Aktualisierung der Datei pom.xml:
- Anpassungen an die OpenJDK Version
- GitHub Einträge (SCM und URL) hinzugefügt
- Aktualisierung der Libraries auf aktuellerer Versionen (z. B. Spring Version 3.1.2.RELEASE, Hibernate Version 4.1.7.Final, JUnit Version 4.10, mockito Version 1.9.0, …)
  Die genaueren Versionen bitte aus den jeweiligen pom.xml auf GitHub entnehmen.

Weitere Beiträge dieser Serie. [verstecken]

Einführung in das Spring Framework

Über
Letzte Artikel

Frank Rahn

Frank Rahn ist Softwarearchitekt. Er unterstützt bei der Konzeption von Softwarearchitekturen mit Java-Technologie. Folge Sie ihm auf Facebook, Twitter oder Google+.

Benötigen Sie Unterstützung? Kontaktieren Sie ihn.

Hat Ihnen dieser Beitrag gefallen? Wir würden uns über Ihren Kommentar freuen! Bitte verwenden Sie Ihren bürgerlichen Namen und eine E-Mail-Adresse mit Gravatar.

Letzte Artikel von Frank Rahn (Alle anzeigen)

Spring Boot Webanwendung: Die ersten Schritte (Tutorial) - Montag, 28. März 2016
Wer ist der optimale Java Bean Mapper? - Sonntag, 19. Juli 2015
Mainframe-Zugriff via Java - Sonntag, 04. Mai 2014

Mittwoch, 03. August 2011/0 Kommentare/von Frank Rahn

Spring mit JPA und Hibernate (Tutorial)

Die Struktur des Projektes

Die Literaturempfehlungen für dieses Beispiel

Das abstrakte und generische Datenzugriffsobjekt

Die Spezialisierung des Data Access Objects für JPA

Die Definition des Service der Fahrerverwaltung

Die Entitäten des Services Fahrerverwaltung

Das Data Access Object für die Fahrerverwaltung

Die Implementierung des Services der Fahrerverwaltung

Die Anwendung mit Logging

Der Unit Test

Der Quellcode und Download des Beispiels

Die Maven Befehl

Update: Criteria API

Update am 28.09.2012

Updates von 06.10.2012 bis zum 14.10.2012

Frank Rahn

Letzte Artikel von Frank Rahn (Alle anzeigen)

Dein Kommentar

Schreibe einen Kommentar Antworten abbrechen

Blogarchiv

Lizenz

Blogkategorien

Das könnte Dich auch interessieren:

Dein Kommentar

Schreibe einen Kommentar Antworten abbrechen

Blogarchiv

Lizenz

Blogkategorien