Java Persistence API (JPA) ist eine Java-Spezifikation, die die M\u00f6glichkeit bietet, Datenbanken in Java-Anwendungen auf eine objektorientierte Weise zu verwenden. JPA erm\u00f6glicht es Entwicklern, Java-Objekte direkt in Datenbanktabellen zu speichern und abzurufen, ohne sich um SQL-Code oder Datenbankdetails k\u00fcmmern zu m\u00fcssen. In diesem Artikel werden die Grundlagen von JPA-Entities erkl\u00e4rt, einem wichtigen Konzept in der JPA-Welt.<\/p>\n\n\n\n
In JPA stellen Entities die grundlegenden Bausteine dar, die Datenbankdaten in Java-Anwendungen repr\u00e4sentieren. Eine JPA-Entity ist im Wesentlichen eine Java-Klasse, die als Repr\u00e4sentation einer Tabelle in der Datenbank fungiert. Jedes Entity-Objekt entspricht einer Zeile in der Tabelle. Mit anderen Worten, Entities sind POJOs (Plain Old Java Objects), die zur Speicherung und Abfrage von Daten aus der Datenbank verwendet werden.<\/p>\n\n\n\n
Hier ist ein einfaches Beispiel f\u00fcr eine JPA-Entity-Klasse:<\/p>\n\n\n
@Entity\n@Table(name = \"person\"<\/span>)\npublic<\/span> class<\/span> Person<\/span> <\/span>{\n @Id\n @GeneratedValue(strategy = GenerationType.IDENTITY)\n private<\/span> Long id;\n private<\/span> String name;\n private<\/span> int age;\n\n \/\/ Konstruktor, Getter und Setter<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\nIn diesem Beispiel repr\u00e4sentiert die Klasse Person<\/code> eine Tabelle namens „person“ in der Datenbank. Die Annotationen @Entity<\/code> und @Table<\/code> werden verwendet, um JPA mitzuteilen, dass diese Klasse eine Entity ist und mit der Tabelle „person“ in der Datenbank verkn\u00fcpft ist.<\/p>\n\n\n\nDie Annotation @Id<\/code> zeigt an, dass das Feld id<\/code> das Prim\u00e4rschl\u00fcsselfeld ist, das eindeutige Werte f\u00fcr jede Zeile in der Tabelle identifiziert. Die Annotation @GeneratedValue<\/code> gibt an, dass der Wert f\u00fcr das Feld id<\/code> automatisch generiert wird.<\/p>\n\n\n\nEigenschaften von JPA-Entities<\/h2>\n\n\n\n
JPA-Entities haben einige wichtige Eigenschaften und Verhaltensweisen, die es zu beachten gilt:<\/p>\n\n\n\n
1. Persistenz<\/h3>\n\n\n\n
Entities sind persistent, was bedeutet, dass sie \u00fcber ihren Lebenszyklus hinaus in der Datenbank gespeichert bleiben. Wenn Sie eine Instanz einer Entity-Klasse erstellen und sie in einer Transaktion speichern, wird diese \u00c4nderung in der Datenbank festgehalten.<\/p>\n\n\n
EntityManager entityManager = ... \/\/ EntityManager initialisieren<\/span>\nPerson person = new<\/span> Person();\nperson.setName(\"John\"<\/span>);\nperson.setAge(30<\/span>);\n\nentityManager.getTransaction().begin();\nentityManager.persist(person); \/\/ Speichern der Entity in der Datenbank<\/span>\nentityManager.getTransaction().commit();<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n2. Lebenszyklus<\/h3>\n\n\n\n
Entities durchlaufen verschiedene Zust\u00e4nde w\u00e4hrend ihres Lebenszyklus:<\/p>\n\n\n\n
\n- New<\/strong>: Eine Entity ist neu erstellt und nicht mit der Datenbank verkn\u00fcpft.<\/li>\n\n\n\n
- Managed<\/strong>: Eine Entity ist mit einem aktiven JPA-Context (EntityManager) verkn\u00fcpft und wird von diesem verwaltet.<\/li>\n\n\n\n
- Detached<\/strong>: Eine Entity war zuvor verwaltet, ist aber nicht mehr mit einem EntityManager verbunden.<\/li>\n\n\n\n
- Removed<\/strong>: Eine Entity wird aus der Datenbank entfernt.<\/li>\n<\/ul>\n\n\n\n
Der EntityManager steuert den \u00dcbergang zwischen diesen Zust\u00e4nden.<\/p>\n\n\n\n
3. Beziehungen<\/h3>\n\n\n\n
Entities k\u00f6nnen Beziehungen zueinander haben, um komplexe Datenstrukturen zu modellieren. Diese Beziehungen k\u00f6nnen eins zu eins, eins zu viele, viele zu eins oder viele zu viele sein. Hier ist ein einfaches Beispiel f\u00fcr eine Beziehung zwischen Person<\/code>– und Address<\/code>-Entities:<\/p>\n\n\n@Entity\npublic<\/span> class<\/span> Person<\/span> <\/span>{\n \/\/ ...<\/span>\n @OneToMany(mappedBy = \"person\"<\/span>)\n private<\/span> List<\/span><Address> addresses;\n \/\/ ...<\/span>\n}\n\n@Entity\npublic<\/span> class<\/span> Address<\/span> <\/span>{\n \/\/ ...<\/span>\n @ManyToOne\n @JoinColumn(name = \"person_id\"<\/span>)\n private<\/span> Person person;\n \/\/ ...<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\nIn diesem Beispiel kann eine Person<\/code> mehrere Address<\/code>-Objekte haben, w\u00e4hrend eine Address<\/code> immer nur zu einer Person<\/code> geh\u00f6rt.<\/p>\n\n\n\n4. Abfrage<\/h3>\n\n\n\n
Mit JPA k\u00f6nnen Sie mithilfe der JPQL (Java Persistence Query Language) oder Criteria-API komplexe Abfragen erstellen, um Daten aus der Datenbank abzurufen und zu filtern.<\/p>\n\n\n
TypedQuery<Person<\/span>><\/span> query = entityManager.createQuery(\"SELECT p FROM Person p WHERE p.age > :age\", Person.class);\nquery.setParameter(\"age\", 25);\nList<Person<\/span>><\/span> resultList = query.getResultList();<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\nIn diesem Beispiel wird eine JPQL-Abfrage erstellt, um alle Personen abzurufen, deren Alter gr\u00f6\u00dfer als 25 ist.<\/p>\n\n\n\n
Entity-Beziehungen<\/h2>\n\n\n\n
Wie bereits erw\u00e4hnt, k\u00f6nnen Entities Beziehungen zueinander haben. Diese Beziehungen k\u00f6nnen unidirektional oder bidirektional sein und m\u00fcssen sorgf\u00e4ltig modelliert werden, um die Konsistenz der Datenbank zu gew\u00e4hrleisten.<\/p>\n\n\n\n
Unidirektionale Beziehung<\/h3>\n\n\n\n
Eine unidirektionale Beziehung bedeutet, dass eine Entity-Instanz auf eine andere Entity-Instanz verweisen kann, aber die andere Entity-Instanz nicht auf die erste verweisen kann. In unserem vorherigen Beispiel mit Person<\/code> und Address<\/code> hatten wir eine unidirektionale Beziehung, da Address<\/code> auf Person<\/code> verwies, aber nicht umgekehrt.<\/p>\n\n\n\nBidirektionale Beziehung<\/h3>\n\n\n\n
Eine bidirektionale Beziehung bedeutet, dass Entities aufeinander verweisen k\u00f6nnen. Dies erfordert zus\u00e4tzliche Konfiguration, um sicherzustellen, dass die Beziehungen in beiden Richtungen konsistent bleiben.<\/p>\n\n\n\n
Hier ist ein Beispiel f\u00fcr eine bidirektionale Beziehung zwischen Author<\/code> und Book<\/code>:<\/p>\n\n\n@Entity\npublic<\/span> class<\/span> Author<\/span> <\/span>{\n \/\/ ...<\/span>\n @OneToMany(mappedBy = \"author\"<\/span>)\n private<\/span> List<\/span><Book> books;\n \/\/ ...<\/span>\n}\n\n@Entity\npublic<\/span> class<\/span> Book<\/span> <\/span>{\n \/\/ ...<\/span>\n @ManyToOne\n @JoinColumn(name = \"author_id\"<\/span>)\n private<\/span> Author author;\n \/\/ ...<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\nIn diesem Fall kann eine Author<\/code>-Instanz eine Liste von Book<\/code>-Instanzen haben, und jede Book<\/code>-Instanz verweist auf ihren Author<\/code>. Dies erm\u00f6glicht es, von Author<\/code> zu Book<\/code> und umgekehrt zu navigieren.<\/p>\n\n\n\nVerwendung von JPA-Entities<\/h2>\n\n\n\n
Um JPA-Entities in Ihrer Java-Anwendung zu verwenden, m\u00fcssen Sie eine Implementierung von JPA (z. B. Hibernate, EclipseLink oder OpenJPA) in Ihr Projekt integrieren und einen EntityManager<\/code> erstellen. Der EntityManager<\/code> ist f\u00fcr die Verwaltung von Entities verantwortlich und bietet Methoden zum Speichern, Aktualisieren, L\u00f6schen und Abfragen von Daten.<\/p>\n\n\n\nHier ist ein einfaches Beispiel, wie Sie den EntityManager<\/code> verwenden k\u00f6nnen:<\/p>\n\n\n\/\/ EntityManagerFactory erstellen (einmalig w\u00e4hrend des Anwendungsstarts)<\/span>\nEntityManagerFactory emf = Persistence.createEntityManagerFactory(\"my-persistence-unit\"<\/span>);\n\n\/\/ EntityManager erstellen (pro Transaktion oder Anfrage)<\/span>\nEntityManager em = emf.createEntityManager();\n\n\/\/ Transaktion starten<\/span>\nem.getTransaction().begin();\n\n\/\/ Entity erstellen und speichern<\/span>\nPerson person = new<\/span> Person();\nperson.setName(\"Alice\"<\/span>);\nperson.setAge(28<\/span>);\nem.persist(person);\n\n\/\/ Transaktion abschlie\u00dfen<\/span>\nem.getTransaction().commit();\n\n\/\/ Entity abfragen<\/span>\nPerson retrievedPerson = em.find(Person.class, 1<\/span>L); \/\/ Hierbei wird die Person mit der ID 1 abgerufen<\/span>\n\n\/\/ EntityManager und EntityManagerFactory schlie\u00dfen<\/span>\nem.close();\nemf.close();<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\nIn diesem Beispiel wird eine EntityManagerFactory<\/code> erstellt, um den EntityManager<\/code> zu erstellen. Dann wird eine Transaktion gestartet, eine Person<\/code>-Entity erstellt und gespeichert. Schlie\u00dflich wird die Transaktion abgeschlossen, die Person<\/code>-Entity abgerufen und die Ressourcen freigegeben.<\/p>\n\n\n\nBest Practices und Tipps<\/h2>\n\n\n\n
Beim Arbeiten mit JPA-Entities gibt es einige bew\u00e4hrte Praktiken und Tipps, die Ihnen helfen k\u00f6nnen, effiziente und konsistente Anwendungen zu erstellen:<\/p>\n\n\n\n
\n- Transaktionsmanagement<\/strong>: Achten Sie darauf, Transaktionen sorgf\u00e4ltig zu verwalten, um Datenkonsistenz sicherzustellen. Verwenden Sie
em.getTransaction().begin()<\/code> zum Starten einer Transaktion und em.getTransaction().commit()<\/code> zum Abschlie\u00dfen.<\/li>\n\n\n\n- Lazy Loading<\/strong>: Verwenden Sie Lazy Loading, um die Leistung Ihrer Anwendung zu verbessern. Dadurch werden Beziehungen zwischen Entities erst geladen, wenn sie ben\u00f6tigt werden.<\/li>\n\n\n\n
- Equals und Hashcode<\/strong>: Implementieren Sie die
equals()<\/code>– und hashCode()<\/code>-Methoden in Ihren Entity-Klassen, um sicherzustellen, dass Entity-Instanzen korrekt verglichen und in Sammlungen verwendet werden k\u00f6nnen.<\/li>\n\n\n\n- Caching<\/strong>: Verwenden Sie den Second-Level-Cache, um h\u00e4ufig abgerufene Daten zu speichern und die Datenbankzugriffe zu minimieren.<\/li>\n\n\n\n
- Validierung<\/strong>: F\u00fchren Sie Datenvalidierung auf Entity-Ebene durch, um sicherzustellen, dass die Datenbank konsistente Daten enth\u00e4lt.<\/li>\n\n\n\n
- DTOs (Data Transfer Objects)<\/strong>: Verwenden Sie DTOs, um die \u00dcbertragung von Daten zwischen Schichten zu vereinfachen und unn\u00f6tige Datenbankzugriffe zu vermeiden.<\/li>\n\n\n\n
- Testing<\/strong>: Schreiben Sie Unit- und Integrationstests f\u00fcr Ihre Entity-Klassen, um sicherzustellen, dass sie wie erwartet funktionieren.<\/li>\n<\/ol>\n\n\n\n
Unterst\u00fctzte Datenbanken<\/h2>\n\n\n\n
Die Java Persistence API (JPA) ist eine Spezifikation f\u00fcr ORM (Object-Relational Mapping), die es erm\u00f6glicht, Java-Objekte mit relationalen Datenbanken zu verkn\u00fcpfen. JPA ist datenbankagnostisch, was bedeutet, dass es mit einer Vielzahl von Datenbanksystemen verwendet werden kann, solange ein kompatibler JDBC-Treiber vorhanden ist.<\/p>\n\n\n\n
Hier ist eine Liste g\u00e4ngiger relationaler Datenbanksysteme, die mittels JPA angebunden werden k\u00f6nnen:<\/p>\n\n\n\n
Open-Source-Datenbanken<\/h3>\n\n\n\n\n- MySQL<\/strong><\/li>\n\n\n\n
- PostgreSQL<\/strong><\/li>\n\n\n\n
- MariaDB<\/strong><\/li>\n\n\n\n
- SQLite<\/strong><\/li>\n\n\n\n
- Apache Derby<\/strong><\/li>\n\n\n\n
- H2 Database<\/strong><\/li>\n\n\n\n
- Firebird<\/strong><\/li>\n<\/ol>\n\n\n\n
Kommerzielle Datenbanken<\/h3>\n\n\n\n\n- Oracle Database<\/strong><\/li>\n\n\n\n
- Microsoft SQL Server<\/strong><\/li>\n\n\n\n
- IBM Db2<\/strong><\/li>\n\n\n\n
- SAP HANA<\/strong><\/li>\n\n\n\n
- Teradata<\/strong><\/li>\n\n\n\n
- Amazon Aurora<\/strong><\/li>\n<\/ol>\n\n\n\n
Cloud-Datenbanken (mit JDBC-Support)<\/h3>\n\n\n\n\n- Google Cloud SQL<\/strong> (unterst\u00fctzt MySQL und PostgreSQL)<\/li>\n\n\n\n
- Amazon RDS<\/strong> (unterst\u00fctzt verschiedene Engines wie MySQL, PostgreSQL, Oracle, SQL Server)<\/li>\n\n\n\n
- Microsoft Azure SQL Database<\/strong><\/li>\n<\/ol>\n\n\n\n
NoSQL-Datenbanken (mit speziellen JPA-Erweiterungen)<\/h3>\n\n\n\n
Einige NoSQL-Datenbanken k\u00f6nnen mit JPA verwendet werden, wenn ein entsprechender Treiber oder eine Middleware-L\u00f6sung verf\u00fcgbar ist. Beispiele:<\/p>\n\n\n\n
\n- MongoDB<\/strong> (\u00fcber spezielle JPA-Implementierungen wie Hibernate OGM)<\/li>\n\n\n\n
- Cassandra<\/strong><\/li>\n\n\n\n
- Neo4j<\/strong><\/li>\n<\/ol>\n\n\n\n
JPA-Implementierungen<\/h3>\n\n\n\n
JPA selbst ist nur eine Spezifikation. Die Verbindung zu den Datenbanken wird durch JPA-Implementierungen erm\u00f6glicht. Zu den h\u00e4ufig verwendeten Implementierungen geh\u00f6ren:<\/p>\n\n\n\n
\n- Hibernate<\/li>\n\n\n\n
- EclipseLink<\/li>\n\n\n\n
- Apache OpenJPA<\/li>\n\n\n\n
- DataNucleus<\/li>\n<\/ul>\n\n\n\n
Voraussetzung<\/h3>\n\n\n\n
Um eine Datenbank mittels JPA anzubinden, ist ein passender JDBC-Treiber erforderlich. Der Treiber wird in der Konfigurationsdatei (z. B. persistence.xml<\/code>) zusammen mit den Verbindungsinformationen eingebunden.<\/p>\n\n\n\nFazit<\/h2>\n\n\n\n
JPA-Entities sind eine wesentliche Komponente bei der Verwendung von JPA zur Datenbankinteraktion in Java-Anwendungen. Sie erm\u00f6glichen es Entwicklern, Datenbankdaten auf eine objektorientierte Weise zu modellieren und zu verwenden. Mit den richtigen Best Practices und Kenntnissen k\u00f6nnen Sie JPA-Entities effektiv nutzen, um leistungsf\u00e4hige und konsistente Anwendungen zu erstellen.<\/p>\n","protected":false},"excerpt":{"rendered":"
Java Persistence API (JPA) ist eine Java-Spezifikation, die die M\u00f6glichkeit bietet, Datenbanken in Java-Anwendungen auf eine objektorientierte Weise zu verwenden. JPA erm\u00f6glicht es Entwicklern, Java-Objekte direkt in Datenbanktabellen zu speichern und abzurufen, ohne sich um SQL-Code oder Datenbankdetails k\u00fcmmern zu m\u00fcssen. In diesem Artikel werden die Grundlagen von JPA-Entities erkl\u00e4rt, einem wichtigen Konzept in der […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-153","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/153","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=153"}],"version-history":[{"count":2,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/153\/revisions"}],"predecessor-version":[{"id":529,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/153\/revisions\/529"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=153"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=153"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=153"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}