2. Bölüm Java Persistence API sine Giriş. 2. Bölüm Java Persistence API sine Giriş... 1

Transkript

1 2. Bölüm Java Persistence API sine Giriş 1 2. Bölüm Java Persistence API sine Giriş 2. Bölüm Java Persistence API sine Giriş Giriş Entity ya da Kalıcı Nesne Entitynin Özellikleri Kalıcılık Birimi (Persistence Unit) ve Ayarları Şema Oluşturma JPA ve Varsayılanlar Kalıcılık Birimi API si JPA nın Temel Nesneleri ve Kavramları Persistence Sınıfı EntityManagerFactory Sınıfı EntityManager ve Kalıcı Nesne Hayat Döngüsü Nesneyi Kaydetme Transactions Kimlik Bilgisi ile Nesne Getirme Veri Tabanından Nesne Sorgulama Entity Güncelleme Veri Tabanından Entity Silme Bölüm Özeti... 45

2 2. Bölüm Java Persistence API sine Giriş Giriş 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 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 tutan kısımlarından olacak. Hedefimiz bu bölümün sonunda temel seviyede JPA ile program yazabilir hale gelmektir Entity ya da Kalıcı Nesne 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ı. 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 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 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

3 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 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 olmayacağını ileride detaylıca ele alacağız ama şu anda varsayılan durumda bir entitynin tüm alanlarının kalıcı olduğunu söyleyerek yetinelim. 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, 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 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 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 dışında herhangi bir yapıya bağımlılıkları yoktur. Bu durum JPA nın bir kolaylığıdır çünkü Java 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 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 işareti getirilerek kullanılır. Bir sınıfın nesnelerinin entity olduğunu belirtmek için kullanacağımız not ise Entity dir 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. package com.jpabook.ch02.domain; import java.util.date; import public class Person private int id; private String firstname; private String lastname; private Date dob; public Person() { public Person(int id, String firstname, String lastname, Date dob){ this.id = id; this.firstname = firstname; this.lastname = lastname; this.dob = dob;... Kod: Person.java

5 2. Bölüm Java Persistence API sine Giriş 5 Yukarıdaki Person sınıfı, sınıf tanımından önce notu ile nesnelerinin hayat döngüsü JPA tarafından yönetilecek bir kalıcı sınıf olarak tanımlanmış notunun sadece bir tane isteğe bağlı, yani kullanılması zorunlu olmayan özelliği (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 notuyla entitynin ismi PersonEntity olarak belirlenmiş olur. Aşağıdaki kod parçalarında bu iki durum public class Person public class Person {... Kod: Person.java 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 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

6 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. 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=" xmlns:xsi=" xsi:schemalocation=" version="2.0"> <description>jpa Book, CH02</description> <package>com.jpabook.ch02.domain</package> <entity class="person" name="personentity"> <table name="persons0201" /> <attributes> <id name="id"> </id> <column name="id"/> <basic name="firstname"> </basic> <column name="firstname" length="30" /> <basic name="lastname"> <column name="lastname" length="50" /> </basic> <basic name="dob"> <column name="dateofbirth" /> <temporal>date</temporal> </basic> </attributes> </entity> </entity-mappings> Kod: Person.xml

7 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 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 notuyla notlandırılması ya da ilgili XML dosyasında <entity> elemanı içinde class özelliği 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 ile 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 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 Entitynin Özellikleri Bir sınıfın JPA nın şartlarına uygun bir entity olabilmesi için başka şartlar da vardır. Bunları 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) 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.

8 2. Bölüm Java Persistence API sine Giriş 8 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 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 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) 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 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 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() ve hashcode() metotlarını tekrar tanımlamamız (override), daha kaliteli geliştirme açısından önemlidir. 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

9 2. Bölüm Java Persistence API sine Giriş 9 public class Person private int id; private String firstname; private String lastname; private Date dob; public Person() { public Person(int id, String firstname, String lastname, Date dob) { this.id = id; this.firstname = firstname; this.lastname = lastname; this.dob = dob; public Person(int id, String firstname, String lastname) { this(id, firstname, lastname, null); public int getid() { return id; public void setid(int id) { this.id = id; public String getfirstname() { return firstname; public void setfirstname(string firstname) { this.firstname = firstname; public String getlastname() { return lastname;

10 2. Bölüm Java Persistence API sine Giriş 10 public void setlastname(string lastname) { this.lastname = lastname; public Date getdob() { return dob; public void setdob(date dob) { this.dob = dob; public java.sql.date getdobassqldate() { return new public int hashcode() { final int prime = 31; int result = 1; result = prime * result + ((firstname == null)? 0 : firstname.hashcode()); result = prime * result + id; result = prime * result + ((lastname == null)? 0 : return result; public boolean equals(object obj) { if (this == obj) return true; if (obj == null) return false; if (getclass()!= obj.getclass())

11 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; else if (!firstname.equals(other.firstname)) return false; if (id!= other.id) return false; if (lastname == null) { if (other.lastname!= null) return false; else if (!lastname.equals(other.lastname)) return false; return public String tostring() { return "Person [id=" + id + ", firstname=" + firstname + ", lastname=" + lastname + ", dob=" + dob + "]"; Kod: Person.java 2.3. Kalıcılık Birimi (Persistence Unit) ve Ayarları JPA ile ilgili bir diğer önemli yapı ise kalıcılık birimi dir (persistence unit). Kalıcılık birimi, 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

12 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.... <persistence-unit name="ch02.00" transaction-type="resource_local"> <provider>org.eclipse.persistence.jpa.persistenceprovider <mapping-file>meta-inf/person.xml</mapping-file> <class>com.jpabook.ch02.domain.person</class> </provider> <exclude-unlisted-classes>true</exclude-unlisted-classes> <properties> <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"/> <property name="javax.persistence.jdbc.user" value="app"/> <property name="javax.persistence.jdbc.password" value="password"/> <property name="eclipselink.logging.level.sql" value="off" /> <property name="eclipselink.ddl-generation" value="create-tables" /> <property name="eclipselink.create-ddl-jdbc-file-name" 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>...

13 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 <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 transactiontype. 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 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ğı 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 (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. 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 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 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.

14 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. <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ı 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 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 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. Kalıcılık birim tanımı ayrıca farklı eşleştirme dosyalarını listeleyebilir. Örneğin, <mapping-file>meta-inf/person.xml </mapping-file> satırı, META-INF dosyasındaki Person.xml isimli bir eşleştirme dosyasını göstermektedir. 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ı

15 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> <exclude-unlisted-classes>true</exclude-unlisted-classes> kısmı gelmektedir. Bu satırlar, JPA ya, sadece burada listelenen entityleri yüklemesini, 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, projenin sınıf- yolunu 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ı 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 <exclude-unlisted-classes>true</exclude-unlisted-classes> gibi bir satırla, burada listelenmeyen başka entitylerin yüklenmemesini sağlayabilirsiniz. Bu satırı 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 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-unlistedclasses> 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

16 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" value="org.apache.derby.jdbc.clientdriver"/> <property name="javax.persistence.jdbc.url" value="jdbc:derby://localhost:1527/jpabook;create=true"/> <property name="javax.persistence.jdbc.user" value="app"/> <property name="javax.persistence.jdbc.password" value="password"/> <property name="eclipselink.logging.level.sql" value="off"/> <property name="eclipselink.ddl-generation" value="create-tables"/> <property name="eclipselink.ddl-generation.output-mode" </properties> value="database"/> Kod: persistence.xml İlk grupta JPA nın 2.0 sürümüyle birlikte standart hale getirilen ve Java SE ortamlarında 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 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

17 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 görmek için bu değeri FINE yapabilirsiniz Şema Oluşturma Yukarıda verilen persistence.xml dosyasındaki son iki özellik ise veri tabanındaki şema (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ş 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 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 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 iyilik yaparlar. İşte son iki satırdaki eclipselink.ddl-generation ve eclipselink.ddl-generation.output-mode EclipseLink in bu amaç için oluşturulmuş iki özelliğidir. İlk özellik olan eclipselink.ddl-generation ın aldığı create-tables değeri 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)

18 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.outputmode 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 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 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 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 ç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. <property name="eclipselink.ddl-generation" value="create-tables"/> <property name="eclipselink.ddl-generation.output-mode" value="database"/> EclipseLink e has özelliklerin listesini ve açıklamalarını, API sindeki org.eclipse.persistence.config.persistenceunitproperties sınıfında bulabilirsiniz. Hibernate ya da OpenJPA gibi farklı JPA ürünlerinin de benzer özellikleri vardır.

19 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 özellikleri hala yukarıdaki EclipseLink özelliklerinde olduğu gibi ancak kendi belirledikleri isim uzayında tanımlayabilirler. 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: javax.persistence.schema-generation.database.action Bu özelliğin alabileceği değerler, none, create, drop-and-create ve 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 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, 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 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 sadece şemayı temizlemek için kullanılabilir, çünkü sonrasında herhangi bir veri 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.schemageneration.scripts.create-target ve javax.persistence.schema-generation.scripts.drop-target

20 2. Bölüm Java Persistence API sine Giriş 20 özelliklerinde belirtilen hedef dosyalara kaydeder. 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. Bu ayarlar aşağıdaki kalıcılık biriminde tanımlanmıştır: <persistence-unit name="ch02.01" transaction-type="resource_local"> <mapping-file>meta-inf/person.xml</mapping-file> <class>com.jpabook.ch02.domain.person</class> <exclude-unlisted-classes>true</exclude-unlisted-classes> <properties> <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"/> <property name="javax.persistence.jdbc.user" value="app"/> <property name="javax.persistence.jdbc.password" value="password"/> <property name="javax.persistence.schema- generation.database.action" value="drop-and-create"/> <property name="javax.persistence.schema- generation.scripts.action" value="drop-and-create"/> <property name="javax.persistence.schema- generation.scripts.create-target" value="create.ddl"/> <property name="javax.persistence.schemageneration.scripts.drop-target" value="drop.ddl" />

21 2. Bölüm Java Persistence API sine Giriş 21 <property name="eclipselink.logging.level.sql" value="fine"/> </properties> </persistence-unit> Kod: persistence.xml 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ı kalıcılık birimi, ch02.00 ve ch02.01 isimleriyle persistence.xml dosyasında tanımlanmışlardır JPA ve Varsayılanlar 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 ü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 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. 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. 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

22 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 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 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. 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. Örnek Uygulama: SchemaCreator1.java Ö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 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 create.ddl ve drop.ddl olarak yaratılacaktır. 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.

23 2.4. Kalıcılık Birimi API si 2. Bölüm Java Persistence API sine Giriş 23 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. 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) çiftleri bulunur öyle ki Properties sınıfındaki load() metodu ile bu değerleri yükler ve 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 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 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 dosyayı okuyup işlemesini ve içindeki setpersistenceunitname() isimli metoda geçilen 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ı yüklemesini sağlayacağız. #JPA Properties #Please activate the suitable set of properties of your DB choice.

24 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 #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 #Oracle XE #javax.persistence.jdbc.user=jpabook #javax.persistence.jdbc.password=password #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 #javax.persistence.schema-generation.scripts.create-target=create.ddl #javax.persistence.schema-generation.scripts.drop-target=drop.ddl # EclipseLink settings eclipselink.logging.level.sql=fine Kod: jpa.properties 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

25 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"> <class>com.jpabook.ch02.domain.person</class> <exclude-unlisted-classes>true</exclude-unlisted-classes> </persistence-unit> Kod: persistence.xml Şimdi de şu ana kadar bahsettiğimiz ayarları kullanarak JPA çalışma zamanı yapısını nasıl başlatır ve veri tabanı işlemlerini yaparız sorusuna cevaplayalım. Bu amaçla JPA nın temel kavramlarını ve nesnelerini görelim JPA nın Temel Nesneleri ve Kavramları Java EE 7 nin bir parçası olan JPA nın 2.1 sürümünde toplam 4 tane paket vardır: 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 dışında tüm notlarını barındırır. Biz önce bu paketteki yapıları öğreneceğiz. 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, 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.

26 2. Bölüm Java Persistence API sine Giriş Persistence Sınıfı Çizim 2.1 Elimizde bir kalıcılık birimi var ise, bu birimin ismini kullanarak JPA çalışma zamanı yapısını 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 iki tane, statik ve overloaded olan createentitymanagerfactory() metotlarına geçilen bilgilerle,

27 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: static EntityManagerFactory createentitymanagerfactory( String persistenceunitname) static EntityManagerFactory createentitymanagerfactory( String persistenceunitname, Map properties) API: Persistence sınıfı 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 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 ayarlarını tamamlar. Biz yazılım geliştiriciler Java SE ortamlarında çalışırken, kodumuzda Persistence sınıfı üzerindeki yukarıdaki iki metottan birini çağırarak EntityManagerFactory nesnesini oluştururuz sonrasında da hayat döngüsünü 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 hayatına son verilmesi vb. safhalarını içeren hayat döngüsünün, geliştirici olarak bizim 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

28 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 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 { private static EntityManagerFactory entitymanagerfactory; static { entitymanagerfactory = public void saveperson(person person) { System.out.println("Saving person:" + person + "\n"); EntityManager em = entitymanagerfactory.createentitymanager();... public void close(){ entitymanagerfactory.close();... Kod: PersonJpaDAO1.java

29 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 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 bittikten sonra çağrılmakta ve EntityManagerFactory nesnesi kapatmaktadır. public class JPAUtil { private static String persistenceunitname; private static Properties properties = new Properties(); private static EntityManagerFactory entitymanagerfactory; static{ try { properties.load(new FileReader("jpa.properties")); catch (FileNotFoundException e) { System.out.println("Properties file not found!"); catch (IOException e) { System.out.println("Problem when reading properties file!");... public static void setpersistenceunitname(string persistenceunitname){ JPAUtil.persistenceUnitName = persistenceunitname; entitymanagerfactory = Persistence.createEntityManagerFactory( persistenceunitname, properties); System.out.println("==========================================="); properties.list(system.out); System.out.println("===========================================");

30 2. Bölüm Java Persistence API sine Giriş public static void close() { System.out.println("============================================="); System.out.println("Closing EntityManagerFactory."); System.out.println("============================================="); entitymanagerfactory.close(); Kod: JPAUtil.java EntityManagerFactory Sınıfı 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 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 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 EntityManagerFactory nesnesi olması gereklidir. Bu konuya ileriki bölümlerde tekrar döneceğiz. 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 aşağıdaki iki metottan birini çağırırız. EntityManager createentitymanager() EntityManager createentitymanager(map map)

31 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 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ı kullanacağız. Önce uygun ayarları jpa.properties dosyasına koyacağız. Sonra da JPAUtil sınıfına arzu ettiğimiz kalıcılık birimi ismini setpersistenceunitname() isimli metoda geçip, getentitymanager() metodunu çağırarak, geçilen kalıcılık birimi ve dinamik JPA özellikleri ile oluşturulmuş EntityManagerFactory nesnesinden bir 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() metodunu çağırmamız yeterli olacaktır.... public static EntityManager getentitymanager(){... return entitymanagerfactory.createentitymanager(); 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

32 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 static void generateschema(string persistenceunitname, Map map) API: Persistence sınıfı metodu da çağrılarak EntityManagerFactory nesnesi oluşturulmadan şema üretimi yapılabilir. Örnek Uygulama: SchemaCreator2.java 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 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 değişiklik yapmadan yukarıdaki persistence.xml ayarlarını kullanırsanız, SchemaCreator1 deki gibi veri tabanında varsa PERSON0201 isimli bir tablo düşürülüp 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 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

33 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 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 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 arasında gidip gelir. Bir başka deyişle entitynin hayat döngüsü 3 farklı durumu içerir. Bu durumlar geçici, kalıcı ve koparılmıştır. Entity sınıfından yeni oluşturulan bir nesne, henüz herhangi bir kalıcılık bağlamıyla 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ı 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 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 ilişkilendirilmiştir. 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()

34 2. Bölüm Java Persistence API sine Giriş 34 <T> T find(class<t> entityclass, Object primarykey) Query createquery(string querystring) <T> T merge(t entity) void remove(object entity) void close() boolean isopen() API: EntityManager 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 metotların nasıl kullanıldığını hızlıca açıklayabiliriz. Örnek Uygulama: PersonJpaDAOTest.java Örnek uygulamadaki PersonJpaDAOTest sınıfı, ebeveyni PersonJpaDAOITest sınıfından devraldığı PersonDAOI arayüzü tipindeki dao isimli alanının değerini kurucusundaki atamayla PersonJpaDAO1 ya da PersonJpaDAO2 nesnesi atanabilir. 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 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.

35 2. Bölüm Java Persistence API sine Giriş 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 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"); EntityManager em = JPAUtil.getEntityManager(); EntityTransaction tx = em.gettransaction(); tx.begin(); em.persist(person); tx.commit(); em.close(); System.out.println("Person saved!"); Kod: PersonJpaDAO2.java Yukarıdaki saveperson() metoduna geçilen Person nesnesi, JPAUtil üzerinden alınan 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 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 java.sql.sqlintegrityconstraintviolationexception fırlatacak ve kaydı yapmayacaktır 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ı,

36 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 kalıcılık biriminden oluşturulmuş EntityManager nesnelerinin yaptığı transactionların kalıcı olmasını ya da geri alınmasını sağlar. void begin() void commit() void rollback() 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 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 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 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 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.

37 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 tabanı işlemlerini daha ayrıntılı olarak göreceğiz Kimlik Bilgisi ile Nesne Getirme Eğer veri tabanında daha önce kaydedilmiş bir entity varsa EntityManager, find() 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 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. 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 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() 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 NoSuchPersonFoundException isimli sıra dışı durum (exception) nesnesi kullandık. Kodda dikkatimizi çeken bir başka husus ise find() metodundan dönen referansı 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.

38 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); em.close(); if (personretrieved == null) { throw new NoSuchPersonException(id); else { return personretrieved; Kod: PersonJpaDAO2.java Yukarıdaki örnekte EntityTransaction nesnesini neden kullanmadık acaba? Çünkü, 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. 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 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 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 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.

39 2. Bölüm Java Persistence API sine Giriş 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 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() { 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(); System.out.println(persons.size() + " objects:"); em.close(); return persons; Kod: PersonJpaDAO2.java Sorgu oluşturmak için çağırdığımız EntityManager nesnesinin createquery() 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ı 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,

40 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 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 List getresultlist() API: javax.persistence.query 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 özel olarak List<Person> şeklinde tanımlanabilir. Bu şekilde veri tabanına gönderilen sorgunun doldurduğu List<Person> torbasından nesneleri alabiliriz. Metodun sonunda her zaman olduğu gibi EntityManager nesnesinin kapatıldığına ve EntityTransaction kullanılmadığına dikkat etmeliyiz 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.

41 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(); tx.begin(); int id = person.getid(); Person personretrieved = em.find(person.class, id); if (personretrieved == null) { throw new NoSuchPersonException(person.getId()); else { personretrieved.setdob(newdob); System.out.println("Person updated!"); tx.commit(); em.close(); Kod: PersonJpaDAO2.java 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 karşılık gelen satırı güncelliyor? EntityManager ile veri tabanından belleğe getirilip kalıcılık 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 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.

42 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 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 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 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 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 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 yönetilen haldeki nesneyi geri döndürecektir. merge() metoduna geçilen nesne ise koparılmış 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, gerekirse güncellemeye devam edebilirsiniz. public void updatepersondob2(person person) throws NoSuchPersonException { System.out.println("Updating a person's date of birth. Person: " + person);

43 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) { throw new NoSuchPersonException(person.getId()); else { System.out.println("Person updated!"); tx.commit(); em.close(); Kod: PersonJpaDAO2.java Veri Tabanından Entity Silme 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 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. public void deleteperson(person person) { System.out.println("Deleting a person:" + person); EntityManager em = JPAUtil.getEntityManager(); 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!");

44 2. Bölüm Java Persistence API sine Giriş 44 tx.commit(); em.close(); Kod: PersonJpaDAO2.java 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 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. Kapatılan EntityManager nesnesi üzerinde çağıracağınız 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 nesnesinin açık olup olmadığını bildiren bu metot tabi olarak close() metodunun çağrılmasından sonra false döndürecektir.

45 2. Bölüm Java Persistence API sine Giriş 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 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 kullanılabileceği ifade edildi. Bu şekilde belirtilmiş olan sınıflara entity ya da kalıcı 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 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 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 isimli statik metotlara sahip bir sınıf kullanılmaktadır. Persistence, EntityManagerFactory, EntityManager, 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 özellikler ile, bir JPA ve ilgili veri tabanı ayarlarını temsil eden EntityManagerFactory nesnesini oluşturmak için kullanılır. EntityManagerFactory 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ı

46 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 oradaki durumunun takip edilmesi, veri tabanından silinmesi işlemlerini yapan metotlara sahiptir.