Hibernate

1. Hibernate Marcin Pamuła Mateusz Stefek

2. Plan prezentacji 1. Wstęp 2. EJB i JDBC a Hibernate 3. Architektura 4. Instalacja 5. Tworzenie najprostszej aplikacji hibernatowej 6. Możliwości Hibernata 7. Połączenie z Hibernata z JBOSSem 8 Podsumowanie

3. Wstęp Hibernate jest obiektowym narzędziem dostępu do bazy danych. Hibernate pozwala tworzyć klasy odpowiadające tabelkom w bazie danych. Umożliwia modelowanie relacji, dziedziczenia, polimorfizmu, kompozycji i kolekcji. W Hibernacie mamy możliwość wykonywania SQL-owych zapytań do bazy danych. Udostępnia też własny język zapytań (HQL), który dorównuje możliwościami SQL-owi, a przewyższa go pod względem przejrzystości.

4. EJB i JDBC a Hibernate JDBC – pozwala na wykonywanie poleceń SQL-owych z poziomu kodu JAVY Entity Java Beans – komponent EJB odpowiada pewnemu zbiorowi obiektów w bazie danych Dlaczego Hibernate jest wygodniejszy?

5. Architektura Hibernata

6. Architektura Hibernata

7. Instalacja Opis instalacji Hibernata: - instalacja bazy danych na przykładzie PostgreSQL • ściągnięcie plików z klasami Hibernata • ściągnięcie drivera JDBC do PostgreSQL • konfiguracje

8. Tworzenie przykładowej aplikacji hibernatowej • Klasy w Javie odpowiadające tabelkom • XMLe z mapowaniami klas • Konfiguracja Hibernata • Tworzenie nowego obiektu i zapamiętanie go w bazie danych • Wczytywanie obiektu z bazy danych • Wykonywanie zapytań do bazy danych

9. Klasy w Javie odpowiadające tabelkom package events; public class Person { private Long id; private int age; private String firstname; private String lastname; public Person() {} // Accessor methods for all properties, private setter for 'id' }

10. XMLe z mapowaniami klas <hibernate-mapping> <class name="events.Person" table="PERSON"> <id name="id" column="PERSON_ID"> <generator class="native"/> </id> <property name="age"/> <property name="firstname"/> <property name="lastname"/> </class> </hibernate-mapping>

11. Konfiguracja Hibernata <hibernate-configuration> <session-factory> <!-- Database connection settings --> <property name="connection.driver_class">org.hsqldb.jdbcDriver</property> <property name="connection.url">jdbc:hsqldb:hsql://localhost</property> <property name="connection.username">sa</property> <property name="connection.password"></property> <!-- JDBC connection pool (use the built-in) --> <property name="connection.pool_size">1</property> <!-- SQL dialect --> <property name="dialect">org.hibernate.dialect.HSQLDialect</property> <!-- Enable Hibernate's automatic session context management --> <property name="current_session_context_class">thread</property> <!-- Disable the second-level cache --> <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property> <!-- Drop and re-create the database schema on startup --> <property name="hbm2ddl.auto">create</property> <mapping resource="events/Event.hbm.xml"/> </session-factory> </hibernate-configuration>

12. Tworzenie nowego obiektu i zapamiętanie go w bazie danych private void createAndStoreEvent(String title, Date theDate) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); Event theEvent = new Event(); theEvent.setTitle(title); theEvent.setDate(theDate); session.save(theEvent); session.getTransaction().commit(); }

13. Wczytywanie obiektu z bazy danych i dokonywanie zmian private void loadAndUpdateEvent(Long personId, Long eventId, String t) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); Event anEvent = (Event) session.load(Event.class, eventId); anEvent.setTitle(t); session.saveOrUpdate(anEvent); session.getTransaction().commit(); }

14. Wykonywanie zapytań do bazy danych private List listEvents() { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); List result = session.createQuery("from Event").list(); return result; }

15. Możliwości Hibernata W Hibernacie możemy zamodelować: • Kolekcje • Kompozycje • Dziedziczenie Dodatkowe możliwości: • HQL • Zapytania SQLowe • Kryteria

16. Kolekcje <set name="names" table="person_names"> <key column="person_id"/> <element column="person_name" type="string"/> </set> <bag name="sizes" table="item_sizes" order-by="size asc"> <key column="item_id"/> <element column="size" type="integer"/> </bag>

17. Kolekcje – relacja jeden do wielu <class name="Parent"> <id name="id" column="parent_id"/> .... <set name="children" inverse="true"> <key column="parent_id"/> <one-to-many class="Child"/> </set> </class> <class name="Child"> <id name="id" column="child_id"/> .... <many-to-one name="parent" class="Parent" column="parent_id" not-null="true"/> </class>

18. Kolekcje – relacja wiele do wielu <class name="Category"> <id name="id" column="CATEGORY_ID"/> ... <bag name="items" table="CATEGORY_ITEM"> <key column="CATEGORY_ID"/> <many-to-many class="Item" column="ITEM_ID"/> </bag> </class> <class name="Item"> <id name="id" column="CATEGORY_ID"/> ... <bag name="categories" table="CATEGORY_ITEM" inverse="true"> <key column="ITEM_ID"/> <many-to-many class="Category" column="CATEGORY_ID"/> </bag> </class>

19. Kompozycje public class Person { private Name name; private String key; public String getKey() { return key; } private void setKey(String key) { this.key=key; } public Name getName() { return name; } public void setName(Name name) { this.name = name; } }

20. Kompozycje public class Name { String first; String last; public String getFirst() { return first; } void setFirst(String first) { this.first = first; } public String getLast() { return last; } void setLast(String last) { this.last = last; } }

21. Kompozycje <class name="eg.Person" table="person"> <id name="Key" column="pid" type="string"> <generator class="native"/> </id> <component name=„name" class="eg.Name"> <property name="first"/> <property name="last"/> </component> </class>

22. Dziedziczenie W Hibernacie mamy 3 sposoby na odwzorowanie dziedziczenia: • Jedna tabela na klasę i klasy z niej dziedziczące • Tabela na każdą klasę • Tabela na każdą klasę nieabstrakcyjną

23. Tabela na schemat dziedziczenia <class name="Payment" table="PAYMENT" discriminator-value=„PAYMENT"> <id name="id" type="long" column="PAYMENT_ID"> <generator class="native"/> </id> <discriminator column="PAYMENT_TYPE" type="string"/> <property name="amount" column="AMOUNT"/> ... <subclass name="CreditCardPayment" discriminator-value="CREDIT"> <property name="creditCardType" column="CCTYPE"/> ... </subclass> <subclass name="CashPayment" discriminator-value="CASH"> ... </subclass> </class>

24. Tabela na każdą klasę <class name="Payment" table="PAYMENT"> <id name="id" type="long" column="PAYMENT_ID"> <generator class="native"/> </id> <property name="amount" column="AMOUNT"/> ... <joined-subclass name="CreditCardPayment" table="CREDIT_PAYMENT"> <key column="PAYMENT_ID"/> <property name="creditCardType" column="CCTYPE"/> ... </joined-subclass> <joined-subclass name="CashPayment" table="CASH_PAYMENT"> <key column="PAYMENT_ID"/> ... </joined-subclass> </class>

25. Tabela na każdą klasę nieabstrakcyjną <class name="Payment"> <id name="id" type="long" column="PAYMENT_ID"> <generator class="sequence"/> </id> <property name="amount" column="AMOUNT"/> ... <union-subclass name="CreditCardPayment" table="CREDIT_PAYMENT"> <property name="creditCardType" column="CCTYPE"/> ... </union-subclass> <union-subclass name="CashPayment" table="CASH_PAYMENT"> ... </union-subclass> </class>

26. Hibernate Query Language (HQL) Hibernate jest wyposażony we własny, bardzo dobry język zapytań przypominający składnią SQL-a. Jednak w przeciwieństwie do niego, HQL jest językiem zorientowanym w pełni obiektowo, rozumiejącym mechanizmy dziedziczenia i polimorfizmu.

27. Hibernate Query Language (HQL) • Składnia • Złączenia • Klauzula SELECT • Klauzula WHERE • Funkcje agregujące i operatory • order by, group by • podzapytania

28. Użycie HQLa List mothers = session.createQuery( "select mother from Cat as cat join cat.mother as mother where cat.name = ?") .setString(0, name) .list(); List kittens = session.createQuery( "from Cat as cat where cat.mother = ?") .setEntity(0, pk) .list();

29. Użycie HQLa Iterator results = sess.createQuery( "select cat.color, min(cat.birthdate), count(cat) from Cat cat " + "group by cat.color") .list() .iterator(); while ( results.hasNext() ) { Object[] row = (Object[]) results.next(); Color type = (Color) row[0]; Date oldest = (Date) row[1]; Integer count = (Integer) row[2]; ..... }

30. Zapytania SQL-owe Zapytania nazwane w plikach z mapowaniami <query name="eg.DomesticCat.by.name.and.minimum.weight"><![CDATA[ from eg.DomesticCat as cat where cat.name = ? and cat.weight > ? ] ]></query> Query q = sess.getNamedQuery("eg.DomesticCat.by.name.and.minimum.weight"); q.setString(0, name); q.setInt(1, minWeight); List cats = q.list();

31. Zapytania SQL-owe Zapytania w kodzie klas List cats = session.createSQLQuery( "SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10", "cat", Cat.class ).list();

32. Kryteria Kryteria udostępniają programiście możliwość dynamicznego budowania zapytań. Ułatwiają też abstrahowanie od języka zapytań. Kryteria udostępniają metodę list, która zwraca listę wyników List studenci = sess.createCriteria(Student.class).list()

33. Kryteria List studenci = sess.createCriteria(Student.class) .add(Restrictions.like("imie", "M%")) .list() List studenci = sess.createCriteria(Student.class) .add(Restrictions.sqlRestriction({alias}.imie like "M%")) .list()

34. Kryteria List studenci = sess.createCriteria(Student.class) .addOrder(Order.asc("imie") .list() List pracownicy = sess.createCriteria(Pracownik.class) .createCriteria("przelozony"). .add(Restriction.like("imie", "Z") .list()

35. Połączenie Hibernata z JBossem Chcemy tak skonfigurować serwer aplikacji, aby hibernate był dostępny jako usługa, a SessionFactory była widoczna w JNDI. • Skonfigurowanie Jbossa, tak aby używał odpowiedniego drivera JDBC • Skopiowanie plików cglib.jar, commons-collections.jar, commons-logging.jar, commons-lang.jar, jcs.jar,odmg.jar i hibernate.jar do ${HIBERNATE_HOME}/lib i ${JBOSS_HOME}/server/default/lib

36. Połączenie Hibernata z JBossem • Utworzenie archiwum SAR o następującej strukturze: • mojpakiet/Student.class • mappings/Student.hbm.xml • META-INF/jboss-service.xml

37. Połączenie Hibernata z JBossem • Jboss-service.xml <server> <mbean code="net.sf.hibernate.jmx.HibernateService" name="jboss.jca:service=HibernateFactory, name=HibernateFactory"> <depends>jboss.jca:service=RARDeployer</depends> <depends>jboss.jca:service=LocalTxCM,name=MySqlDS</depends> <!-- Make it deploy ONLY after DataSource had been started --> <attribute name="MapResources">mappings/Student.hbm.xml</attribute> <attribute name="JndiName">java:/hibernate/HibernateFactory</attribute> <attribute name="Datasource">java:/MySqlDS</attribute> <attribute name="Dialect">net.sf.hibernate.dialect.MySQLDialect</attribute>

38. Połączenie Hibernata z JBossem <attribute name="TransactionStrategy">net.sf.hibernate.transaction.JTATransactionFactory</attribute> <attribute name="TransactionManagerLookupStrategy">net.sf.hibernate.transaction.JBossTransactionManagerLookup</attribute> <attribute name="UseOuterJoin">false</attribute> <attribute name="ShowSql">false</attribute> <attribute name="UserTransactionName">UserTransaction</attribute> </mbean> </server> Po zdeplojowaniu wszystkie pisane przez nas komponenty mogą wyciąg SessionFactory z JNDI.

39. Podsumowanie Główną zaletą Hibernata, jest jego prostota i łatwość użycia. Dzięki niemu nie trzeba pisać setek poleceń w SQLu. Hibernate robi to za nas. Poza tym jest intuicyjny i łatwy do nauki. Wydaję się on być najlepszą technologią umożliwiającą dostęp do bazy danych, występującą obecnie na rynku.