تقدير المشروع
← كل المقالات

Hibernate أم Exposed: اختيار أفضل أداة حفظ بيانات لـ Kotlin – الجولة الثانية

تضع المقالة الثانية من السلسلة Hibernate وExposed جنبًا إلى جنب فيما يخص تخزين البيانات واسترجاعها والتعامل مع المعاملات.

15 دقائق قراءة
KotlinKtorKotlinServerSideحفظ البيانات

حان وقت الجولة الثانية من مواجهة Hibernate وExposed! أنت تعرف بالفعل كيف يختلف Hibernate وExposed في تصميمهما. وقد رأيت كيف يُضبط الإطاران في بيئات مختلفة. وتستطيع ربط جداول قاعدة البيانات بالتجريدات المقابلة في شيفرة تطبيقك. كما يمكنك توليد المخطط تلقائيًا من أصنافك.

ومع ذلك، لا يمنح أي من هذا تطبيقك وظائف أعمال فعلية بعد. تأتي القيمة الحقيقية للأعمال من القدرة على الاستعلام عن بياناتك وحفظها وتعديلها وتعريف المعاملات.

ولا تقلق – فهذا بالضبط موضوع هذه المقالة.

حفظ البيانات واسترجاعها

أولًا، لننظر في الأساليب المختلفة لـ DML (لغة معالجة البيانات) والاستعلام التي يقدمها كل إطار.

Hibernate Criteria API

إحدى طرق Hibernate للاستعلام عن البيانات هي Criteria API. استعلامات Criteria هي في جوهرها لغة DSL آمنة الأنواع موضوعة فوق كيانات Hibernate تتيح لك كتابة استعلامات SQL في الشيفرة. حسنًا، ليست استعلامات SQL تمامًا – لأن Hibernate، كما ذُكر سابقًا، يخفي SQL منخفض المستوى خلف الكيانات. لذا فمع Criteria API ما زلت تعمل مع الكيانات وتستخدم مفردات الكيانات بدلًا من التعامل مع جداول قاعدة البيانات مباشرة.

يبدأ بناء استعلام Criteria عادةً بـ CriteriaBuilder، ثم تحدد عناصر الاستعلام ومعاملاته، متعمقًا في الرسم البياني للكائنات في Criteria API.

وهذا مثال على استخدام Criteria API مع كيان Hibernate المعروف لدينا BoardGame:

val dune = BoardGame("Dune: Imperium", 1, 4, 120)
val everdell = BoardGame("Everdell", 1, 4, 100)

// first we need to save some entities to database
session.persist(dune)
session.persist(everdell)

// actual Criteria API usage starts here
val criteriaBuilder = session.criteriaBuilder
val criteria = criteriaBuilder.createQuery(BoardGame::class.java)
val root = criteria.from(BoardGame::class.java)
criteria.select(root)
criteria.where(criteriaBuilder.greaterThan(root.get("playTimeInMinutes"), 60))
criteria.orderBy(criteriaBuilder.desc(root.get<String>("title")))

val resultList = session.createQuery(criteria).resultList

يختار استعلام Criteria أعلاه ببساطة كل لعبة لوحية يتجاوز زمن لعبها 60 دقيقة ويرتب النتائج حسب العنوان تنازليًا. ومع ذلك، قد لا تكون كلمة «ببساطة» دقيقة تمامًا. فكما لاحظت ربما، تطلّب بناء حتى هذا الاستعلام البسيط نسبيًا إنشاء كائنات criteriaBuilder وcriteria وroot. وفوق ذلك، احتاجت عبارتا where وorderBy إلى تعبيرات مطوّلة نوعًا ما – مع تمرير أسماء الحقول سلاسل نصية عادية.

هذا رأيي الشخصي فقط، وأنت حر تمامًا في أن ترى غير ذلك، لكن بالنسبة لي فإن Criteria API صعب ومرهق نسبيًا في التعامل. ومع ذلك، إن أردت التعمق، فألقِ نظرة على فصل Criteria في توثيق Hibernate.

لغة استعلام Hibernate – HQL

يمنحك Hibernate أيضًا طريقة أخرى للاستعلام من قاعدة البيانات. فإذا كنت مستعدًا للتخلي عن أمان الأنواع مقابل التعبيرية والبساطة، فقد تستحق لغة استعلام Hibernate (HQL) النظر.

HQL لغة استعلام كائنية التوجه تشبه SQL كثيرًا – إلا أنك بدلًا من الاستعلام عن جداول قاعدة البيانات الكامنة، تستعلم عن كياناتك.

أما أنواع استعلامات HQL فهناك نهجان رئيسيان:

  • الاستعلامات المضمّنة (Inline queries) – تُعطى سلاسل نصية للدالة createQuery وقت التشغيل. وأي أخطاء في الاستعلام لا تظهر إلا عند تشغيله.
  • الاستعلامات المسمّاة (Named queries) – تُعرَّف مسبقًا بـ XML أو بالتعليقات التوضيحية، ثم يُشار إليها بالاسم في الدالة createQuery. يحلل Hibernate هذه الاستعلامات عند بدء التطبيق، لذا يمكن اكتشاف بعض المشكلات أبكر بكثير.

يبيّن هذا القسم كيفية كتابة استعلامات HQL بسيطة وتشغيلها.

سنبدأ بجلب كل لعبة لوحية يزيد زمن لعبها على 60 دقيقة، مرتبة حسب العنوان تنازليًا – هذه المرة بـ HQL:

val resultList = session.createQuery(
   "FROM BoardGame WHERE playTimeInMinutes > :playtime ORDER BY title DESC",
   BoardGame::class.java
)
.setParameter("playtime", 60)
.resultList

كان ذلك استعلامًا مضمّنًا. بعد ذلك لنعرّف الاستعلام نفسه استعلامًا مسمّى. للبدء نعرّف الاستعلام المسمّى على الكيان BoardGame:

@NamedQuery(
   name = "find_boardgames_with_playtime_at_least",
   query = "FROM BoardGame WHERE playTimeInMinutes > :playtime ORDER BY title DESC"
)
@Entity
@Table(name = "board_games")
open class BoardGame(
...

بعد ذلك يمكننا الاستعلام من قاعدة البيانات به:

val resultList = session.createNamedQuery(
   "find_boardgames_with_playtime_at_least",
   BoardGame::class.java
)
.setParameter("playtime", 60)
.resultList

هذا لا يمس سوى سطح HQL. فاللغة قوية جدًا، فإن أردت تعلمها بشكل أشمل، فإن فصل HQL في توثيق Hibernate نقطة انطلاق ممتازة.

مستودعات Spring Data JPA

على الرغم من أنه يقع، بالمعنى الدقيق، خارج نطاق هذه المقالة، أودّ ذكر طريقة أخرى للاستعلام من قاعدة البيانات مع Hibernate بسرعة – طريقة متاحة في Spring فقط.

مستودعات Spring Data JPA ليست آلية استعلام مستقلة في Hibernate، بل هي طبقة تجريد فوق واجهات استعلام JPA الموجودة، مدمجة مع Spring.

وهي ليست ميزة أصلية في Hibernate، لكنني لم أرَ أن بإمكاني إغفالها في مقالة تقارن بين Hibernate وExposed – خصوصًا أن مستودعات Spring Data JPA شائعة جدًا بين المطورين، وأنك تحصل عليها مع Hibernate، لكن لا مع Exposed.

لمعرفة المزيد، ألقِ نظرة على توثيق Spring حول مستودعات JPA.

Exposed DSL

كما ذُكر سابقًا، التجريد المركزي الذي يستخدمه Exposed للعمل مع جداول قاعدة البيانات هو كائن Table. غير أن الجداول في Exposed لا تخدم تعريف المخطط فحسب – بل هي أيضًا الطريقة التي تستعلم بها عن البيانات وتعدّلها.

بالنظر إلى BoardGamesTable من المقالة السابقة، هكذا يمكنك تنفيذ عمليات مختلفة عليه، تغطي CRUD (الإنشاء والقراءة والتحديث والحذف) إضافة إلى استعلامات أكثر تعقيدًا:

// insert
val boardGameId = BoardGamesTable.insert {
   it[title] = "Dune: Imperium"
   it[minPlayers] = 1
   it[maxPlayers] = 4
   it[playTimeInMinutes] = 120
} get BoardGamesTable.id

// add some ratings...

// select all
BoardGamesTable.selectAll().forEach {
   println("Board game: id = ${it[BoardGamesTable.id]}, title = ${it[BoardGamesTable.title]}, ...")
}

// select average rating for board game
val averageRatingAlias = RatingsTable.rating.avg().alias("average_rating")

RatingsTable.select(RatingsTable.boardGameId, averageRatingAlias)
   .groupBy(RatingsTable.boardGameId)
   .forEach {
       println("Board game id = ${it[RatingsTable.boardGameId]}, average rating = ${it[averageRatingAlias]}")
   }

// update
BoardGamesTable.update({ BoardGamesTable.id eq boardGameId }) {
   it[title] = "Dune: Imperium - Uprising"
}

// select single row
val singleBoardGame = BoardGamesTable.select(
   BoardGamesTable.title,
   BoardGamesTable.minPlayers,
   BoardGamesTable.maxPlayers
)
.where(BoardGamesTable.id eq boardGameId)
.single()

// delete
BoardGamesTable.deleteWhere { id eq boardGameId }

تذكّر أنه مع Exposed Table DSL تُربط الخصائص فقط بأعمدة قاعدة البيانات الفعلية لذلك الجدول المحدد.

وهذا يعني أنه لاسترجاع تقييمات لعبة لوحية علينا الاستعلام عن RatingsTable صراحةً. وخيار آخر هو ضم الجداول بحيث يُثرى كل ResultRow من RatingsTable ببعض تفاصيل اللعبة اللوحية ذات الصلة:

RatingsTable
   .innerJoin(BoardGamesTable)
   .select(BoardGamesTable.title, RatingsTable.rating)
   .where(RatingsTable.boardGameId eq boardGameId)
   .forEach {
       println("Rating for board game ${it[BoardGamesTable.title]}: ${it[RatingsTable.rating]}")
   }

Exposed DAO

ربما تتذكر الكيان BoardGame من قسم تعيين الربط وتعريف المخطط – Exposed DAO في المقالة السابقة. في ذلك القسم أشرت إلى الكائن المرافق (companion object) من النوع LongEntityClass المعلن داخل الكيان. وهذا الكائن المرافق هو ما يمنح صنف كياننا قدراته المختلفة على معالجة قاعدة البيانات والاستعلام منها.

فيما يلي أمثلة على عمليات مختلفة على كيانات BoardGame – تحاكي عمليات BoardGamesTable من القسم السابق:

// insert
val boardGame = BoardGame.new {
   title = "Dune: Imperium"
   minPlayers = 1
   maxPlayers = 4
   playTimeInMinutes = 120
}

// add some ratings...

// select all
val allBoardGames = BoardGame.all().toList()

// select average rating for board game
BoardGame.all().with(BoardGame::ratings) //'with' function to eagerly load the ratings
   .map { boardGame -> Pair(
       boardGame,
       boardGame.ratings.map { it.rating }.average()
   )}
   .forEach {
       println("Board game '${it.first.title}', average rating = ${it.second}")
   }

// update
BoardGame.findByIdAndUpdate(
   boardGame.id.value,
   { it.title = "Dune: Imperium - Uprising" }
)

// or
boardGame.title = "Dune: Imperium - Uprising"

// select single row
BoardGame.findById(boardGame.id)

// delete
boardGame.delete()

بعض الملاحظات على المقطع أعلاه:

  • ربما لاحظت أنه رغم أن DAO يعمل مع كائنات بدلًا من صفوف الجداول الخام، فإن واجهته البرمجية تشبه كثيرًا DSL الجداول. ولذلك قد يجد مستخدمو DSL الذين يفكرون في الانتقال إلى DAO أنه مألوف.
  • لم يعد حساب متوسط التقييم لكل لعبة لوحية يتطلب أي ضم، لأن الكيان BoardGame له خاصية ratings تحمّل التقييمات ذات الصلة. والعيب هو أننا لم نعد قادرين على حساب المتوسط في قاعدة البيانات باستعلام مخصص – فـ DAO يعمل على كائنات الكيانات وخصائصها. ويجب حساب المتوسط في الشيفرة بعد جلب البيانات.
  • ومع ذلك، لا يزال بالإمكان تنفيذ مثل هذه الاستعلامات باستخدام DSL – فاختيار DAO في موضع لا يمنعك من استخدام DSL في أجزاء أخرى من تطبيقك.
  • ربما رأيت أيضًا استدعاء with(BoardGame::ratings) مطبّقًا على نتيجة الاستعلام BoardGame.all(). فهو يحمّل تقييمات كل كيان BoardGame تحميلًا مبكرًا (eager)، لأننا نعرف مسبقًا أننا سنحتاج إليها.
  • يمكن تحديث الكيانات بطريقتين. يمكنك استدعاء الدالة BoardGame.findByIdAndUpdate()، أو إسناد قيمة جديدة مباشرة إلى خاصية الكيان. الخيار الأول يناسب الحالات التي تعرف فيها معرّف الكيان المراد تحديثه لكنك لم تحمّله من قاعدة البيانات. والثاني أنسب عندما يكون كائن الكيان محمّلًا بالفعل ويمكنك تعديله مباشرة.

هناك نقطة أخرى تستحق التأكيد بشأن كيانات Exposed DAO. فكيانات Hibernate يُراد لها أن تكون كائنات Java (أو Kotlin) عادية مستقلة عن الإطار قدر الإمكان، أما كيانات Exposed DAO فليست كذلك.

فهي مرتبطة بالإطار ارتباطًا وثيقًا:

  • يجب أن ترث أصنافًا أساسية معينة.
  • يجب أن تشير إلى جدول Exposed مقابل.
  • كل خاصية فيها مفوَّضة إلى عمود معرَّف في الجدول.
  • وأخيرًا، لا تستطيع العمل دون اتصال بقاعدة بيانات مضبوط.

ولهذا عواقب مهمة. قد يجعل استخدام كيانات Exposed DAO نموذجًا للمجال (domain model) – أي في طبقة منطق الأعمال – كتابة اختبارات الوحدة صعبة. والسبب أن كل اختبار سيحتاج إلى تشغيل قاعدة بيانات (حقيقية أو في الذاكرة) وإعداد اتصال بها.

ولهذا فالتوصية المعتادة هي تجنب استخدام كيانات Exposed DAO نماذج للمجال وحصرها في طبقة حفظ البيانات.

التعامل مع المعاملات

عندما تبني عمليات الأعمال وسير العمل في تطبيقاتك، تحتاج كثيرًا إلى أن تُنفَّذ أجزاء من المنطق بصورة ذرية (atomically) – إما كاملة أو لا تُنفَّذ إطلاقًا. وتسمى وحدة العمل هذه معاملة (transaction). ولحسن حظ المطورين، فإن لقواعد البيانات العلائقية مفهومها الخاص عن المعاملات، وهو يطابق تقريبًا ما نتوقعه من منطق الأعمال. وقد يكون هذا أحد أسباب ميل شيفرتنا إلى الاعتماد الكبير على آليات معاملات قاعدة البيانات.

لذلك، عندما تختار إطار حفظ بيانات معينًا – وهو طبقة تجريد فوق قاعدة بياناتك – فمن المرجح أنك تتوقع منه أن يتيح لك إدارة تلك المعاملات والتحكم فيها. ولحسن الحظ، يدعم الإطاران المشمولان هنا ذلك، وإن كانا يفعلان ذلك بطرق مختلفة نوعًا ما.

لننظر فيما يوفره كل منهما.

Hibernate Transaction API

يقدم Hibernate آليتين مختلفتين لإدارة المعاملات:

  • JDBC – تدير المعاملات مباشرة عبر java.sql.Connection الكامن
  • JTA – تدير المعاملات عبر JTA (Java Transaction API)

في التطبيقات غير المعتمدة على JPA (مثل تطبيقات JVM العادية)، يكون وضع تنسيق المعاملات الافتراضي هو JDBC.

لتغيير هذا الإعداد، يمكنك وضع الأسطر التالية في ملف hibernate.properties:

hibernate.transaction.coordinator_class=jta
hibernate.transaction.jta.platform=<SOME_JTA_PLATFORM_IMPL>

ضع في اعتبارك أن عليك توفير منصة JTA مخصصة لكي يعمل التطبيق، لأن تنفيذ JTAPlatform الافتراضي في Hibernate هو… NoJtaPlatform. ونتيجة لذلك قد ترى أخطاء مثل: “Could not locate TransactionManager to suspend any current transaction.”

وأيًّا كانت طريقة ضبط منسّق المعاملات، فإن واجهة إدارة المعاملات القياسية الموحدة في Hibernate متاحة لك.

بالنظر إلى SessionFactory، هكذا تنفّذ الشيفرة داخل معاملة:

val session = sessionFactory.openSession()

try {
   session.transaction.begin()

   // perform some DB operations

   session.transaction.commit()
} catch (e: Exception) {
   if (session.transaction.status == ACTIVE || session.transaction.status == MARKED_ROLLBACK) {
       session.transaction.rollback()
   }

   // further handle the exception
} finally {
   session.close()
}

وهناك أيضًا صيغة تصريحية أقصر، على حساب تحكم أقل قليلًا:

sessionFactory.inTransaction { session ->
   // perform some DB operations
}

إضافة إلى التحكم الأساسي في دورة حياة المعاملة (البدء والتثبيت والتراجع)، يتيح لك Hibernate ضبط المعاملات أكثر لتناسب احتياجاتك. لنستعرض بعض الخيارات الأكثر استخدامًا.

أولًا: مستويات عزل المعاملات. وإن كان المفهوم جديدًا عليك، فإن توثيق PostgreSQL يقدم نظرة عامة جيدة.

أنظف الطرق وأكثرها رسمية لتغيير مستوى عزل المعاملات هي ضبطه في hibernate.properties:

hibernate.connection.isolation=REPEATABLE_READ

للاطلاع على القيم والصيغ المقبولة، راجع توثيق Hibernate الرسمي حول ضبط مستوى عزل الاتصال.

هذا الإعداد ثابت – فهو يؤثر في كل جلسة ومعاملة في تطبيقك. ومع ذلك يمكنك تغييره في الشيفرة على نسخة Connection باستخدام Connection.setTransactionIsolation(). لكن انتبه إلى أن التغيير سيسري على كل جلسة (ومعاملة) تخدمها نسخة Connection تلك.

أما تبديل مستوى العزل ديناميكيًا وقت التشغيل لكل جلسة فممكن نظريًا، لكنه غير موثق رسميًا، وأراه غير موثوق وأقرب إلى الحيلة. ولهذا السبب لن أبيّن كيفية فعل ذلك. وإن كنت فضوليًا على أي حال، فاطلع على الدالة Session.doWork() التي تكشف Connection الكامن مباشرة، وابحث عن أمثلة المجتمع على الإنترنت.

يتيح لك Hibernate أيضًا التحكم فيما إذا كانت المعاملة للقراءة فقط. ويُضبط هذا لكل جلسة. فالكيانات في الجلسة قابلة للتعديل افتراضيًا. لكن عندما تُجعل الجلسة للقراءة فقط، يعطّل Hibernate فحص التغييرات (dirty checking) لتلك الجلسة. أي أنه لا يزال بإمكانك تغيير خصائص الكيانات في الذاكرة، لكن التغييرات لن تُكتب إلى قاعدة البيانات.

وبوجود جلسة في يدك، يمكنك جعلها للقراءة فقط كما يلي:

session.isDefaultReadOnly = true

لاحظ أن Hibernate يدير إعداد القراءة فقط هذا بنفسه تمامًا. فهو لا يتفاعل مع أي ميزات للقراءة فقط قد تمتلكها قاعدة البيانات الكامنة ولا يعتمد عليها.

كتلة المعاملة في Exposed

في Exposed، يجب أن تُنفَّذ كل عملية CRUD داخل معاملة. والبنية الأساسية في Exposed للتعامل مع المعاملات هي كتلة transaction.

تنفيذ عمليات قاعدة البيانات في معاملة بهذه السهولة:

transaction {
   // some DSL or DAO operations go here
}

يمكن لكتلة transaction أيضًا إرجاع قيم، لذا إن احتجت إلى مواصلة العمل مع بيانات أنتجتها المعاملة، يمكنك كتابة شيء كهذا:

val boardGame = transaction {
   BoardGame.findById(boardGameId)
}

doSomethingOutsideOfTransaction(boardGame)

تستخدم كتلة transaction قاعدة البيانات الافتراضية ما لم يُقل خلاف ذلك – أي تلك التي اتُّصل بها أخيرًا عبر Database.connect()، أو المعيَّنة في TransactionManager.defaultDatabase. وهذا كافٍ تمامًا عندما يعمل تطبيقك مع قاعدة بيانات واحدة فقط. وإن لم يكن كذلك، يمكنك أن تحدد صراحةً أي قاعدة بيانات ينبغي أن تستخدمها معاملة معينة:

val db = Database.connect("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1", driver = "org.h2.Driver")

transaction(db) {
   // DB operations here
}

وإضافة إلى اختيار قاعدة البيانات، توفر كتلة معاملة Exposed عددًا من خيارات الضبط، منها عزل المعاملة، ووضع القراءة فقط، والحد الأقصى للمحاولات، ومهلة الاستعلام.

وهذه كتلة معاملة مضبوطة بكل هذه الخيارات:

transaction(
   transactionIsolation = Connection.TRANSACTION_REPEATABLE_READ, // values from java.sql.Connection
   readOnly = true // false by default
) {
   maxAttempts = 5 // number of retries on SQLException
   queryTimeout = 10 // in seconds

   // DSL or DAO operations here
}

ضع في اعتبارك أنه، باستثناء maxAttempts، لا يتولى Exposed معالجة أي من هذه المعاملات بنفسه. فهي تُسلَّم إلى مشغّل JDBC الكامن وتعتمد كليًا على دعمه. لذا إذا كان مشغّل JDBC معين لا يدعم بعض هذه الميزات، فلن يكون لها ببساطة أي تأثير.

يقدم Exposed أيضًا ميزات أكثر تقدمًا للتعامل مع المعاملات لم أغطها هنا – مثل المعاملات المتداخلة ونقاط الحفظ (savepoints) ودعم كوروتينات Kotlin. وأنصح بشدة بالقراءة عنها في فصل المعاملات في توثيق Exposed.

التعليق التوضيحي Spring @Transactional

إذن لقد قرأت قسم التعامل مع المعاملات في هذه المقالة بأكمله وما زلت تسأل نفسك: “ماذا حدث للتعليق التوضيحي @Transactional الذي أستخدمه كل يوم؟”

حسنًا، إنه يأتي من إطار Spring. وهناك سببان لعدم ذكره في الأقسام الفرعية السابقة.

أولًا، رغم أن الناس كثيرًا ما يربطون التعليق التوضيحي @Transactional بـ Hibernate، فإنه ليس في الحقيقة ميزة في Hibernate. بل في الواقع قد يكون في ذهنك أحد تعليقين @Transactional:

  • jakarta.transaction.Transactional من معيار JTA،
  • org.springframework.transaction.annotation.Transactional، تنفيذ Spring الخاص للأول.

وهذه المدونة لا تركز على Spring ولا على JTA.

ثانيًا، بما أنه يمكن دمج كل من Hibernate وExposed مع Spring، يمكنك تطبيق التعليق التوضيحي @Transactional مع أي منهما في مشروع قائم على Spring. فهو يعمل بسلاسة مع آليتي التعامل مع المعاملات كلتيهما.

ولنجعل ذلك ملموسًا، لنرَ كيف يتصرف التعليق التوضيحي @Transactional عمليًا مع كل إطار.

بدايةً، خدمة Spring تستدعي مستودع JPA مدعومًا بـ Hibernate:

@Service
open class BoardGamesService(
   private val boardGamesRepository: BoardGamesRepository
) {
   @Transactional
   open fun rateBoardGame(title: String, rating: Int) {
       val boardGame = boardGamesRepository.findByTitle(title) ?: throw EntityNotFoundException()
       val rating = Rating(rating, Instant.now(), boardGame)
       boardGame.ratings.add(rating)
   }
}

بعد ذلك، مقطع مماثل لخدمة Spring تعتمد على Exposed DAOs في حفظ البيانات:

@Service
open class BoardGamesService {
   @Transactional
   open fun rateBoardGame(title: String, rating: Int) {
       val boardGame = BoardGame.find { BoardGamesTable.title eq title }.firstOrNull()
           ?: throw EntityNotFoundException()

       Rating.new {
           this.rating = rating
           this.boardGame = boardGame
       }
   }
}

وكما يبيّن المثالان، كل ما احتجناه لجعل الشيفرة تعمل في معاملة هو وضع @Transactional على الدالة. ولا حاجة إلى استدعاء صريح لـ session في Hibernate أو كتلة transaction في Exposed.

يأتي التعليق التوضيحي Spring @Transactional أيضًا بعدد لا بأس به من خيارات الضبط. راجع توثيق Spring الرسمي حول إدارة المعاملات للتفاصيل.

الخلاصة

بهذا نختتم موضوع اليوم. وفيما يلي ملخص قصير لأهم ما جاء في هذه المقالة.

الاستعلام

يوفر Hibernate طرقًا قوية ومرنة للاستعلام (Criteria API وHQL وSpring Data JPA)، لكنها تأتي مع إسهاب وهشاشة أحيانًا (مثلًا HQL المعتمد على السلاسل النصية).

أما Exposed DSL فهي أكثر إيجازًا وأمانًا للأنواع وتعبيرية – خصوصًا إن كانت دلالات SQL تبدو طبيعية لك.

التعامل مع المعاملات

يدعم الإطاران المعاملات جيدًا، لكنهما يتبعان فلسفتين مختلفتين.

يلتزم Hibernate بنمط الجلسة/المعاملة التقليدي (ويجعل @Transactional من Spring الأمور أسلس).

أما كتلة transaction في Exposed فهي مباشرة وتناسب Kotlin جيدًا وتتيح ضبطًا دقيقًا منذ البداية. ويعمل معها التعليق التوضيحي Spring @Transactional أيضًا.