JPA nedir? Java Persistence API'ye Giriş

Bir belirtim olarak, Java Persistence API kalıcılık ile ilgilenir; bu, Java nesnelerinin kendilerini oluşturan uygulama sürecinden daha uzun yaşadığı herhangi bir mekanizma anlamına gelir. Tüm Java nesnelerinin kalıcı olması gerekmez, ancak çoğu uygulama temel iş nesnelerini korur. JPA spesifikasyonu, hangi nesnelerin kalıcı olması gerektiğini ve bu nesnelerin Java uygulamalarınızda nasıl kalması gerektiğini tanımlamanıza olanak tanır .

JPA kendi başına bir araç veya çerçeve değildir; daha ziyade, herhangi bir araç veya çerçeve tarafından uygulanabilecek bir dizi kavramı tanımlar. JPA'nın nesne-ilişkisel haritalama (ORM) modeli başlangıçta Hibernate'e dayanıyor olsa da, o zamandan beri gelişti. Benzer şekilde, JPA başlangıçta ilişkisel / SQL veritabanları ile kullanılmak üzere tasarlanmışken, bazı JPA uygulamaları NoSQL veri depolarıyla kullanılmak üzere genişletilmiştir. NoSQL ile JPA destekleyen popüler bir çerçeve, JPA 2.2 için referans uygulama olan EclipseLink'tir.

Jakarta EE'de JPA 2.2

Java Persistence API ilk olarak Java EE 5'te EJB 3.0 spesifikasyonunun (JSR 220) bir alt kümesi olarak piyasaya sürüldü. O zamandan beri Java EE 6'da (JSR 317) JPA 2.0 sürümünden başlayarak kendi spesifikasyonu olarak gelişti. Bu yazı itibariyle, Jakarta EE'nin bir parçası olarak JPA 2.2'nin devamı için kabul edilmiştir.

JPA ve Hazırda Bekletme

İç içe geçmiş geçmişleri nedeniyle, Hibernate ve JPA sıklıkla birbirine karıştırılır. Bununla birlikte, Java Servlet belirtimi gibi, JPA da birçok uyumlu araç ve çerçeve üretmiştir; Hazırda bekletme bunlardan sadece biri.

Gavin King tarafından geliştirilen ve 2002'nin başlarında piyasaya sürülen Hibernate, Java için bir ORM kitaplığıdır. King, kalıcılık için varlık fasulyelerine alternatif olarak Hibernate'i geliştirdi. Çerçeve o kadar popülerdi ve o zamanlar o kadar gerekliydi ki fikirlerinin çoğu ilk JPA spesifikasyonunda benimsendi ve kodlandı.

Bugün, Hibernate ORM, en olgun JPA uygulamalarından biridir ve Java'da ORM için hala popüler bir seçenektir. Hibernate ORM 5.3.8 (bu yazının mevcut sürümü) JPA 2.2'yi uygular. Ayrıca, Hibernate'in araç ailesi, NoSQL için alan modeli kalıcılığını destekleyen Hazırda Bekletme Araması, Hazırda Bekletme Doğrulayıcısı ve Hazırda Beklet OGM gibi popüler araçları içerecek şekilde genişledi.

JPA ve EJB

Daha önce belirtildiği gibi, JPA, EJB 3.0'ın bir alt kümesi olarak tanıtıldı, ancak o zamandan beri kendi spesifikasyonu olarak gelişti. EJB, JPA'dan farklı odağa sahip bir spesifikasyondur ve bir EJB konteynerinde uygulanır. Her EJB konteyneri, JPA spesifikasyonu ile tanımlanan bir kalıcılık katmanı içerir.

Java ORM nedir?

Yürütmede farklılık gösterse de, her JPA uygulaması bir tür ORM katmanı sağlar. JPA ve JPA uyumlu araçları anlamak için, ORM hakkında iyi bir kavrayışa sahip olmanız gerekir.

Nesne-ilişkisel haritalama, geliştiricilerin manuel olarak yapmaktan kaçınmak için iyi nedenlere sahip olduğu bir görevdir . Hibernate ORM veya EclipseLink gibi bir çerçeve, bu görevi bir kitaplık veya çerçeve, bir ORM katmanı olarak kodlar . Uygulama mimarisinin bir parçası olarak ORM katmanı, yazılım nesnelerinin ilişkisel bir veritabanındaki tablolar ve sütunlarla etkileşime girecek şekilde dönüştürülmesinden sorumludur. Java'da ORM katmanı, Java sınıflarını ve nesnelerini ilişkisel bir veritabanında depolanabilmeleri ve yönetilebilmeleri için dönüştürür.

Varsayılan olarak, kalıcı olan nesnenin adı tablonun adı olur ve alanlar sütun haline gelir. Tablo oluşturulduktan sonra, her tablo satırı uygulamadaki bir nesneye karşılık gelir. Nesne eşleme yapılandırılabilir, ancak varsayılanlar iyi çalışma eğilimindedir.

NoSQL ile JPA

Oldukça yakın zamana kadar, ilişkisel olmayan veritabanları alışılmadık bir meraktı. NoSQL hareketi tüm bunları değiştirdi ve şimdi Java geliştiricileri için çeşitli NoSQL veritabanları mevcuttur. Hibernate OGM ve EclipseLink dahil olmak üzere bazı JPA uygulamaları NoSQL'i kapsayacak şekilde gelişti.

Şekil 1, JPA ve ORM katmanının uygulama geliştirmedeki rolünü göstermektedir.

JavaWorld /

Java ORM katmanını yapılandırma

JPA kullanmak için yeni bir proje kurduğunuzda, veri deposunu ve JPA sağlayıcısını yapılandırmanız gerekecektir. Seçtiğiniz veritabanına (SQL veya NoSQL) bağlanmak için bir veri deposu bağlayıcısı yapılandıracaksınız . Hibernate veya EclipseLink gibi bir çerçeve olan JPA sağlayıcısını da dahil edecek ve yapılandıracaksınız . JPA'yı manuel olarak yapılandırabilseniz de, birçok geliştirici Spring'in kullanıma hazır desteğini kullanmayı tercih ediyor. Hem manuel hem de Yay tabanlı JPA kurulum ve kurulumunun bir gösterimi için aşağıdaki " JPA kurulumu ve kurulumu " bölümüne bakın.

Java Veri Nesneleri

Java Data Objects, esas olarak nesnede kalıcılık mantığını desteklemesi ve ilişkisel olmayan veri depolarıyla çalışma için uzun süredir devam eden desteği ile JPA'dan farklı olan standartlaştırılmış bir kalıcılık çerçevesidir. JPA ve JDO, JDO sağlayıcıları da sıklıkla JPA'yı destekleyecek kadar benzerdir. JPA ve JDBC gibi diğer kalıcılık standartlarıyla ilişkili olarak JDO hakkında daha fazla bilgi edinmek için Apache JDO Projesine bakın.

Java'da veri kalıcılığı

Bir programlama perspektifinden, ORM katmanı bir adaptör katmanıdır : nesne grafiklerinin dilini SQL diline ve ilişkisel tablolara uyarlar. ORM katmanı, nesne yönelimli geliştiricilerin, nesne yönelimli paradigmadan hiç ayrılmadan verileri kalıcı hale getiren yazılımlar oluşturmasına olanak tanır.

JPA kullandığınızda , veri deposundan uygulamanızın veri modeli nesnelerine bir harita oluşturursunuz . Nesnelerin nasıl kaydedildiğini ve geri alındığını tanımlamak yerine, nesneler ve veritabanınız arasındaki eşlemeyi tanımlar, ardından bunları sürdürmek için JPA'yı çağırırsınız. İlişkisel bir veritabanı kullanıyorsanız, uygulama kodunuz ile veritabanı arasındaki gerçek bağlantının çoğu, Java Veritabanı Bağlantı API'si olan JDBC tarafından işlenecektir.

Bir spesifikasyon olarak JPA, nesneler ve veritabanı arasındaki eşlemeyi tanımlamak için kullandığınız meta veri açıklamalarını sağlar . Her JPA uygulaması, JPA ek açıklamaları için kendi motorunu sağlar. JPA spec de sağlar PersistanceManagerveya EntityManager(iş mantığı kodu nedir eşleştirilmiş nesnelerle yapmak sistemini anlatır burada) JPA sistemi ile temas temel noktalar şunlardır hangi.

Tüm bunları daha somut hale getirmek için, bir müzisyeni modellemek için basit bir veri sınıfı olan Liste 1'i düşünün.

Liste 1. Java'da basit bir veri sınıfı

 public class Musician { private Long id; private String name; private Instrument mainInstrument; private ArrayList performances = new ArrayList(); public Musician( Long id, String name){ /* constructor setters... */ } public void setName(String name){ this.name = name; } public String getName(){ return this.name; } public void setMainInstrument(Instrument instr){ this.instrument = instr; } public Instrument getMainInstrument(){ return this.instrument; } // ...Other getters and setters... } 

MusicianListesinde 1 sınıf tutma veri sağlamak için kullanılır. Ad alanı gibi ilkel verileri içerebilir . Ayrıca mainInstrumentve gibi diğer sınıflarla ilişkileri de tutabilir performances.

Musicianbireyin varlığının nedeni verileri içeren etmektir. Bu sınıf türü bazen bir DTO veya veri aktarım nesnesi olarak bilinir . DTO'lar, yazılım geliştirmenin ortak bir özelliğidir. Pek çok türde veriyi tutsalar da herhangi bir iş mantığı içermezler. Veri nesnelerini kalıcı hale getirmek, yazılım geliştirmede her yerde karşılaşılan bir zorluktur.

JDBC ile veri kalıcılığı

Musicianİlişkisel bir veritabanına sınıfın bir örneğini kaydetmenin bir yolu , JDBC kitaplığını kullanmaktır. JDBC, bir uygulamanın temeldeki veritabanı uygulamasını düşünmeden SQL komutları vermesine izin veren bir soyutlama katmanıdır.

Liste 2, MusicianJDBC kullanarak sınıfı nasıl devam ettirebileceğinizi gösterir.

Liste 2. JDBC kayıt ekleme

 Musician georgeHarrison = new Musician(0, "George Harrison"); String myDriver = "org.gjt.mm.mysql.Driver"; String myUrl = "jdbc:mysql://localhost/test"; Class.forName(myDriver); Connection conn = DriverManager.getConnection(myUrl, "root", ""); String query = " insert into users (id, name) values (?, ?)"; PreparedStatement preparedStmt = conn.prepareStatement(query); preparedStmt.setInt (1, 0); preparedStmt.setString (2, "George Harrison"); preparedStmt.setString (2, "Rubble"); preparedStmt.execute(); conn.close(); // Error handling removed for brevity 

Liste 2'deki kod oldukça kendi kendini belgelendiriyor. georgeHarrisonNesne yerde (göndermek ön uç, dış hizmet, vs.) gelebilir ve bunun kimliği ve adı alanları belirledi. Nesne üzerindeki alanlar daha sonra bir SQL insertifadesinin değerlerini sağlamak için kullanılır . ( PreparedStatementSınıf, değerleri bir SQL sorgusuna güvenli bir şekilde uygulamak için bir yol sunan JDBC'nin bir parçasıdır.)

JDBC, manuel konfigürasyonla gelen kontrole izin verirken, JPA ile karşılaştırıldığında hantaldır. Veritabanını değiştirmek için, önce Java nesnenizden ilişkisel bir veritabanındaki tablolarla eşleşen bir SQL sorgusu oluşturmanız gerekir. Daha sonra, bir nesne imzası her değiştiğinde SQL'i değiştirmeniz gerekir. JDBC ile SQL'i korumak başlı başına bir görev haline gelir.

JPA ile veri kalıcılığı

Şimdi MusicianJPA kullanarak sınıfı sürdürdüğümüz Liste 3'ü düşünün .

Liste 3. JPA ile George Harrison Kalıcı

 Musician georgeHarrison = new Musician(0, "George Harrison"); musicianManager.save(georgeHarrison); 

Liste 3, Liste 2'deki manuel SQL'i tek bir satırla değiştirir ve session.save()bu da JPA'ya nesneyi sürdürmesi talimatını verir. O andan itibaren, SQL dönüşümü çerçeve tarafından ele alınır, böylece nesne yönelimli paradigmayı asla terk etmek zorunda kalmazsınız.

JPA'daki meta veri ek açıklamaları

Liste 3'teki sihir, JPA'nın ek açıklamaları kullanılarak oluşturulan bir yapılandırmanın sonucudur . Geliştiriciler, JPA'ya hangi nesnelerin kalıcı olması gerektiğini ve nasıl sürdürülmesi gerektiğini bildirmek için ek açıklamaları kullanır.

Liste 4, Musiciansınıfı tek bir JPA notuyla gösterir.

Liste 4. JPA'nın @Entity ek açıklaması

 @Entity public class Musician { // ..class body } 

Persistent objects are sometimes called entities. Attaching @Entity to a class like Musician informs JPA that this class and its objects should be persisted.

XML vs. annotation-based configuration

JPA also supports using external XML files, instead of annotations, to define class metadata. But why would you do that to yourself?

Configuring JPA

Like most modern frameworks, JPA embraces coding by convention (also known as convention over configuration), in which the framework provides a default configuration based on industry best practices. As one example, a class named Musician would be mapped by default to a database table called Musician.

The conventional configuration is a timesaver, and in many cases it works well enough. It is also possible to customize your JPA configuration. As an example, you could use JPA's @Table annotation to specify the table where the Musician class should be stored.

Listing 5. JPA's @Table annotation

 @Entity @Table(name="musician") public class Musician { // ..class body } 

Listing 5 tells JPA to persist the entity (Musician class) to the musician table.

Primary key

In JPA, the primary key is the field used to uniquely identify each object in the database. The primary key is useful for referencing and relating objects to other entities. Whenever you store an object in a table, you will also specify the field to use as its primary key.

In Listing 6, we tell JPA what field to use as Musician's primary key.

Listing 6. Specifying the primary key

 @Entity public class Musician { @Id private Long id; 

In this case, we've used JPA's @Id annotation to specify the id field as Musician's primary key. By default, this configuration assumes the primary key will be set by the database--for instance, when the field is set to auto-increment on the table.

JPA supports other strategies for generating an object's primary key. It also has annotations for changing individual field names. In general, JPA is flexible enough to adapt to any persistence mapping you might need.

CRUD operations

Once you've mapped a class to a database table and established its primary key, you have everything you need to create, retrieve, delete, and update that class in the database. Calling session.save() will create or update the specified class, depending on whether the primary-key field is null or applies to en existing entity. Calling entityManager.remove() will delete the specified class.

Entity relationships in JPA

Simply persisting an object with a primitive field is only half the equation. JPA also has the capability to manage entities in relation to one another. Four kinds of entity relationships are possible in both tables and objects:

    1. One-to-many
    2. Many-to-one
    3. Many-to-many
    4. One-to-one

Each type of relationship describes how an entity relates to other entities. For example, the Musician entity could have a one-to-many relationship with Performance, an entity represented by a collection such as List or Set.

If the Musician included a Band field, the relationship between these entities could be many-to-one, implying collection of Musicians on the single Band class. (Assuming each musician only performs in a single band.)

If Musician included a BandMates field, that could represent a many-to-many relationship with other Musician entities.

Son olarak, Musicianbir olabilir bire bir ilişki bir ile Quoteünlü bir alıntı temsil etmek için kullanılan bir varlık,: Quote famousQuote = new Quote().

İlişki türlerini tanımlama

JPA, ilişki eşleme türlerinin her biri için ek açıklamalara sahiptir. Liste 7, Musicianve Performances arasındaki bire çok ilişkisine nasıl açıklama ekleyebileceğinizi gösterir .

Liste 7. Bire çok ilişkiye açıklama ekleme