Uygulamalar
Oyun
Yazılım
Yardım
Dota 2
LOL
Silkroad
WOT
Point Blank
Diğer
Yeni
Eski
Haber
Pazar
asp & .net
java
c# c++
python
php
Diğer
Windows
Donanım
Linux
Güvenlik
Program
Modeller
Destek
14-11-2017, Saat: 01:35
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
Kod:
EntityManagergibi 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
Kod:
EntityManagerile 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.
2.2 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, “varlık” gibi, söylendiğinde hiç bir şey ifade etmeyen, akla ilgili hiç bir şey getirmeyen bir karşılık bulabiliriz. 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. Aslında ikinci anlam için kalıcı sınıf da kullanılabilir. Coğunlukla, 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 durumuna 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.
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 kullanılır. Bir sınıfın nesnelerinin entity olduğunu belirtmek için kullanacağımız not ise Entity’dir ve
olarak nitelediği sınıfın tanımından önce kullanılır. XML ile ayar yapıldığında ise
elemanı kullanılır.
Kod:
@Entityolarak nitelediği sınıfın tanımından önce kullanılır. XML ile ayar yapıldığında ise
Kod:
<entity>elemanı kullanılır.
package com.jpaBook.ch02.domain;
import java.util.Date;
import javax.persistence.Entity;
@Entity(name="PersonEntity")
public class Person {
@Id
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
Yukarıdaki
sınıfı, sınıf tanımından önce kullanılan
notu ile nesnelerinin hayat döngüsü JPA tarafından yönetilecek bir kalıcı sınıf olarak tanımlanmış olur.
Kod:
Personsınıfı, sınıf tanımından önce kullanılan
Kod:
@Entitynotu ile nesnelerinin hayat döngüsü JPA tarafından yönetilecek bir kalıcı sınıf olarak tanımlanmış olur.
Kod:
@Entitynotunun sadece bir tane isteğe bağlı, yani kullanılması zorunlu olmayan özelliği vardır. String tipinde ve
Kod:
nameisminde 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
Kod:
com.jpaBook.ch02.domain.Personolan sınıfın yalın ismi
Kod:
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
Kod:
@Entity(name="PersonEntity")notuyla entitynin ismi
Kod:
PersonEntityolarak belirlenmiş olur. Aşağıdaki kod parçalarında bu iki durum gösterilmiştir.
public class Person { . . . }
@Entity(name="PersonEntity")
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 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ı
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:
Kod:
Personsı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"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi
chemaLocation="http://java.sun.com/xml/ns/persistence/ormhttp://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">
<table name="PERSONS0201" />
<attributes>
<id name="id">
<column name="ID"/>
</id>
<basic name="firstName">
<column name="FIRSTNAME" length="30" />
</basic>
<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
XML kodunda görüldüğü gibi
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
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.
Kod:
<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
Kod:
<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 ya
notuyla notlandırılması ya da ilgili XML dosyasında
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 ya
ile notlandırılmış ya da XML kullanımında
elemanı ile belirlenmiş ve veri tabanındaki ana anahtar (ya da kısaca anahtar) alana karşılık gelen bir alanı olmak zorundadır.
Kod:
@Entitynotuyla notlandırılması ya da ilgili XML dosyasında
Kod:
<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 ya
Kod:
@Idile notlandırılmış ya da XML kullanımında
Kod:
<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.
2.2.1 Entitynin ÖzellikleriBir 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. - 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.
