Hibernate Session merge, update, save, saveOrUpdate, persist Metotları: Detaylı Bir İnceleme

Hibernate Session merge, update, save, saveOrUpdate, persist Metotları: Detaylı Bir İnceleme

Giriş: Hibernate ve Varlık Yönetimi

Modern Java uygulamalarında veritabanı etkileşimini kolaylaştıran en güçlü araçlardan biri Hibernate’tir. Bir Object-Relational Mapping (ORM) çerçevesi olarak Hibernate, Java nesneleri ile ilişkisel veritabanı tabloları arasında bir köprü görevi görür. Bu köprü sayesinde geliştiriciler, SQL sorguları yazmak yerine Java nesneleri üzerinde işlem yaparak veritabanı manipülasyonu gerçekleştirebilirler. Hibernate, JPA (Java Persistence API) spesifikasyonunun popüler bir implementasyonudur ve veritabanı işlemlerini yönetmek için bir dizi güçlü API sunar. Bu API’lerin temelini, veritabanı ile etkileşimin merkezi noktası olan Session veya EntityManager (JPA terminolojisinde) nesnesi oluşturur.

Bir uygulamanın performansı ve veri tutarlılığı, varlıkların (entity) yaşam döngüsünün doğru bir şekilde yönetilmesine bağlıdır. Hibernate’te varlıkların yaşam döngüsü, Session nesnesi tarafından sağlanan çeşitli metotlar aracılığıyla kontrol edilir. Bu metotlar arasında save, persist, update, merge ve saveOrUpdate en sık kullanılanlardır. Her bir metot, varlığın mevcut durumuna (state) göre farklı davranışlar sergiler ve belirli senaryolar için optimize edilmiştir. Bu makalede, bu metotların her birini derinlemesine inceleyecek, aralarındaki farkları, kullanım senaryolarını ve dikkat edilmesi gereken noktaları örnek kodlarla açıklayacağız. Amacımız, geliştiricilerin bu metotları doğru ve etkin bir şekilde kullanarak Hibernate uygulamalarını daha sağlam ve verimli hale getirmelerine yardımcı olmaktır.

Hibernate Varlık Durumları (Entity States)

Hibernate’in varlık yönetimi metotlarını anlamak için öncelikle bir varlığın sahip olabileceği farklı durumları kavramak esastır. Bir varlık, yaşam döngüsü boyunca üç ana durumda bulunabilir:

Transient (Geçici) Durum

Bir varlık nesnesi, new anahtar kelimesiyle oluşturulduğunda ve henüz bir Hibernate Session‘ı ile ilişkilendirilmediğinde bu durumdadır. Bu durumda varlığın veritabanında karşılığı yoktur ve bir kimlik (ID) değeri atanmamıştır (eğer ID veritabanı tarafından otomatik oluşturulacaksa). Transient durumdaki bir varlık üzerinde yapılan değişiklikler, veritabanına yansıtılmaz.

Örnek:

User user = new User("Alice", "alice@example.com"); // Transient durumda

Persistent (Kalıcı/Yönetilen) Durum

Bir varlık, bir Session ile ilişkilendirildiğinde ve o Session tarafından yönetildiğinde persistent durumdadır. Bu, varlığın veritabanında bir karşılığı olduğu ve bir kimlik (ID) değerine sahip olduğu anlamına gelir. Persistent durumdaki bir varlık üzerinde yapılan değişiklikler, Session‘ın flush edilmesi veya commit edilmesi durumunda otomatik olarak veritabanına senkronize edilir (dirty checking mekanizması sayesinde). Bu varlıklar, Session‘ın önbelleğinde (first-level cache) tutulur.

Örnek:

User user = new User("Bob", "bob@example.com");
session.save(user); // user artık persistent durumda
// user üzerinde yapılan değişiklikler session.flush() veya commit() ile veritabanına yansır

Detached (Ayrık) Durum

Bir varlık, daha önce persistent durumdayken ilişkili olduğu Session kapatıldığında veya Session‘dan açıkça ayrıldığında (örneğin session.evict(entity) metoduyla) detached duruma geçer. Detached durumdaki bir varlık, hala bir kimlik (ID) değerine sahiptir ve veritabanında bir karşılığı vardır, ancak artık bir Session tarafından yönetilmemektedir. Bu durumda yapılan değişiklikler otomatik olarak veritabanına yansıtılmaz. Detached bir varlığı tekrar persistent duruma getirmek için belirli Hibernate metotları kullanılmalıdır.

Örnek:

User user = session.get(User.class, 1L); // user persistent durumda
session.close(); // Session kapandığında user detached duruma geçer
user.setEmail("new_bob@example.com"); // Bu değişiklik veritabanına otomatik yansımaz

Bu üç durum, Hibernate’in varlık yönetimi metotlarının nasıl çalıştığını anlamanın temelidir. Şimdi, bu metotları detaylı olarak inceleyelim.

save() Metodu

save() metodu, bir Transient durumdaki varlığı Persistent duruma geçirmek için kullanılır. Bu metot, Hibernate’e özgü bir metottur ve JPA spesifikasyonunda doğrudan bir karşılığı yoktur (JPA’daki karşılığı persist() metodudur).

Davranış ve Özellikler

* Transient’tan Persistent’a: save() metodu, veritabanında henüz bir karşılığı olmayan Transient bir varlığı alır ve onu Persistent duruma geçirir. Bu işlem sırasında, varlığa bir kimlik (ID) değeri atanır (eğer ID veritabanı tarafından otomatik olarak üretiliyorsa).
* ID Üretimi: Varlığın ID’si, veritabanı stratejisine (örneğin AUTO, IDENTITY, SEQUENCE) göre oluşturulur ve varlık nesnesine set edilir. save() metodu, atanan bu ID değerini Serializable türünde döndürür.
* Dirty Checking: Varlık Persistent duruma geçtiği anda, Session tarafından yönetilmeye başlar. Bu noktadan sonra varlık üzerinde yapılan değişiklikler, Session‘ın flush edilmesi veya commit edilmesi sırasında otomatik olarak veritabanına yansıtılır.
* Detached Varlıklarla Kullanım: save() metodu, Detached bir varlık üzerinde çağrıldığında bir NonUniqueObjectException veya PersistentObjectException hatası fırlatır, çünkü Detached bir varlığın zaten bir ID’si vardır ve save() metodu yeni bir kayıt eklemeyi bekler.
* Performans: save() metodu, Session‘ın önbelleğine (first-level cache) ekleme yapar ve genellikle hemen bir INSERT sorgusu çalıştırmaz. Sorgu, Session‘ın flush edilmesi anında çalıştırılır.

Örnek Kullanım

Önce User entity sınıfını tanımlayalım:

// User.java
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    public User() {}

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    @Override
    public String toString() {
        return "User{" +
               "id=" + id +
               ", name='" + name + '\'' +
               ", email='" + email + '\'' +
               '}';
    }
}

Şimdi save() metodunu kullanalım:

// HibernateUtil sınıfınızın olduğunu varsayalım
Session session = HibernateUtil.getSessionFactory().openSession();
Transaction transaction = null;

try {
    transaction = session.beginTransaction();

    User newUser = new User("Charlie", "charlie@example.com"); // Transient durumda
    System.out.println("newUser (Transient): " + newUser);
    
    Long userId = (Long) session.save(newUser); // newUser persistent duruma geçti
    System.out.println("newUser (Persistent, after save): " + newUser);
    System.out.println("Generated ID: " + userId);

    newUser.setEmail("charlie_new@example.com"); // Persistent nesne üzerinde değişiklik
    System.out.println("newUser (Persistent, after modification): " + newUser);

    transaction.commit(); // Değişiklikler veritabanına yansır
    System.out.println("User saved and committed.");

} catch (Exception e) {
    if (transaction != null) {
        transaction.rollback();
    }
    e.printStackTrace();
} finally {
    session.close();
}

Yukarıdaki örnekte, newUser nesnesi save() çağrılmadan önce Transient durumdadır. save() çağrıldıktan sonra Persistent duruma geçer ve bir ID alır. Bu noktadan sonra yapılan setEmail değişikliği, commit() çağrıldığında veritabanına yansıtılır.

persist() Metodu

persist() metodu, save() metoduna benzer şekilde Transient durumdaki bir varlığı Persistent duruma geçirmek için kullanılır. Ancak persist(), JPA spesifikasyonunun bir parçasıdır ve save()‘e göre bazı önemli farklılıkları vardır.

Davranış ve Özellikler

* JPA Standartı: persist() metodu, JPA’nın bir parçasıdır. Bu, uygulamanızın Hibernate yerine başka bir JPA implementasyonu (örneğin EclipseLink) kullanması durumunda da aynı davranışı sergileyeceği anlamına gelir.
* Void Dönüş Tipi: persist() metodu void döndürür. Yani, save() metodunun aksine, varlığın atanan ID’sini doğrudan döndürmez. ID, varlık nesnesinin kendisine set edilir.
* ID Üretimi ve Garantisi: persist() metodu, save() gibi ID’yi üretir ve varlık nesnesine set eder. Ancak, persist() çağrıldıktan hemen sonra varlık nesnesinin ID’sinin garanti altına alındığı söylenemez. Özellikle IDENTITY stratejisi kullanıldığında, ID’nin oluşumu flush işlemi anına kadar ertelenebilir. Bu durum, persist() çağrıldıktan hemen sonra varlığın ID’sini kullanmaya çalışırsanız sorunlara yol açabilir. save() ise ID’yi hemen döndürdüğü için bu konuda daha kesindir.
* Detached Varlıklarla Kullanım: persist() metodu da Detached bir varlık üzerinde çağrıldığında bir EntityExistsException veya benzeri bir hata fırlatır, çünkü mevcut bir ID’ye sahip bir varlığı “yeni” olarak kaydetmeye çalışır.
* Cascading: persist() metodu, ilişkili varlıklar üzerinde CascadeType.PERSIST veya CascadeType.ALL tanımlanmışsa, bu ilişkili varlıkları da Persistent duruma geçirir.

Örnek Kullanım

Session session = HibernateUtil.getSessionFactory().openSession();
Transaction transaction = null;

try {
    transaction = session.beginTransaction();

    User newUser = new User("David", "david@example.com"); // Transient durumda
    System.out.println("newUser (Transient): " + newUser);
    
    session.persist(newUser); // newUser persistent duruma geçti
    // ID'nin hemen atanıp atanmadığını kontrol edelim
    System.out.println("newUser (Persistent, after persist, ID may or may not be set yet): " + newUser);

    // Eğer ID hemen atanmadıysa ve ona ihtiyacınız varsa, session.flush() çağırabilirsiniz
    // session.flush(); 
    // System.out.println("newUser (Persistent, after flush, ID is guaranteed): " + newUser);

    newUser.setEmail("david_new@example.com"); // Persistent nesne üzerinde değişiklik

    transaction.commit(); // Değişiklikler veritabanına yansır, ID de bu aşamada kesinleşir
    System.out.println("User persisted and committed.");
    System.out.println("newUser (Persistent, after commit): " + newUser);

} catch (Exception e) {
    if (transaction != null) {
        transaction.rollback();
    }
    e.printStackTrace();
} finally {
    session.close();
}

Bu örnekte, persist() çağrıldıktan hemen sonra newUser.getId()‘nin null olup olmadığını kontrol etmek önemlidir. Eğer IDENTITY stratejisi kullanılıyorsa, ID’nin commit veya flush anında atanması daha olasıdır.

update() Metodu

update() metodu, Detached durumdaki bir varlığı tekrar Persistent duruma geçirmek ve üzerinde yapılan değişiklikleri veritabanına yansıtmak için kullanılır. Bu metot da Hibernate’e özgüdür.

Davranış ve Özellikler

* Detached’tan Persistent’a: update() metodu, daha önce bir Session tarafından yönetilmiş, ancak artık Detached durumda olan bir varlığı alır ve onu tekrar Persistent duruma getirir.
* ID Varlığı: update() metodu, varlığın geçerli bir ID’ye sahip olmasını bekler. Eğer varlığın ID’si null ise veya geçersizse bir hata fırlatabilir.
Aynı ID’ye Sahip Başka Varlık: Eğer Session‘ın önbelleğinde (first-level cache) update() edilmeye çalışılan varlıkla aynı ID’ye sahip farklı bir varlık* zaten varsa, update() metodu bir NonUniqueObjectException fırlatır. Bu, Session içinde aynı ID’ye sahip iki farklı varlık nesnesinin bulunmasını engeller.
* Transient Varlıklarla Kullanım: update() metodu, Transient bir varlık üzerinde çağrıldığında bir PersistentObjectException fırlatır, çünkü update() varlığın daha önce veritabanında var olduğunu varsayar.
* Void Dönüş Tipi: update() metodu void döndürür. Orijinal Detached varlık nesnesi, Persistent duruma geçer ve Session tarafından yönetilmeye başlar.

Örnek Kullanım

Session session = HibernateUtil.getSessionFactory().openSession();
Transaction transaction = null;
User detachedUser = null;

try {
    transaction = session.beginTransaction();
    // 1. Kullanıcıyı veritabanından çek ve Detached duruma getir
    User user = new User("Eve", "eve@example.com");
    session.save(user); // Önce kaydedelim ki ID'si olsun
    transaction.commit();
    session.close(); // Session'ı kapatarak user'ı Detached yapalım

    detachedUser = user; // user artık detached durumda
    System.out.println("detachedUser (Detached, initial): " + detachedUser);

    // 2. Detached kullanıcı üzerinde değişiklik yap
    detachedUser.setEmail("new_eve@example.com");
    detachedUser.setName("Eve Smith");
    System.out.println("detachedUser (Detached, after modification): " + detachedUser);

    // 3. Yeni bir Session aç ve detachedUser'ı update et
    session = HibernateUtil.getSessionFactory().openSession();
    transaction = session.beginTransaction();
    
    session.update(detachedUser); // detachedUser persistent duruma geçti
    System.out.println("detachedUser (Persistent, after update): " + detachedUser);

    transaction.commit(); // Değişiklikler veritabanına yansır
    System.out.println("User updated and committed.");

} catch (Exception e) {
    if (transaction != null) {
        transaction.rollback();
    }
    e.printStackTrace();
} finally {
    if (session != null && session.isOpen()) {
        session.close();
    }
}

Bu örnekte, detachedUser önce bir Session ile kaydedilir, ardından Session kapatılarak Detached duruma getirilir. Detached durumdayken üzerinde değişiklik yapılır ve yeni bir Session içinde update() metodu kullanılarak tekrar Persistent duruma geçirilip değişiklikler veritabanına yansıtılır.

merge() Metodu

merge() metodu, Detached bir varlığı tekrar Persistent duruma getirmek veya Transient bir varlığı Persistent duruma geçirmek için kullanılır. update()‘ten farklı olarak, merge() metodu her zaman yeni bir Persistent varlık örneği döndürür ve orijinal varlık nesnesinin durumunu değiştirmez. merge() metodu JPA spesifikasyonunun bir parçasıdır.

Davranış ve Özellikler

* JPA Standartı: merge() metodu, JPA’nın bir parçasıdır.
* Dönüş Tipi (Yeni Persistent Varlık): merge() metodu, her zaman Persistent durumdaki bir varlık örneği döndürür. Bu, update()‘ten en önemli farkıdır. Orijinal varlık nesnesi (metoda parametre olarak verilen) Detached veya Transient durumunda kalır ve Session tarafından yönetilmez. merge()‘den dönen değeri kullanmak esastır.
* Detached Varlıklarla Kullanım: Eğer metoda Detached bir varlık verilirse:
* Session‘ın önbelleğinde aynı ID’ye sahip bir Persistent varlık varsa, bu varlığın durumu Detached varlığın değerleriyle güncellenir ve bu Persistent varlık döndürülür.
* Session‘ın önbelleğinde aynı ID’ye sahip bir Persistent varlık yoksa, veritabanından bu ID’ye sahip varlık yüklenir, durumu Detached varlığın değerleriyle güncellenir ve bu yüklenen Persistent varlık döndürülür.
* Transient Varlıklarla Kullanım: Eğer metoda Transient bir varlık verilirse (ID’si null veya varsayılan değerdeyse):
* merge() metodu, bu Transient varlığı yeni bir Persistent varlık olarak kaydeder (tıpkı persist() gibi).
* Yeni oluşturulan Persistent varlık döndürülür. Orijinal Transient varlık nesnesi Transient durumda kalır.
* Persistent Varlıklarla Kullanım: Eğer metoda Persistent bir varlık verilirse, merge() metodu basitçe bu varlığı döndürür. Herhangi bir işlem yapmaz.
* Esneklik: merge() metodu, varlığın Transient mi yoksa Detached mı olduğundan emin olmadığınız durumlarda güvenli bir seçenektir. Her iki durumda da doğru işlemi yapar ve her zaman Persistent bir varlık döndürür.

Örnek Kullanım

Session session = HibernateUtil.getSessionFactory().openSession();
Transaction transaction = null;
User originalDetachedUser = null;
User mergedUser = null;

try {
    transaction = session.beginTransaction();
    // 1. Kullanıcıyı veritabanından çek ve Detached duruma getir
    User user = new User("Frank", "frank@example.com");
    session.save(user); // Önce kaydedelim ki ID'si olsun
    transaction.commit();
    session.close(); // Session'ı kapatarak user'ı Detached yapalım

    originalDetachedUser = user; // user artık detached durumda
    System.out.println("originalDetachedUser (Detached, initial): " + originalDetachedUser);

    // 2. Detached kullanıcı üzerinde değişiklik yap
    originalDetachedUser.setEmail("new_frank@example.com");
    originalDetachedUser.setName("Frank White");
    System.out.println("originalDetachedUser (Detached, after modification): " + originalDetachedUser);

    // 3. Yeni bir Session aç ve detachedUser'ı merge et
    session = HibernateUtil.getSessionFactory().openSession();
    transaction = session.beginTransaction();
    
    mergedUser = (User) session.merge(originalDetachedUser); // mergedUser persistent duruma geçti
    
    System.out.println("originalDetachedUser (Still Detached): " + originalDetachedUser);
    System.out.println("mergedUser (Persistent): " + mergedUser);

    // mergedUser üzerinde yapılan değişiklikler veritabanına yansır
    mergedUser.setEmail("final_frank@example.com"); 

    transaction.commit(); // Değişiklikler veritabanına yansır
    System.out.println("User merged and committed.");

} catch (Exception e) {
    if (transaction != null) {
        transaction.rollback();
    }
    e.printStackTrace();
} finally {
    if (session != null && session.isOpen()) {
        session.close();
    }
}

// Transient bir varlıkla merge kullanımı
System.out.println("\n--- Transient Varlık ile merge ---");
session = HibernateUtil.getSessionFactory().openSession();
transaction = null;

try {
    transaction = session.beginTransaction();
    User transientUser = new User("Grace", "grace@example.com"); // Transient
    System.out.println("transientUser (Transient): " + transientUser);

    User persistentUserFromMerge = (User) session.merge(transientUser);
    
    System.out.println("transientUser (Still Transient): " + transientUser); // Orijinal transient kalır
    System.out.println("persistentUserFromMerge (Persistent): " + persistentUserFromMerge); // Yeni persistent nesne döner

    persistentUserFromMerge.setEmail("new_grace@example.com"); // Bu nesne üzerinde yapılan değişiklikler izlenir

    transaction.commit();
    System.out.println("Transient user merged (saved) and committed.");

} catch (Exception e) {
    if (transaction != null) {
        transaction.rollback();
    }
    e.printStackTrace();
} finally {
    if (session != null && session.isOpen()) {
        session.close();
    }
}

merge() örneğinde, originalDetachedUser nesnesi merge() çağrısından sonra hala Detached durumdadır. Session tarafından yönetilen ve veritabanına yansıtılacak olan değişiklikler, merge() metodunun döndürdüğü mergedUser nesnesi üzerinde yapılmalıdır. Transient bir varlık ile kullanıldığında da benzer şekilde, merge metodu yeni bir Persistent varlık döndürür ve orijinal Transient varlık değişmeden kalır.

saveOrUpdate() Metodu

saveOrUpdate() metodu, bir varlığın Transient mi yoksa Detached mı olduğunu otomatik olarak belirleyerek uygun işlemi (kaydetme veya güncelleme) gerçekleştiren bir Hibernate kolaylık metodudur.

Davranış ve Özellikler

* Otomatik Karar Verme: saveOrUpdate() metodu, varlığın ID’sine ve @Version (eğer kullanılıyorsa) alanına bakarak varlığın yeni mi (Transient) yoksa mevcut bir kaydın ayrık hali mi (Detached) olduğuna karar verir.
* Eğer varlığın ID’si null ise veya unsaved-value olarak belirtilen değere eşitse (varsayılan olarak 0 veya null), varlığı Transient kabul eder ve save() gibi davranır.
* Eğer varlığın geçerli bir ID’si varsa ve @Version alanı varsa ve varsayılan değeri aşmışsa, varlığı Detached kabul eder ve update() gibi davranır.
* Void Dönüş Tipi: saveOrUpdate() metodu void döndürür. Metoda verilen orijinal varlık nesnesi, Persistent duruma geçer.
* Esneklik ve Potansiyel Risk: Bu metot, varlığın durumunu bilmediğiniz veya kodunuzu basitleştirmek istediğiniz durumlarda kullanışlı olabilir. Ancak, otomatik karar verme mekanizması bazen beklenmedik davranışlara yol açabilir, özellikle ID’lerin manuel olarak atanması veya karmaşık varlık modelleri söz konusu olduğunda.
* JPA Karşılığı Yok: saveOrUpdate() metodu Hibernate’e özgüdür ve JPA’da doğrudan bir karşılığı yoktur.

Örnek Kullanım

Session session = HibernateUtil.getSessionFactory().openSession();
Transaction transaction = null;

try {
    transaction = session.beginTransaction();

    // 1. Transient bir varlık için saveOrUpdate (save gibi davranır)
    User transientUser = new User("Henry", "henry@example.com"); // Transient
    System.out.println("transientUser (Transient, before saveOrUpdate): " + transientUser);
    
    session.saveOrUpdate(transientUser);
    System.out.println("transientUser (Persistent, after saveOrUpdate): " + transientUser); // ID atanmış olmalı

    // 2. Detached bir varlık için saveOrUpdate (update gibi davranır)
    transaction.commit(); // Henry'yi kaydet
    session.close(); // Session'ı kapat, transientUser artık detached

    User detachedUser = transientUser; // detachedUser artık detached durumda
    System.out.println("detachedUser (Detached, initial): " + detachedUser);
    detachedUser.setEmail("new_henry@example.com"); // Değişiklik yap

    session = HibernateUtil.getSessionFactory().openSession();
    transaction = session.beginTransaction();

    session.saveOrUpdate(detachedUser); // detachedUser persistent duruma geçti
    System.out.println("detachedUser (Persistent, after saveOrUpdate): " + detachedUser);

    transaction.commit(); // Değişiklikler veritabanına yansır
    System.out.println("User (Henry) saved, updated and committed using saveOrUpdate.");

} catch (Exception e) {
    if (transaction != null) {
        transaction.rollback();
    }
    e.printStackTrace();
} finally {
    if (session != null && session.isOpen()) {
        session.close();
    }
}

Bu örnekte, saveOrUpdate() metodu önce Transient bir varlığı kaydetmek için, ardından Detached bir varlığı güncellemek için kullanılmıştır. Her iki durumda da doğru işlemi otomatik olarak belirleyip gerçekleştirir.

Metotların Karşılaştırması ve Ne Zaman Hangisini Kullanmalı?

Aşağıdaki tablo, incelenen metotların temel özelliklerini özetlemektedir:

| Metot | JPA Standardı mı? | Giriş Varlığı Durumu | Dönüş Değeri | Orijinal Varlık Durumu Değişir mi? | Ana Amaç | Notlar |
| :————- | :—————- | :——————- | :—————————- | :——————————— | :—————————————- | :——————————————————————————————————————————————————————————— |
| save() | Hayır (Hibernate) | Transient | Serializable (ID) | Evet (Persistent olur) | Yeni varlığı kaydetme | Detached varlıklarla hata verir. ID’yi hemen döndürür. |
| persist() | Evet (JPA) | Transient | void | Evet (Persistent olur) | Yeni varlığı kaydetme | Detached varlıklarla hata verir. ID’nin hemen atanacağını garanti etmez (flush/commit’e kadar ertelenebilir). Tercih edilen yeni kayıt metodu. |
| update() | Hayır (Hibernate) | Detached | void | Evet (Persistent olur) | Detached varlığı tekrar bağlama/güncelleme | Transient varlıklarla hata verir. Aynı ID’ye sahip başka bir Persistent nesne varsa hata verir. Orijinal nesneyi persistent yapar. |
| merge() | Evet (JPA) | Transient, Detached, Persistent | Persistent varlık örneği | Hayır (Orijinal aynı kalır) | Varlığı Persistent yapma veya güncelleme | Her zaman yeni veya mevcut bir Persistent nesne döndürür. Orijinal nesne Detached/Transient kalır. En esnek ve güvenli metotlardan biri. |
| saveOrUpdate() | Hayır (Hibernate) | Transient, Detached | void | Evet (Persistent olur) | Varlığın durumuna göre kaydet/güncelle | Hibernate’e özgü bir kolaylık metodudur. Durumu otomatik belirler. Bazı durumlarda beklenmedik davranışlara yol açabilir. |

Ne Zaman Hangisini Kullanmalı?

* Yeni Varlık Kaydetme:
* persist(): Yeni bir varlığı veritabanına kaydetmek için tercih edilen JPA standardı yöntemidir. Temiz ve standart bir yaklaşımdır. ID’ye hemen ihtiyacınız yoksa kullanın.
* save(): persist()‘e alternatif olarak kullanılabilir, ancak persist() tercih edilmelidir. save() ID’yi hemen döndürme garantisi verir.
* Detached Varlığı Güncelleme/Tekrar Bağlama:
* merge(): En güvenli ve esnek seçenektir. Varlığın Detached mı yoksa Transient mı olduğundan emin olmadığınızda veya orijinal nesnenin Detached kalmasını tercih ettiğinizde kullanın. Her zaman Persistent bir kopya döndürdüğü için bu kopyayı kullanmayı unutmayın.
* update(): Eğer kesinlikle Detached bir varlığı tekrar Persistent duruma getirmek ve orijinal nesnenin kendisini Persistent yapmak istiyorsanız kullanın. Session içinde aynı ID’ye sahip başka bir nesne olmadığından emin olmalısınız.
* Hem Yeni Kaydetme Hem de Güncelleme (Otomatik):
* saveOrUpdate(): Yalnızca Hibernate kullanıyorsanız ve varlığın Transient mi yoksa Detached mi olduğunu manuel olarak kontrol etmek istemiyorsanız bir kolaylık olarak kullanılabilir. Ancak, genellikle persist() ve merge()‘i açıkça kullanmak daha anlaşılır ve daha az hata potansiyeli taşır.

Sonuç

Hibernate’in save, persist, update, merge ve saveOrUpdate metotları, varlıkların yaşam döngüsünü yönetmede merkezi bir rol oynar. Her bir metot, varlığın mevcut durumuna (Transient, Persistent, Detached) göre farklı davranışlar sergiler ve belirli senaryolar için en uygun olanı vardır.

persist() ve merge() metotları JPA standardının bir parçası olduğu için, taşınabilir uygulamalar geliştirmek isteyen geliştiriciler tarafından tercih edilmelidir. persist() yeni varlıkları kaydetmek için, merge() ise hem yeni varlıkları kaydetmek hem de ayrık varlıkları güncellemek için esnek ve güvenli bir yol sunar. save() ve update() Hibernate’e özgü metotlardır ve saveOrUpdate() de bir kolaylık metodudur.

Bu metotların inceliklerini ve aralarındaki farkları anlamak, Hibernate uygulamalarında veri tutarlılığını sağlamak, beklenmedik hataları önlemek ve performansı optimize etmek için kritik öneme sahiptir. Doğru metodu doğru zamanda kullanmak, sağlam ve bakımı kolay bir ORM katmanı oluşturmanın temelidir.