.png)
JPA, nesne yönelimli programlama yaklaşımını veritabanı işlemlerine uygulayarak, veritabanı işlemlerini daha anlaşılır ve bakımı daha kolay hale getirir. JPA, veritabanı tabloları ve Java sınıfları arasındaki ilişkileri yönetmek için kullanılan JPA işaretçileri sayesinde birçok veritabanı işlemini otomatikleştirir.
JPA ile veritabanı işlemlerini gerçekleştirmek için Entity Manager nesnesini kullanabilirsiniz. Entity Manager, veritabanı işlemlerini gerçekleştirmek için kullanılan bir nesnedir. EntityManager, JPA'nın sağladığı API'leri kullanarak veritabanı işlemlerini gerçekleştirir. EntityManager, veritabanı tablolarındaki kayıtları işlemek için CRUD işlemlerini (Create, Read, Update, Delete) destekler.
JPA, Entity sınıflarını kullanarak veritabanı tabloları ve Java sınıfları arasındaki ilişkileri yönetir. Bir Entity sınıfı, bir veritabanı tablosuna karşılık gelir. Entity sınıflarında, veritabanı tablosundaki her sütun bir özellik (property) olarak tanımlanır. Entity sınıflarında tanımlanan özellikler, veritabanındaki sütunlarla eşleştirilir.
JPA işaretçileri, veritabanı işlemleri için kullanılan özel işaretçilerdir. Bu işaretçileri kullanarak, bir Entity sınıfının bir veritabanı tablosuna karşılık geldiğini belirtebilirsiniz. Ayrıca, bir Entity sınıfındaki bir özelliğin bir veritabanı sütununa karşılık geldiğini belirtebilirsiniz.
JPA, bir veritabanından veri almak için JPQL (Java Persistence Query Language) adında özel bir sorgu dilini de destekler. JPQL, SQL benzeri bir sorgu dilidir. JPQL, bir Entity Manager üzerinden çalışır ve veritabanından veri çekmek için kullanılır.
JPA'nın avantajları arasında veritabanı işlemlerinin daha kolay ve anlaşılır hale getirilmesi, nesne yönelimli programlama yaklaşımının veritabanı işlemlerine uygulanması, ORM araçlarının desteklenmesi, JPQL'nin kullanımı ve daha az kod yazımı gibi konular yer alır.
JPA, veritabanı işlemlerinin daha kolay ve anlaşılır hale getirilmesi, daha az kod yazma ihtiyacı ve veritabanı işlemlerinin daha hızlı gerçekleştirilmesi gibi avantajları nedeniyle Java programlama dili için popüler bir ORM aracıdır. JPA (Java Persistence API), Java programlama dilinde bir ORM (Object-Relational Mapping) aracıdır. ORM araçları, veritabanı işlemlerini gerçekleştirmek için kullanılan SQL (Structured Query Language) sorgularını yazmak yerine, Java nesneleri arasındaki ilişkileri kullanarak veritabanı işlemlerini gerçekleştirmeyi mümkün kılar.
JPA, özellikle Java EE (Enterprise Edition) uygulamalarında kullanılmak üzere tasarlanmıştır. JPA'nın temel amacı, veritabanı tabloları ve Java sınıfları arasındaki ilişkileri yönetmektir. Bu sayede, veritabanı işlemleri için kullanılan SQL sorgularını yazmak zorunda kalmadan, Java kodu üzerinden veritabanı işlemlerini gerçekleştirebilirsiniz.
JPA, JDBC (Java Database Connectivity) kütüphanesine dayanır. Ancak, JDBC'de olduğu gibi doğrudan SQL sorguları yazmak yerine, JPA'da veritabanı işlemleri için bir Entity Manager kullanılır. Entity Manager, veritabanı işlemlerini gerçekleştirmek için kullanılan bir nesnedir. Veritabanı işlemleri, Entity Manager aracılığıyla gerçekleştirilir.
JPA'nın en büyük avantajlarından biri, nesne yönelimli programlama yaklaşımının veritabanı işlemlerine uygulanmasıdır. Bu sayede, veritabanı işlemleri için kullanılan kodların daha anlaşılır ve bakımı daha kolay olur. Ayrıca, veritabanı tabloları ve Java sınıfları arasındaki ilişkileri yönetmek için kullanılan JPA işaretçileri (annotations) sayesinde, birçok veritabanı işlemi otomatikleştirilir.
JPA, farklı ORM (Object-Relational Mapping) araçlarını destekler. Hibernate, EclipseLink ve OpenJPA gibi farklı ORM araçları, JPA'nın desteği altındadır. Bu sayede, bir uygulamanın veri tabanı işlemlerini yönetmek için kullanılan Hibernate veya EclipseLink gibi bir ORM aracını değiştirerek JPA'ya geçebilirsiniz.
JPA ayrıca, bir veritabanından veri almak için JPQL (Java Persistence Query Language) adında özel bir sorgu dilini de destekler. JPQL, SQL benzeri bir sorgu dilidir, ancak Java sınıfları ve JPA işaretçileri kullanarak veritabanından veri çekmeyi mümkün kılar.
Sonuç olarak, JPA, Java programlama dili için veritabanı işlemlerini yönetmek için kullanılan bir ORM aracıdır. JPA, JDBC kütüphanesine dayanır ve veritabanı işlemleri için Entity Manager nesnesini kullanır.
PA (Java Persistence API) işaretçileri, Java sınıfları ve veritabanı tabloları arasındaki ilişkileri tanımlamak için kullanılan özel işaretçilerdir
- @Entity: Bir Java sınıfının bir veritabanı tablosuna karşılık geldiğini belirtir.
- @Table: Bir Java sınıfının hangi veritabanı tablosuna karşılık geldiğini belirtir.
- @Id: Bir sınıf özelliğinin bir veritabanı tablosundaki birincil anahtar (primary key) sütunu olduğunu belirtir.
- @GeneratedValue: Birincil anahtar sütununun nasıl oluşturulacağını belirler.
- @Column: Bir sınıf özelliğinin bir veritabanı sütunu olduğunu belirtir.
- @Basic: Bir sınıf özelliğinin basit bir veritabanı sütunu olduğunu belirtir.
- @Temporal: Bir tarih veya zaman özelliğinin veritabanındaki tarih veya zaman sütunlarına nasıl eşleneceğini belirler.
- @Transient: Bir sınıf özelliğinin veritabanına kaydedilmemesi gerektiğini belirtir.
- @OneToOne: Bir sınıfın diğer bir sınıf ile bir-bir ilişkisi olduğunu belirtir.
- @OneToMany: Bir sınıfın diğer bir sınıf ile bir-çok ilişkisi olduğunu belirtir.
- @ManyToOne: Bir sınıfın diğer bir sınıf ile çok-bir ilişkisi olduğunu belirtir.
- @ManyToMany: İki sınıf arasında birçok-çok ilişkisi olduğunu belirtir.
- @JoinColumn: İki sınıf arasındaki ilişkide kullanılacak veritabanı sütununu belirtir.
- @JoinTable: İki sınıf arasındaki ilişki için kullanılacak ortak bir tablonun adını belirtir.
- @Index: Bir veritabanı tablosunda bir indeksin tanımlanmasını sağlar.
- @NamedQuery: Bir JPQL (Java Persistence Query Language) sorgusunun adını ve sorgusunu tanımlar.
- @NamedQueries: Birden fazla @NamedQuery tanımlar.
- @QueryHint: Bir JPQL sorgusu için veritabanı yönetim sistemine yönelik bir ipucu sağlar.
- @SqlResultSetMapping: SQL sorguları tarafından döndürülen sonuçların nasıl eşleneceğini belirler.
- @Cacheable: Bir sınıfın ve/veya bir sınıf özelliğinin önbelleğe alınması gerektiğini belirtir.
- @Cache: Bir önbellek için yapılandırma bilgilerini sağlar.
- @ElementCollection: Bir sınıf özelliğinin bir koleksiyon olarak tutulacağını belirtir.
- @Embedded: Bir sınıf özelliğinin başka bir sınıfın özellikleriyle birleştirileceğini belirtir.
- @Embeddable: Bir sınıfın diğer bir sınıfın özelliği olarak kullanılabileceğini belirtir.
- @AttributeOverride: @Embedded sınıfının özelliklerinin nasıl eşleneceğini belirler.
- @AttributeOverrides: Birden fazla @AttributeOverride tanımlar.
- @Transient: Bir sınıf özelliğinin geçici olduğunu ve veritabanına kaydedilmemesi gerektiğini belirtir.
- @Version: Bir sınıfın optimistik kilitlemesini belirtir.
- @Access: Bir sınıf özelliğinin nasıl erişilebileceğini belirtir.
- @DiscriminatorColumn: Kalıtımlı sınıfların nasıl ayırt edileceğini belirler.
- @DiscriminatorValue: Bir kalıtımlı sınıfın değerini belirler.
- @Inheritance: Kalıtım stratejisini belirler.
- @NamedQuery: JPQL sorgularının adını ve sorgusunu tanımlar.
- @NamedQueries: Birden fazla @NamedQuery tanımlar.
- @SecondaryTable: Bir sınıfın birincil tablosuna ek olarak kullanılacak bir veya daha fazla tablonun adını belirtir.
- @SecondaryTables: Birden fazla @SecondaryTable tanımlar.
- @SequenceGenerator: Bir sınıfın birincil anahtarının nasıl oluşturulacağını belirler.
- @TableGenerator: Bir sınıfın birincil anahtarının nasıl oluşturulacağını belirler.
- @ExcludeSuperclassListeners: Bir sınıfın ana sınıfının olay dinleyicilerinin kullanılmamasını belirtir.
- @ExcludeDefaultListeners: Bir sınıfın varsayılan olay dinleyicilerinin kullanılmamasını belirtir.
- @EntityListeners: Bir sınıfın olay dinleyicilerini belirtir.
- @PrePersist: Bir sınıf örneği kalıcı hale getirilmeden önce çalışacak işlemi belirtir.
- @PostPersist: Bir sınıf örneği kalıcı hale getirildikten sonra çalışacak işlemi belirtir.
- @PreUpdate: Bir sınıf örneği güncellenmeden önce çalışacak işlemi belirtir.
- @PostUpdate: Bir sınıf örneği güncellendikten sonra çalışacak işlemi belirtir.
- @PreRemove: Bir sınıf örneği silinmeden önce çalışacak işlemi belirtir.
- @PostRemove: Bir sınıf örneği silindikten sonra çalışacak işlemi belirtir.
- @PostLoad: Bir sınıf örneği veritabanından yüklendikten sonra çalışacak işlemi belirtir.
- @MapKeyColumn: Bir harita sınıfının anahtar sütununun adını belirtir.
- @MapKeyJoinColumn: Bir harita sınıfının anahtar sütununu belirleyen bir join column oluşturur.
- @OrderBy: Bir koleksiyonun veya sıralı bir haritanın nasıl sıralanacağını belirler.
- @Lob: Bir sınıf özelliğinin büyük verileri tutmak için kullanılabileceğini belirtir.
- @NamedNativeQuery: Native SQL sorgularının adını ve sorgusunu tanımlar.
- @NamedNativeQueries: Birden fazla @NamedNativeQuery tanımlar.
- @SqlResultSetMappings: Native SQL sorguları tarafından döndürülen sonuçların nasıl eşleneceğini belirler.
- @SqlResultSetMapping: Bir SQL sonucu kümesinin bir sınıfa nasıl eşleneceğini belirtir.
- @Convert: Bir sınıf özelliğinin veritabanına nasıl dönüştürüleceğini belirler.
- @Converter: Bir dönüştürücü sınıfını belirtir.
- @AttributeConverter: Bir sınıf özelliğinin nasıl dönüştürüleceğini belirleyen bir dönüştürücü sınıfını belirtir.
- @ElementCollection: Bir sınıf özelliğinin bir koleksiyon olarak tutulacağını belirtir.
- @CollectionTable: Bir @ElementCollection için tablo ismini belirler.
- @AssociationOverride: Kalıtım hiyerarşisinde bir ilişkiyi geçersiz kılar.
- @AttributeOverride: Bir gömülü sınıfın veya bir sınıfın özelliklerinin nasıl eşleneceğini belirler.
- @BatchSize: Hibernate tarafından kullanılan önbellekleme için yüksek bir sayı belirtir.
- @Proxy: Hibernate tarafından kullanılan proxy'lerin davranışını belirler.
- @NaturalId: Bir sınıf özelliğinin doğal bir kimlik olduğunu belirtir.
- @NaturalIdCache: Bir doğal kimlik için önbellekleme bilgilerini sağlar.
- @Immutable: Bir sınıfın değiştirilemez olduğunu belirtir.
- @Filter: Bir sınıfın veya koleksiyonun dinamik olarak filtrelenmesine izin verir.
- @Filters: Birden fazla @Filter tanımlar.
- @TypeDef: Bir özel tip tanımlar.
- @Type: Bir sınıf özelliğinin özel bir tiple ilişkili olduğunu belirtir.
- @Loader: Bir ilişki yükleyicisini belirtir.
- @FetchProfile: Bir yük profili tanımlar.
- @PersistenceContext: Bir EntityManager referansı almak için kullanılır.
- @PersistenceUnit: Bir EntityManagerFactory referansı almak için kullanılır.
- @Enumerated: Bir özellik için belirtilen enum tipinin nasıl eşleneceğini belirler.
- @SequenceGenerator: Bir sınıfın birincil anahtarının nasıl oluşturulacağını belirler.
JPA yaşam döngüsü, şu aşamalardan oluşur:
- Yeni nesne oluşturma: Bir nesne oluşturulduğunda, bu nesne henüz JPA yönetimi altında değildir. Bu aşamada nesne "new" durumundadır.
- Yönetilen durum: Bir EntityManager tarafından yönetilen bir nesne oluşturulduğunda, JPA tarafından yönetilen bir duruma girer. Bu aşamada nesne "managed" durumundadır.
- Yönetilen durumda değişiklikler: Yönetilen bir nesnedeki değişiklikler, otomatik olarak EntityManager tarafından izlenir ve veritabanına yansıtılır. Bu aşamada nesne "managed" durumunda kalır.
- Yönetilen durumdan ayrılma: EntityManager'dan çıkarılan bir nesne, "detached" duruma geçer. Detached durumdaki nesne, EntityManager tarafından yönetilmemekte ve veritabanında değişiklikler yansıtılmamaktadır.
- Yönetilen duruma geri getirme: EntityManager tarafından yönetilmeyen bir nesne, EntityManager tarafından tekrar yönetilen bir nesne haline getirilebilir. Bu durumda nesne tekrar "managed" durumuna geçer.
- Silme: EntityManager tarafından yönetilen bir nesne silindiğinde, nesne "removed" durumuna geçer.
- Veritabanına kaydetme: EntityManager tarafından yönetilen bir nesne veritabanına kaydedildiğinde, nesne "persistent" durumuna geçer.
- Veritabanından silme: EntityManager tarafından yönetilen bir nesne veritabanından silindiğinde, nesne "transient" durumuna geçer.
JPA yaşam döngüsü, EntityManager nesnesinin yönettiği nesnelerin her birinde gerçekleşir ve JPA özelliklerini kullanarak nesnenin durumunu izler. Bu süreç, JPA entegrasyonu olan herhangi bir uygulama tarafından kullanılabilir ve nesnelerin veritabanı ile etkileşimini yönetmek için çok önemlidir.
Hibernate, bir JPA (Java Persistence API) uygulamasıdır ve JPA yaşam döngüsünü takip eder. Hibernate'in yaşam döngüsü, bir nesnenin oluşturulmasından, veritabanına kaydedilmesine ve nihayetinde veritabanından silinmesine kadar geçen süreçleri kapsar. Hibernate yaşam döngüsü, bir Hibernate uygulamasında kullanılabilir.
Hibernate yaşam döngüsü, şu aşamalardan oluşur:
- Yeni nesne oluşturma: Bir nesne oluşturulduğunda, bu nesne henüz Hibernate yönetimi altında değildir. Bu aşamada nesne "transient" durumundadır.
- Kalıcı nesne: Bir nesne Hibernate tarafından yönetildiğinde, Hibernate tarafından yönetilen bir duruma girer. Bu aşamada nesne "persistent" durumundadır.
- Yönetilen durumda değişiklikler: Yönetilen bir nesnedeki değişiklikler, Hibernate tarafından izlenir ve veritabanına yansıtılır. Bu aşamada nesne "persistent" durumunda kalır.
- Yönetilen durumdan ayrılma: Session'dan çıkarılan bir nesne, "detached" duruma geçer. Detached durumdaki nesne, Hibernate tarafından yönetilmemekte ve veritabanında değişiklikler yansıtılmamaktadır.
- Ayrılmış durum için kullanılan yöntemler şunlardır:
session.evict(e);
session.clear();
session.close();
// Transient State
Employee e = new Employee("Neha Shri Rudra", 21, 180103);
// Persistent State
session.save(e);
// Detached State
session.close(); 5.Silme: Session tarafından yönetilen bir nesne silindiğinde, nesne "removed" durumuna geçer.
6.Veritabanına kaydetme: Session tarafından yönetilen bir nesne veritabanına kaydedildiğinde, nesne "persistent" durumuna geçer
7.Veritabanından silme: Session tarafından yönetilen bir nesne veritabanından silindiğinde, nesne "transient" durumuna geçer.
Hibernate yaşam döngüsü, Session nesnesinin yönettiği nesnelerin her birinde gerçekleşir ve Hibernate özelliklerini kullanarak nesnenin durumunu izler. Bu süreç, Hibernate entegrasyonu olan herhangi bir uygulama tarafından kullanılabilir ve nesnelerin veritabanı ile etkileşimini yönetmek için çok önemlidir.
Hibernate'de persistent durumunda olan nesnelerdeki değişiklikler, Hibernate tarafından otomatik olarak takip edilir ve veritabanına yansıtılır. Ancak bu işlem, bir işlem sırasında farklı noktalarda gerçekleşebilir.
Genellikle, bir Hibernate işlemi, bir transaction (işlem) içinde gerçekleştirilir. Bir transaction içinde, nesnelerin veritabanına yansıtılması tam olarak kontrol edilebilir. Bir transaction içinde, veritabanındaki herhangi bir değişiklik (oluşturma, güncelleme, silme vb.) geri alınabilir.
Persistent nesnelerde yapılan değişiklikler, transaction'in commit (onaylama) işlemi gerçekleştirildiğinde veritabanına yansıtılır. Örneğin, bir nesne üzerinde yapılan değişiklikler, Session'ın flush() metodu çağrıldığında, transaction commit edildiğinde veya Session kapatıldığında veritabanına yansıtılır.
Hibernate, bir Session içindeki tüm persistent nesneleri otomatik olarak takip eder ve değişiklikleri otomatik olarak veritabanına yansıtır. Bu sayede, geliştiricinin değişiklikleri elle takip etmesine gerek yoktur.
Ancak, bazı durumlarda, bazı değişikliklerin otomatik olarak veritabanına yansıtılmasını istemeyebilirsiniz. Bu durumlarda, Session'ın setFlushMode() metodu kullanılarak flush mode (sıfırlama modu) ayarlanabilir. Bu modda, otomatik flush işlemi devre dışı bırakılabilir veya flush işlemi, geliştiricinin belirlediği bir zaman diliminde gerçekleştirilebilir.
Özetle, Hibernate'de persistent durumunda olan nesnelerde yapılan değişiklikler, Session'ın flush işlemi gerçekleştirdiği anda veya transaction commit edildiğinde veritabanına yansıtılır. Ancak, Session'ın flush modu ayarlanarak, flush işlemi geciktirilebilir veya devre dışı bırakılabilir.
Hibernate'de flush() metodunu veya commit() metodunu çağırmazsam nesne yine de veritabanına kaydedilir mi?
Hibernate'de flush() veya commit() metotlarının çağrılmaması durumunda, Hibernate otomatik olarak bir flush işlemi gerçekleştirir. Bu flush işlemi, nesnenin veritabanına kaydedilmesini sağlar.
Ancak, otomatik flush işleminin zamanlaması, bir Session'in flush moduna bağlıdır. Hibernate'de flush modu, Session'ın flush işleminin ne zaman gerçekleştirileceğini kontrol eder. Varsayılan olarak, Hibernate, transaction commit edildiğinde veya bir sorgu çalıştırıldığında otomatik flush işlemi gerçekleştirir.
Ancak, flush modu değiştirilerek flush işlemi zamanlaması kontrol edilebilir. Örneğin, Session'ın setFlushMode() metodu kullanılarak FlushModeType.MANUAL moduna ayarlandığında, otomatik flush işlemi devre dışı bırakılır. Bu durumda, nesnenin veritabanına kaydedilmesi için flush() metodu çağrılması gerekir.
Özetle, Hibernate'de, Session'ın flush() veya commit() metotları çağrılmadığında bile, Hibernate otomatik olarak bir flush işlemi gerçekleştirir ve nesnenin veritabanına kaydedilmesini sağlar. Ancak, flush modu değiştirilerek flush işlemi zamanlaması kontrol edilebilir ve flush() metodu çağrılmadan önce veritabanına kaydetmek için flush işlemi manuel olarak gerçekleştirilmelidir.
Hibernate'de removed state'inde bulunan bir nesne veritabanından otomatik olarak silinir mi?
Hibernate'de removed state'inde bulunan bir nesne, veritabanından otomatik olarak silinmez. Removed state, sadece nesnenin Hibernate tarafından veritabanından silinmek üzere işaretlendiği durumdur. Nesnenin veritabanından silinmesi için, işaretlenmiş olmasına rağmen, Hibernate tarafından bir delete işlemi gerçekleştirilmesi gerekir.
Removed state'e geçirilen bir nesne, Session tarafından yönetilen nesneler listesinden kaldırılır ve Hibernate tarafından veritabanından silinmek üzere işaretlenir. Bu, nesnenin Session tarafından yönetilmediği anlamına gelir, ancak nesne henüz veritabanından silinmemiştir.
Hibernate'de veritabanından bir nesneyi silmek için, Session.delete() metodu kullanılır. Bu metot, veritabanındaki nesneyi siler ve Hibernate Session'dan da kaldırır. Bu yöntem çağrılmadan önce, nesnenin persistent state'de olması gerekir.
Özetle, Hibernate'de removed state'inde bulunan bir nesne, veritabanından otomatik olarak silinmez. Nesnenin veritabanından silinmesi için, Hibernate tarafından delete() metodu çağrılması gerekir.
Converting Persistent State to Removed State
Example
// Java Pseudo code to Illustrate Remove State // Transient State Employee e = new Employee(); Session s = sessionfactory.openSession(); e.setId(01); // Persistent State session.save(e) // Removed State session.delete(e);
Hibernate'de detach ile evict arasındaki fark nedir?
Hibernate'de detach() ve evict() metotları, bir nesnenin Session yönetiminden kaldırılmasını sağlar. Ancak, bu iki metot arasında bazı farklılıklar vardır.
detach() metodu, bir nesnenin Session ile olan bağlantısını keser, ancak nesne Hibernate Session yönetiminde kalır. Yani, nesne, detached (bağlantısı kesilmiş) bir nesne haline gelir, ancak hala Session içinde yer alır ve Session'ın kontrolü altındadır. Detach() metodu çağrıldığında, nesnenin Hibernate Session yönetiminden kaldırılması, nesnenin veritabanındaki durumunu etkilemez.
Öte yandan, evict() metodu, bir nesnenin Session yönetiminden kaldırılmasını ve Session tarafından tamamen unutulmasını sağlar. Yani, nesne Hibernate Session yönetiminden tamamen kaldırılır ve nesne artık Session tarafından yönetilmez. Evict() metodu çağrıldığında, nesnenin Hibernate Session yönetiminden kaldırılması, nesnenin veritabanındaki durumunu etkilemez. Ancak, bir nesne evict edildikten sonra, Session tarafından yeniden yönetilmek istenirse, nesne tekrar yüklenmesi gerekir.Genel olarak, detach() metodu, nesnenin Session yönetiminden çıkarılmasını sağlar, ancak nesne ile ilgili verilerin Session'dan kaldırılmamasını sağlar. Bu nedenle, nesne ile ilgili değişiklikler, daha sonra yeniden yönetildiğinde veritabanına kaydedilebilir. Öte yandan, evict() metodu, nesneyi tamamen unutulmuş hale getirir ve yeniden yüklenene kadar nesnenin değişiklikleri kaydedilmez. Bu nedenle, evict() metodu, nesnenin Session yönetiminden kalıcı olarak kaldırılması gerektiği durumlarda kullanılır.
Hibernate'de detach edilmiş bir nesne tekrar sesiona nasıl eklenir?
Hibernate'de detach edilmiş bir nesne, daha sonra tekrar Session'a eklemek için merge() veya update() metotları kullanılabilir. Bu iki metot arasındaki farklılıklar şunlardır:
Merge() metodu, detach edilmiş nesne üzerinde yapılan değişiklikleri korur ve yeni bir persistent nesne oluşturur. Detach edilmiş nesne, merge edildikten sonra, Hibernate Session'ın yönetimine geri alınır.
MyEntity detachedEntity = ...;
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
MyEntity persistentEntity = (MyEntity) session.merge(detachedEntity);
tx.commit();
session.close();
Update() metodu, detach edilmiş nesnenin verilerini veritabanından yeniden yükler. Bu nedenle, detach edilmiş nesne üzerinde yapılan değişiklikler kaybedilir ve veritabanındaki verilere göre nesne yeniden oluşturulur.
MyEntity detachedEntity = ...;
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
session.update(detachedEntity);
tx.commit();
session.close();
Özetle, detach edilmiş bir nesneyi tekrar Hibernate Session'a eklemek için, merge() veya update() metotları kullanılabilir. Merge() metodu, nesnenin değişikliklerini korurken, update() metodu, nesneyi veritabanından yeniden yükleyerek, değişiklikleri kaybeder.