2. Bölüm - JPA`ya Giris
advertisement
2. Bölüm Java Persistence API’sine Giriş 1 2. Bölüm Java Persistence API’sine Giriş co
m
w
w
.jp
ab
oo
k.
2. Bölüm Java Persistence API’sine Giriş ....................................................................... 1 2.1. Giriş ............................................................................................................................. 2 2.2. Entity ya da Kalıcı Nesne .............................................................................................. 2 2.2.1. Entitynin Özellikleri ...................................................................................................... 7 2.3. Kalıcılık Birimi (Persistence Unit) ve Ayarları ............................................................... 11 2.3.1. Şema Oluşturma ......................................................................................................... 17 2.3.2. JPA ve Varsayılanlar ................................................................................................... 21 2.4. Kalıcılık Birimi API’si ................................................................................................... 23 2.5. JPA’nın Temel Nesneleri ve Kavramları ....................................................................... 25 2.5.1. Persistence Sınıfı ........................................................................................................ 26 2.5.2. EntityManagerFactory Sınıfı ....................................................................................... 30 2.5.3. EntityManager ve Kalıcı Nesne Hayat Döngüsü ......................................................... 32 2.5.4. Nesneyi Kaydetme ..................................................................................................... 35 2.5.5. Transactions ............................................................................................................... 35 2.5.6. Kimlik Bilgisi ile Nesne Getirme .................................................................................. 37 2.5.7. Veri Tabanından Nesne Sorgulama ............................................................................ 39 2.5.8. Entity Güncelleme ...................................................................................................... 40 2.5.9. Veri Tabanından Entity Silme ..................................................................................... 43 2.6. Bölüm Özeti ................................................................................................................ 45 w
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 2 Giriş co
m
2.1.
Bu bölümde JPA’nın temellerinden bahsedeceğiz. Önce entity/kalıcı nesne kavramını ele alacağız. Sonra JPA’nın temel ayarlarının nasıl yapılabileceğini hem XML hem de programatik yöntemleri kullanarak öğreneceğiz. Sonrasında JPA API’sinin EntityManager gibi en sık k.
kullanılan nesnelerini, kavramlarını ve aralarındaki ilişkileri ele alacağız. Kalıcı nesnenin hayat döngüsü ve bu döngünün EntityManager ile nasıl yönetileceği, bu bölümün en fazla yer oo
tutan kısımlarından olacak. Hedefimiz bu bölümün sonunda temel seviyede JPA ile program yazabilir hale gelmektir. 2.2.
ab
Entity ya da Kalıcı Nesne .jp
JPA’nın terimleri içerisinde hem en önemlisi hem de mantıksal olarak ön önce geleni “entity” yani “kalıcı nesne”dir. (Gerek bu kitaba başlarken gerek uzun yıllar boyunca ilgili konularda eğitim verirken aklımda hep “entity kavramını dilimizde en iyi nasıl ifade ederiz” sorusu vardı. w
Derdim çeviri değildir, iyi ifade etmek, denilmek isteneni kendi dilimizde karşılamaktır. Çeviri yapmaya kalkarsak, sözlüğe bakıp “varlık” gibi, söylendiğinde hiç bir şey ifade etmeyen, akla w
ilgili hiç bir şey getirmeyen bir karşılık bulabiliriz. Maalesef bu tip çeviriler çok yaygın. Ama amacımız, söylendiğinde, ilk defa duyan okuyucuların zihninde bile anlamlı bir şeyler w
uyandırmaksa sanırım “kalıcı nesne” güzel bir ifadedir. Zaten entity kavramını İngilizce olarak açıkladığımızda “persistent object” ifadesini kullanırız. Bu kitapta, karışıklıklara yol açmamak için sıklıkla entity kelimesini, bazen de kalıcı nesne ifadesini entity yerine geçecek şekilde kullanacağız.) (Bir başka dikkat çekmek istediğimiz husus da nesne ve sınıf kavramlarını çoğu zaman birbiri yerine kullandığımız gerçeğidir. Bu anlamda entity ile bazen kalıcı nesnenin kendisini bazen de nesneleri kalıcı olan sınıfı kastederiz. Bazen ikinci anlam için kalıcı sınıf da 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 3 kullanılabilir. Bazen sadece nesne dediğimizde de aslında kalıcı nesneyi kastediyoruz demektir. Siz bağlama göre hangisini kastettiğimizi anlayacaksınız.) Entity yani kalıcı nesne, JPA’nın, durumunu veri tabanında kalıcı (persistent) hale getirdiği nesneye denir. Bir nesnenin durumunun veri tabanında kalıcı hale getirilmesi, nesnenin co
m
durumunu oluşturan nesne değişkenlerinin (instance variables) ya da kısaca alanlarının (fields) veri tabanındaki tabloların sütunlarına yazılması demektir. Bu noktada nesnenin, veri tabanındaki sütunlara yazılan alanlarına, kalıcı alan (persistent field) da denir. Tahmin edeceğiniz gibi, bir nesnenin tüm alanları kalıcı olmak zorunda değildir. Nesne, kalıcı olan ve olmayan alanlara sahip olabilir. Bir entitynin hangi alanlarının nasıl kalıcı olacağını ya da alanlarının kalıcı olduğunu söyleyerek yetinelim. k.
olmayacağını ileride detaylıca ele alacağız ama şu anda varsayılan durumda bir entitynin tüm oo
JPA ile veri tabanında saklanan entitynin durumu, daha sonra isteğe bağlı olarak, veri tabanından uygulamaya getirilebilir ve sonrasında uygulamada entitynin durumunda yapılan güncellemeler veri tabanına yansıtılır. Bir önceki bölümde de bahsettiğimiz gibi bu işlemler, ab
kalıcı nesnelerle ilgili 4 temel nesne-­‐veri tabanı işlemidir ve kısaca YOGS (yaratma, okuma, güncelleme ve silme (CRUD, create, read, update, delete) olarak adlandırılır. JPA’nın, entity ile .jp
ilgili YOGS işlemleri yapmasına, entitynin hayat döngüsünü (life cycle) yönetmesi denir. JPA’da entityler, POJO’durlar (POJO, “Plain Old Java Objects”in kısaltmasıdır ve kanımızca dilimizdeki en güzel karşılığı, “şu bizim dedelerimizin kullandığı nesneler” olabilir). Yani w
entitylerin herhangi bir sınıftan miras devralmaları gerekmediği gibi, herhangi bir ara yüzü de gerçekleştirmeleri gerekmez. Dolayısıyla entityler hafif (light-­‐weight) nesnelerdir yani Java dili w
dışında herhangi bir yapıya bağımlılıkları yoktur. Bu durum JPA’nın bir kolaylığıdır çünkü Java w
dünyasında JPA’dan önce çıkan pek çok NİE yapısı örneğin Kurumsal Java Beanleri’nin (Enterprise Java Beans, EJB) bu amaçla çıkarılmış türü olan Entity Bean, POJO değildi, daha karmaşık bir yapıya sahipti ve bundan dolayı da geliştirme daha farklı ve karmaşık yapılıyordu. Bu noktada EJB’lerin çıkışından 3.0 sürümüne kadar parçası olmuş bir türü olan Entity Beani ile JPA’nın entitysinin kavramsal olarak aynı amaca yönelik yapılar olmasına rağmen mekanizma olarak tamamen farklı olduklarını ve karıştırılmamaları gerektiğini ifade edelim. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 4 Peki, JPA’da entityler POJO ise, bir sınıfın nesnelerinin kalıcı yani entity olduğunu nasıl belirtiriz? Bunun için iki yöntemden birisini kullanmalıyız: notlar (annotation) ya da XML ayarları. Bilindiği gibi, Java’da notlar, alan, metot ve sınıf gibi yapılar için geçerlidir ve bazen kod üretmek, bazen derleyiciye belli bilgiler vermek, bazen de ayar yapmak amacıyla kullanılır. Java’da notlar, Java API’sinin bir parçasıdır ve kod içinde önlerine “@” işareti getirilerek co
m
kullanılır. Bir sınıfın nesnelerinin entity olduğunu belirtmek için kullanacağımız not ise Entity’dir ve @Entity olarak nitelediği sınıfın tanımından önce kullanılır. XML ile ayar yapıldığında ise <entity> elemanı kullanılır. k.
package com.jpaBook.ch02.domain;
oo
import java.util.Date;
import javax.persistence.Entity;
public class Person {
@Id
.jp
private int id;
ab
@Entity(name="PersonEntity")
private String firstName;
private String lastName;
w
private Date dob;
public Person() {}
w
public Person(int id, String firstName, String lastName, Date dob){
this.id = id;
w
this.firstName = firstName;
this.lastName = lastName;
this.dob = dob;
}
. . .
}
Kod: Person.java 4 Eylül 2013 5 2. Bölüm Java Persistence API’sine Giriş Yukarıdaki Person sınıfı, sınıf tanımından önce kullanılan @Entity notu ile nesnelerinin hayat döngüsü JPA tarafından yönetilecek bir kalıcı sınıf olarak tanımlanmış olur. @Entity notunun sadece bir tane isteğe bağlı, yani kullanılması zorunlu olmayan özelliği co
m
(attribute) vardır. String tipinde ve name isminde olan bu özellik, kalıcı nesneye, sınıfın yalın ismi dışında bir isim vermek istendiğinde kullanılır. Yalın isimden kasıt ise, sınıfın, paketi hesaba katılmadan kullanılan ismidir. Tam ismi com.jpaBook.ch02.domain.Person olan sınıfın yalın ismi Person’dır. Yukarıdaki örnekte eğer name özelliğini kullanmasaydık, kalıcı nesnenin ismi de sınıfın yalın ismi olan Person olurdu. Fakat yukarıdaki gibi k.
@Entity(name="PersonEntity") notuyla entitynin ismi PersonEntity olarak @Entity
ab
public class Person { . . . }
oo
belirlenmiş olur. Aşağıdaki kod parçalarında bu iki durum gösterilmiştir. .jp
@Entity(name="PersonEntity")
public class Person { . . . }
Kod: Person.java w
w
Entity tanımlamak için bir başka zorunluluk da kimlik (identity, ya da id) bilgisidir. Her entity, aynı tipten nesneler arasında kendini ayırt eden bir kimlik bilgisine sahip olmalıdır. Entitynin w
durumu veri tabanında saklanacağından, kimlik bilgisi, veri tabanındaki ana anahtar (primary key) alana karşı gelmek zorundadır. Dolayısıyla tanımı gereği ana anahtar alanın değeri de tablodaki her satır için tekil yani ayırt edici olmak zorundadır. JPA’da entitynin bir alanını kimlik olarak tanımlamak için Id notu ya da XML ile ayar yapılıyorsa <id> elemanı kullanılmalıdır. Kimlik bilgisi bir ya da daha fazla alandan oluşabileceği gibi ayrı bir sınıfın nesnesi de kimlik olarak kullanılabilir. Kimlik bilgisini yazılım geliştiren kod 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 6 içinde atayabileceği gibi arzu edilirse JPA’ya ister kendi isterse veri tabanının yeteneklerini kullanarak kimlik bilgisini oluşturması söylenebilir. Burada dikkat edilmesi gereken şey, bir entitynin kimlik bilgisinin aldığı değerin değişmemesi gerektiği gerçeğidir. Biz kimlik bilgilerini detaylıca alacağımız kısma gelinceye kadar nesnelerin kimlik bilgilerini kod içinde belirleyeceğiz. co
m
Aynı Person sınıfını, alternatif yöntem olan XML kullanarak entity olarak tanımlamak istersek, aşağıdaki gibi bir XML kod parçası kullanmamız gereklidir: <?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
k.
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm
oo
http://java.sun.com/xml/ns/persistence/orm_2_0.xsd” version="2.0">
<description>JPA Book, CH02</description>
<package>com.jpaBook.ch02.domain</package>
<entity class="Person" name="PersonEntity">
<attributes>
<id name="id">
ab
<table name="PERSONS0201" />
</id>
.jp
<column name="ID"/>
<basic name="firstName">
<column name="FIRSTNAME" length="30" />
w
</basic>
<basic name="lastName">
w
<column name="LASTNAME" length="50" />
</basic>
w
<basic name="dob">
<column name="DATEOFBIRTH" />
<temporal>DATE</temporal>
</basic>
</attributes>
</entity>
</entity-mappings>
Kod: Person.xml 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 7 XML kodunda görüldüğü gibi <entity> etiketi, içinde class ve name özellikleri ile kullanılmıştır. Tahmin edebileceğiniz gibi class özelliği zorunlu ama name özelliği seçimlidir ve name özelliği kullanılmadığında entitynin ismi, notlu haldeki gibi, sınıfın yalın ismi olarak belirlenir. Yukarıdaki örnekten görüldüğü gibi <description> not karşılığı olmayan etiketlerdendir ve kalıcı yapılan nesne ile ilgili bilgi vermek amacıyla kullanılabilir. Bu etiketin co
m
not karşılığının olmaması ise son derece anlaşılır bir durumdur çünkü Java kodunda bu amaçla yorumlar örneğin Javadoc kullanılır. Kısaca tekrar etmek istersek, bir sınıfın entity olabilmesi için ya @Entity notuyla notlandırılması ya da ilgili XML dosyasında <entity> elemanı içinde class özelliği k.
kullanılarak belirtilmesi zorunludur. Eğer bir sınıf hem not hem de XML dosyasında entity olarak belirtilirse, XML dosyasındaki ayarlar nottaki ayarları ezecektir. Ayrıca kalıcı sınıfın ya @Id ile oo
notlandırılmış ya da XML kullanımında <id> elemanı ile belirlenmiş ve veri tabanındaki ana anahtar (ya da kısaca anahtar) alana karşılık gelen bir alanı olmak zorundadır. Daha fazla ilerlemeden kısaca entitynin isminin ne işe yaradığından bahsedelim. Entitynin ab
ismi, genel olarak sorgularda kullanılır. Dolayısıyla uzun olan ya da çok da anlamlı olmayan sınıf ismi yerine daha kısa ya da daha anlamlı bir isim seçmek amacıyla bu özellik tercih edilebilir. .jp
2.2.1. Entitynin Özellikleri w
Bir sınıfın JPA’nın şartlarına uygun bir entity olabilmesi için başka şartlar da vardır. Bunları w
kısaca şöyle sıralayabiliriz: Entity öncelikle bir sınıf olmalıdır, enum ya da interface entity olamaz. •
Sınıf, en üst seviyede bir sınıf olmalıdır. Yani entity olacak sınıf, bir iç sınıf (inner class) w
•
olmamalıdır. •
Benzer şekilde entity sınıfı final olmamalı ve herhangi bir final kalıcı alan ve metoda sahip olmamalıdır. final anahtar kelimesinin kullanımı ile ilgili bu kısıtlamanın nedenini ileride göreceğiz. 4 Eylül 2013 8 2. Bölüm Java Persistence API’sine Giriş •
Sınıf, muhakkak public ya da protected olan bir varsayılan (default) yani argümansız (no-­‐arg) kurucuya (constructor) sahip olmalıdır. Entity sınıfı, tabi olarak, varsayılan kurucu yanında, argüman alan pek çok farklı kurucuya sahip olabilir. •
Eğer entity uzak ara yüzlere (remote interface) geçilecekse, sınıfın •
co
m
java.io.Serializable ara yüzünü gerçekleştirmesi de gereklidir. Entity soyut bir sınıf olabilir. Bu durumda belli ki bir kalıtım hiyerarşisi vardır ve soyut olan bu sınıftan miras devralan tüm sınıflar da doğrudan entity olurlar. •
Entity sınıfı, entity olmayan bir başka sınıftan miras devir alabileceği gibi, entity k.
olmayan bir sınıf da entity olan bir başka sınıftan miras devir alabilir. İlerideki bölümlerde, miras devir alma ile ilgili ayrıntıları ele alacağız. Entitynin durumunu oluşturan nesne değişkenleri daima sarmalama (encapsulation) oo
•
prensibine uygun bir şekilde yani bean özellikleri olarak ifade edilmelidir. Dolayısıyla entitynin müşterileri ya da istemcileri (clients), entitynin kalıcı olan nesne ab
değişkenlerine ancak getter-­‐setter metotları ya da diğer iş metotları (business methods) üzerinden erişebilmelidir. Bu anlamda kalıcı olan nesne değişkenleri private ya da devir alınma durumu göz önüne alınarak protected olarak .jp
nitelenmeli ve bu değişkenlerin, erişim ve değişme durumları göz önüne alınarak, ilgili set ve get metotları oluşturulmalıdır. Pek tabi olarak, her Java sınıfı için unutulmaması gereken toString(), equals() w
•
ve hashCode() metotlarını tekrar tanımlamamız (override), daha kaliteli geliştirme w
açısından önemlidir. w
Yukarıdaki maddeleri göz önüne aldığımızda Person entity sınıfını şu şekilde ifade edebiliriz: package com.jpaBook.ch02.domain;
import java.util.Date;
import javax.persistence.Entity;
@Entity(name="PersonEntity")
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş public class Person {
@Id
private int id;
private String firstName;
private String lastName;
co
m
private Date dob;
public Person() {}
public Person(int id, String firstName, String lastName, Date dob) {
this.id = id;
k.
this.firstName = firstName;
this.lastName = lastName;
oo
this.dob = dob;
}
public Person(int id, String firstName, String lastName) {
}
ab
this(id, firstName, lastName, null);
public int getId() {
return id;
.jp
}
public void setId(int id) {
w
this.id = id;
w
}
public String getFirstName() {
return firstName;
w
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
4 Eylül 2013 9 2. Bölüm Java Persistence API’sine Giriş 10 }
public void setLastName(String lastName) {
this.lastName = lastName;
}
co
m
public Date getDob() {
return dob;
}
public void setDob(Date dob) {
this.dob = dob;
k.
}
oo
public java.sql.Date getDobAsSQlDate() {
return new java.sql.Date(dob.getTime());
@Override
ab
}
public int hashCode() {
final int prime = 31;
int result = 1;
.jp
result = prime * result + ((firstName == null) ? 0 :
firstName.hashCode());
result = prime * result + id;
w
result = prime * result + ((lastName == null) ? 0 :
lastName.hashCode());
w
return result;
}
w
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 11 return false;
Person other = (Person) obj;
if (firstName == null) {
if (other.firstName != null)
return false;
return false;
if (id != other.id)
return false;
if (lastName == null) {
if (other.lastName != null)
return false;
k.
} else if (!lastName.equals(other.lastName))
co
m
} else if (!firstName.equals(other.firstName))
return false;
}
@Override
ab
public String toString() {
oo
return true;
return "Person [id=" + id + ", firstName=" + firstName + ",
lastName=" + lastName + ", dob=" + dob + "]";
}
.jp
}
w
Kod: Person.java Kalıcılık Birimi (Persistence Unit) ve Ayarları w
2.3.
JPA ile ilgili bir diğer önemli yapı ise kalıcılık birimi’dir (persistence unit). Kalıcılık birimi, w
projenin JPA ayarları ile bu ayarları paylaşan kalıcı sınıfların oluşturduğu mantıksal yapının ismidir. Kalıcılık birimi, JPA projesinin kökünde olan META-INF klasöründeki persistence.xml dosyası içinde tanımlanır. META-INF klasörü ile persistence.xml dosyasının isimleri ve yerlerinin bu şekilde olması bir zorunludur, değişemez. Kalıcılık birimi istenirse program içinde de ilgili API kullanılarak programatik bir şekilde tanımlanabilir. Bunu nasıl yapabileceğimizi bu bölümde daha ileride göreceğiz. Kalıcılık birimi, projenin JPA ile 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 12 yönetilecek olan kalıcılık yapısıyla ilgili ayarlarını içerir ve projenin kurulumunun (deployment) da parçasıdır. Aşağıdaki kod parçasında tipik aynı zamanda da basit bir persistence.xml görülmektedir. co
m
. . .
<persistence-unit name="ch02.00"
transaction-type="RESOURCE_LOCAL">
<provider>org.eclipse.persistence.jpa.PersistenceProvider
k.
</provider>
<mapping-file>META-INF/Person.xml</mapping-file>
oo
<class>com.jpaBook.ch02.domain.Person</class>
<exclude-unlisted-classes>true</exclude-unlisted-classes>
<properties>
ab
<property name="javax.persistence.jdbc.driver"
value="org.apache.derby.jdbc.ClientDriver"/>
<property name="javax.persistence.jdbc.url"
.jp
value="jdbc:derby://localhost:1527/JPABOOK;create=true"/>
<property name="javax.persistence.jdbc.user" value="app"/>
<property name="javax.persistence.jdbc.password"
w
value="password"/>
<property name="eclipselink.logging.level.sql" value="OFF" />
w
<property name="eclipselink.ddl-generation" value="create-tables" />
<property name="eclipselink.create-ddl-jdbc-file-name"
w
value="create.ddl" />
<property name="eclipselink.drop-ddl-jdbc-file-name"
value="drop.ddl" />
<property name="eclipselink.ddl-generation.output-mode"
value="database" />
</properties>
</persistence-unit>
. . .
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 13 Kod: persistence.xml Yukarıdaki persistence.xml dosyasını incelersek, en başta her XML dosyasında olduğu gibi bir XML tanıtım satırı görürüz. Sonra ise XML dokümanının kök elemanı olan co
m
<persistence> gelmektedir. <persistence> elemanının içinde bir ya da daha fazla <persistence-unit> elemanı kullanarak bir ya da daha fazla sayıda kalıcılık birimi tanımlanabilir. Yukarıdaki örnekte sadece bir tane kalıcılık birimi tanımlanmıştır. <persistence-unit> elemanının iki tane özelliği vardır: name ve transaction-
k.
type. name zorunludur ve kalıcılık biriminin ismidir, değer olarak bir String almalıdır. transaction-type ise kalıcılık biriminin transaction tipidir ve RESOURCE_LOCAL ya da oo
JTA değerlerinden birisini almalıdır. (Transaction kelimesini de dilimizde “veri tabanı işlemi” olarak çevirmek anlamda karışıklıklara yol açtığı için bu kelimeyi de aynen İngilizce aslıyla kullandık.) JTA, Java Transaction API’sinin kısaltması olup, Java EE’nin, birden fazla veri kaynağı ab
kullanarak oluşturulan dağıtık transactionları (distributed transactions) yönetmeyi sağlayan ara yüzüdür. Kalıcılık biriminin işlem tipinin JTA olduğu JPA kullanılan projeler, uygulama sunucusu .jp
(application server) gibi bir JTA gerçekleştirmesine sahip ortamlarda olmalıdırlar. Kalıcılık biriminin transaction tipi, ayrıca belirtilmediğinde varsayılan değer olarak RESOURCE_LOCAL’dır. RESOURCE_LOCAL genelde Java SE ortamlarında kullanılır. w
RESOURCE_LOCAL transaction türüne sahip bir JPA projesinde transactionlar, JPA’nın bir nesnesi olan EntityTransaction üzerinden yönetilir. Bu durumda, JPA ürünleri, altta var w
olan JDBC bileşeninin transactionlarını kullanarak EntityTransaction
nesnesini oluştururlar ve JPA’nın transactionlarını yerine getirirler. Ayrıca Java EE ortamı olduğu halde JTA w
yerine RESOURCE_LOCAL tipinde kalıcılık birimi kullanılabileceğini de belirtmeliyiz. Biz JTA kullanan kalıcılık birimi ile Java EE ortamlarında JPA kullanımına ilerideki bölümlerde gireceğiz. O zaman kadar örneklerimizde, aksi söylenmedikçe, daima RESOURCE_LOCAL tipinde transactiona sahip kalıcılık birimleriyle çalışacağız. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 14 Sonra gelen satır, JPA gerçekleştirmesini ifade eder. Bunun için <provider> elemanı kullanılmıştır. Aslen <provider> elemanının kullanımı seçimlidir. co
m
<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
Java çalışma zamanı (run-­‐time) ortamı ya da JVM, (Java Virtual Machine ya da Java Sanal Makinası) kalıcılık birimini oluşturmak için önce sınıf-­‐yolunda (classpath) JPA’nın javax.persistence.spi.PersistenceProvider
arayüzünü gerçekleştiren sınıfı k.
arar. JVM uygun sınıfı bulduğunda onu belleğe yükler ve üzerindeki metotları çağırarak JPA yapısını başlatır. Bu yüzden JPA ayarları içinde <provider> elemanın belirtmenize gerek oo
yoktur, zorunlu değildir. Bu durumda JVM, sınıf-­‐yolunda bulunan JPA gerçekleştirmesini kullanacaktır. Uygulamanızda belirli bir JPA ürününü kullanmayı öngörüyorsanız tabi olarak <provider> elemanını kullanabilirsiniz. Bu durumda her yeni JPA gerçekleştirme ab
değişikliğinde bu satırı güncellemeniz gerekecektir. Yukarıdaki örnekte, kitapta kullanacağımız JPA gerçekleştirmesi olan EclipseLink’in <provider> elemanı için gerekli sınıfı verilmiştir. Fakat kitabın örnek uygulamalarında gerekmedikçe <provider> elemanı kullanılmayacaktır. .jp
Kalıcılık birim tanımı ayrıca farklı eşleştirme dosyalarını listeleyebilir. Örneğin, w
<mapping-file>META-INF/Person.xml </mapping-file>
w
satırı, META-INF dosyasındaki Person.xml isimli bir eşleştirme dosyasını göstermektedir. w
Eşleştirme bilgisi doğrudan persistence.xml dosyasına da konabilir fakat çok sayıda eşleştirmenin burada yapılması pek de sağlıklı bir durum değildir. Bu yüzden eşleştirmeleri notlarla yapmak yerine XML ile yapmayı düşünüyorsanız, bir ya da daha fazla eşleştirme dosyasına istediğiniz isim(ler)i verip onları istediğiniz yere koyabilirsiniz. Önemli olan eşleştirme dosyalarına olan referansları persistence.xml dosyasında <mapping-file> elemanı 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 15 ile sıralamanızdır. Biz örneklerimizde eşleştirme dosyasını ya da dosyalarını, yukarıdaki örnekte olduğu gibi META-INF klasörüne koyacağız. Yukarıdaki persistence.xml dosyasında daha sonra <class>com.jpaBook.ch02.domain.Person</class>
co
m
<exclude-unlisted-classes>true</exclude-unlisted-classes>
kısmı gelmektedir. Bu satırlar, JPA’ya, sadece burada listelenen entityleri yüklemesini, k.
listelenmeyenleri ise yüklememesini söylemektedir. Asıl itibarıyla, bir JPA projesindeki entitylerin persistence.xml dosyasında listelenmesi zorunludur. Ama bazı JPA ürünleri, oo
projenin sınıf-­‐yolunu tarayarak @Entity ile notlandırılmış sınıfları ve varsa eşleştirme dosyalarına bakarak <entity> elemanı ile belirtilmiş sınıfları, entity sınıfı olarak belleğe yüklemektedir. Fakat asıl olan, hem tüm entityleri liste olarak bir arada görme hem de aynı ab
entityi, öğrenme ve deneme amacıyla birden fazla sınıfta farklı şekillerde tanımlama gibi amaçlar için, böyle bir listeyi yapıp .jp
<exclude-unlisted-classes>true</exclude-unlisted-classes>
w
gibi bir satırla, burada listelenmeyen başka entitylerin yüklenmemesini sağlayabilirsiniz. Bu satırı w
kullanmadığınızda JPA, projenin sınıf-­‐yolunda var olan bütün entity sınıflarını belleğe yükleyecektir. Siz bu kitabın kodlarında aynı entitynin, örneğin Person, farklı paketlerdeki w
Person sınıflarıyla tekrar tekrar tanımlandığını göreceksiniz. Eğer persistence.xml
dosyasında ilgili Person sınıfı, <class> elemanı ile listelense bile <exclude-unlisted-
classes> elemanı true değeriyle kullanılmazsa, projedeki bir çok farklı Person sınıfı kalıcı nesne olarak doğrudan belleğe yüklenecektir. Bu durum da problemlere yol açacaktır. Kalıcılık birimi tanımlamasında daha sonra JPA özellikleri gelmektedir. <properties> elemanı ve içindeki pek çok <property> elemanı ile ifade edilen özellikler ya JPA’nın standart 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 16 özellikleri ya da kullanılan JPA ürününün kendine has özellikleri olarak sıralanır. <property> elemanının name ve value isimli iki özelliği vardır ve bunların aldığı değerler iki tane çift tırnak (” “) içinde ifade edilirler. Kalıcılık biriminin tanımdan aşağıya aldığımız özellikler de bu duruma uygun olarak iki ayrı tip olarak ele alınabilir. <properties>
<property name="javax.persistence.jdbc.driver"
co
m
value="org.apache.derby.jdbc.ClientDriver"/>
<property name="javax.persistence.jdbc.url"
value="jdbc:derby://localhost:1527/JPABOOK;create=true"/>
k.
<property name="javax.persistence.jdbc.user" value="app"/>
<property name="javax.persistence.jdbc.password"
oo
value="password"/>
<property name="eclipselink.logging.level.sql" value="OFF"/>
<property name="eclipselink.ddl-generation"
ab
value="create-tables"/>
<property name="eclipselink.ddl-generation.output-mode"
value="database"/>
.jp
</properties>
Kod: persistence.xml w
İlk grupta JPA’nın 2.0 sürümüyle birlikte standart hale getirilen ve Java SE ortamlarında w
kullanılan veri tabanı bağlantı bilgileri yer almaktadır. (Java EE ortamlarında veri tabanı için veri kaynağı (data source) tanımlanması gereklidir.) Dört adet olan bu bilgiler, veri tabanına ulaşmak w
için kullanılacak sürücü (driver), veri tabanı patika bilgisi (url), veri tabanı kullanıcı adı (user) ve şifresidir (password). Yukarıda verilen persistence.xml dosyasındaki son üç özellik ise kullanılan JPA ürününe has özelliklerdir ve ürüne göre değişiklik göstermektedir. Kullanmakta olduğumuz JPA gerçekleştirmesi olan EclipseLink’in özelliklerinden olan, eclipselink.logging.level.sql, EclipseLink’e çalışma zamanında üretmiş olduğu 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 17 SQL cümlelerini konsola yazmamasını bildirmektedir. EclipseLink dokümanlarına baktığınızda burada bulunan OFF değeri yerine, bilgi verilecek durumunun hassasiyetine göre sıralarsak, SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST, ALL değerlerinden birini kullanabiliriz. Örneğin kitabın örneklerini çalıştırırken üretilen SQL cümlelerini basit bir şekilde co
m
görmek için bu değeri FINE yapabilirsiniz. 2.3.1. Şema Oluşturma Yukarıda verilen persistence.xml dosyasındaki son iki özellik ise veri tabanındaki şema k.
(schema) ile ilgilidir. JPA ürünleri haklı olarak aksini onlara söylemediğiniz sürece, veri tabanında kullanıma hazır bir şema olduğunu ve bu şemanın entitylere uygun olarak oluşturulmuş oo
tablolara ile ilgili trigger, sequence vb. yapılara sahip olduğunu varsayar. Zaten olması gereken de budur; yani veri tabanı şeması ya zaten içinde verileriyle birlikte, önceden çalışan sistemleri destekleyecek şekilde hali hazırda vardır ve siz bu var olan şemaya ve verilerine karşı JPA ab
kodlarını yazıyorsunuzdur ya da entitylere uygun bir veri tabanı şeması tasarımı yapılacaktır. Dolayısıyla her halükarda veri tabanı şeması tam ya da kısmi olarak hazırdır. Fakat bu durum, JPA ile oynayarak onu öğrenmek ya da hızlıca bazı testler yapmak istediğinizde dolayısıyla da .jp
veri tabanındaki yapılarınız hazır olmadığında, önünüze problem olarak çıkar. Bu durumda JPA ürünleri sizin için şema oluşturup, entitylere uygun tablo yapılarını yaratarak size çok büyük bir yaparlar. İşte son iki satırdaki eclipselink.ddl-generation
w
iyilik eclipselink.ddl-generation.output-mode
EclipseLink’in bu amaç ve
için w
oluşturulmuş iki özelliğidir. İlk özellik olan eclipselink.ddl-generation’ın aldığı create-tables değeri w
EclipseLink’e, eğer veri tabanında gerekli tabloları ve diğer yapıları ya da kısaca şemayı, yok ise yaratmasını söylemektedir. Eğer uygun şema varsa diğer JPA ürünleri gibi EclipseLink de herhangi bir yaratma işlemi yapmaz ve var olanları kullanır; fakat şemada bir problem varsa hata verir. EclipseLink dokümanları bize create-tables değerine alternatif olarak, dropand-create-tables değerinin de özellikle test amaçlı kullanılabileceğini ve bu durumda da her çalışmada EclipseLink’in şemadaki bütün tabloları ve ilgili yapıları önce düşürüp (drop) 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 18 sonra tekrar yaratacağını, dolayısıyla da her seferinde eski verinin kaybolacağını söylemektedir. Eğer eclipselink.ddl-generation özelliği kullanılmazsa ya da varsayılan değeri olan none kullanılırsa EclipseLink, veri tabanındaki şema ile ilgili hiç bir işlem yapmayacaktır. Şema oluşturma ile ilgili ikinci özellik ise eclipselink.ddl-generation.output-
co
m
mode’dur ve aldığı değer database’dir. Bu özellik EclipseLink’e, var olan entityler ve ilgili bilgiler ışığında CREATE, DROP, ALTER vb. SQL terimlerini kullanarak oluşturacağı veri tanımlama dili (Data Definition Language, DDL) ifadelerinin hedefinin, veri tabanının kendisi olduğunu söyler. Yani database değeri, eclipselink.ddl-generation özelliğinin değeri ister create-tables isterse drop-and-create-tables olsun, şema işlemlerin hedefinin k.
veri tabanı olduğunu ifade eder. Alternatif olarak bu özelliğin değerini sql-script de yapabilirsiniz. Bu durumda EclipseLink, şema için ürettiği veri tanımlama dili ifadelerini veri oo
tabanında çalıştırmak yerine sizin için SQL kod parçası olarak üretip varsayılan durumda yeni yaratmalar için createDDL.jdbc, var olanları düşürme için ise dropDDL.jdbc isimli bir dosyaya kaydedecektir. Eğer bu dosyaların isimlerini siz belirlemek isterseniz EclipseLink’in ab
sırasıyla eclipselink.create-ddl-jdbc-file-name ve eclipselink.dropddl-jdbc-file-name isimli özelliklerini kullanabilirsiniz. Aşağıdaki örnek değerler, veri tabanında yoksa şemayı oluşturmak için verilmiştir. JPA uygulamasını bu değerlerle ilk defa .jp
çalıştırınca EclipseLink gerekli şemayı sizin için oluşturacak, sonraki seferlerde ise herhangi bir şey oluşturmayıp var olan şemayı kullanacaktır. w
<property name="eclipselink.ddl-generation" value="create-tables"/>
w
<property name="eclipselink.ddl-generation.output-mode"
value="database"/>
w
EclipseLink’e has özelliklerin listesini ve açıklamalarını, org.eclipse.persistence.config.PersistenceUnitProperties
API’sindeki sınıfında bulabilirsiniz. Hibernate ya da OpenJPA gibi farklı JPA ürünlerinin de benzer özellikleri vardır. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 19 Yukarıdaki paragraflarda tartıştığımız JPA ürünü olarak EclipseLink’in şemadaki yapıları sizin için oluşturmasıyla ilgili özellikleri, ürüne bağlı olan ayaralardır ve JPA’nın 2.1 sürümüyle birlikte bunlar ve diğer pek çok özellik standart hale getirilmiştir. JPA’nın standart özellikleri javax.persistence isim uzayında tanımlanırlar. JPA üreticileri ise kendilerine has olan uzayında tanımlayabilirler. co
m
özellikleri hala yukarıdaki EclipseLink özelliklerinde olduğu gibi ancak kendi belirledikleri isim Güzel bir gelişme olan bu standardizasyon sayesinde artık JPA ayarları çok daha taşınabilir hale gelmiştir. Bu amaçla JPA standardına yeri geldikçe detaylı olarak ele alacağımız pek çoğu ile birlikte aşağıdaki kalıcılık birimi özellikleri de eklenmiştir: Bu javax.persistence.schema-generation.database.action
özelliğin alabileceği değerler, none,
k.
•
create,
drop-and-create ve
oo
drop’dır. Bu özellik kullanılmadığında JPA, gerekli yapıların var olduğunu düşünür ve veri tabanında herhangi bir işlem yapmaz. Tahmin edebileceğiniz gibi, none varsayılan değer olup veri tabanında herhangi bir yaratma ya da düşürme ab
yapmamaktadır., dolayısıyla etkisi bu özelliğin hiç kullanılmadığı durumla aynıdır. create kullanıldığında JPA ürünü veri tabanında bulamadığı yapıları yaratır, .jp
bulduklarıyla ilgili olarak hiç bir işlem yapmaz. drop-and-create değeri varsa JPA veri tabanındaki yapıları önce düşürür sonra da yenilerini yaratır. Bu değer kullanıldığında veri tabanında veri birikmesi söz konusu olmaz, dolayısıyla bu seçeneği w
daha çok birim testleri için kullanmayı tercih edebilirsiniz. Son seçenek olan drop ise adından da anlaşılacağı üzere, var olan yapıları düşürür. Dolayısıyla bu seçenek w
sadece şemayı temizlemek için kullanılabilir, çünkü sonrasında herhangi bir veri w
tabanı işlemi yapılamaz.
•
javax.persistence.schema-generation.scripts.action
Bu özellik ise yukarıdaki özellikle aynı değerlere sahiptir ve belirtildiğinde JPA tarafından oluşturulan veri tanımlama dili SQL cümlelerini javax.persistence.schemave
generation.scripts.create-target
javax.persistence.schema-generation.scripts.drop-target
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş özelliklerinde belirtilen hedef dosyalara kaydeder. 20 Dolayısıyla javax.persistence.schema-generation.scripts.action özelliğinin aldığı değere göre create ve/veya drop hedef dosyalarının da kalıcılık biriminde belirtilmiş olmalıdır aksi taktirde JPA hata verecektir.
<persistence-unit name="ch02.01"
co
m
Bu ayarlar aşağıdaki kalıcılık biriminde tanımlanmıştır: transaction-type="RESOURCE_LOCAL">
k.
<mapping-file>META-INF/Person.xml</mapping-file>
<class>com.jpaBook.ch02.domain.Person</class>
oo
<exclude-unlisted-classes>true</exclude-unlisted-classes>
<properties>
ab
<property name="javax.persistence.jdbc.driver"
value="org.apache.derby.jdbc.ClientDriver"/>
<property name="javax.persistence.jdbc.url"
value="jdbc:derby://localhost:1527/JPABOOK;create=true"/>
.jp
<property name="javax.persistence.jdbc.user" value="app"/>
<property name="javax.persistence.jdbc.password"
w
value="password"/>
<property name="javax.persistence.schemageneration.database.action"
w
value="drop-and-create"/>
w
<property name="javax.persistence.schemageneration.scripts.action"
value="drop-and-create"/>
<property name="javax.persistence.schemageneration.scripts.create-target"
value="create.ddl"/>
<property name="javax.persistence.schemageneration.scripts.drop-target"
value="drop.ddl" />
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 21 <property name="eclipselink.logging.level.sql"
value="FINE"/>
</properties>
</persistence-unit>
Kod: persistence.xml co
m
Yukarıda da belirtildiği gibi aynı persistence.xml dosyasında birden fazla kalıcılık birimi tanımlanabilir; ama isimleri tabi olarak farklı olmalıdır; çünkü kalıcılık birimleri JPA API’sinde isimleriyle yüklenir. Dolayısıyla şu ana kadar ele aldığımız örnekler için oluşturulmuş iki farklı k.
kalıcılık birimi, ch02.00 ve ch02.01 isimleriyle persistence.xml dosyasında tanımlanmışlardır. oo
2.3.2. JPA ve Varsayılanlar ab
Burada akla doğrudan şöyle bir soru gelecektir: JPA, veri tabanında hangi bilgilerle tablo ve sütunları oluşturacak? Çünkü biz JPA’ya ne bir tablo ismi ne de sütunlarla ilgili isim, tip vb. bilgiler verdik. Bu sorunun cevabı, JPA’nın her zaman olabildiğince varsayılan (default) yapılar .jp
üzerinden çalışıyor olmasında yatmaktadır. Yani JPA, siz özellikle belirtmezseniz, sadece veri tabanındaki tablolar ve sütunları hakkında değil, pek çok gerekli konuda varsayılan bilgilere ve w
davranışa sahiptir. Bu durum JPA ile programlama yapmamızı da kolaylaştırmaktadır, özellikle de JPA’ya yeni başlamışsak ya da hızlıca bazı şeyleri ayağa kaldırmak istiyorsak. w
Varsayılan üzerinden çalışma prensibi, yukarıdaki soruya nasıl yansıyor? JPA, ister kendisi oluştursun ister var olan bir şemayı kullansın, özel olarak verilmedikçe tablo, sütun isimleri vb. w
konularda da varsayılan bilgileri kullanır. Örneğin, bir entity için gerekli olan tablonun ismi özel olarak belirtilmedikçe, entitynin ismini varsayılan tablo ismi olarak kullanır. Yukarıdaki örnekte Person entitysinin ismi PersonEntity olarak verildiğinden tablo ismi olarak da PersonEntity’yi kullanacaktır. EclipseLink eğer kendisi şema oluşturuyorsa tabloyu bu isimle oluşturacak, yok var olan bir şemayı kullanıyorsa bu isimde bir tablo arayacaktır. Sütun isimleri için de aynı varsayılan durum geçerlidir. Tablolardaki sütunların isimleri, özel olarak 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 22 belirtilmemişse, doğrudan nesnenin alanlarının isimleri olacaktır. Nesne üzerinde Id notu ya da <id> elemanı ile kimlik olarak gösterilen alan ise tablonun anahtar alanı olarak işaretlenecektir. Sütunların tipleri, tiplere uygun olarak konulabilecek uzunluk gibi bilgiler, index koymaya sebep olacak teklik (uniqueness) gibi kısıtlar, aksi belirtilmediği müddetçe hep JPA’nın varsayılan yapısı içerisinde çözümlenir. Bu anlamda JPA’nın her konudaki varsayılan davranışının co
m
ne olduğunu bilmek önemlidir. Sonuçta JPA, önce veri tabanına ulaşımı sağlayan sürücü, sonra da sürücü üzerinden veri tabanıyla haberleştiğinden, JPA’nın kontrolü dışında olan pek çok konu vardır. Örneğin tekil olması gerektiğini belirttiğiniz bir nesne alanına karşı gelen sütuna veri tabanının indeks koyması böyle bir konudur. Bu yüzden, çalıştığınız veri tabanı, ona ulaşmak için k.
kullandığınız sürücü ve nihayetinde pek tabi olarak kullandığınız JPA ürününün, JPA standardı dışındaki ek özelliklerini bilmek etkin bir JPA programlaması açısından son derece önemlidir. oo
Diğer tüm Java standartları gibi JPA da bir standart olarak farklılıkları olabildiğince soyutlamak ve programcıya basit ve kullanışlı bir arayüz sunma amacındadır. Lakin Java dışındaki dünya her zaman kolayca soyutlanabilecek seviyeden daha karmaşık olabilmektedir. ab
Örnek Uygulama: SchemaCreator1.java .jp
Örnek uygulamadaki com.jpaBook.ch02.jpa.SchemaCreator1 sınıfı, kalıcılık birimi olarak ch02.01’yi kullanarak belirtilen şema oluşturma-­‐düşürme ve ilgili SQL kodlarını oluşturma ayarlarına göre çalışmaktadır. Eğer hiç bir değişiklik yapmadan yukarıdaki w
persistence.xml ayarlarını kullanırsanız, veri tabanında varsa PERSON0201 isimli bir tablo düşürülüp tekrar oluşturulacak, bu iki işlemle ilgili SQL kodları da projenizin kökünde w
create.ddl ve drop.ddl olarak yaratılacaktır. w
Bu uygulamada SchemaCreator1 sınıfının kodlarına odaklanmak yerine şema oluşturma ayarlarına odaklanmak daha doğru bir yaklaşım olacaktır çünkü kodun detayları aşağıda ayrıntılı olarak ele alınacaktır. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 2.4.
23 Kalıcılık Birimi API’si Kalıcılık birimi arzu edilirse API’si yardımıyla dinamik olarak da oluşturulabilir yani persistence.xml dosyasına yazdığımız özellikleri çalışma zamanında geçerek JPA çalışma zamanı yapısını başlatabiliriz. Bu amaçla Java’nın özellik (properties) dosyalarını kullanabiliriz. co
m
Sağlıklı programlamanın en temel şartlarından birisi, örneğin veri tabanı bağlantı bilgileri gibi, farklı ayarlar için değişecek program sabitelerini olabildiğince dışarıdan almak ve böylece farklı ayarlar için, örneğin test için, kodu tekrar derlemeye ihtiyaç duymamaktır. Java programcıları bu amaçla java.util.Properties sınıfını kullanırlar. Bilindiği gibi, özellik dosyaları Java geleneğinde sonu “.properties” ile biter ve bu dosyalar içinde anahtar-­‐değer (key-­‐value) k.
çiftleri bulunur öyle ki Properties sınıfındaki load() metodu ile bu değerleri yükler ve oo
getProperty() metoduyla anahtarı geçip, karşı gelen değeri alırız. Kalıcılık birimini properties dosyası ile okumak istememizde, bu kitabın uygulamaları açışından en temel amacımız şudur: kitabın kodlarının, veri tabanı, JPA ürünü, şema oluşturma ab
vb. ayarlarının rahatça değişebilmesini sağlamak. Dolayısıyla kitaptan faydalanmak isteyen okuyucular, kodu değiştirmeden sadece ilgili özellikleri dosyada değiştirerek kodu kendi ortamına göre davranabilir hale getirebilirler. Bu amaçla buradan itibaren örnek uygulamalarda .jp
jpa.properties isimli bir dosya kullanacağız. Projenin kökünde olan bu dosyanın içerisine JPA’nın persistence.xml dosyasında kullandığımız özelliklerini koyup, ortamımıza uygun değerler vereceğiz. Daha sonra ilgili bölümün util paketi altındaki JPAUtil sınıfının bu w
dosyayı okuyup işlemesini ve içindeki setPersistenceUnitName() isimli metoda geçilen w
kalıcılık birimi ismini kullanarak, her çağrıldığında persistence.xml dosyasındaki ilgili kalıcılık birimi ayarlarıyla birlikte jpa.properties dosyasında tanımlanan ayarları w
yüklemesini sağlayacağız. #JPA Properties
#Please activate the suitable set of properties of your DB choice.
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 24 #JavaDB (Derby)
javax.persistence.jdbc.url=jdbc:derby://localhost:1527/JPABOOK;create=true
javax.persistence.jdbc.user=app
javax.persistence.jdbc.password=password
javax.persistence.jdbc.driver=org.apache.derby.jdbc.ClientDriver
co
m
#PostgreSQL
#javax.persistence.jdbc.url=jdbc:postgresql://localhost:5432/JPABook
#javax.persistence.jdbc.user=postgres
#javax.persistence.jdbc.password=password
#javax.persistence.jdbc.driver=org.postgresql.Driver
k.
#Oracle XE
#javax.persistence.jdbc.url=jdbc:oracle:thin:@localhost:1521:xe
oo
#javax.persistence.jdbc.user=jpabook
#javax.persistence.jdbc.password=password
ab
#javax.persistence.jdbc.driver=oracle.jdbc.driver.OracleDriver
# Schema creation settings.
javax.persistence.schema-generation.database.action=drop-and-create
#javax.persistence.schema-generation.scripts.action=drop-and-create
.jp
#javax.persistence.schema-generation.scripts.create-target=create.ddl
#javax.persistence.schema-generation.scripts.drop-target=drop.ddl
w
# EclipseLink settings
Kod: jpa.properties w
w
eclipselink.logging.level.sql=FINE
Yukarıdaki jpa.properties dosyasında görüldüğü gibi veri tabanı olarak hem Java DB (Apache Derby) hem de Oracle XE için ayarlar verilmiştir. Ayrıca şema ayarları ile EclipseLink’e özel bir ayar da burada verilmiştir. JPAUtil sınıfı ise bu ayarlardan açık olan yani başında “#” olmayan ayarları okumaktadır. Dolayısıyla persistence.xml dosyamızdaki kalıcılık birimi 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 25 tanımı son derece küçülmüştür çünkü hiç bir özellik tanımı kalmamıştır, sadece kalıcı nesne listesi vardır. <persistence-unit name="ch02.02" transaction-type="RESOURCE_LOCAL">
co
m
<class>com.jpaBook.ch02.domain.Person</class>
<exclude-unlisted-classes>true</exclude-unlisted-classes>
</persistence-unit>
Kod: persistence.xml k.
Şimdi de şu ana kadar bahsettiğimiz ayarları kullanarak JPA çalışma zamanı yapısını nasıl kavramlarını ve nesnelerini görelim. JPA’nın Temel Nesneleri ve Kavramları ab
2.5.
oo
başlatır ve veri tabanı işlemlerini yaparız sorusuna cevaplayalım. Bu amaçla JPA’nın temel Java EE 7’nin bir parçası olan JPA’nın 2.1 sürümünde toplam 4 tane paket vardır: .jp
javax.persistence, javax.persistence.criteria, javax.persistence.metamodel, javax.persistence.spi. Bu dört paketten en temeli olan javax.persistence, JPA’nın en önemli nesnelerini, enumerationlarını ve biri w
dışında tüm notlarını barındırır. Biz önce bu paketteki yapıları öğreneceğiz. w
JPA’nın temel nesneleriyle kavramlarını ve bunların arasındaki ilişkileri açıklayan çizim aşağıda verilmiştir. Buna göre JPA’nın en temel 5 nesnesi, Persistence, w
EntityManagerFactory, EntityManager, EntityTransaction ve Query’dir. Çizimde görülen diğer iki kutucuk ise bu 3 nesne arasında kullanılan iki kavramı göstermektedir ki bunlardan kalıcılık birimini (persistence unit) ayrıntılı olarak inceledik. Diğer kavram ise kalıcılık bağlamıdır (persistence context). Şimdi bu 3 nesne ile 2 kavramı ve aralarındaki ilişkileri görelim. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 26 Çizim 2.1 w
.jp
ab
oo
k.
co
m
w
2.5.1. Persistence Sınıfı Elimizde bir kalıcılık birimi var ise, bu birimin ismini kullanarak JPA çalışma zamanı yapısını w
başlatabiliriz. JPA’nın, Java SE ortamlarında, kalıcılık birimi ayarlarını okuyarak veri tabanı işlemlerini yapmamızı sağlayacak yapıyı kurgulayan nesnesi Persistence’dir. Bir başlatma (bootstrap) mekanizması olan Persistence, javax.persistence paketi içindeki tek sınıftır. Bu sınıf, üzerindeki createEntityManagerFactory()
iki tane, statik metotlarına 4 Eylül 2013 ve overloaded geçilen olan bilgilerle, 2. Bölüm Java Persistence API’sine Giriş 27 EntityManagerFactory nesnesini yaratarak, ilgili kalıcılık birimini başlatır. Bu metotların arayüzleri şöyledir: co
m
static EntityManagerFactory createEntityManagerFactory(
String persistenceUnitName)
static EntityManagerFactory createEntityManagerFactory(
String persistenceUnitName, Map properties)
k.
API: Persistence sınıfı oo
Bu metotlardan ilki sadece String olan kalıcılık birimi ismini alır, diğeri ise bu isim yanında, kalıcılık biriminin özelliklerini dinamik olarak geçmemizi sağlayan bir Map nesnesi de alır. Bu iki ab
metodun dönüş tipleri aynı yani EntityManagerFactory nesnesidir. Yine aynı pakette olan bu arayüz adından da anlaşılacağı gibi bir üretici (factory) nesnedir ve Persistence sınıfına geçilen kalıcılık biriminin ismini kullanarak, bu isim altında olan özellikler yardımıyla JPA .jp
ayarlarını tamamlar. Biz yazılım geliştiriciler Java SE ortamlarında çalışırken, kodumuzda sınıfı Persistence üzerindeki yukarıdaki iki metottan birini çağırarak EntityManagerFactory nesnesini oluştururuz sonrasında da hayat döngüsünü w
uygulamamızda yönetiriz. Bir nesneyi uygulamanın yönetmesi (application managed), o nesnenin oluşturulması, durumunun değiştirilmesi ve nihayetinde nesnenin kapatılarak w
hayatına son verilmesi vb. safhalarını içeren hayat döngüsünün, geliştirici olarak bizim w
yazdığımız kod tarafından yönetilmesi demektir. Java EE ortamlarında ise aynı nesne, içinde bulunulan Java EE kabı (Java EE container) tarafından bizim için oluşturulur ve yönetilir. Biz, bu gibi temel nesnelerin sorumluluğunu üzerimizden alan yönetilen (managed) ortamlarda JPA kullanımını görünceye kadar, sadece Java SE ortamlarına odaklanacağız. Dolayısıyla örnek uygulamamızın kullandığı PersonJpaDAO1 sınıfında, EntityManagerFactory nesnesini, ilgili “ch02.01” isimli kalıcılık birimini kullanarak 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 28 oluşturmak üzere aşağıdaki satırlar yer almıştır. Burada yapılan statik olarak tanımlanmış bir EntityManagerFactory tipindeki bir alanın, bir kereliğine çalışacak olan yine statik bir blokta başlatılmasıdır (initialization). Sonrasında çağrılacak olan nesne metotları (instance methods) başlatılan EntityManagerFactory nesnesini kullanarak EntityManager
nesnesini oluşturacaklardır, kullandıktan sonra da üzerindeki close() metodunu kullanarak co
m
kapatacaklardır. En alttaki metot da tüm veri tabanı işlemleri bittikten sonra çağrılmakta ve EntityManagerFactory nesnesi de kapatmaktadır. public class PersonJpaDAO1 implements PersonDAOI {
k.
private static EntityManagerFactory entityManagerFactory;
oo
static {
entityManagerFactory = Persistence.createEntityManagerFactory("ch02.01");
}
. . .
ab
@Override
public void savePerson(Person person) {
System.out.println("Saving person:" + person + "\n");
. . .
.jp
EntityManager em = entityManagerFactory.createEntityManager();
em.close();
w
}
@Override
w
public void close(){
entityManagerFactory.close();
}
w
. . .
}
Kod: PersonJpaDAO1.java 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 29 Yukarıdaki kod örneğinde olduğu gibi EntityManagerFactory nesnesini yaratmak için kod yazmak yerine, hem bu işi başka bir üreticiye (factory) havale etmek, hem de yukarıda bahsettiğimiz jpa.properties dosyasındaki JPA özelliklerini dinamik olarak geçmek için bütün metotları statik olan JPAUtil sınıfını devreye sokabiliriz. Önce JPAUtil sınıfının setPersistenceUnitName() metoduna bir String nesnesi olarak ilgili kalıcılık co
m
biriminin ismini geçilir. Bu metot aşağıdaki kodundan anlaşılacağı gibi hem jpa.properties dosyasındaki özellikleri hem de persistence.xml dosyasındaki ismi geçilen kalıcılık birimi özelliklerini okuyarak EntityManagerFactory nesnesini oluşturur. Yukarıdaki PersonJpaDAO1 sınıfındakine benzer şekilde de en alttaki metot, tüm veri tabanı işlemleri k.
bittikten sonra çağrılmakta ve EntityManagerFactory nesnesi kapatmaktadır. oo
public class JPAUtil {
private static String persistenceUnitName;
private static Properties properties = new Properties();
ab
private static EntityManagerFactory entityManagerFactory;
static{
try {
.jp
properties.load(new FileReader("jpa.properties"));
} catch (FileNotFoundException e) {
System.out.println("Properties file not found!");
w
} catch (IOException e) {
System.out.println("Problem when reading properties file!");
w
}
}
. . .
w
public static void setPersistenceUnitName(String persistenceUnitName){
JPAUtil.persistenceUnitName = persistenceUnitName;
entityManagerFactory = Persistence.createEntityManagerFactory(
persistenceUnitName, properties);
System.out.println("===========================================");
properties.list(System.out);
System.out.println("===========================================");
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 30 }
. . .
public static void close() {
System.out.println("=============================================");
System.out.println("Closing EntityManagerFactory.");
}
}
Kod: JPAUtil.java oo
2.5.2. EntityManagerFactory Sınıfı k.
co
m
System.out.println("=============================================");
entityManagerFactory.close();
Adından da anlaşılacağı gibi EntityManagerFactory nesnesi, EntityManager nesnelerini üreten bir sınıftır. Yukarıda açıkladığımız gibi EntityManagerFactory nesnesi ab
bir kalıcılık birimi ismi geçilerek oluşturulduğundan o birimin özelliklerini ifade eder. Yani elimizde sadece bir grup özellik varsa, bütün uygulama için bir EntityManagerFactory nesnesi yeterlidir. Birden fazla EntityManagerFactory nesnesine ihtiyaç duyacağımız .jp
ortamlar birden fazla veri tabanıyla çalışan projeler olabilir. Çünkü JPA özellikleri arasında veri tabanı bilgileri de olduğundan, uygulamada kaç tane veri tabanı var ise o kadar w
EntityManagerFactory nesnesi olması gereklidir. Bu konuya ileriki bölümlerde tekrar döneceğiz. w
Elimizde EntityManagerFactory nesnesi varsa amacımız, JPA programlamada kendisiyle en fazla haşır neşir olacağımız EntityManager nesnesine ulaşmaktır. Bu amaçla w
aşağıdaki iki metottan birini çağırırız. EntityManager
createEntityManager()
EntityManager
createEntityManager(Map map)
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 31 API: EntityManagerFactory sınıfı İlk metot hiç bir bilgi almadan, sadece EntityManagerFactory nesnesinin bildiği kalıcılık birimi ayarlarını kullanarak, ikinci metot ise Map içinde geçilen bilgileri kullanarak co
m
EntityManager nesnesini oluşturur. Bu EntityManager nesnesi, Java SE ortamları içindir ve uygulamanın yönettiği bir nesnedir. Eğer Java EE ortamında olsaydık, EntityManager nesnesi de EntityManagerFactory nesnesi gibi uygulamamız yerine kap tarafından oluşturulur ve hayat döngüsü yine bizim için kap tarafından yönetilirdi. Yukarıda da anlattığımız gibi bundan sonra uygulamalarımızda JPAUtil sınıfını dosyasına koyacağız. Sonra da k.
kullanacağız. Önce uygun ayarları jpa.properties
JPAUtil sınıfına arzu ettiğimiz kalıcılık birimi ismini setPersistenceUnitName() isimli oo
metoda geçip, getEntityManager() metodunu çağırarak, geçilen kalıcılık birimi ve dinamik JPA özellikleri ile oluşturulmuş EntityManagerFactory nesnesinden bir ab
EntityManager nesnesini alacağız. Uygulamada kalıcılık birimi ismini bir kere statik olan setPersistenceUnitName() isimli metoda geçerek sabitledikten sonra her EntityManager nesnesine ihtiyacımız olduğunda sadece getEntityManager() .jp
metodunu çağırmamız yeterli olacaktır. . . .
w
public static EntityManager getEntityManager(){
w
return entityManagerFactory.createEntityManager();
}
w
. . .
Kod: JPAUtil.java Ayrıca şunu da ekleyelim ki, EntityManagerFactory nesnesi ilk defa oluşturulduğunda, detaylarını yukarıda verdiğimiz ayarların olması durumunda, şema ile ilgili işlemler yapılır, yani verdiğiniz ayarlara göre, ya var olan şema düşürülüp yeniden oluşturulur ya da zaten şema 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 32 yoktur, baştan gerekli yapılar oluşturulur. Yukarıda verdiğimiz SchemaCreator1.java uygulaması bunu göstermektedir. Arzu edilirse, Persistence sınıfı üzerindeki API: Persistence sınıfı co
m
static void generateSchema(String persistenceUnitName, Map map)
yapılabilir. oo
Örnek Uygulama: SchemaCreator2.java k.
metodu da çağrılarak EntityManagerFactory nesnesi oluşturulmadan şema üretimi Bu örnek uygulamadaki com.jpaBook.ch02.jpa.SchemaCreator2 sınıfı, önceki uygulamadaki SchemaCreator1’deki gibi kalıcılık birimi olarak ch02.01’yi kullanarak ab
belirtilen şema oluşturma-­‐düşürme ve ilgili SQL kodlarını oluşturma ayarlarına göre çalışmaktadır. Fakat şema oluşturmak için EntityManagerFactory nesnesini oluşturmak yerine Persistence sınıfı üzerindeki generateSchema() metodunu kullanmaktadır. Eğer hiç bir yapmadan yukarıdaki .jp
değişiklik persistence.xml ayarlarını kullanırsanız, SchemaCreator1’deki gibi veri tabanında varsa PERSON0201 isimli bir tablo düşürülüp w
tekrar oluşturulacak ve bu iki işlemle ilgili SQL kodları da projenizin kökünde create.ddl ve drop.ddl olarak yaratılacaktır. w
w
2.5.3. EntityManager ve Kalıcı Nesne Hayat Döngüsü EntityManager bir arayüzdür ve kalıcı nesneler olan entitylerin hayat döngüsünü kontrol eder. EntityManager’in hayat döngüsünü yönettiği bellekteki nesnelerin bütününe, kalıcılık bağlamı (persistence context) denir. Kalıcılık bağlamı bir çalışma zamanı kavramıdır ve daima açık olan yani kapatılmamış bir EntityManager nesnesine aittir. Kalıcılık bağlamında aynı EntityManager nesnesi tarafından veri tabanına kaydedilen nesneler yanında, veri 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 33 tabanından uygulamaya getirilen nesneler de bulunur. Kalıcılık bağlamında, her bir entity sınıfından aynı kimlik bilgisine (ID) sahip sadece bir nesne ya da entity bulunabilir. Her EntityManager nesnesinin bir tane kalıcılık bağlamı bulunur ve bu bağlam, aynı EntityManager nesnesi tarafından yönetilir, dolayısıyla kalıcılık bağlamının ömrü sahibi olan co
m
EntityManager nesnesinin ömrüyle belirlenir. Yukarıda EntityManager nesnesi, kalıcı nesnelerin yani entitylerin hayat döngülerini yönetir dedik. Yani biz yazılım geliştiriciler, EntityManager’in APIsini kullanarak nesnelerimizi veri tabanına kaydeder, sonrasında oradan ister tekil olan kimlik bilgisi, isterse de sorgu yardımıyla nesnelerimizi tekrardan belleğe yükler ve ilgili kalıcılık bağlamıyla k.
ilişkilendiririz. İstersek EntityManager’in APIsini kullanarak kalıcı hale getirilmiş nesneleri veri tabanından silebiliriz. Tüm bu işlemler sırasında entitynin hayat döngüsü 3 farklı durum durumlar geçici, kalıcı ve koparılmıştır. oo
arasında gidip gelir. Bir başka deyişle entitynin hayat döngüsü 3 farklı durumu içerir. Bu Entity sınıfından yeni oluşturulan bir nesne, henüz herhangi bir kalıcılık bağlamıyla ab
ilişkilendirilmediği için, veri tabanında da yoktur. Bu duruma geçici (transient) ya da yeni (new) denir. Bu entity durum olarak geçicidir çünkü henüz veri tabanına kaydedilmemiştir yani kalıcı .jp
olmamıştır, yenidir çünkü henüz yeni oluşturulmuştur. Geçici olan bir nesne veri tabanına kaydedildiği zaman kalıcı (persistent) hale gelir. Veri tabanında kalıcı hale getirilen entity tekrar belleğe daha doğru ifadeyle kalıcılık bağlamına yüklenirse, bu entityye yapılan değişiklikler w
EntityManager tarafından otomatik olarak veri tabanına yansıtılır. Çünkü entity zaten kalıcı durumdadır, yani hem veri tabanında saklanmaktadır hem de bir kalıcılık bağlamıyla w
ilişkilendirilmiştir. w
Aşağıda EntityManager’in APIsinin ciddi bir kısmını oluşturan ve entitylerin hayat döngülerini yöneten metotlar listelenmiştir. void
persist(Object entity)
EntityTransaction
getTransaction()
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 34 <T> T
find(Class<T> entityClass, Object primaryKey)
Query createQuery(String queryString)
void
remove(Object entity)
void
close()
boolean isOpen()
k.
API: EntityManager co
m
<T> T merge(T entity)
oo
Yukarıda listelenen metotlarla birlikte EntityManager’in APIsini daha detaylı olarak ileride apayrı bir bölümde ele alacağız. Fakat o zamana kadar amacımıza yetecek kadar bu ab
metotların nasıl kullanıldığını hızlıca açıklayabiliriz. .jp
Örnek Uygulama: PersonJpaDAOTest.java Örnek uygulamadaki PersonJpaDAOTest sınıfı, ebeveyni PersonJpaDAOITest w
sınıfından devraldığı PersonDAOI arayüzü tipindeki dao isimli alanının değerini kurucusundaki atamayla PersonJpaDAO1 ya da PersonJpaDAO2 nesnesi atanabilir. w
PersonJpaDAO1 nesnesi kalıcılık birimi olarak ch02.01, PersonJpaDAO2 nesnesi ise kalıcılık birimi olarak ch02.02 kullanmaktadır. PersonJpaDAO2 nesnesi aynı zamanda w
JPAUtil sınıfı ile jpa.properties dosyasında tanımlı özellikleri de kullanmaktadır. Her iki test de veri tabanında PERSON0201 isimli bir tablo oluşturacaktır. Aşağıdaki başlıklarda ele alınacak olan konular, bu uygulamaya atıfta bulunmaktadır. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 35 2.5.4. Nesneyi Kaydetme Elimizde kalıcı olarak belirtilmiş bir sınıftan oluşturulmuş bir nesne yani entity varsa, bu nesneyi EntityManager’in persist() metoduna geçerek, o entitynin durumunun veri tabanına kaydedilmesini sağlarız. Bir başka deyişle persist() metodu, kendisine geçilen ve co
m
sınıfı kalıcı olarak belirtilmiş herhangi bir Java nesnesini veri tabanında kalıcı hale getirir. Bu durumda entitynin durumu da geçici halden kalıcı hale döner. public void savePerson(Person person) {
System.out.println("Saving person:" + person + "\n");
k.
EntityManager em = JPAUtil.getEntityManager();
EntityTransaction tx = em.getTransaction();
em.persist(person);
tx.commit();
em.close();
oo
tx.begin();
ab
System.out.println("Person saved!");
}
Kod: PersonJpaDAO2.java .jp
Yukarıdaki savePerson() metoduna geçilen Person nesnesi, JPAUtil üzerinden alınan w
EntityManager nesnesi üzerindeki persist() metodu çağrılarak, veri tabanında kalıcı hale getirilmektedir. Aynı kimlik bilgisine sahip olan bir entityyi ikinci defa aynı veri tabanına w
kaydetmek isterseniz, JPA, veri tabanından gelen ve kaydedilen nesnenin tablosundaki anahtar sütunda aynı değerden ikincisinin oluşturulmaya çalışıldığını ifade eden w
java.sql.SQLIntegrityConstraintViolationException fırlatacak ve kaydı yapmayacaktır. 2.5.5. Transactions Yukarıdaki kodda dikkatimizi çeken bir diğer nokta da EntityTransaction nesnesi ve onun üzerinde çağırılan begin() ve commit() metotlarıdır. Bildiğimiz gibi veri tabanları, 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 36 kendilerine karşı yapılan ve sakladıkları veriyi değiştiren işlemleri kalıcı kılmak için, dilimize “atomik veri tabanı işlemi” diye çevirebileceğimiz transaction olarak adlandırılan bir mekanizmaya yapıya ihtiyaç duyarlar. JPA’nın bu yapıya karşı gelen nesnesi EntityTransaction’dır. Daha detaylıca ifade edersek EntityTransaction,
javax.persistence paketindeki arayüzlerden birisi olup, tipi RESOURCE_LOCAL olan co
m
kalıcılık biriminden oluşturulmuş EntityManager nesnelerinin yaptığı transactionların kalıcı olmasını ya da geri alınmasını sağlar. begin()
void
commit()
void
rollback()
oo
void
k.
ab
API: EntityTransaction EntityManager nesnesi ile yapılan veri tabanı işlemlerinin, veri tabanında kalıcı olması için, EntityManager nesnesinden önce getTransaction() metodu ile .jp
EntityTransaction nesnesi alınmalı, daha sonra da bu nesne üzerinde begin() ve commit() metotları çağırılarak, bu iki çağrı arasında veri tabanına gönderilen değişiklikler w
kalıcı hale getirilmelidir. Eğer EntityTransaction nesnesi üzerinde begin() diyerek başlattığınız transactionın geri alınmasını yani veri tabanında kalıcı olmamasını istiyorsanız bu w
durumda commit() yerine rollback() metodunu çağırmalısınız. Üzerinde rollback() metodu çağırılan EntityTransaction nesnesi, veri tabanını, kendisiyle yapılan tüm w
değişiklikleri geri alarak, eski haline getirir. Yukarıdaki kodun sonunda, veri tabanı işlemini commit() ile kalıcı kıldıktan sonra EntityManager nesnesini close() metodunu çağırarak kapatıyoruz çünkü veri tabanına karşı yapacağımız başka bir işlem kalmamıştır. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 37 Yukarıdaki gibi veri tabanına bir değişiklik yapan JPA kodunda EntityTransaction nesnesi kullanılmazsa, veri tabanına karşı yapılan işlemlerin zaten kalıcı olmayacağını öngörüyoruz demektir. Bu durum, EntityTransaction nesnesi kullanılıp da sonunda rollback() çağrısı yapmakla, en azından şu anki bilgimiz itibariyle eş değerdir. İleride veri 2.5.6. Kimlik Bilgisi ile Nesne Getirme co
m
tabanı işlemlerini daha ayrıntılı olarak göreceğiz. Eğer veri tabanında daha önce kaydedilmiş bir entity varsa EntityManager, find() k.
metoduyla bu nesneyi bulup size geri getirir. Daha resmi bir şekilde ifade edilirse, geri getirmekten kastedilen tabi olarak, durumu veri tabanında saklanan nesnenin, kalıcılık oo
bağlamında, bu durum ile tekrardan oluşturulmasıdır; dolayısıyla veri tabanından gerçekte getirilen, entitynin daha önce saklanmış olan durumudur. Veri tabanından find() metodu ile kalıcılık bağlamına getirilen nesnenin durumu kalıcı olur. ab
Yukarıdaki arayüz bilgisinden de görüleceği gibi find() metodu iki tane argüman alır. Argümanlardan ilki entity sınıfının Class nesnesi, ikincisi ise bulunmak istenen nesnenin kimlik .jp
bilgisidir. Dolayısıyla find() metodu veri tabanında Class nesnesi verilen tipten ve geçilen kimlik bilgisine sahip bir entity bulursa bunu size geri döndürür, bulamazsa, yani veri tabanında o kimlik bilgisine sahip bir satır yoksa geriye null değerini döndürür. Bu yüzden find() w
metodunun döndüreceği nesnenin varlığından emin değilseniz, dönen referansın null olup olmadığını daima kontrol etmeniz gerekir. Biz kodumuzda bu amaçla w
NoSuchPersonFoundException isimli sıra dışı durum (exception) nesnesi kullandık. Kodda dikkatimizi çeken bir başka husus ise find() metodundan dönen referansı w
dönüştürmeye (cast) ihtiyacımızın olmamasıdır. Bunun sebebi ise JPA’ya ne tip bir nesne istediğimizi find() metoduna geçtiğimiz ve Class tipinden olan ilk argüman ile belirtmiş olmamızdır. Tahmin edebileceğiniz gibi bu argüman, muhakkak kalıcı nesne olarak belirtilmiş bir sınıfın Class nesnesi olmalıdır, aksi taktirde JPA, geçilen nesnenin kalıcı bir nesne olarak tanımlanmadığını belirterek hata verecektir. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 38 public Person retrievePerson(int id) throws NoSuchPersonFoundException {
System.out.println("Retrieving the person with id = " + id);
EntityManager em = JPAUtil.getEntityManager();
Person personRetrieved = em.find(Person.class, id);
co
m
em.close();
if (personRetrieved == null) {
throw new NoSuchPersonException(id);
} else {
return personRetrieved;
}
k.
}
Kod: PersonJpaDAO2.java oo
Yukarıdaki örnekte EntityTransaction nesnesini neden kullanmadık acaba? Çünkü, ab
kodumuz veri tabanında bir değişiklik yapmıyor dolayısıyla EntityTransaction nesnesini kullanmanın bir katkısı olmayacaktı, dolayısıyla boşuna kaynak harcamamak için bu nesneyi başlatmadık. .jp
JPA’daki en temel etkin programlama prensiplerinden ikisini son iki metotta kullanmış olduk. İlki EntityManager nesnesinin, veri tabanı bağlantısı vb. pek çok yapıyı temsil eden çok w
değerli bir nesne olduğundan dolayı, çok kısa bir ömre sahip olacak şekilde kullanmamız gerektiğidir. İhtiyacımız kalmadığında, close() metodunu çağırarak hayatına son vermeliyiz ki w
bu nesnenin tuttuğu kaynaklar, ihtiyacı olanlarca kullanılabilsin. İkincisi ise gerekmedikçe yani veri tabanına bir değişiklik yapılmıyorsa EntityTransaction nesnesini kullanmamak w
gerektiğidir. Ayrıca uygulama kapanırken ya da ihtiyacımız kalmadığında örneğin transactionları tamamen bitirip, yenisine ihtiyaç duyulmadığında EntityManagerFactory üzerindeki close() metodunu çağırarak bu nesne de kapatmalıdır. Bu durumda bu nesneden oluşturulmuş tüm EntityManager nesneleri de kapanacaktır. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 39 2.5.7. Veri Tabanından Nesne Sorgulama Peki, veri tabanından bir tane değil de birden çok entity getirmek istersek ne yapmalıyız? Bunu find() metoduyla yapamayacağımız bellidir çünkü bu metot sadece bir nesne co
m
döndürebiliyor. Veri tabanından verdiğimiz şartlara uyan bir ya da daha fazla entity getirmenin yolu sorgu (query) yazmaktır. Bu amaçla EntityManager nesnesinin createQuery() metodunu çağırıp, String tipindeki nesne sorgumuzu geçmemiz gereklidir. Bu şekilde yazılmış ve veri tabanındaki tüm Person nesnelerini getiren metot aşağıdaki gibidir: public List<Person> retrieveAllPersons() {
k.
oo
System.out.println("\nRetrieving all persons by query.");
EntityManager em = JPAUtil.getEntityManager();
Query allPersons = em.createQuery("Select p from PersonEntity p");
List<Person> persons = allPersons.getResultList();
em.close();
return persons;
.jp
}
ab
System.out.println(persons.size() + " objects:");
Kod: PersonJpaDAO2.java w
Sorgu oluşturmak için çağırdığımız EntityManager nesnesinin createQuery()
w
metodunun argüman olarak aldığı String değer, geçerli bir nesne sorgusu olmalıdır. Bu amaçla JPA’nın nesne sorgu dili, JPQL (Java Persistence Query Language) devreye girer. Yapı w
olarak SQL’e çok benzeyen JPQL’in en temel farkı, tablo ve sütun isimleri yerine entity ve alan isimlerini içermesidir. Yani nasıl SQL, veri tabanındaki tablo ve sütunları üzerinden yazılıyorsa JPQL de entity ve onun alanları üzerinden yazılır. Detaylarına daha sonra apayrı bir bölümde gireceğimiz sorguların en basiti, veri tabanından bir entitynin tüm nesneleri getirmek olabilir. SQL’de “select” ifadesi diye kısaca bahsettiğimiz seçim yapan sorgular da JPQL’de benzer şekilde “select” ifadesi olarak yazılır. Bu anlamda “Select p from PersonEntity p” sorgusu, 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 40 Person entity sınıfından oluşturularak veri tabanına kaydedilmiş tüm nesneleri seçecektir. Bu şekilde bir sorgu ile kalıcılık bağlamına getirilen tüm entityler kalıcı durumda olacaklardır. Burada dikkat edilmesi gereken bir diğer husus da Person entitysinin ismi PersonEntity olduğundan, sorguda bu ismin kullanılmış olmasıdır. Eğer sorguda co
m
PersonEntity yerine Person kullanılırsa, JPA ilgili entityyi bulamayıp hata verecektir. EntityManager nesnesinin üzerinde çağırdığımız createQuery() metodu Query tipinde bir referans döndürmektedir. Query, javax.persistence paketindeki arayüzlerden birisidir ve veri tabanına gönderilen sorguları kontrol eder. Query, temsil ettiği sorgunun tipine göre çağrılabilecek pek çok metoda sahiptir. Yukarıdaki kodda çağırdığımız getResultList()
oo
List
k.
API: javax.persistence.Query
ab
metodu, java.util.List cinsinden bir referans döndürmektedir. Dönen entitylerin tiplerinin Person olduğu bilindiğinden List torba (collection) nesnesi, Person nesnesine .jp
özel olarak List<Person> şeklinde tanımlanabilir. Bu şekilde veri tabanına gönderilen sorgunun doldurduğu List<Person> torbasından nesneleri alabiliriz. w
Metodun sonunda her zaman olduğu gibi EntityManager nesnesinin kapatıldığına ve EntityTransaction kullanılmadığına dikkat etmeliyiz. w
w
2.5.8. Entity Güncelleme EntityManager nesnesinin yönettiği kalıcılık bağlamında, durumu daha önce veri tabanına kaydedilmiş bir nesne varsa, bu nesneye yapılan değişiklikler doğrudan veri tabanına yansıtılır. Ne demek istediğimizi aşağıdaki kod üzerinden açıklayalım. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 41 public void updatePersonDOB1(Person person, Date newDob)
throws NoSuchPersonException {
System.out.println("Updating a person's date of birth. Person: " +
person + "New Date of birth: " + newDob);
EntityManager em = JPAUtil.getEntityManager();
EntityTransaction tx = em.getTransaction();
co
m
tx.begin();
int id = person.getId();
Person personRetrieved = em.find(Person.class, id);
if (personRetrieved == null) {
throw new NoSuchPersonException(person.getId());
personRetrieved.setDob(newDob);
k.
} else {
System.out.println("Person updated!");
oo
}
tx.commit();
em.close();
}
ab
Kod: PersonJpaDAO2.java .jp
Yukarıdaki updatePersonDOB1 metodunda, veri tabanından find() ile getirilen bir Person nesnesinin doğum tarihi, referansı null kontrolünden geçerse, geçilen değer ile güncelleniyor. Peki, updatePersonDOB1 metodunun hangi satırı veri tabanında ilgili nesneye w
karşılık gelen satırı güncelliyor? EntityManager ile veri tabanından belleğe getirilip kalıcılık w
bağlamına eklenen entitylerin hayat döngüsü yine EntityManager tarafından yönetilir, bu entityler de zaten kalıcı haldedirler. Hayat döngüsünü yönetmeye, entitynin durumuna yapılan w
değişikliklerin, içinde bulunulan EntityTransaction nesnesinin commit() metoduyla birlikte veri tabanına yansıtılması da dahildir. Dolayısıyla kalıcılık bağlamında bulunan nesneler, EntityTransaction tarafından takip edilir ve durumlarına yapılan değişiklikler, ilk commit() metodunda veri tabanına yansıtılacak şekilde kayıt altına alınır. Bu yüzden yukarıdaki metotta, örneğin update() ve benzeri isimde apayrı bir güncelleme metodunun çağrılmasına ihtiyaç yoktur. 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 42 JPA’da update() isimli bir metot yoktur, onun yerine merge() metodu vardır. merge() metodu, yukarıdaki arayüz bilgisinden de anlaşılacağı gibi bir entity nesnesi alır ve bir başka entity nesnesi geriye döndürür. Bu metodun çalışmasını anlamak için şöyle bir durumu düşünelim: Diyelim ki ihtiyacımız olan entity, az önce ele aldığımız retrievePerson() metoduyla veri tabanından getirildi. Bu metoda baktığınız zaman, getirilen Person nesnesini co
m
geri döndürüp EntityManager nesnesini de kapattığı görülür. EntityManager nesnesi kapatılmadan önce Person nesnesi, kalıcılık bağlamında bulunuyordu, hayat döngüsünün kalıcı halindeydi ve durumu da takip ediliyordu. Eğer EntityManager nesnesi kapatılmadan Person nesnesini güncelleseydik, ilgili transactionın commit() metodunda bu güncellemeler k.
veri tabanına yansıtılacaktı. Bu, yukarıdaki updatePersonDOB1() metodundaki durumdur. Fakat Person nesnesi, retrievePerson() metodundan geri döndürülüyor ve bu oo
metottaki EntityManager nesnesi, dolayısıyla da onun yönettiği kalıcılık bağlamı kapatılıyor. Bu durumda Person nesnesinin durumu artık herhangi bir kalıcılık bağlamı tarafından yönetilmiyor demektir çünkü açık bir EntityManager yoktur. Kalıcı durumdaki bir ab
nesne, kalıcılık bağlamıyla ilişkisi kesildiğinde, koparılmış (detached) duruma girer. Koparılmış entitylerin durumu veri tabanında kalıcı haldedir ama bellekteki durumları açık bir EntityManager almadığından, hiç bir kalıcılık bağlamına dahil değildir, dolayısıyla takip de .jp
edilmemektedir. Koparılmış haldeki nesnelerin durumlarındaki değişiklikleri veri tabanına yansıtmanın yolu bir EntityManager’in merge() metodunu çağırıp, koparılmış entityyi geçmektir. merge() metodu, koparılmış nesnenin durumunu veri tabanına yansıtacak ve w
yönetilen haldeki nesneyi geri döndürecektir. merge() metoduna geçilen nesne ise koparılmış w
olarak kalmaya devam edecek dolayısıyla da durumu takip edilmeyecektir. Dolayısıyla, merge() metodu çağırdığınızda, döndürdüğü kalıcı haldeki nesneyi alıp onu kullanmaya, w
gerekirse güncellemeye devam edebilirsiniz. public void updatePersonDOB2(Person person)
throws NoSuchPersonException {
System.out.println("Updating a person's date of birth. Person: " +
person);
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 43 EntityManager em = JPAUtil.getEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
Person updatedPerson = em.merge(person);
if (updatedPerson == null) {
} else {
System.out.println("Person updated!");
}
tx.commit();
em.close();
}
co
m
throw new NoSuchPersonException(person.getId());
k.
Kod: PersonJpaDAO2.java oo
2.5.9. Veri Tabanından Entity Silme ab
Sıradaki EntityManager metodu remove()’dır. Bu metot, bir entity nesnesi alır ve onun veri tabanından siler. Bir entitynin veri tabanından silinmesi, tabi olarak bellekten silinmesi anlamına gelmez. O nesne erişilebilir olduğu müddetçe hala bellekte kalmaya devam .jp
edecek ama kalıcılık bağlamından çıkmış olacaktır. Silinen nesneyi veri tabanından örneğin find() metoduyla getirmeye çalışsak, bu metot bize null döndürecektir. w
public void deletePerson(Person person) {
w
System.out.println("Deleting a person:" + person);
EntityManager em = JPAUtil.getEntityManager();
w
tx.begin();
Person personToDelete = em.find(Person.class, person.getId());
if (personToDelete == null) {
throw new NoSuchPersonException(person.getId());
} else {
em.remove(personToDelete);
System.out.println("Person deleted!");
}
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 44 tx.commit();
em.close();
}
Kod: PersonJpaDAO2.java co
m
Fark ettiğiniz gibi yukarıdaki kodda EntityTransaction kullanılmıştır çünkü EntityManager üzerinde çağırdığımız remove() metodu veri tabanında değişiklik yapmaktadır. EntityManager nesnesinin değerli kaynakları kullanan bir nesne olduğundan k.
bahsetmiştik. Bu yüzden bu nesnenin ömrünü olabildiğince kısa tutmamız gerektiğinden ihtiyacımız kalmadığında üzerindeki close() metodunu çağırarak bu nesneyi kapatmalıyız. EntityManager
nesnesi üzerinde çağıracağınız oo
Kapatılan pek çok metot IllegalStateException sıra dışı durum fırlatacaktır. Bu durumun istisnalarından birisi isOpen() metodudur ve boolean değer döndürmektedir. Bir EntityManager
ab
nesnesinin açık olup olmadığını bildiren bu metot tabi olarak close() metodunun çağrılmasından sonra false döndürecektir. .jp
w
w
w
4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 2.6.
•
45 Bölüm Özeti Bu bölümde JPA’nın temellerine giriş yapıldı. Önce kalıcı nesne kavramı ve mekanizması, JPA’nın temel ayarları ve bunların arasında şema oluşturma ve dinamik JPA ayarları ele alındı. Sonrasında JPA’nın temel nesneleri kısaca açıklandı ve co
m
EntityManager’i kullanarak kalıcı nesnelerin hayat döngüsünün nasıl yönetileceği ele alındı. •
Öncelikle bir sınıfın, kendisinden üretilen nesnelerin JPA tarafından veri tabanında kalıcı hale getirilebilmesi için Entity notuyla notlandırılması ya da <entity> elemanıyla betimlenmesi gerektiğini, bunu yaparken de name özelliğini k.
kullanılabileceği ifade edildi. Bu şekilde belirtilmiş olan sınıflara entity ya da kalıcı •
oo
sınıf/nesne denir. JPA’nın ayarları kalıcılık birimi (persistence unit) isimli kavramsal yapının parçası olup temelde persistence.xml isimli dosyada tanımlanır. Bir name ve ab
transaction-type özelliklerine sahip olan <persistence-unit> elemanı içerisinde <properties> elemanı içerisinde <property> elemanı ile JPA’nın standart özellikleri yanında, kullanılan JPA gerçekleştirmesine has özellikler de .jp
belirtilebilir. Arzu edilirse özellikler JPA’nın API’sini kullanarak da çalışma zamanında geçilebilir. Bu amaçla bu kitapta jpa.properties özellik dosyası ve JPAUtil w
isimli statik metotlara sahip bir sınıf kullanılmaktadır. •
Persistence, EntityManagerFactory, EntityManager, w
EntityTransaction ve Query, JPA’nın en temel beş nesnesidir. Bu nesnelerden Persistence, kendisine geçilen kalıcılık birimi ismi ve gerektiğinde dinamik w
özellikler ile, bir JPA EntityManagerFactory EntityManagerFactory
ve ilgili veri nesnesini tabanı ayarlarını oluşturmak için temsil eden kullanılır. kalıcı nesnelerin hayat döngülerini kontrol eden metotlara sahip olan ve kendisinden EntityTransaction ve Query gibi diğer iki önemli nesne elde edilen EntityManager isimli, temelde bir veri tabanı 4 Eylül 2013 2. Bölüm Java Persistence API’sine Giriş 46 bağlantısıyla kalıcılık bağlamı isimli ikinci önemli kavramı temsil eden bir nesne elde edilir. •
EntityManager JPA’nın en önemli nesnesi olup, kalıcı nesnelerin veri tabanına kaydedilmesi, veri tabanından sorgulanıp, kalıcılık bağlamına geri getirilmesi ve co
m
oradaki durumunun takip edilmesi, veri tabanından silinmesi işlemlerini yapan metotlara sahiptir. w
w
w
.jp
ab
oo
k.
4 Eylül 2013
