Komponenten-basierte Entwicklung Teil 14: Persistenz mit ...wi.f4.htw-berlin.de/users/messer/LV/AI-KBE-WS14/Folien/KBE-14/14-KBE... · Komponenten – WS 2014/15 – Teil 14/Hibernate-JPA1

13.01.15 1Komponenten – WS 2014/15 – Teil 14/Hibernate-JPA1

Komponenten-basierte Entwicklung

Teil 14: Persistenz mit Hibernate-JPATeil 1

Komponenten – WS 2014/15 – Teil 14/Hibernate-JPA1 2

Literatur

[14-1] Müller, Bernd; Wehr, Harald: Java Persistence API 2. Hanser, 2012.

[14-2] http://www.jpainfo.de/projekte/download.html

[14-3] Beeger, Robert et al.: Hibernate. Persistenz in Java-Systemen mit Hibernate 3. dpunkt, 2006

[14-4] http://sourceforge.net/projects/hibernatesample/

[14-5] http://hibernate.org/

[14-6] http://mvnrepository.com/artifact/org.hibernate

[14-8] http://upload.wikimedia.org/wikipedia/commons/8/81/Java_Persistence.pdf


Was macht Hibernate?

• Hibernate realisiert die JPA-Schnittstelle in der Version 2.0.Siehe: http://de.wikipedia.org/wiki/Hibernate_(Framework)

• JPA = Java Persistence APISiehe: http://de.wikipedia.org/wiki/Java_Persistence_API

Die Fehlermeldungen sind meist besser als beim nativen Hibernate,trotzdem noch grausig.


Maven und Hibernate

<hibernate.version>4.3.7.Final</hibernate.version>… … … <dependency>

<groupId>org.hibernate</groupId><artifactId>hibernate-core</artifactId><version>${hibernate.version}</version>

</dependency><dependency> <groupId>javax.persistence</groupId> <artifactId>persistence-api</artifactId> <version>1.0.2</version></dependency><dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>${hibernate.version}</version> <exclusions> <exclusion> <groupId>org.hibernate.javax.persistence</groupId> <artifactId>hibernate-jpa-2.0-api</artifactId> </exclusion> </exclusions></dependency>

Es soll nur die Java-APIbenutzt werden.


Klasse Person I

@Entitypublic class Person implements Serializable { @Id @GeneratedValue(strategy= GenerationType.AUTO) private Long id; private String firstName; private String lastName;

public Person() {} public Person(String firstName, String lastName) { this.firstName= firstName; this.lastName= lastName; } … … Getter und Setter … … @Override public String toString() { return String.format("####---Id=%d: %s %s",id,firstName,

lastName); }


Klasse Person II - Bemerkungen

• Alle Beans oder POJOs heißen nun einfach Entities.

• Diese müssen mit @Entity eingeleitet werden.

• Es muss ein ID-Attribut vorhanden sein, meistens id genannt.Dieses sollte ein Long oder ein String sein.

• Bei der Verwaltung bzw. Erzeugung der IDs gibt es unterschiedliche Strategien, hier die „automatische":@Id @GeneratedValue(strategy= GenerationType.AUTO)

• Alle Attribute müssen mit Getter/Setter-Funktionen versehen werden.

• Attribute mit Getter/Setter-Funktionen werden Properties genannt (Mehrfache Bedeutung dieses Begriffs).


persistence.xml I

<?xml version="1.0" encoding="UTF-8"?><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_2_0.xsd" version="2.0"> <persistence-unit name="bankexample" transaction-type="RESOURCE_LOCAL"> … … Optionen … … </persistence-unit></persistence>

Name des Persistenz-kontextes

Java-SE-Umgebung


persistence.xml II

<description>Ein einfaches Beispiel fuer 1 oder 2 Klassen</description> <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider><class>de.htw_berlin.f4.kbe.jpa.Person</class><properties>  <property name="javax.persistence.jdbc.url"

value="jdbc:mysql://localhost/bankexample" /> <property name="javax.persistence.jdbc.user" value="root" /> <property name="javax.persistence.jdbc.password" value="" /> <property name="javax.persistence.jdbc.driver"

value="com.mysql.jdbc.Driver" />  <property name="hibernate.show_sql" value="true"/> <property name="hibernate.dialect"

value="org.hibernate.dialect.MySQL5InnoDBDialect"/> <property name="hibernate.hbm2ddl.auto" value="create"/></properties>

Siehe u.a.http://docs.jboss.org/hibernate/entitymanager/3.5/reference/en/html/configuration.html


persistence.xml III - Erläuterungen

• Die Datei persistence.xml ist die zentrale Konfigurationsdatei.

• Mit Properties werden die Parameter den einzelnen Komponenten zugeordnet.

• Wie beim nativen Hibernate gibt es SQL-Dialekte:http://javamanikandan.blogspot.in/2014/05/sql-dialects-in-hibernate.html

• Die Hibernate-Property hibernate.hbm2ddl.auto steuert das automatische Erzeugen und Vernichten der Tabellen in der Datenbank, folgende Werte sind möglich:

– validate: nur Prüfen des vorhandenen Schemas

– update: Aktualisieren des vorhandenen Schemas

– create: Vollständiges Erzeugen des Schemas zum Beginn

– create-drop: create und nach dem Lauf Löschen des Schemas


Ort für persistence.xml I

| pom.xml+---src| +---main| | +---java| | | \---de| | | \---htw_berlin| | | \---f4| | | \---kbe| | | \---jpa| | | App.java| | | Person.java| | | | | \---resources| | \---META-INF| | persistence.xml

\---target +---classes | | | +---de | | \---htw_berlin | | \---f4 | | \---kbe | | \---jpa | | App.class | | Person.class | | | \---META-INF | persistence.xml

So muss bei netbeans derSRC-Baum aussehen.

Mit Hilfe von maven wird die Datei an die richtigeStelle kopiert.

(Sie muss im jar-File imMETA-INF-Bereich sein)


Ort für persistence.xml II - netbeans

Die Datei und der OrdnerMETA-INF können überFilesystem erzeugt werdenoder nach CTRL_n:


Das Hauptprogramm I - Schema

private void runner() { ...createFactory("bankexample"); EntityManager em= emf.createEntityManager(); em.getTransaction().begin(); … … … Alle Aktivitäten … … … em.getTransaction().commit(); em.close(); emf.close();}

Wenn keine Daten verändert werden, z.B. mit Selects, dannkann die Klammerung in einer Transaktion fortfallen.


Das Hauptprogramm II

private void runner() { createFactory("bankexample"); EntityManager em= emf.createEntityManager(); Person person; em.getTransaction().begin(); person= new Person("Heidi","Musterfrau"); System.out.println(person); em.persist(person); System.out.println(person); System.out.println("Heidi ist gespeichert? --> "+em.contains(person)); person= new Person("Paul","MusterMann"); em.persist(person); System.out.println(person); person= new Person("Erika","Rödenhufer"); em.persist(person); System.out.println(person); em.getTransaction().commit(); em.close(); emf.close();}


Das Hauptprogramm III - createFactory()

public class App { EntityManagerFactory emf;

private void setEntityManagerFactory(String persistenceUnitName,Map properties) {

… … emf= provider.createEntityManagerFactory(persistenceUnitName,

properties); } private void createFactory(String persistenceUnit) { setEntityManagerFactory(persistenceUnit,null); }

public static void main( String[] args ) { (new App()).runner(); }


Output des ersten Laufs

(01) Hibernate: drop table if exists Person(02) Hibernate: create table Person (id bigint not null auto_increment,(03) firstName varchar(255), lastName varchar(255),(04) primary key (id)) ENGINE=InnoDB(05) ####---Id=null: Heidi Musterfrau(06) Hibernate: insert into Person (firstName, lastName) values (?, ?)(07) ####---Id=1: Heidi Musterfrau(08) Heidi ist gespeichert? --> true(09) Hibernate: insert into Person (firstName, lastName) values (?, ?)(10) ####---Id=2: Paul MusterMann(11) Hibernate: insert into Person (firstName, lastName) values (?, ?)(12) ####---Id=3: Erika Rödenhufer

In Zeile (05) ist die ID noch nicht bestimmt, erst nach dempersist()-Aufruf.Die Zeilen mit "Hibernate:" sind die an die Datenbank gesendetenSQL-Statements.


Datenbank "bankexample"

Nun schauen wir uns das generierte Schema mit dengespeicherten Werten an.


Warnung wegbekommen I

WARN: HHH015016: Encountered a deprecated javax.persistence.spi.PersistenceProvider[org.hibernate.ejb.HibernatePersistence];use [org.hibernate.jpa.HibernatePersistenceProvider]

private void setEntityManagerFactory(String persistenceUnitName, Map properties) { emf= null; PersistenceProvider fallBackProvider= null; List<PersistenceProvider> providers = PersistenceProviderResolverHolder .getPersistenceProviderResolver().getPersistenceProviders(); for(PersistenceProvider provider : providers) { if(provider instanceof org.hibernate.ejb.HibernatePersistence) { fallBackProvider= provider; System.out.println("#### "+provider+" ++++ skip"); continue; } System.out.println("#### "+provider); emf= provider.createEntityManagerFactory(persistenceUnitName, properties); if(emf!=null) { break; } }


Warnung wegbekommen II

if(emf==null) { if(fallBackProvider==null) { throw new RuntimeException(„..."); } emf= fallBackProvider.createEntityManagerFactory

(persistenceUnitName,properties); } }

Output:#### org.hibernate.ejb.HibernatePersistence@6d311334 ++++ skip#### org.hibernate.jpa.HibernatePersistenceProvider@682a0b20

Es gibt also zwei Provider, wobei der nicht zu benutzende zuerstangeboten wird – wir nehmen den zweiten und die Warnung ist weg.


Optionen angeben

private void createFactoryWithOptions(String persistenceUnit) { Map<String, Object> configOverrides= new HashMap<>(); configOverrides.put("hibernate.hbm2ddl.auto","create-drop"); setEntityManagerFactory(persistenceUnit,configOverrides); }

Beim Erzeugen der Factory können noch Werte für Propertiesin Form einer HashMap angegeben werden, hier wird der Wert fürhibernate.hbm2ddl.auto auf create-drop gesetzt.

Statt createFactory() wird dann createFactoryWithOptions() benutzt.


Alternativer ID-Generator I

@Id@GeneratedValue(strategy= GenerationType.TABLE)private Long id;

Es werden nun zwei Tabellen zum Verwalten der vergebenen ID-Werteangelegt und von Hibernate benutzt – dies geht bei allen Datenbanken.


Alternativer ID-Generator II

@Id@GeneratedValue(strategy= GenerationType.TABLE, generator= "personGenerator")@TableGenerator( name= "personGenerator", table= "ID_GEN", pkColumnName= "GEN_KEY", valueColumnName= "GEN_VALUE", pkColumnValue= "PERSON_ID", AllocationSize= 10)private Long id;

Die Tabelle für die ID-Verwaltung kann explizit benannt und samt allenSpalten definiert werden.


Selbst verwaltete IDs I

@Entity public class Person implements Serializable { private String id; private String firstName; private String lastName;

public Person() { this.id= UUID.randomUUID().toString(); } public Person(String firstName, String lastName) { this(); this.firstName= firstName; this.lastName= lastName; } @Id public String getId() { return id; } public void setId(String id) { this.id= id; }

Es muss nun auchein Setter für IDvorhanden sein.

Zugriff auf ID nurüber Getter/Setter


Selbst verwaltete IDs II

So sehen dann die generierten IDs aus.


Lesen eines Objekts

em.getTransaction().begin(); person= new Person("Heidi", "Musterfrau"); em.persist(person); String pKey= person.getId(); System.out.println(person); person= new Person("Paul", "MusterMann"); em.persist(person); System.out.println(person); person= new Person("Erika", "Rödenhufer"); em.persist(person); System.out.println(person);

person= em.find(Person.class, pKey); System.out.println(person);em.getTransaction().commit();

####---Id=d121cadd-c220-49a7-bc1b-6230a489452a: Heidi Musterfrau####---Id=9678a802-f760-44c4-847d-94f0088ec5ae: Paul MusterMann####---Id=68482017-8b0f-481b-bbb9-5a0405345fd7: Erika Rödenhufer####---Id=d121cadd-c220-49a7-bc1b-6230a489452a: Heidi Musterfrau


Variation der Datentypen I

@Entity public class Person implements Serializable { @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id; @Column(nullable=true, length= 20) private String firstName; @Column(name="name", length= 20) private String lastName; @Temporal(TemporalType.DATE) private Date birthday; @Temporal(TemporalType.TIME) private Date birthtime; @Transient private Date adminDate; @Lob char[] mark; @Enumerated(EnumType.ORDINAL) private Sex sex; @Enumerated(EnumType.STRING) private Salutation salutation; @Column(precision= 10, scale= 2) private BigDecimal purse;


Variation der Datentypen II

public Person(String firstName, String lastName, String birthday) { DateFormat format= new SimpleDateFormat("dd.MM.yyyy HH:mm:ss"); this.firstName= firstName; this.lastName= lastName; try { this.birthday= format.parse(birthday); this.birthtime= format.parse(birthday); } catch (ParseException e) { throw new IllegalArgumentException("Wrong Date format"); }}

Der Konstruktor muss nun etwas anders aussehen.Hier wie mit Zeitformaten umgegangen werden kann.


Enums und das Hauptprogramm

public enum Sex { WOMAN, MAN}

public enum Salutation { Ms, Mr, Dr, Prof}

char[] abc= {'a','b','c'};createFactory("bankexample");EntityManager em= emf.createEntityManager();Person person;… … … person= new Person("Heidi", "Musterfrau","02.10.1970 18:13:10"); em.persist(person); person.setSex(Sex.WOMAN); person.setSalutation(Salutation.Dr); person.setMark(abc); person.setPurse(new BigDecimal("12.5")); Long pKey= person.getId(); System.out.println(person); person= em.find(Person.class, pKey); System.out.println(person);


Datenbank


1:1-Relation unidirektional I

Address Person1

Besitzende SeiteInverse Seite

1 Ebene derObjekte

Ebene derTabellen


1:1-Relation unidirektional II

@Entity public class Person implements Serializable { @Id @GeneratedValue(strategy= GenerationType.AUTO) private Long id; private String firstName; private String lastName; //@OneToOne @OneToOne(cascade= CascadeType.ALL, orphanRemoval= true) @JoinColumn(name= "myAddress", nullable= true) private Address address; … Getter/Setter …

@Entity public class Address implements Serializable{ @Id @GeneratedValue(strategy= GenerationType.AUTO) private Long id; private String city; private String street; private int houseNumber; … Getter/Setter …

JoinColumn ist die Spaltemit dem Fremdschlüssel undcharakterisiert die besitzendeSeite


1:1-Relation unidirektional III

em.getTransaction().begin(); address= new Address("Berlin","Gustavzeile",3); //em.persist(address); person= new Person("Heidi", "Musterfrau",address); em.persist(person); System.out.println(person); address= new Address("Fürstenwalde","Karl-May-Allee",23); person= new Person("Gudrun", "von Oiouten",address); em.persist(person); System.out.println(person); person.setAddress(null); //em.detach(person); em.remove(person);em.getTransaction().commit()

Ohne Kaskadierenmuss das Address-Objektexplizit gespeichert werden

Ohne nullable= trueergibt dies eine wenigaussagende Fehlermeldung


1:1-Relation unidirektional IV - Bemerkungen

• Wenn bei der besitzenden Klasse (dort, wo das Join-Attribut sich befindet) nur ein @OneToOne steht, dann müssen alle beteiligten

Objekte mit em.persist() gespeichert werden.

• Wenn das Kaskadierden mit @OneToOne(cascade=CascadeType.ALL) eingeschaltet ist, dann werden alle mit Referenzen verbundenen Entities in der Datenbank gespeichert.

• Mit dem Parameter orphanRemoval= true werden nicht per Referenz verbundene Entities auch in der Datenbank gelöscht.Das Setzen der Adresse mit null und anschließenden Löschen mit em.remove(person) führt ansonsten zu einem Waisen.

• Mit em.remove() wird das Objekt in der Datenbank gelöscht, mit em.detach() wird es nur dem Programm entzogen, verbleibt aber in der Datenbank.

• Die beiden Operationen em.remove() und em.detach() betreffen nur das JPA, nicht die Objekte im RAM des Programms. Diese werden ganz normal mit dem Garbage-Collector entfernt.


1:1-Relation unidirektional V - Schemata

Besitzer-Seite

Inverse Seite

JoinColumn mitgeänderten Namen

JoinColumn mitOriginalnamen


1:1-Relation bidirektional I

Address Person1 1 Ebene der

Objekte

Besitzende SeiteInverse SeiteEbene derTabellen


1:1-Relation bidirektional II

@Entity public class Person implements Serializable { @Id @GeneratedValue(strategy= GenerationType.AUTO) private Long id; private String firstName; private String lastName; @OneToOne(cascade= CascadeType.ALL) @JoinColumn(name= "address") private Address address;

@Entity public class Address implements Serializable { @Id @GeneratedValue(strategy= GenerationType.AUTO) private Long id; private String city; private String street; private int houseNumber; @OneToOne(mappedBy= "address") private Person person;

Besitzende Seite

Inverse Seite


1:1-Relation bidirektional III

em.getTransaction().begin(); address= new Address("Berlin","Gustavzeile",3); person= new Person("Heidi", "Musterfrau",address); address.setPerson(person); em.persist(person); System.out.println(person); address= new Address("Fürstenwalde","Karl-May-Allee",23); person= new Person("Gudrun", "von Oiouten",address); address.setPerson(person); em.persist(person); System.out.println(person);em.getTransaction().commit();

Bidirektional bezieht sich auf die Zeigerstruktur, d.h. auf beidenSeiten muss es jeweils ein Attribut in der Klasse geben, in dem aufdas jeweilige andere Objekt verwiesen wird.


1:1-Relation bidirektional IV - Schemata

Klasse Person

Klasse Address

Aufgrund der Relationen ändert sich an der Tabellenstruktur im Vergleichzu unidirektionalen Beziehung nichts(!).


1:N-Relation unidirektional I

Address Person Account1 1..*1 1

Die 1:N-Relation wirddurch eine eigeneTabelle realisiert.

Ebene derObjekte

Ebene derTabellen


1:N-Relation unidirektional II

@Entity public class Account implements Serializable{ @Id @GeneratedValue(strategy= GenerationType.AUTO) private Long id; private long number; private double bankBalance; public Account() {} public Account(long number, double bankBalance) { this.number= number; this.bankBalance= bankBalance; }

@Entity public class Person implements Serializable { @Id @GeneratedValue(strategy= GenerationType.AUTO) private Long id; private String firstName; private String lastName; @OneToOne(cascade= CascadeType.ALL) @JoinColumn(name= "address") private Address address; @OneToMany(cascade= CascadeType.ALL) private Set<Account> accounts;

Ebene derObjekte:Set


1:N-Relation unidirektional III - Hauptprogramm

em.getTransaction().begin(); address= new Address("Berlin","Gustavzeile",3); person= new Person("Heidi", "Musterfrau",address); address.setPerson(person); em.persist(person); account= new Account(42,0.0); person.getAccounts().add(account); account= new Account(100,7450.80); person.getAccounts().add(account);

address= new Address("Fürstenwalde","Karl-May-Allee",23); person= new Person("Gudrun", "von Oiouten",address); address.setPerson(person); em.persist(person); account= new Account(5678,0.0); person.getAccounts().add(account);em.getTransaction().commit();

Zwei Kontenwerden ein-gerichtet

Ein Kontowird ein-gerichtet


1:N-Relation unidirektional IV - Schemata

Klasse Person

Klasse Account

Tabelle person_accountDiese Tabelle realisiertdie 1:N-Beziehung.


1:N-Relation unidirektional V - Tabelleninhalte

Klasse Person

Klasse Account

Tabelle person_account

Heidi hat zwei Konten,während Gudrun nur eines hat.


1:N-Relation bidirektional I

Address Person Account1 1..*1 1

Die 1:N-Relation wirdnun ohne extra Tabellemit einem Fremdschlüsselrealisiert.

Ebene derObjekte

Ebene derTabellen

Besitzende SeiteInverse Seite


1:N-Relation bidirektional II

@Entity public class Account implements Serializable{ @Id @GeneratedValue(strategy= GenerationType.AUTO) private Long id; private long number; private double bankBalance; @ManyToOne(optional= false) @JoinColumn(name= "person",nullable= false) private Person person;

@Entity public class Person implements Serializable { @Id @GeneratedValue(strategy= GenerationType.AUTO) private Long id; private String firstName; private String lastName; @OneToOne(cascade= CascadeType.ALL) @JoinColumn(name= "address") private Address address; @OneToMany(mappedBy= "person",cascade= CascadeType.ALL,

orphanRemoval= true) private Set<Account> accounts;


1:N-Relation bidirektional III - Hauptprogramm

em.getTransaction().begin(); address= new Address("Berlin","Gustavzeile",3); person= new Person("Heidi", "Musterfrau",address); address.setPerson(person); em.persist(person); account= new Account(42,0.0); person.getAccounts().add(account); account.setPerson(person); account= new Account(100,7450.80); person.getAccounts().add(account); account.setPerson(person); address= new Address("Fürstenwalde","Karl-May-Allee",23); person= new Person("Gudrun", "von Oiouten",address); address.setPerson(person); em.persist(person); account= new Account(5678,0.0); person.getAccounts().add(account); account.setPerson(person);em.getTransaction().commit();

Rückverkettungen

Rückverkettung


1:N-Relation bidirektional IV - Schemata

Klasse Person

Klasse Account

Tabelle Person Tabelle Account


Nach dieser Anstrengung etwas Entspannung...

Documents

Komponenten-basierte Entwicklung Teil 14: Persistenz mit ...wi.f4.htw-berlin.de/users/messer/LV/AI-KBE-WS14/Folien/KBE-14/14-KBE... · Komponenten – WS 2014/15 – Teil 14/Hibernate-JPA1