İşlemler

4.1 Hibernate'deki işlemlere giriş

Yukarıdakilerin hepsine, işlemler hakkında bilgi eklemek istiyorum. Bildiğiniz gibi, bir işlem yalnızca hep birlikte gerçekleştirilmesi gereken bir eylemler grubudur . Herhangi bir eylem başarısız olursa veya bir hatayla gerçekleştirilirse, diğer tüm işlemler iptal edilmelidir.

Hibernate, iki tür işlemle çalışabilir:

• JDBC
• JTA

Bir JDBC işlemi aslında bir veritabanı işlemidir. Veritabanıyla çalışmaya, JDBC bağlantısına bağlıdır. Ve veritabanıyla çalışırken eylemlerin olması gerektiği gibi yapıldığından emin olur: ya hep ya hiç.

JTA - İşlem, uygulama düzeyinde bir işlemdir. Herhangi bir veri tabanına bağlı değildir. Görevi, belirli eylemlerin gerçekleştirilmesini sağlamaktır: ya hep ya hiç.

Örneğin, tek bir JTA işlemi içinde birkaç farklı veri tabanına veri yazabilirsiniz. Daha sonra bir hata oluşursa, JTA işleminin tüm veritabanlarındaki değişiklikleri geri alması gerekecektir. Belirli bir veritabanı açısından başarıyla yürütülenler bile.

4.2 Hazırda Bekleme İşlemleri Arayüzü

Hibernate kitaplığında, bir işlem, farklı uygulamalara sahip olabilen Transaction arabirimi tarafından temsil edilir. Örneğin, Spring ile çalışırken, Spring kendi JTA işlem mekanizmasını sağlar.

Bu arabirimin yöntemleri şunlardır:

Önemli! Bir işlem nesnesi oluşturmak ve bir işlem başlatmak iki farklı şeydir. Burada Thread sınıfıyla bir benzetme yapabilirsiniz. Bir Thread() nesnesi oluşturduğunuzda, JVM henüz yeni bir thread başlatmaz. Başlatmak için, Thread nesnesinde start() yöntemini çağırmanız gerekir. Bir işlemde de durum aynıdır - begin() yöntemini çağırması gerekir.

İşlemlerin genellikle Hazırda Bekletme modunda nasıl işlendiğine dair bir örnek:

Session session = sessionFactory.openSession();
Transaction transaction = session.getTransaction();
try {
    transaction.begin();
    Long count = session.createQuery("select count(*) from Employee", Long.class).uniqueResult();
    transaction.commit();
}
catch (Exception e) {
	if (transaction.getStatus() == ACTIVE || transaction.getStatus() == MARKED_ROLLBACK) {
    transaction.rollback();
    }
}
finally {
	session.close();
	sessionFactory.close();
}

Burada üç şey görüyoruz:

İlk olarak, veritabanıyla yapılan tüm çalışmalar, yöntemleri çağırarak bir işleme sarılır begin()ve commit()bu iki yönteme yapılan çağrılar arasındaki tüm eylemler gerçekleştirilmelidir: ya hep birlikte ya da hiçbir şey.

İkincisi, herhangi bir hata oluşursa, işlemi geri almaya çalışırız - rollback(). begin()Bu, TransactionManger'ın önce ve arasındaki tüm eylemleri kaydetmesi commit()ve ardından her şeyi çağırdığımız gibi döndürmesi gerektiği anlamına gelir rollback().

Bu arada rollback yöntemi çağrılırken hata olmayacağı da bir gerçek değil. Hatalar her zaman olur. Sadece bu gerçeği kabul etmeli ve buna hazır olmalısın.

4.3 İşlem yöneticisi

İşlem yönetimi açısından Hibernate, JDBC için yalnızca hafif bir nesne sarmalayıcıdır. Hazırda bekletme, işlem işleme özelliklerine sahip değildir. Hazırda Bekletme İşlemi aslında temel alınan JDBC işlemi (veya JTA işlem sarmalayıcısı) için bir sarmalayıcıdır. JDBCTransaction varsayılandır. Hiberante ayarları dosyasından örnek:

hibernate.transaction.factory_class  org.hibernate.transaction.JTATransactionFactory
hibernate.transaction.factory_class  org.hibernate.transaction.JDBCTransactionFactory

İşlemleri kullanarak kodumuza bir kez daha göz atalım:

Session session = sessionFactory.openSession();
Transaction transaction = session.getTransaction();
transaction.begin();
//here is your code for working with the base
session.flush();
transaction.commit();
session.close();

Şimdi JDBCTransaction sınıf koduna bakalım:

public class JDBCTransaction implements Transaction {

    public void begin() throws HibernateException {
    	...
    	if (toggleAutoCommit) jdbcContext.connection().setAutoCommit(false);
    	...
    }
}

Bu, bir işlem başlatma yöntemidir. Ardından gönderme yöntemine bakın:

public void commit() throws HibernateException {
    ...
    jdbcContext.connection().commit();
    ...
    jdbcContext.connection().setAutoCommit( true );
    ...
}

Şimdi bu kodu Hibernate örnek koduyla değiştirelim:

Session session = sessionFactory.openSession();
Transaction transaction = session.getTransaction();
transaction.begin();
//here is your code for working with the database
session.flush();
transaction.commit();
session.close();

Connection conn = jdbcContext.connection();
conn.setAutoCommit(false);
 
//here is your database code
conn.commit ()
conn.setAutoCommit(true);
conn.close();

Dolayısıyla yerel Hazırda Bekletme işlemleri, yalnızca veritabanına yapılan yerel JDBC çağrılarıdır. Daha fazla ve daha az değil. Ancak JTA işlemleri daha ilgi çekicidir. Ama bunun hakkında daha fazlası başka bir zaman.