Hibernate թե՞ Exposed. Kotlin-ի համար լավագույն persistence գործիքի ընտրությունը – Երկրորդ փուլ
Շարքի երկրորդ հոդվածը Hibernate-ն ու Exposed-ը դնում է կողք կողքի տվյալների պահպանման և ստացման, ինչպես նաև տրանզակցիաների կառավարման տեսանկյունից։
Եկել է Hibernate-ի և Exposed-ի մրցակցության երկրորդ փուլի ժամանակը։ Դուք արդեն գիտեք, թե ինչպես են Hibernate-ը և Exposed-ը տարբերվում իրենց նախագծմամբ։ Տեսել եք, թե ինչպես կարգավորել երկու ֆրեյմվորքերը տարբեր միջավայրերում։ Կարող եք տվյալների բազայի աղյուսակները արտապատկերել հավելվածի կոդի համապատասխան աբստրակցիաներին։ Կարող եք նաև սխեման ավտոմատ գեներացնել ձեր դասերից։
Այնուամենայնիվ, այս ամենը դեռ ձեր հավելվածին իրական բիզնես ֆունկցիոնալություն չի տալիս։ Իրական բիզնես արժեքը գալիս է տվյալների վրա հարցումներ անելու, դրանք պահպանելու, փոփոխելու և տրանզակցիաներ սահմանելու հնարավորությունից։
Եվ մի անհանգստացեք. հենց այդ մասին է այս հոդվածը։
Տվյալների պահպանում և ստացում
Նախ դիտարկենք DML-ի (data manipulation language) և հարցումների տարբեր մոտեցումները, որոնք առաջարկում է յուրաքանչյուր ֆրեյմվորք։
Hibernate Criteria API
Hibernate-ի տվյալներ հարցնելու եղանակներից մեկը Criteria API-ն է։ Criteria հարցումները, ըստ էության, տիպային անվտանգությամբ (type-safe) DSL են Hibernate entity-ների վերևում, որը թույլ է տալիս SQL հարցումներ գրել կոդով։ Դե, ոչ ճիշտ SQL հարցումներ, քանի որ, ինչպես նշվել է, Hibernate-ը թաքցնում է ցածր մակարդակի SQL-ը entity-ների հետևում։ Այսպիսով, Criteria API-ով դուք դեռ աշխատում եք entity-ների հետ և օգտագործում եք entity-ների բառապաշարը, այլ ոչ թե ուղղակիորեն խոսում եք տվյալների բազայի աղյուսակների հետ։
Criteria հարցում կառուցելը սովորաբար սկսվում է CriteriaBuilder-ից, որից հետո նշում եք հարցման տարրերը և պարամետրերը՝ ավելի խորանալով Criteria API-ի օբյեկտային գրաֆում։
Ահա Criteria API-ի օգտագործման օրինակ մեր հայտնի BoardGame Hibernate entity-ով.
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-ի հետ աշխատելը բավականին դժվար է և անշնորհք։ Սակայն եթե ուզում եք ավելի խորանալ, նայեք Hibernate-ի փաստաթղթերի Criteria գլուխը։
Hibernate Query Language – HQL
Hibernate-ը տվյալների բազային հարցում անելու մեկ այլ եղանակ ևս տալիս է։ Եթե պատրաստ եք տիպային անվտանգությունը զոհել արտահայտչականության և պարզության համար, Hibernate Query Language-ը (HQL) կարող է արժանի լինել ուշադրության։
HQL-ը օբյեկտ-կողմնորոշված հարցումների լեզու է, որը խիստ նման է SQL-ին, միայն թե ներքևի տվյալների բազայի աղյուսակներին հարցում անելու փոխարեն դուք հարցում եք անում ձեր entity-ներին։
HQL հարցումների տեսակների առումով երկու հիմնական մոտեցում կա.
- Inline հարցումներ – տրվում են որպես տողեր
createQueryմեթոդին runtime-ում։ Հարցման ցանկացած սխալ երևան է գալիս միայն դրա կատարման ժամանակ։ - Named հարցումներ – սահմանվում են նախօրոք 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
Դա inline հարցում էր։ Այժմ նույն հարցումը հայտարարենք որպես named հարցում։ Սկզբում named հարցումը սահմանում ենք BoardGame entity-ի վրա.
@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-ի միայն մակերեսն է։ Լեզուն բավականին հզոր է, ուստի եթե ուզում եք այն ավելի մանրակրկիտ սովորել, Hibernate-ի փաստաթղթերի HQL գլուխը հիանալի մեկնակետ է։
Spring Data JPA repositories
Թեև խիստ ասած դա դուրս է այս հոդվածի շրջանակից, կուզենայի արագ նշել Hibernate-ով տվյալների բազային հարցում անելու ևս մեկ եղանակ, որը հասանելի է միայն Spring-ում։
Spring Data JPA repositories-ը Hibernate-ում առանձին հարցումների մեխանիզմ չէ, այլ աբստրակցիայի շերտ գոյություն ունեցող JPA հարցումների API-ների վերևում, ինտեգրված Spring-ին։
Դա Hibernate-ի բնիկ հնարավորություն չէ, բայց չէի կարծում, թե կարող եմ այն դուրս թողնել Hibernate-ը և Exposed-ը համեմատող հոդվածից, մանավանդ որ Spring Data JPA repositories-ը շատ սիրված են մշակողների շրջանում, և որ դրանք ստանում եք Hibernate-ի հետ, բայց ոչ Exposed-ի հետ։
Ավելին իմանալու համար նայեք Spring-ի փաստաթղթերը JPA repositories-ի մասին։
Exposed DSL
Ինչպես նշվել է, տվյալների բազայի աղյուսակների հետ աշխատելու համար Exposed-ի օգտագործած կենտրոնական աբստրակցիան Table օբյեկտն է։ Սակայն Exposed-ում աղյուսակները ծառայում են ոչ միայն սխեման սահմանելուն. դրանցով նաև հարցումներ են անում և փոփոխում տվյալները։
Նախորդ հոդվածի մեր BoardGamesTable-ի օրինակով՝ ահա թե ինչպես կարելի է դրա վրա կատարել տարբեր գործողություններ, որոնք ընդգրկում են և՛ CRUD (create, read, update, delete), և՛ ավելի բարդ հարցումներ.
// 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-ին։ Մեկ այլ տարբերակ է աղյուսակները միացնելը (join), որպեսզի RatingsTable-ի յուրաքանչյուր ResultRow հարստացվի սեղանի խաղի որոշ առնչվող մանրամասներով.
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 entity-ն նախորդ հոդվածի Mapping & Schema Definition – Exposed DAO բաժնից։ Այդ բաժնում ես ուշադրություն հրավիրեցի entity-ի ներսում հայտարարված LongEntityClass տիպի companion object-ի վրա։ Հենց այս companion object-ն է մեր entity դասին տալիս տվյալների բազայի փոփոխման և հարցումների տարբեր կարողություններ։
Ստորև բերված են BoardGame entity-ների վրա տարբեր գործողությունների օրինակներ՝ արտացոլելով նախորդ բաժնի 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-ն աշխատում է օբյեկտների, այլ ոչ թե աղյուսակի հում տողերի հետ, նրա API-ն խիստ նման է աղյուսակի DSL-ին։ Դրա շնորհիվ DSL-ի օգտագործողները, որոնք մտածում են DAO-ին անցնելու մասին, կարող են այն ծանոթ գտնել։
- Յուրաքանչյուր սեղանի խաղի միջին գնահատականը հաշվարկելն այլևս join-եր չի պահանջում, քանի որ
BoardGameentity-ն ունիratingsհատկություն, որը բեռնում է առնչվող գնահատականները։ Թերությունն այն է, որ միջինը այլևս չենք կարող հաշվել տվյալների բազայում՝ հատուկ հարցումով. DAO-ն աշխատում է entity օբյեկտների և նրանց հատկությունների վրա։ Միջինը պետք է հաշվարկվի կոդում՝ տվյալները ստանալուց հետո։ - Այնուամենայնիվ, նման հարցումները դեռ կարելի է կատարել DSL-ով. DAO-ն մեկ տեղում ընտրելը չի խանգարում DSL-ն օգտագործել հավելվածի այլ մասերում։
- Գուցե տեսել եք նաև
with(BoardGame::ratings)կանչը, որը կիրառվել էBoardGame.all()հարցման արդյունքի վրա։ Այն եռանդուն (eagerly) կերպով բեռնում է յուրաքանչյուրBoardGameentity-ի գնահատականները, քանի որ նախապես գիտենք, որ դրանք մեզ պետք կգան։ - Entity-ները կարելի է թարմացնել երկու եղանակով։ Կարող եք կանչել
BoardGame.findByIdAndUpdate()ֆունկցիան, կամ կարող եք նոր արժեք վերագրել ուղղակիորեն entity-ի հատկությանը։ Առաջին տարբերակը հարմար է այն դեպքերում, երբ գիտեք թարմացվող entity-ի ID-ն, բայց այն տվյալների բազայից չեք բեռնել։ Երկրորդը ավելի լավ է, երբ entity օբյեկտն արդեն բեռնված է, և կարող եք այն փոփոխել ուղղակիորեն։
Exposed DAO entity-ների մասին կա ևս մեկ կետ, որը արժե շեշտել։ Hibernate entity-ները պետք է լինեն սովորական Java (կամ Kotlin) օբյեկտներ, որոնք հնարավորինս անկախ են ֆրեյմվորքից, բայց Exposed DAO entity-ները այդպիսին չեն։
Դրանք սերտորեն կապված են ֆրեյմվորքի հետ.
- Դրանք պետք է ընդլայնեն որոշակի բազային դասեր։
- Դրանք պետք է մատնացույց անեն համապատասխան Exposed Table-ը։
- Դրանց յուրաքանչյուր հատկություն պատվիրակվում է (delegated) Table-ում սահմանված սյունին։
- Վերջապես, դրանք չեն կարող աշխատել առանց կարգավորված տվյալների բազայի միացման։
Սա նշանակալի հետևանքներ ունի։ Exposed DAO entity-ները որպես ձեր domain մոդել՝ այսինքն ձեր բիզնես տրամաբանության շերտում օգտագործելը կարող է դժվարացնել unit թեստերի գրումը։ Պատճառն այն է, որ յուրաքանչյուր թեստի համար կպահանջվի գործարկել (իրական կամ in-memory) տվյալների բազա և կարգավորել տվյալների բազայի միացում։
Ահա թե ինչու սովորական խորհուրդն է խուսափել Exposed DAO entity-ները որպես domain մոդելներ օգտագործելուց և փոխարենը դրանք սահմանափակել persistence շերտով։
Տրանզակցիաների կառավարում
Երբ հավելվածներում ստեղծում եք բիզնես գործընթացներ և աշխատանքային հոսքեր, հաճախ անհրաժեշտ է, որ տրամաբանության որոշ մասեր կատարվեն ատոմարար՝ կամ ամբողջությամբ, կամ ընդհանրապես ոչ։ Աշխատանքի նման միավորը կոչվում է տրանզակցիա։ Մշակողների բախտից՝ ռելացիոն տվյալների բազաներն ունեն տրանզակցիաների իրենց սեփական հասկացությունը, որը մոտավորապես համապատասխանում է բիզնես տրամաբանությունից մեր սպասածին։ Դա կարող է լինել մեկ պատճառ, թե ինչու է մեր կոդը հակված այդքան շատ կախված լինել տվյալների բազայի տրանզակցիոն մեխանիզմներից։
Այսպիսով, երբ ընտրում եք որոշակի persistence ֆրեյմվորք՝ ձեր տվյալների բազայի վերևի աբստրակցիայի շերտ, հավանաբար սպասում եք, որ այն թույլ կտա կառավարել և վերահսկել այդ տրանզակցիաները։ Բարեբախտաբար, այստեղ դիտարկվող երկու ֆրեյմվորքերն էլ աջակցում են դրան, թեև այն անում են փոքր-ինչ տարբեր եղանակներով։
Տեսնենք, թե ինչ է տրամադրում նրանցից յուրաքանչյուրը։
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 պլատֆորմ, քանի որ Hibernate-ի լռելյայն JTAPlatform իրականացումը… NoJtaPlatform-ն է։ Արդյունքում կարող եք տեսնել այսպիսի սխալներ՝ «Could not locate TransactionManager to suspend any current transaction.»։
Ինչպես էլ կարգավորեք տրանզակցիաների կոորդինատորը, Hibernate-ի ստանդարտ, միասնական տրանզակցիաների կառավարման API-ն հասանելի է ձեզ։
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
}
Տրանզակցիայի կյանքի ցիկլի հիմնական վերահսկողությունից (begin, commit, rollback) բացի՝ Hibernate-ը թույլ է տալիս տրանզակցիաները լրացուցիչ կարգավորել ըստ ձեր կարիքների։ Անցնենք ամենահաճախ օգտագործվող տարբերակներից մի քանիսով։
Նախ՝ տրանզակցիաների մեկուսացման մակարդակները (isolation levels)։ Եթե հասկացությունը ձեզ համար նոր է, PostgreSQL-ի փաստաթղթերը լավ ակնարկ են տալիս։
Տրանզակցիայի մեկուսացման մակարդակը փոխելու ամենամաքուր և ամենապաշտոնական եղանակը այն hibernate.properties-ում սահմանելն է.
hibernate.connection.isolation=REPEATABLE_READ
Ընդունելի արժեքների և ձևաչափերի համար տե՛ս Hibernate-ի պաշտոնական փաստաթղթերը միացման մեկուսացման մակարդակի կարգավորման մասին։
Այս կարգավորումը ստատիկ է. այն ազդում է հավելվածի բոլոր session-ների և տրանզակցիաների վրա։ Դուք դեռ կարող եք այն փոխել կոդում Connection ինստանսի վրա Connection.setTransactionIsolation()-ով։ Սակայն իմացեք, որ փոփոխությունը կկիրառվի այդ Connection ինստանսի սպասարկած յուրաքանչյուր session-ի (և տրանզակցիայի) համար։
Մեկուսացման մակարդակը runtime-ում դինամիկ փոխելը յուրաքանչյուր session-ի համար տեսականորեն հնարավոր է, բայց պաշտոնապես փաստաթղթավորված չէ, և ես այն անհուսալի եմ համարում և մի քիչ հաքի նման։ Այդ պատճառով ցույց չեմ տա, թե ինչպես դա անել։ Եթե միևնույն է հետաքրքրում է, նայեք Session.doWork() մեթոդը, որը ուղղակիորեն բացահայտում է ներքևի Connection-ը, և փնտրեք համայնքի օրինակներ առցանց։
Hibernate-ը թույլ է տալիս նաև վերահսկել, թե արդյոք տրանզակցիան միայն կարդալու (read-only) է։ Սա սահմանվում է ըստ session-ի։ Session-ի entity-ները լռելյայն կարելի է փոփոխել։ Սակայն երբ session-ը դարձվում է read-only, Hibernate-ը անջատում է dirty checking-ը այդ session-ի համար։ Այլ խոսքով՝ դուք դեռ կարող եք փոխել entity-ի հատկությունները հիշողության մեջ, բայց փոփոխությունները չեն գրվի տվյալների բազայում։
Session ունենալով՝ կարող եք այն դարձնել read-only հետևյալ կերպ.
session.isDefaultReadOnly = true
Նկատեք, որ Hibernate-ը այս read-only կարգավորումը կառավարում է լիովին ինքնուրույն։ Այն ո՛չ փոխազդում է, ո՛չ էլ հիմնվում է որևէ read-only հնարավորության վրա, որ կարող է ունենալ ներքևի տվյալների բազան։
Exposed transaction block
Exposed-ում յուրաքանչյուր CRUD գործողություն պետք է կատարվի տրանզակցիայի ներսում։ Տրանզակցիաները կառավարելու Exposed-ի հիմնական կառուցվածքը transaction block-ն է։
Տվյալների բազայի գործողությունները տրանզակցիայում կատարելը այսքան հեշտ է.
transaction {
// some DSL or DAO operations go here
}
transaction block-ը կարող է նաև արժեքներ վերադարձնել, ուստի եթե պետք է շարունակեք աշխատել տրանզակցիայի ստեղծած տվյալների հետ, կարող եք գրել այսպիսի բան.
val boardGame = transaction {
BoardGame.findById(boardGameId)
}
doSomethingOutsideOfTransaction(boardGame)
transaction block-ը օգտագործում է լռելյայն տվյալների բազան, եթե այլ բան չասվի. այսինքն՝ այն, որ վերջին անգամ միացվել է 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 block-ն ապահովում է մի շարք կոնֆիգուրացիոն տարբերակներ, այդ թվում՝ տրանզակցիայի մեկուսացում, read-only ռեժիմ, փորձերի առավելագույն քանակ և հարցման timeout։
Ահա transaction block, որը կարգավորված է այս բոլոր տարբերակներով.
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-ը առաջարկում է նաև տրանզակցիաների կառավարման ավելի առաջադեմ հնարավորություններ, որոնք այստեղ չեմ քննարկել. օրինակ՝ ներդրված տրանզակցիաներ, savepoint-ներ և Kotlin coroutines-ի աջակցություն։ Խստորեն խորհուրդ եմ տալիս կարդալ դրանց մասին Exposed-ի փաստաթղթերի Transactions գլխում։
Spring @Transactional annotation
Այսպիսով, դուք անցել եք այս հոդվածի ամբողջ Տրանզակցիաների կառավարում բաժնով և դեռ հարցնում եք ինքներդ ձեզ. «Ի՞նչ եղավ @Transactional անոտացիան, որ ամեն օր օգտագործում եմ»։
Դե, այն գալիս է Spring ֆրեյմվորքից։ Երկու պատճառ կա, թե ինչու այն չհիշատակեցի նախորդ ենթաբաժիններում։
Նախ, թեև մարդիկ հաճախ @Transactional անոտացիան կապում են Hibernate-ի հետ, այն իրականում Hibernate-ի հնարավորություն չէ։ Փաստորեն, ձեր մտքում կարող է լինել երկու @Transactional անոտացիաներից մեկը.
jakarta.transaction.TransactionalJTA ստանդարտից,org.springframework.transaction.annotation.Transactional՝ նախորդի Spring-ի սեփական իրականացումը։
Իսկ այս բլոգ գրառումը կենտրոնացած չէ ո՛չ Spring-ի, ո՛չ JTA-ի վրա։
Երկրորդ, քանի որ և՛ Hibernate-ը, և՛ Exposed-ը կարելի է ինտեգրել Spring-ի հետ, @Transactional անոտացիան կարող եք կիրառել նրանցից յուրաքանչյուրի հետ Spring-ի վրա հիմնված նախագծում։ Այն սահուն աշխատում է տրանզակցիաների կառավարման երկու մեխանիզմների հետ։
Որպեսզի սա շոշափելի դառնա, տեսնենք, թե ինչպես է @Transactional անոտացիան գործնականում վարվում յուրաքանչյուր ֆրեյմվորքի հետ։
Սկզբից՝ Spring սերվիս, որը կանչում է Hibernate-ով ապահովված JPA repository.
@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 սերվիսի համար, որը persistence-ի համար հիմնվում է Exposed DAO-ների վրա.
@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-ով։ Hibernate-ի session-ի կամ Exposed-ի transaction block-ի հստակ կանչ պահանջվում չէ։
Spring-ի @Transactional անոտացիան ևս ունի բավականին շատ կոնֆիգուրացիոն տարբերակներ։ Մանրամասների համար տե՛ս Spring-ի պաշտոնական փաստաթղթերը տրանզակցիաների կառավարման մասին։
Ամփոփում
Այսօրվա համար սա ամենը։ Ահա այս հոդվածի հիմնական եզրակացությունների կարճ ամփոփումը։
Հարցումներ
Hibernate-ը տրամադրում է հզոր և ճկուն հարցումների եղանակներ (Criteria API, HQL, Spring Data JPA), բայց դրանք ուղեկցվում են շատախոսությամբ և երբեմն փխրունությամբ (օրինակ՝ տողերի վրա հիմնված HQL-ը)։
Exposed DSL-ը ավելի հակիրճ է, տիպային անվտանգությամբ և արտահայտիչ, մասնավորապես եթե SQL-ի իմաստաբանությունը ձեզ բնական է թվում։
Տրանզակցիաների կառավարում
Երկու ֆրեյմվորքերն էլ լավ աջակցում են տրանզակցիաներին, բայց հետևում են տարբեր փիլիսոփայությունների։
Hibernate-ը հավատարիմ է մնում ավանդական session/transaction օրինաչափությանը (Spring-ի @Transactional-ը գործերը դարձնում է ավելի սահուն)։
Exposed-ի transaction block-ը պարզ է, լավ է համապատասխանում Kotlin-ին և անմիջապես թույլ է տալիս մանրակրկիտ կարգավորում։ Spring-ի @Transactional անոտացիան նույնպես աշխատում է դրա հետ։