Enterprise Applikationen führen üblicherweise massenhaft Operationen auf Datenbanken durch, wobei grosse Mengen an Daten bearbeitet werden. Für eine Datenbankanbindung braucht man dabei entweder eine Menge Code, wenn man die Anbindung selber programmiert, oder man verwendet eines der berühmten Frameworks wie Spring. Eine weitere Möglichkeit ist die Verwendung von JPA = Java Persistance API. Dieses Application Programming Interface reduziert den Aufwand, den man hat, um mit einer Datenbank zu kommunizieren.

Die Objekte oder Objektmodelle des Java Programmes werden dabei mit den relationalen Modellen verbunden. Der Unterschied ist dabei, dass die relationalen Objekte der Datenbank eher in tabellenform daherkommt, während das Objekt im Java Code ein Ojekt mit etlichen Attributen darstellt – Wobei jedes Attribut schlussendlich wieder ein ganz anderes Objekt sein kann.

Wie kann mir JPA nun helfen?

JPA ist eine Sammlung von Klassen und Methoden, um das Speichern von Daten in Datenbanken zu unterstützen. Dabei gibt es verschiedene Anbieter von Datenbankdiensten, sogenannte JPA Provider, wie etwa Oracle, Redhat, Eclipse etc. Produkte dieser Firma sind etwa Hibernate, Eclipselink, Toplink oder Spring Data JPA.

Die Idee von JPA ist es, ein ganz normales Java Objekt (POJO, Plain Old Java Object) als relationales Datenbankobjekt zu speichern.

Wie heissen die JPA Objekte?

Das Grundobjekt von JPA ist die sogenannte Entity, welche ein zu persistierendes Objekt darstellt beziehungsweise am Ende einfach ein Record in der Datenbank.

Weitere Objekte sind:

• Persistence – Beinhaltet statische Methoden, um eine EntityManagerFactory zu erhalten
• EntityManagerFactory – Erstellt Instanzen von EntityManager
• EntityManager – Erstellt Istanzen von Query’s
• EntityTransaction – Jeder EntityManager wird unterstützt von einem EntityTransaction Objekt
• Query – Wird zur Verfügung gestellt von den JPA Providers, um auf die Daten zuzugreifen

Wie erstellt man eine JPA Entity?

Um diesen Eintrag nicht unnötig aufzublähen, werde ich mich auf die Definition eines Entity Objekts beschränken. Als Beispiel soll ein Buch in einer Buchhandlung als relationales Objekt definiert werden.

Ein Buch kann erstellt, aktualisiert, gefunden und gelöscht werden. Das Buch selber ist dabei ein einfaches POJO, für die vier Transaktionen wird jeweils eine Serviceklasse erstellt:

• Java Model bzw. POJO: Book.java

Ein Buch ist dabei sehr simpel, es hat gerade mal eine ID und einen Titel. Die Klasse Book.java hat dafür Getter und Setter.
Für die Definition ist die Annotation @Entity zuständig. @Table sagt dabei, welche Tabelle mit dieser Entität erstellt werden soll.

Die Id des Buches wird mit der Annotation @Id versehen – damit wird auch gleich gesagt, dass dies der Primary Key sein soll. Mit der Annotation @GeneratedValue kann man dem System mitteilen, dass ein Wert automatisch generiert werden soll, was hauptsächlich bei Primary Keys Sinn macht (AUTO ist dabei die Standardeinstellung). Diese generierten Werte sind dabei einzigartig für die gesamte Datenbank.

Die Datenbank selber könnte man nun in der Datei Persistence.xml registrieren. Dies lasse ich hier aber aus.

// import javax.persistence.Entity etc.

@Entity
@Table
public class Book {
 
   @Id
   @GeneratedValue(strategy = GenerationType.AUTO) 
   private int id;
   private String title;
 
   public Book(int id, String title) {
     super( );
     this.id = id;
     this.title = title;
   }
 
   // getter und setter und ggf. toString()
}

Entity Beziehungstypen

Zwischen den Entitäten sind verschiedene Beziehungen. Grundsätzlich lässt sich sagen, dass Beziehungen effektiver zwischen Tabellen in der Datenbank sind. JPA behandelt deshalb die Klassen als relationale Tabellen.

Folgende Beziehungen sind möglich:

@ManyToOne
@OneToMany
@OneToOne
@ManyToMany

Die @ManyToOne Beziehung zum Beispiel wäre sinnvoll für die Beziehung zwischen der One Buchhandlung, welche Many Bücher beinhaltet.

Die Beziehung wird nun direkt in der Entität der Klasse Book.java angegeben:

@ManyToOne
private Bookstore bookstore;

Wie spielen die verschiedenen Klassen zusammen?

Ich zeige noch einen konkreten Fall, wie ein Buch erstellt wird. Dabei sieht man schön, wie die oben genannten Klassen zusammenspielen.

Bei dem Beispiel handelt es sich um die Serviceklasse CreateBook.java, welche einem ein Buch erstellt.

// import javax.persistence.Entity etc.

public class CreateBook {
 
 public static void main( String[ ] args ) {
 
    EntityManagerFactory factory = Persistence
    .createEntityManagerFactory( "Eclipselink_JPA" );
 
    EntityManager entityManager = factory.createEntityManager( );
    entityManager.getTransaction( ).begin( );
 
    Book book = new Book( );
    book.setId(1234);
    book.setTitle("Kochen fuer Programmierer");
 
    entityManager.persist( book );
    entityManager.getTransaction( ).commit( );
 
    entityManager.close( );
    factory.close( );
  }
}

So, dies sollte als kurzer Einstieg in das Thema JPA reichen.