JPA Einführung – Schluss mit dem SQL-Boilerplate!

Java Anwendungsentwicklung – Tag 8 von 10
Von Franz-Martin, CTO bei Java Fleet Systems Consulting

Schwierigkeit: 🟢 Grundlagen
Voraussetzungen: Tag 6-7 (JDBC) abgeschlossen

🗺️ Deine Position im Kurs

Legende: 🟢 Einsteiger-freundlich | 🟡 Erfordert Grundlagen | 🔴 Optional/Anspruchsvoll

⚡ Das Wichtigste in 30 Sekunden

Was ist JPA? Java Persistence API – der Standard für Object-Relational Mapping (ORM).

Das bedeutet:

• Du arbeitest mit Java-Objekten, nicht mit SQL
• JPA generiert das SQL automatisch
• Hibernate ist die populärste JPA-Implementation

Der Unterschied zu JDBC:

// JDBC (Tag 6): ~20 Zeilen für eine Abfrage
String sql = "SELECT * FROM personen WHERE id = ?";
// ... Connection, PreparedStatement, ResultSet, Mapping ...

// JPA (heute): 1 Zeile!
Person person = entityManager.find(Person.class, id);

🟢 GRUNDLAGEN: Die JPA-Architektur

Abbildung 1: JPA sitzt zwischen deinem Code und JDBC

JPA ist eine Spezifikation (wie eine Schnittstelle), keine Implementation:

🟢 Entity Mapping

Abbildung 2: Eine Java-Klasse wird zur Datenbank-Tabelle

Eine einfache Entity

@Entity
@Table(name = "personen")
public class Person {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, length = 100)
    private String name;
    
    private Integer alter;  // Spaltenname = Feldname
    
    private String email;
    
    // Pflicht: Standard-Konstruktor
    public Person() {}
    
    // Getter & Setter...
}

Die wichtigsten Annotations

🟢 Der EntityManager

Der EntityManager ist dein Tor zur Datenbank:

// Einmal pro Anwendung: EntityManagerFactory
EntityManagerFactory emf = Persistence.createEntityManagerFactory("javafleet-pu");

// Pro "Arbeitseinheit": EntityManager
EntityManager em = emf.createEntityManager();

try {
    // Speichern
    em.getTransaction().begin();
    em.persist(neuePerson);
    em.getTransaction().commit();
    
    // Laden
    Person person = em.find(Person.class, 1L);
    
    // Löschen
    em.getTransaction().begin();
    em.remove(person);
    em.getTransaction().commit();
    
} finally {
    em.close();
}

🟡 PROFESSIONALS: JDBC vs JPA

Abbildung 3: Gleiche Funktionalität, viel weniger Code

Das „Dirty Checking“

em.getTransaction().begin();

Person person = em.find(Person.class, 1L);
person.setName("Neuer Name");  // Einfach Setter aufrufen!

em.getTransaction().commit();  // UPDATE wird automatisch generiert!

JPA bemerkt Änderungen an managed Entities und generiert automatisch UPDATE-Statements!

🟡 Entity Lifecycle

Eine Entity durchläuft 4 Zustände:

    ┌─────────┐
    │   NEW   │ ← new Person()
    └────┬────┘
         │ persist()
         ▼
    ┌─────────┐
┌───│ MANAGED │───┐
│   └────┬────┘   │
│        │        │ detach()
│ remove()        ▼
│        │   ┌──────────┐
│        │   │ DETACHED │
│        │   └────┬─────┘
│        │        │ merge()
│        ▼        │
│   ┌─────────┐   │
│   │ REMOVED │   │
│   └─────────┘   │
└─────────────────┘

💬 Real Talk: Warum nicht gleich JPA?

Java Fleet Kaffeeküche, Mittwoch 10:00 Uhr.

Nova: „Franz-Martin, wenn JPA so viel einfacher ist – warum haben wir JDBC überhaupt gelernt?“

Franz-Martin: „Gute Frage. Drei Gründe:“

Nova: „Ich höre.“

Franz-Martin: „Erstens: JPA baut auf JDBC auf. Wenn du JDBC verstehst, verstehst du was JPA im Hintergrund macht.“

Nova: „Okay…“

Franz-Martin: „Zweitens: Manchmal ist JPA zu viel. Für ein einfaches Skript, das eine CSV in die DB importiert? JDBC reicht.“

Nova: „Und drittens?“

Franz-Martin: „Debugging. Wenn JPA merkwürdiges SQL generiert oder die Performance schlecht ist, musst du verstehen was passiert.“

Nova: „Also: JDBC für das Verständnis, JPA für die Produktivität?“

Franz-Martin: „Genau. Und manchmal brauchst du beides – JPA für die meisten Operationen, natives SQL für komplexe Reports.“

Nova: „Kann JPA auch natives SQL?“

Franz-Martin: „Klar. em.createNativeQuery(\"SELECT ...\"). Aber das zeigen wir morgen.“

✅ Checkpoint

📝 Quiz

Frage 1: Was ist der Unterschied zwischen JPA und Hibernate?

A) Es gibt keinen, das ist dasselbe
B) JPA ist die Spezifikation, Hibernate ist eine Implementation
C) Hibernate ist neuer als JPA
D) JPA ist schneller als Hibernate

Frage 2: Welche Annotation markiert den Primary Key?

A) @PrimaryKey
B) @Key
C) @Id
D) @Primary

Frage 3: Was passiert wenn du bei einer MANAGED Entity person.setName("Neu") aufrufst?

A) Nichts, du musst em.update() aufrufen
B) Eine Exception wird geworfen
C) JPA bemerkt die Änderung und generiert beim Commit ein UPDATE
D) Die Änderung wird sofort in die DB geschrieben

Frage 4: Warum braucht eine Entity einen Standard-Konstruktor?

A) Das ist Java-Konvention
B) JPA muss Objekte per Reflection erstellen können
C) Für die Serialisierung
D) Für bessere Performance

📝 Quiz-Lösungen

Frage 1: ✅ B – JPA ist die Spezifikation, Hibernate eine Implementation
Wie JDBC (Spezifikation) und MySQL Connector (Implementation).

Frage 2: ✅ C – @Id
@Id markiert den Primary Key. @GeneratedValue sagt, dass die DB die ID generiert.

Frage 3: ✅ C – JPA generiert automatisch ein UPDATE
Das nennt sich „Dirty Checking“ – JPA trackt alle Änderungen an managed Entities.

Frage 4: ✅ B – JPA muss Objekte per Reflection erstellen
Wenn JPA eine Entity aus der DB lädt, erstellt es erst ein leeres Objekt und füllt dann die Felder.

❓ FAQ

Brauche ich immer Hibernate?
Nein, es gibt auch EclipseLink, OpenJPA, DataNucleus. Aber Hibernate ist der De-facto-Standard und Spring Boot Default.

Was ist der Unterschied zwischen persist() und merge()?
persist() ist für neue Entities (NEW → MANAGED). merge() ist für detached Entities (DETACHED → MANAGED). Für Updates von managed Entities brauchst du beides nicht!

Muss ich Transaktionen immer manuell starten?
In reinem JPA: Ja. Mit Spring: Nein, @Transactional macht das automatisch.

Was ist persistence.xml?
Die Konfigurationsdatei für JPA. Definiert die Persistence Unit (Entities, Datenbank, Provider).

Kann JPA auch JOIN-Abfragen?
Ja, mit JPQL und Criteria API. Das zeigen wir morgen in Tag 9!

📦 Downloads

Quick Start:

mvn exec:java                # Hallo JPA
mvn exec:java -Plifecycle    # Entity Lifecycle Demo
mvn exec:java -Pcrud         # JPA CRUD Demo

🔗 Weiterführende Links

🎉 Tag 8 geschafft!

Was du heute gelernt hast:

✅ JPA vs. Hibernate (Spezifikation vs. Implementation)
✅ Entity erstellen mit Annotations
✅ EntityManager für CRUD-Operationen
✅ Entity Lifecycle (NEW, MANAGED, DETACHED, REMOVED)
✅ Dirty Checking – automatische Updates

Morgen – Tag 9: JPA CRUD & Queries

JPQL, Criteria API, Relationships (@OneToMany, @ManyToOne). Von einfachen Abfragen zu komplexen Datenmodellen!

Fragen? franz-martin@java-developer.online

© 2026 Java Fleet Systems Consulting | java-developer.online