AnkaraJUG Nisan 2013 - Java Persistance API

1

Ertuğrul ASLAN

: @ertugrulaslan: ertugrulaslan.blogspot.com: /ertugrulaslan

Mail: ertugrul@devinim.com.tr

2

Agenda ORM (Object Relational Mapping) teknolojisi

JPA (Java Persistence API) JPA’mı Hibernate’mi kullanmalıyız.? Persistence.xml Entity ve annotasyonlar EntityManager  Relatationships JPQL (JPA sorgulama dili) JPA concurrency Java EE 7 ve JPA 2.1 ile gelecek yeni özellikler Demo uygulama

3

OBJECT RELATION MAPPING (ORM)

public class Person {

private String adı; private String soyadı; private String yaşı; private String telefon; //getter and setter}

• Objelerin tablolarda kalıcı hale getirilmeleri için uygulamadaki classların veritabanındaki tablolara, classlarda tanımlanan obje özelliklerinin yani obje değişkenlerinin bu tablolardaki sütunlarla eşleştirilmesi ORM (Object-Relational Mapping) denir.

4

ORM teknolojilerine neden ihyiyaç duyuldu.? Object-oriented dil kullanan programcılar, objelerini

yine object-oriented bir veritabanı sisteminde tutmak istiyorlar.

Yazılımda çalışma zamanında üretilen nesnelerin taşıdıkları bilgilerin daha sonra kullanılmak üzere kalıcı hale getirilmesinin en tabii yöntemi, olsa olsa bir object-oriented veri tabanı yönetim sistemi kullanmaktır.

Fakat şuan veriyi kalıcı kılmanın en tabii yolu olarak ilişkisel veri tabanı yönetim sistemleri (Relational Database Management Systems, RDBMS)

5

ORM teknolojilerine neden ihyiyaç duyuldu.?

Ve bunu basarabilmek icin, aşağıdaki yöntem kullanılmaktaydı. ResultSet’den dönen sonucuları objeye map etme vs.

6

ORM teknolojilerine neden ihyiyaç duyuldu.?

Bu şekilde uygulama geliştiren programcılar, zaman zaman tabloların yapısının değişmesiyle kodlarında tekrar tekrar düzeltme yapmak zorunda kaldı ve uygulamalar büyüdükçe bu katlanılamaz bir durum olmaya başladı.

Peki ne yapılmalı.?

7

ORM teknolojilerine neden ihyiyaç duyuldu.?

Bu uyumsuzluğun önüne geçmek için, RDBMS önüne konulacak bir katmanla, RDBMS in Object-oriented db’ye dönüştürülmesidir. Yani RDBMS ile uygulama arasına konulacak böyle bir katmanın iki arayüzü olacaktır: Birisi SQL(JDBC)’ı kullanarak RDBMS ile haberleşen interface, diğeri ise bir API üzerinden objelerle alakalı CRUD(Create, Read, Update,Delete) işlemlerini yapmaya izin veren interface. Dolayısıyla bu katman, programcıları, arkadaki RDBMS’in ilişikisel yapısından uzak tutacak ve onlara, objeleri sanki bir Object-oriented veritabanında kalıcı hale getiriyormuş gibi program yazma imkanı sağlayacaktır.

8

JPA’dan önce J2EE’nin ilk sürümü olan Aralık 1999 tarihli ilk versiyonunda EJB (Enterprise

JavaBean)’nin iki türünden birisi olan entity bean, bir ORM aracı idi ve Java ile geliştirilen uygulamaların veri katmanını halledecek şekilde geliştirilmişti. Büyük umutlarla beklenen EJB’ler ve özellikle de Entity beanler kısa sürede hayal kırıklığı yarattı.

Aynı zamanda birer uzak/dağıtık obje olan EJB’ler, gerek işin doğasının zaten çok zor olması gerek ise aşırı akademik yaklaşımdan dolayı kullanıcılarına öğrenme, uygulama ve özellikle de çalışma zamanındaki performans ve ölçeklenirlik açısından ciddi sıkıntılar yaşattı.

Sun EJB 2.0’ı yayınlayıp, özellikle performans ve ölçeklenirlik konusunda belli ilerlemeler sağladıysa da entity beanlere olan güvenin azalmış olması gerek Java programcılarını veri katmanınında kullanacakları ORM aracı konusunda alternatifler aramaya itti.

9

JPA(Java Persistence API)’nın doğuşu

10

JPA(Java Persistence API)’nın doğuşu

Hibernate, TopLink vs. çok başarılıydı fakat, farklı API’lere sahiplerdi.

Bu yüzden bu çözümler birbirlerinin yerine geçebilir durumda değillerdi.

Bu konuda bu kadar çok kütüphane çıktıktan sonra ortada bir karmaşa oluştu.

Ve Java dünyasında her konuda olduğu gibi bu konuda da üretilen bunca kütüphanenin ortak ve iyi yönleri toplanmış ve bir standart belirlenmiştir. İşte bu spesifikasyon Java Persistence API (JPA).

11

JPA(Java Persistence API)’nın doğuşu Ana teması daha kolay geliştirme ve programcılara çok büyük

kolaylık ve yenilikler getiren Java EE 5’in içindeki EJB 3.0’ın bir parçası olarak 2006 yılında ilk versiyon olan JPA 1.0 yayınlandı.

EJB 3.0 ile birlikte tanıtılan bu spesifikasyon java dünyasında büyük bir ilgi karşılandı.

Hibernate ve TopLink, JPA uyumlu ürünlerini piyasaya çıkardılar. Ve hem JPA hem de kendi özel (native) API’leri üzerinden programlama yapılabildiler.

Bu durum specifikasyon tabanlı ilerleyen java’nın yapısına çok daha uygundu ve Java programcıları artık standart bir API üzerinden pek çok farklı ORM ürününü kullanabilir hale gelmişlerdi. 2009’un sonrlarında yayınlanan Java EE 6. sürümünün bir parçası olarak yayınlanan JPA 2.0 sürümü, 1.0 sürümüne yaptığı eklerle JPA’yi çok daha güçlü hale getirdi.

12

JPA’mı Hibernate’mi kullanılmalı

JPA, Java EE ve ORM dünyasındaki karmaşalar sonucunda ortaya çıkmış bir persistence API’dir.

JPA, bir spesifikasyondur. Implementasyon değil.

JPA, kullanabilmek için bir implementasyona ihtiyaç vardır.

Bu implementasyonlarda, Hibernate, Toplink, EcpliseLink vs. Birer JPA implementasyonudur.

Hibernate

JPA

13

JPA(Java Persistence API) faydaları - I Öğrenimi ve kullanımı çok kolaydır.

Java SE hem de Java EE ortamlarında rahatlıkla kullanılabilmektedir.

Objeler arasında OneToMany, OneToOne ve ManyTo Many ilişkiler yanında inheritance ve polymorphism gibi özellikleri de destekler.

Konfigurasyon bilgileri ister XML’de istersek Java anotation’ları ile yapma imkanı verir.

Default değerle çalışabilir.

LazyFetching

Cascade Operations: Bir objeyi silince ona bağlı diğer objelerinde silinmesi veya güncellenmesi

14

JPA(Java Persistence API) faydaları - II Callbacks, veritabanlarındaki triggerlara benzetebiliriz.

@PrePersist, @PostRemove

NamedQueries, Sorgumuzu oluşturup bir isim veriyoruz ve sorgumuzu istenilen yerde bu isimle çağırıyoruz. PreparedStatementlera benzetebiliriz.

Native SQL, JPQL’in dışında kendi kendi SQL’lerimizi yazma imkanı verir. Büyük uygulamalarda yazmak zorunda kalabiliyoruz.

15

Persistence.xml JPA kullanmak için gerekli olan .xml dosyası

Örnek bir persistence.xml dosyası

16

Persistence.xml Unit name

Transaction type, JTA veya RESOURCE_LOCAL

17

Persistence.xml

Kullanılan JPA provider

18

Persistence.xml

19

Persistence.xml İmplementasyona bağlı propertyler olabililir.

20

Persistence.xml İmplementasyona bağlı propertyler olabililir.

21

Entity

Entity; JPA’yı kullanarak veritabanında kalıcı olacak objeye denir.

Bir objenin entity olması için o objenin kendisinden üretileceği classın @Entity annotasyonuyla ifade edilmesi yeterlidir.

Seralizable olması dikkat etmeliyiz, katmanlar arası geçişte kullanıyor olabiliriz.

22

Entity - II

23

@ Annotationlar

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

@Column(name = "MAIL", unique = true, length = 80, nullable = false) private Long id;

@Transient; veritabanında kalıcı olmasını istemediğimiz değişkenler (property) için kullanırız.

@Transient private String surname;

Not: javax.persistence paketinden import ediyoruz.

24

@ Annotationlar - II

@Embedded private Address address;

25

@ Annotationlar - III

@Enumurated

public enum PhoneType { MOBILE,HOME,WORK}

@Entity@Table(name="PERSONS")public class Person implements Serializable { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id;

@Enumerated(EnumType.STRING) private PhoneType phoneType;

26

EntityManager EntityManager; Entity class’larımız üzerinde CRUD

(CREATE,READ,UPDATE,DELETE) işlemlerini yapmak için kullanılan bir interface’dir.

Uygulama sunucusu kullanılıp kullanılmadığımıza bağlı olarak, EntityManager interface’ine ulaşmak için değişik yöntemler kullanılmalıdır.

EntityManagerFactory, tek objeli (singleton) bir interface olup, üzerinde entitylerle ilgili CRUD(create, read, update, delete) metodlarını çağıracağımız EntityManager nesnelerinin fabrikasıdır (factory).

27

EntityManager - II @PersistenceContext

EntityManager em;

* Bu kullanımda uygulama sunucusu tarafından EntityManager objesinin inject edilmesini sağlıyoruz.

@PersistenceUnit(unitName="ankaraJugPU") EntityManagerFactory emf; EntityManager em = emf.createEntityManager();

EntityManagerFactory emf =

Persistence.createEntityManagerFactory("ankaraJugPU"); EntityManager em = emf.createEntityManager();

* Bu kullanım ise uygulama sunucusu olmayan(uygulama sunucusu olan ortamlarda olabilir) desktop uygulamalarında kullanılan yöntemdir.

28

EntityManager - III

Persistence Context and EntityManager

PersistenceContext

EntityManager

persist()remove()refresh()merge()find()createQuery()createNativeQuery()createNamedQuery()contains()flush()

JavaBeanServlet

29

EntityManager - IV

30

EntityTransaction

JPA, veri üzerinde CUD yapan işlemler için mutlaka bir transaction beklemektedir.

Sizin DataSource bean'ı üzerinde veya hibernate.cfg.xml içerisinde autocommit davranışını true yapmanızın bir etkisi olmamaktadır.

Transaction kullanılmasa javax.persistence.TransactionRequiredException hatası anlınacaktır.

EJB kullanıyorsa, ejb metodları default olarak transactional olarak çalışmaktadır.

31

EntityTransaction

EJB metodu içerisinde aşağıdaki gibi kullanılabilinir.

32

Relationships

@OneToOne @OneToMany

@ManyToOne @ManyToMany

Bidirectional ve Undirectional

33

Relationships -II

public class Order {

int id; ...

Customer cust;}

public class Customer {

int id; ... Set<Order> orders;}

@Entity @Entity

@ManyToOne @OneToMany(mappedBy=“cust”)

@Id @Id

CUSTOMER

ID . . .

ORDER

CUST_IDID. . .

1 n

OneToMany Bidirectional

34

Relationships -III

ManyToOne

public class Customer {

int id;

Address addr;}

CUSTOMER

ADDR_IDID

ADDRESS

. . .ID

@Entity

@ManyToOne

@Id

ADDR_ID

35

Relationships -III

ManyToMany

public class Customer {

int id; ...

Collection<Phone> phones;}

PHONES_IDCUSTS_ID

@Entity @Entity(access=FIELD)

@Id @Id

@ManyToMany @ManyToMany(mappedBy=“phones”)

public class Phone {

int id; ...

Collection<Customer> custs;}

CUSTOMER

ID . . .

PHONE

ID. . .

CUSTOMER_PHONEID

@Entity

36

Relationships -IV

ManyToMany

PHONES_IDCUST_ID

CUSTOMER

ID . . .

PHONE

ID. . .CUST_PHONE

@Entitypublic class Customer { ... @ManyToMany @JoinTable(table=@Table(name=“CUST_PHONE”), joinColumns=@JoinColumn(name=“CUST_ID”), inverseJoinColumns=@JoinColumn(name=“PHONES_ID”)) Collection<Phone> phones;}

İlişkinin sahibi

37

Relationships -IV

ManyToMany

PHONES_IDCUST_ID

CUSTOMER

ID . . .

PHONE

ID. . .CUST_PHONE

@Entitypublic class Customer { ... @ManyToMany @JoinTable(table=@Table(name=“CUST_PHONE”), joinColumns=@JoinColumn(name=“CUST_ID”), inverseJoinColumns=@JoinColumn(name=“PHONES_ID”)) Collection<Phone> phones;}

İlişkinin sahibi

38

Relationships -VCascading

Persist

@Entitypublic class Student implements Serializable {  @Id @GeneratedValue private Long id; private String name; @OneToOne(cascade = CascadeType.PERSIST) private Address address

39

@Entitypublic class Student implements Serializable {  @Id @GeneratedValue private Long id; private String name; @OneToOne(cascade = {PERSIST, REMOVE}) private Address address;

Tip Tanım

PERSIST Nesne persist edilirse alt nesne de persist edilir

MERGE Nesne merge edilirse alt nesne de merge edilir

REMOVE Nesne silinirse bağlı alt nesne de silinir

REFRESH Nesne yenilenirse bağlı alt nesne de yenilenir

ALL Tüm işlemler birlikte yapılır

40

Queries(Sorgular) – JPQL

JPQL (Java Persistence Query Language)

Named, Dynamic, Native Queries

SELECT e FROM Employee e

SELECT e FROM Employee e WHERE e.name=‘ali’;

SELECT e FROM Employee e WHERE e.name=‘ali’ and e.email=‘abc@tt.com’;

em.createQuery("SELECT e FROM Employee e").getResultList();

em.createQuery("SELECT e FROM Employee e WHERE e.name=‘ali’").getResultList();

em.createQuery("SELECT e FROM Employee e WHERE e.name=:name") .setParameter("name", name).getResultList();

41

Queries(Sorgular) – JPQL

JPQL;List<Person> persons = em.createQuery("SELECT e FROM Person

e").getResultList();

Native SQL; List<Person> persons2 = em.createNativeQuery("SELECT * FROM Persons").getResultList();

JOINSSELECT e.name, d.name FROM Employee e JOIN e.department dWHERE e.status = ‘Tam zamanlı’

SELECT DISTINCT o FROM Order o JOIN o.lineItems l JOIN l.product p WHERE p.productType = ‘shoes’

42

Queries(Sorgular) – JPQL

Query query = em.createQuery("SELECT p FROM Person p " + "WHERE p.name LIKE :name"); query.setParameter(“name", adı); query.setFirstResult(5); query.setMaxResults(10);

List<Person> list = query.getResultList();

Dikkat !

Person pr = (Person) em.createQuery("SELECT p FROM Person p WHERE p.email=:") .setParameter("email“,mail).getSingleResult();

- Birden fazla kayıt dönerse hata alınır.

43

Queries(Sorgular) – JPQL Named

Queries

List<Person> list = em.createNamedQuery("Person.findAll"). getResultList();

Query query = em.createNamedQuery("Person.findByEmail"); query.setParameter(“mail", mail);

List<Person> list = query.getResultList();

Kullanımı

44

Queries(Sorgular) – JPQL Criteria Query

SELECT c FROM Country c

CriteriaBuilder cb = em.getCriteriaBuilder();

CriteriaQuery<Person> q = cb.createQuery(Person.class);Root<Person> c = q.from(Person.class);q.select(c);

TypedQuery<Person> query = em.createQuery(q); List<Person> results = query.getResultList();

45

JPA 2.0 Concurrency and locking

tx1.begin(); //employee id 5 e1 = findEmp(5);

e1.setSalary(4000);

tx1.commit();//e1.version == 2 in db

tx2.begin(); //employee id 5 e1 = findEmp(5);

e1.setSalary(5000);

tx2.commit();//OptimisticLockException

Zaman

Peki bu durumda sonuç ne olacak.?

Transaction Locking; Locking mekanizması entity objeleri üzerinde yapılan okuma ve yazma işlemlerine farklı kilit türlerinin konmasını tanımlayan mekanizmadır.  

46

JPA 2.0 Concurrency and locking READ(JPA 1.0) || OPTIMISTIC (JPA 2.0)

Entity objeleri üzeride okuma kilidi. Kilitleme mekanizmalarında genel olarak o anda bir yazma işlemi yapılmıyorsa, aynı anda yapılan birden fazla eşzamanlı okuma işlemine izin verilir

WRITE (JPA 1.0) || OPTIMISTIC_FORCE_INCREMENT (JPA 2.0) Entity objeleri üzeride yazma kilidi. Eğer bir entity nesnesi üzerinde eşzamanlı olarak veri değişikliği yapılmak isteniyorsa bu işleme müdahale edilmez, ama geliştiriciye OptimisticLockingException istisnası fırlatılarak bilgilendirme yapılır.

Veritabanı seviyesinde kilit uygulanmaz

47

JPA 2.0 Concurrency and locking

PESSIMISTIC_WRITE Entity objesi üzerinde işlem yapılırken o anki yazma ya da okuma işlemi haricindeki tüm diğer okuma ve yazma işlemleri o işlem tamamlanana kadar askıya alınırlar.

PESSIMISTIC_READ Bu kilit mekanizması okuma işlemlerine kilit koyarken veritabanı seviyesinde kilit uygulanır. PESSIMISTIC_READ uygulanan bir entity nesnesi üzerinde eşzamanlı yapılan okuma işlemlerine müdahale edilmez. Okuma anında yapılmak istenen yazma işlemleri ise okuma işlemi tamamlanana kadar askıya alınır. Bu sayede karışıklıkta giderilmiş olur.

PESSIMISTIC_FORCE_INCREMENT Versiyonlama özelliğiyle entity nesnesi üzerinde yapılan her bir değişiklik, entity nesnesinin @Version annotasyonu ile (@Version Long vers) +1 değer arttırımına neden olur. Bu sayede her bir veri değişikliği versiyonlanmış olur. Çalışma anında bellek alanında bir entity nesnesinin birden fazla yönetimli karşılığı olabilir, versiyonlama sistemiyle en yüksek değerlikli versiyon değerine sahip entity nesnesi diğer eski versiyonlarına göre tercih edilmelidir, çünkü en günceli odur.

48

JPA 2.0 Concurrency and locking

Örnek kullanımlar

em.lock(person, LockModeType.PESSIMISTIC_FORCE_INCREMENT);

em.find(Person.class, 10L, LockModeType.READ);

em.refresh(person, LockModeType.PESSIMISTIC_READ);

49

JPA 2.1 New features

Stored procedures ve function desteği

Update ve Delete Critieria queries desteği

Schema generation desteği

CDI injection into listeners

50

JPA 2.1 New features

@Entity@NamedStoredProcedureQuery(

name="topGiftsStoredProcedure", procedureName="Top10Gifts")

StoredProcedreQuery query = EntityManager.createNamedStoredProcedureQuery("topGiftsStoredProcedure");

query.registerStoredProcedureParameter(1,String.class, ParameterMode.INOUT);

query.setParameter(1, "top10");

query.registerStoredProcedureParameter(2, Integer.class, ParameterMode.IN);

query.setParameter(2, 100);

query.execute();

String response = query.getOutputParameterValue(1);

51

JPA 2.1 New features

SELECT c FROM Customer c WHERE FUNCTION(‘hasGoodCredit’, c.balance, c.creditLimit)

52

JPA 2.1 New features

CriteriaUpdate<Customer> q = cb.createCriteriaUpdate(Customer.class); 

Root<Customer> c = q.from(Customer.class); q.set(c.get(Customer_.status), "outstanding") .where(cb.lt(c.get(Customer_.balance), 10000));

update/delete using Criteria

CriteriaDelete<Customer> q = cb.createCriteriaDelete(Customer.class); Root<Customer> c = q.from(Customer.class); q.where(cb.equal(c.get(Customer_.status), "inactive"),        cb.isEmpty(c.get(Customer_.orders)));

53

JPA 2.1 New features

CriteriaUpdate<Customer> q = cb.createCriteriaUpdate(Customer.class); 

Root<Customer> c = q.from(Customer.class); q.set(c.get(Customer_.status), "outstanding") .where(cb.lt(c.get(Customer_.balance), 10000));

update/delete using Criteria

CriteriaDelete<Customer> q = cb.createCriteriaDelete(Customer.class); Root<Customer> c = q.from(Customer.class); q.where(cb.equal(c.get(Customer_.status), "inactive"),        cb.isEmpty(c.get(Customer_.orders)));

54

55