Persistenz für Desktop Anwendungen mit JPA und JavaDB

Im neuen Java 6 Release wird eine Datenbank (Java DB) gleich mitgeliefert, daher liegt es nahe diese für Desktop Anwendungen zu benutzen. Außerdem wurde innerhalb des JSR 220 die sogenannte Java Persistence API (JPA) spezifiziert. Die Persistierung von Objekten wird dadurch transparenter und ist nicht mehr vom Persistenz Framework (z.B. Hibernate) abhängig. Zudem ist das objektrelationale Mapping deutlich einfacher, da es anhand von Annotations gesteuert wird.

Voraussetzungen

In dieser Beschreibung benutze ich die Eclipse Entwicklungsumgebung und Hibernate als Implementierung der JPA. Es werden folgende Hibernate Komponenten benötigt: Hibernate Core, Hibernate Annotations und Hibernate EntityManager. Außerdem ist ein installiertes Java 6 erforderlich.

Aus den verschiedenen Hibernate Komponenten werden folgende Bibliotheken benötigt, die am besten in den Ordner lib kopiert werden.

- lib
+ antlr-2.7.6.jar
+ asm-attrs.jar
+ asm.jar
+ c3p0-0.9.0.jar
+ cglib-2.1.3.jar
+ commons-collections-2.1.1.jar
+ commons-logging-1.0.4.jar
+ dom4j-1.6.1.jar
+ ejb3-persistence.jar
+ hibernate-annotations.jar
+ hibernate-entitymanager.jar
+ hibernate3.jar
+ javassist.jar
+ jboss-archive-browsing.jar
+ jta.jar
+ log4j-1.2.11.jar

Diese Bibliotheken müssen im Klassenpfad eingetragen sein. Außerdem ist es notwendig, die derby.jar ($JAVA_HOME/db/lib/) ebenfalls in den Klassenpfad aufzunehmen.

Konfiguration

Trotz Verwendung von Annotations für das objektrelationale Mapping ist eine Konfiguration mittels XML Datei erforderlich. Für JPA wird dazu im Verzeichnis etc/META-INF/ die Datei persistence.xml angelegt. Darin wird angegeben, welche JPA Implementierung genutzt wird. Außerdem werden Persistenz Framework spezifische Einstellungen vorgenommen. Da diese Datei, ebenso wie die Jar-Dateien, im Klassenpfad verfügbar sein muss, wird das etc Verzeichnis zu den Quellverzeichnissen (Source Folder) hinzugefügt.

<persistence 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_1_0.xsd" version="1.0">
<persistence-unit name="hibernate">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<properties>
<property name="hibernate.connection.driver_class" value="org.apache.derby.jdbc.EmbeddedDriver" />
<property name="hibernate.connection.url" value="jdbc:derby:TestDatabase;create=true" />
<property name="hibernate.dialect" value="org.hibernate.dialect.DerbyDialect" />
</properties>
</persistence-unit>
</persistence>

Jeder persistence-unit muss ein provider zugeordnet werden. Außerdem können weitere Providerspezifische Eigenschaften definiert werden.
Für das Beispiel mit Hibernate müssen Eigenschaften der Verbindung eingetragen werden. So z.B. der verwendete JDBC Treiber (hibernate.connection.driver_class) und die URL zur Datenbank (hibernate.connection.url). Die mitgelieferte JavaDB kann über jdbc:derby:$database erreicht werden. Beispielsweise wird durch die URL jdbc:derby:TestDatabase;create=true die Datenbank TestDatabase benutzt. Sollte diese nicht existieren, wird sie angelegt. Das Hibernate auch mit der JavaDB arbeiten kann, muss zudem der zu verwendende Dialekt eingestellt werden.

Diese drei Einstellungen sind notwendig, um mit der Hibernate auf JavaDB zu arbeiten. Es können aber noch viel mehr Einstellungen für Hibernate vorgenommen werden (siehe Hibernate Konfiguration).

Verwendung

Nach der Erstellung der Konfiguration können nun Objekte dauerhaft gespeichert und wieder gelesen werden. Dazu müssen die zu persistierenden Beans (bzw. POJOs) mit Annotations versehen werden. Alle Klassen, die persistiert werden sollen, erhalten die Annotation javax.persistence.Entity.

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

@Entity
public class Person {

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

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

private String firstName;

public String getFirstName() {
return this.firtsName;
}

public void setFirstName(final String firstName) {
this.firstName = firstName;
}

public long getId() {
return this.id;
}

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

public String getName() {
return this.name;
}

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

Daneben ist es notwendig, dass die Bean ein Attribut besitzt, über die das Objekt eindeutig identifiziert werden kann. Im Normalfall ist dieses Attribut vom Typ long. Dieser Identifier muss mit einer entsprechenden Annotation markiert werden (javax.persistence.Id). Weiterhin kann die Generierungsstrategie einer neuen Id festgelegt werden. Dazu wird die Annotation javax.persistence.GeneratedValue benutzt.
Neben der Deklaration der Id kann jeder Spalte der entsprechende Spaltenname in der Datenbank zugeordnet werden. Das geht über javax.persistence.Colum. Diese Annotation ist optional. Ist ein Attribut nicht damit versehen, wird einfach der Attributname als Spaltenname benutzt.
Dies sind nur ein paar wenige Einstellungen für eine JavaBean. Für weiterführende Informationen kann die API zu Rate gezogen werden.

Objekt speichern

Die zentrale Klasse zum speichern und laden von Objekten ist javax.persistence.EntityManager. Eine Instanz kann über javax.persistence.EntityManagerFactory erstellt werden.

final EntityManagerFactory emf = Persistence.createEntityManagerFactory("hibernate");
final EntityManager em = emf.createEntityManager();

Nachdem der EntityManager verfügbar ist, wird eine javax.persistence.EntityTransaction benötigt. Diese Klasse ist zur Steuerung der Transaktionen verantwortlich. Will man ein Objekt in die Datenbank schreiben, braucht es eine offene Transaktion.

final EntityTransaction tx = em.getTransaction();
tx.begin();

Innerhalb dieser Transaktion kann nun ein Objekt persistiert werden.

final Person person = new Person();
person.setName("mrotzek");
person.setFirstName("michael");
em.persist(person);

Letztendlich muss die Transaktion noch geschlossen werden, um Änderungen wirklich in die Datenbank zu schreiben.

tx.commit();
em.close();
emf.close();

Objekt lesen

final EntityManagerFactory emf = Persistence.createEntityManagerFactory("hibernate");
final EntityManager em = emf.createEntityManager();
final EntityTransaction tx = em.getTransaction();
tx.begin();
final List persons = em.createQuery("select p from Person p").getResultList();
System.out.println(persons.size() + " person(s) found");
for (final Object p : persons) {
final Person lPerson = (Person) p;
System.out.println(lPerson .getName()+", "+lPerson .getFirstName()+" : "+lPerson .getId());
}
tx.commit();
em.close();
emf.close();

Referenzen

Java DB
Using Java DB in Desktop Applications
Working with Derby and Hibernate
Java Persistence with Hibernate
The Java Persistence API
Standardizing Java Persistence with the EJB3 Java Persistence API