Java Persistence 2.0
1 gefällt mir996 aufrufe
Das Dokument behandelt die Java Persistence API (JPA) 2.0, die eine objekt-relationalen Abbildung (O/R-Mapping) zwischen Java-Objekten und relationalen Datenbanken ermöglicht. Es werden die Vorteile der JPA im Vergleich zu traditionellen JDBC-Lösungen dargelegt, einschließlich der Verwendung von Annotationen für die Modellierung von Entitäten und der Verwaltung von Beziehungen. Darüber hinaus werden wichtige Konzepte wie Transaktionsverwaltung, Locking-Mechanismen und die Verwendung von Kriterienabfragen vorgestellt.
Java Persistence 2.0
- 1. Java Persistence API 2.0 Treffpunkt Semicolon, 27.04.2010, GFU Cyrus AG Dirk Weil, GEDOPLAN GmbH
- 2. Warum JPA? public class Country { private String isoCode; Aufgabenstellung: private String name; Speichern und Laden von public Country(String isoCode, String description) Java-Objekten { Mapping OO RDBMS ... } public String getIsoCode() Lösungsansätze: { return this.isoCode; JDBC } Entity-EJBs (bis EJB 2.1) public void setIsoCode(String isoCode) { O/R-Mapper this.isoCode = isoCode; } 2
- 3. Warum JPA? Konventionelle Lösung Direktes JDBC Country country = new Country(...); … Connection connection = JdbcUtil.getConnection(); PreparedStatement statement = connection.prepareStatement( "insert into Country(isoCode,name) values (?,?)"); statement.setString(1, country.getIsoCode()); statement.setString(2, country.getName()); statement.executeUpdate(); connection.commit(); … 3
- 4. Warum JPA? @Entity public class Country { JPA-Lösung @Id private String isoCode; Normale Java-Klasse (POJO) private String name; mit Annotationen … Country country = new Country(...); … EntityManager em = entityManagerFactory.createEntityManager(); EntityTransaction tx = em.getTransaction(); tx.begin(); em.persist(country); tx.commit(); 4
- 5. Warum JPA? Relationen (1:1, 1:n, n:m) @Entity @Entity public class Person public class MailAddress { { @Id @Id public Integer id; 1 n public Integer id; public String name; public String userId; public String domain; @OneToMany @JoinColumn(name = "PERSON_ID") public List<MailAddress> mailAddresses = new ArrayList<MailAddress>(); 5
- 6. Warum JPA? @Entity Vererbungs- @Inheritance(strategy=InheritanceType.JOINED) public abstract class Vehicle beziehungen { @Id private Integer id; private String name; @Entity @Entity public class Car extends Vehicle public class Ship extends Vehicle { { private int noOfDoors; private double tonnage; 6
- 7. Warum JPA? Anforderungen an O/R-Mapper Feld-Zuordnung Erstellen der SQL-Befehle ID-Generierung Navigation über Relationen Abbildung von Vererbung Verwaltung kompletter Objekt-Graphen Verbindungsverwaltung Transaktionsverwaltung Caching Schemagenerierung 7
- 8. Entwicklung des Standards 'JPA' 1998 EJB 1.0 1999 EJB 1.1 2000 2001 JDO 1.0 Hibernate 1 EJB 2.0 2002 2003 JDO 1.0.1 Hibernate 2 EJB 2.1 2004 2005 EJB 3.0 JPA 1.0 Hibernate 3 2006 2007 2008 JPA 2.0 2009 8
- 9. Detached Entities Managed Entities können vom Entity Manager gelöst werden mittels clear oder detach mittels rollback durch Schließen des Entity Managers durch Serialisierung/Deserialisierung EntityManager em = …; String isoCode = "DE"; Country country = em.find(Country.class, isoCode); em.detach(country); … 9
- 10. Mapping-Annotationen und Defaults Configuration by Exception Meist gute Defaults vorhanden Dennoch: Werte angeben Tabellen- und Spaltennamen Zugriffstyp @Entity … @Table(name="COUNTRY") @Access(AccessType.FIELD) public class Country { @Column(name="ISO_CODE") @Id private String isoCode; 10
- 11. Queries Abfragesprache: JPQL Ähnlich SQL, jedoch objektorientiert Java-Interface: TypedQuery<E> (bis JPA 1.0 nur Query) Ausführung mit getSingleResult bzw. getResultList TypedQuery<Country> query = em.createQuery( "select c from Country c where c.carCode='D'", Country.class); Country c = query.getSingleResult(); TypedQuery<Country> query = em.createQuery( "select c from Country c where c.name like 'D%'", Country.class); List<Country> l = query.getResultList(); 11
- 12. Orphan Removal "Garbage Collection" @Entity für abhängige Objekte public class OrderLine { @Id @GeneratedValue private Integer id; private String name; private int count; @Entity public class Order @ManyToOne { private Order order; @Id @GeneratedValue private Integer id; @OneToMany(mappedBy = "order", orphanRemoval = true) private List<OrderLine> orderLines = new ArrayList<OrderLine>(); 12
- 13. Anordnung von Relationenelementen Kann durch ein Feld der referenzierten Entity erzwungen werden @OneToMany(mappedBy = "order") @OrderBy("name") private List<OrderLine> orderLines = new ArrayList<OrderLine>(); Alternative: Persistente Ordnung mittels zusätzlicher Spalte @OneToMany(mappedBy = "order") @OrderColumn(name = "ORDERLINES_ORDER") private List<OrderLine> orderLines = new ArrayList<OrderLine>(); 13
- 14. Relationen als Id-Attribute (Derived Identity) Häufig bei zusammengesetzten Schlüsseln Id-Attribut stellt Relation dar public class ProjectId implements Serializable @Entity { @IdClass(ProjectId.class) public Integer department; public class Project public String prjId; { … @Id @ManyToOne private Department department; @Id private String prjId; … 14
- 15. Collections von einfachen Typen oder einbettbaren Objekten Attribute vom Typ Collection<E> oder davon abgeleitet Einfache Elementtypen oder Embeddables @Entity public class Employee { … @ElementCollection(fetch = FetchType.EAGER) private List<String> skills = new ArrayList<String>(); … Abbildung auf Zusatztabelle 15
- 16. Locking User A User B Some Entity Problemstellung: Gleiche Daten werden read parallel verändert read update update Abhilfe: Optimistic Locking (mittels Versionsattribut) Pessimistic Locking (durch Sperren in der DB) 16
- 17. Locking Pro Objekt anwendbar em.lock(someEntity, beim Lesen LockModeType.PESSIMISTIC_WRITE); für bereits gelesene Objekte LockModeType. Bedeutung NONE Keine Sperren nutzen OPTIMISTIC Optimistic Locking benutzen OPTIMISTIC_FORCE_INCREMENT dito, aber mit Erhöhung des Versionsattributs PESSIMISTIC_READ Shared Lock benutzen PESSIMISTIC_WRITE Exclusive Lock benutzen PESSIMISTIC_FORCE_INCREMENT dito, aber mit Erhöhung des Versionsattributs 17
- 18. Criteria Queries Problem: Keine Korrektheitskontrolle von JPQL zur Compilezeit, z.B. falsche Schlüsselwörter select c fron Cocktail c unvollständige Statements select c from Cocktail falsche Attributnamen Typkonflikte select c from Cocktail c where c.nam=:name Criteria Query API objektorientiert stellt Vollständigkeit sicher typsicher 18
- 19. Criteria Queries // "select c from Cocktail c where c.name=:name" CriteriaBuilder builder = em.getCriteriaBuilder(); // Criteria Query für Ergebnistyp erzeugen CriteriaQuery<Cocktail> cQuery = builder.createQuery(Cocktail.class); // Projektionsvariablen erzeugen (FROM-Klausel) Root<Cocktail> c = cQuery.from(Cocktail.class); // Selektion angeben (SELECT-Klausel) cQuery.select(c); // Bedingung erstellen und der Query hinzufügen Predicate hatNamen = builder.equal(c.get("name"), name); cQuery.where(hatNamen); // Query ausführen TypedQuery<Cocktail> q = em.createQuery(cQuery); List<Cocktail> found = q.getResultList(); 19
- 20. Statisches JPA-Metamodell Metamodell-Klasse E_ zu jeder persistenten Klasse E @Entity public class Cocktail { @Id @GeneratedValue private Integer id; private String name; @ManyToMany private Set<Zutat> zutaten = new HashSet<Zutat>(); @StaticMetamodel(Cocktail.class) public abstract class Cocktail_ { public static volatile SingularAttribute<Cocktail, Integer> id; public static volatile SingularAttribute<Cocktail, String> name; public static volatile SetAttribute<Cocktail, Zutat> zutaten; 20
- 21. Criteria Queries / Statisches JPA-Metamodell // "select c from Cocktail c where c.name=:name" CriteriaBuilder builder = em.getCriteriaBuilder(); // Criteria Query für Ergebnistyp erzeugen CriteriaQuery<Cocktail> cQuery = builder.createQuery(Cocktail.class); // Projektionsvariablen erzeugen (FROM-Klausel) Root<Cocktail> c = cQuery.from(Cocktail.class); // Selektion angeben (SELECT-Klausel) cQuery.select(c); // Bedingung erstellen und der Query hinzufügen Predicate hatNamen = builder.equal(c.get(Cocktail_.name), name); cQuery.where(hatNamen); // Query ausführen TypedQuery<Cocktail> q = em.createQuery(cQuery); List<Cocktail> found = q.getResultList(); 21
- 22. Weitere Neuerungen in JPA 2.0 Zusätzliche Id-Typen Explizite Access Types Verschachtelte Embeddables Embeddables mit Relationen Unidirektionale 1:n-Relationen Erweiterung von JPQL Ermittelung des Load State Caching … 22
- 23. Mehr … im Java-Magazin 4.2010 Artikel ab Mitte Mai auch auf www.gedoplan.de in GFU-Seminaren oder: Fragen Sie! 23