Գնահատել նախագիծը
← Բոլոր հրապարակումները

Hibernate և Exposed. ո՞րն է Kotlin-ի համար լավագույն persistence գործիքը – 1-ին փուլ

Hibernate-ի և Exposed-ի համեմատությունը Kotlin-ում։ Իմացեք, թե որ SQL persistence ֆրեյմվորքն է առավել հարմար ձեր հաջորդ նախագծի համար։

20 րոպե
KotlinKtorKotlinServerSidePersistence

Ներածություն

Persistence-ը և տվյալների պահպանումը ՏՏ համակարգերի առանցքային գաղափարներ են։ Իմ կարիերայի ընթացքում ես շատ ավելի հաճախ եմ հանդիպել վիճակ պահող հավելվածների, քան զուտ stateless հավելվածների։ Տվյալների բազաների հսկայական բազմազանությունը, որոնցից յուրաքանչյուրը կառուցված է տարբեր նպատակի համար, կարծես հաստատում է դա։

Ավելի ուշադիր նայելիս՝ ռելյացիոն տվյալների բազաները դեռ ամենատարածվածն են բոլոր գոյություն ունեցող տվյալների բազաների մեջ։ db-engines.com վարկանիշի վերջին տվյալները ցույց են տալիս, որ ժողովրդականությամբ ռելյացիոն տվյալների բազաները կազմում են շուկայի գրեթե 72%-ը։

relational-databases

Սա նկատի ունենալով՝ ակնհայտ է, թե որքան արժեքավոր է ձեր գործիքակազմում ամուր, հուսալի, արագ և հեշտ օգտագործվող SQL persistence ֆրեյմվորքի առկայությունը։

Յուրաքանչյուր ծրագրավորման լեզու ունի իր փորձարկված SQL ֆրեյմվորքները։ Այս հոդվածում ես կհամեմատեմ JVM-ի երկու լայնորեն օգտագործվող, բայց սկզբունքորեն տարբեր SQL ֆրեյմվորքներ և այն, թե ինչպես են դրանք աշխատում Kotlin նախագծերում։

Ներկայացնեմ.

  • Hibernate – Java persistence ֆրեյմվորք ռելյացիոն տվյալների բազաների համար,
  • Exposed – թեթև, տիպով անվտանգ SQL persistence ֆրեյմվորք, ստեղծված Kotlin-ի համար։

Սա լուրջ մրցամարտ է լինելու։ Սկսենք առաջին փուլը։

Փիլիսոփայություն և նախագծման նպատակներ

Ձեր հաջորդ նախագծի համար persistence ֆրեյմվորք ընտրելուց առաջ պետք է պատասխանել մի քանի հարցի։ Ավելի քիչ ակնհայտներից մեկը կարող է լինել. «Ի՞նչ փիլիսոփայություն է կանգնած տվյալ ֆրեյմվորքի հետևում։»

Սա կարող է ֆրեյմվորք ընտրելու ակնհայտ գործոն չթվալ, բայց, զարմանալիորեն, ժամանակի ընթացքում կարող է խնայել ձեզ շատ դժվարություններից։ Ֆրեյմվորքի փիլիսոփայությունն ընդգրկում է այն, թե ինչու է այն գոյություն ունի, որ խնդիրներին է անդրադառնում (և որոնց՝ ոչ), ինչպես նաև այն, թե ինչպես է դրանք լուծում։ Գալիք նախագծի ձեր ըմբռնման և SQL ինտեգրացիաների շուրջ ձեր (կամ ձեր մշակողների) հմտությունների ու մտածելակերպի ձեր իրազեկվածության հետ համադրված՝ այս գիտելիքը կարող է իսկական օգնություն լինել։

Hibernate

Hibernate-ը persistence ֆրեյմվորք է, որը ամբողջությամբ կառուցված է ORM-ի շուրջ (object-relational mapping)։ Նրա հիմնական նպատակը SQL-ի բարդությունը Java (կամ այստեղ՝ Kotlin) դասերի հետևում թաքցնելն է։ Այն փորձում է թույլ տալ մշակողներին բարդ տվյալների բազայի փոխազդեցություններ սկսել՝ կատարելով պարզ գործողություններ սովորական Java կամ Kotlin օբյեկտների վրա։ Նախագծի կայքում նույնիսկ կա «Relational persistence for idiomatic Java» նշանաբանը։ Այսպիսով, ամբողջ բարդությունը թաքնված է կապոտի տակ՝ ֆրեյմվորքի կոդի ներսում։

Այդուհանդերձ, Hibernate-ը մշակողներին թույլ է տալիս աշխատել հիմքում ընկած տվյալների բազայի հետ ավելի ուղիղ և վերահսկելի ձևով՝ HQL կոչվող հատուկ հարցումների բարբառի միջոցով (դիտարկվում է այս շարքի հաջորդ հոդվածում)։ Սակայն դա դեռ վերացարկում է մաքուր SQL-ի վրա և դեռ իրական բարդությունը թաքցնում է մշակողների աչքից։

Hibernate-ի նախագծման մեկ այլ կարևոր տարր է նրա JPA համատեղելիությունը (Jakarta Persistence, նախկինում կոչվում էր Java Persistence API)։ Hibernate-ը մի ժամանակ նույնիսկ օգնել է ձևավորել JPA-ն, և այսօր այն ստանդարտի ամենալայնորեն օգտագործվող իրականացումներից մեկն է։ Արդյունքում Hibernate-ը կարելի է օգտագործել ամենուր, որտեղ JPA է պետք, բայց այն նաև պետք է համապատասխանի ստանդարտին և հուսալիորեն տրամադրի JPA-ի սահմանած ֆունկցիոնալությունն ու API-ն։ Հետևաբար Hibernate-ի մշակողները կարող են ունենալ ավելի քիչ ազատություն և ճկունություն ֆրեյմվորքը զարգացնելիս, քան կունենային, եթե չպետք է համապատասխանեին կոնկրետ երրորդ կողմի ստանդարտին։

Hibernate-ի փիլիսոփայության մասին խոսելիս դժվար է բաց թողնել տվյալների բազաների լայն շրջանակի աջակցությունը։ Այս տողերը գրելու պահին Hibernate-ի պահպանողները նշում են, որ այն աշխատում է (և փորձարկվում է) PostgreSQL, MySQL, Db2, Oracle, SQL Server, Sybase ASE, EDB, TiDB, MariaDB, HANA, CockroachDB, H2 և HSQLDB-ի հետ։

Տվյալների բազաների շարժունակությունը Hibernate-ի (և ընդհանրապես object-relational mapping-ի) հիմնական առավելություններից մեկն է։ Բացի բազմաթիվ տվյալների բազաների աջակցությունից՝ Hibernate-ը խոստանում է թույլ տալ ձեր հավելվածին աշխատել դրանցից ցանկացածի հետ՝ առանց կոդը փոխելու, իսկ իդեալականում՝ նաև առանց mapping-ի մետատվյալներին դիպչելու։

Exposed

Exposed-ի հեղինակները այն նկարագրում են որպես ORM ֆրեյմվորք Kotlin-ի համար, ինչպես նաև որպես թեթև SQL գրադարան JDBC դրայվերի վրա՝ Kotlin-ի համար։ Իմ կարծիքով՝ երկու նկարագրություններն էլ ճշգրիտ են, բայց անձամբ ես կարծում եմ, որ երկրորդը ավելի լավ է արտացոլում Exposed-ի հիմնական փիլիսոփայությունը։

Exposed-ում տվյալների բազաների հետ խոսելու հիմնական, լռելյայն եղանակը նրա DSL-ն է, որը աշխատում է որպես տիպով անվտանգ SQL Kotlin-ի համար։ Ընտրովի կարող եք ավելացնել թեթև ORM-ի մոդուլ և օգտագործել այն նույն մոդելի վրա, որը սահմանել եք պարզ DSL հարցումների համար։ Այսպիսով՝ որպես մշակող ստանում եք ճկունություն՝ ընտրելու տվյալների բազայի հետ փոխազդեցության ոճը, որն ավելի է համապատասխանում ձեզ։

Արժե ընդգծել, որ ինչ ոճ էլ ընտրեք (DSL կամ ORM), Exposed-ը մնում է «պարզապես» բավականին բարակ շերտ JDBC-ի վրա, ինչը հանգեցնում է մի շատ կարևոր հատկության. դուք ավելի շատ վերահսկողություն ունեք իրականում կատարվող հարցումների վրա, և այն ավելի թափանցիկ է այն հարցում, թե իրականում ինչ է կատարվում տվյալների բազայում։

Exposed ֆրեյմվորքի նախագծման մեկ այլ առանցքային սկզբունք այն է, որ այն աշխատում է բազմաթիվ տարբեր ռելյացիոն տվյալների բազաների հետ։ Այս պահին Exposed-ի թիմը նշում է հետևյալ տվյալների բազաների աջակցությունը՝ H2, MariaDB, MySQL, Oracle, PostgreSQL, Microsoft SQL Server և SQLite։

Վերջապես, Exposed-ն ամբողջությամբ գրված է Kotlin-ով և Kotlin-ի համար և պահպանվում է JetBrains-ի կողմից, այն ընկերության, որը կանգնած է Kotlin-ի հետևում։ Սա արտացոլում է Kotlin-ի իդիոմներին նվիրվածությունը, սեմանտիկան և շարահյուսությունը որպես նախագծման հիմնական սկզբունք։

Սկսելը և կարգավորումը

Ֆրեյմվորքի հետ աշխատելուց առաջ պետք է այն տեղադրել և կարգավորել։ Սովորաբար դա արվում է մեկ անգամ, թեև միկրոսերվիսների դեպքում կարող է պետք լինել մի քանի անգամ անցնել կարգավորման միջով։

Այս բաժնում ես ցույց կտամ մի քանի պարզ օրինակ՝ ինչպես կարգավորել և՛ Hibernate-ը, և՛ Exposed-ը Kotlin նախագծում երեք տարածված էկոհամակարգերում.

  • պարզ JVM
  • Spring
  • Ktor

Յուրաքանչյուր գործիք այս էկոհամակարգերից յուրաքանչյուրում սովորաբար ունի բազմաթիվ կարգավորման տարբերակներ։ Այնպես որ, իրական կոդով պարզ օրինակներից բացի, ես ձեզ կտամ նաև պատկերացում յուրաքանչյուր գործիքը կարգավորելու ավելի առաջադեմ կամ այլընտրանքային եղանակների մասին։

Բավական է տեսությունը, անցնենք անմիջապես կոդին։

Պարզ JVM նախագիծ – Hibernate

Hibernate-ը ձեր Kotlin նախագծին ավելացնելու համար սկսեք build.gradle.kts ֆայլում ճիշտ կախվածությունները հայտարարելով։ Նվազագույնը ձեզ պետք են hibernate-core և տվյալների բազայի դրայվեր (այստեղ՝ PostgreSQL).

dependencies {
   implementation("org.hibernate.orm:hibernate-core:6.6.13.Final")
   implementation("org.postgresql:postgresql:42.7.5")
}

Hibernate-ը տրամադրում է նաև մի շարք լրացուցիչ մոդուլներ, որոնք հասանելի են որպես ընտրովի կախվածություններ։ Ամբողջական ցանկը կգտնեք Getting Started ուղեցույցի Hibernate ORM Modules մասում։

Հետո պետք է տրամադրել միացման տվյալներ և այլ հատկություններ։ Բնիկ JVM հավելվածում ստանդարտ մոտեցումն այն է, որ դրանք դրվեն classpath-ում գտնվող hibernate.properties ֆայլում (այստեղ՝ src/main/resources թղթապանակում).

hibernate.connection.url=jdbc:postgresql://localhost:5432/boardgames
hibernate.connection.username=bgamer
hibernate.connection.password=pass

hibernate.hbm2ddl.auto=create

Սրանք միացման հիմնական տարբերակներն են (DDL ստեղծման ռեժիմի հետ միասին)։ Կարգավորման տարբերակների ամբողջական ցանկը կարելի է գտնել Hibernate User Guide-ի հավելվածում։

Վերջապես, կոդում ստեղծում եք SessionFactory, որը թույլ է տալիս բացել իրական տվյալների բազայի միացումներ.

fun main() {
   val registry = StandardServiceRegistryBuilder().build()

   val sessionFactory =
       MetadataSources(registry)
           .addAnnotatedClass(MyEntity::class.java)
           .buildMetadata()
           .buildSessionFactory()

SessionFactory-ն առկա լինելու դեպքում կարող եք ստեղծել սեսիաներ և տրանզակցիաներ և աշխատել հիմքում ընկած տվյալների բազայի հետ։

Պարզ JVM նախագիծ – Exposed

Exposed-ը պարզ Kotlin նախագծում օգտագործելու համար ձեր build.gradle.kts-ին ավելացրեք մի քանի կախվածություն՝ հենց Exposed-ի և տվյալների բազայի դրայվերի համար (այստեղ՝ PostgreSQL).

dependencies {
   implementation("org.jetbrains.exposed:exposed-core:$exposed_version")
   implementation("org.jetbrains.exposed:exposed-jdbc:$exposed_version")
   implementation("org.postgresql:postgresql:42.7.5")
}

Exposed-ն ունի նաև որոշ ընտրովի մոդուլներ։ Դրանք բոլորը թվարկված են Exposed-ի փաստաթղթերի կայքի Modules բաժնում։

Exposed-ի կարգավորման հաջորդ և վերջին քայլը տվյալների բազայի միացման սահմանումն է։ Դա արվում է ուղղակիորեն Kotlin կոդում՝ Database.connect() ֆունկցիայի կանչով.

Database.connect(
   url = "jdbc:postgresql://localhost:5432/boardgames",
   driver = "org.postgresql.Driver",
   user = "bgamer",
   password = "pass"
)

Database.connect() ֆունկցիայի մի քանի տարբերակ կա, որոնք թույլ են տալիս այն կարգավորել ընտրովի պարամետրերի մի շարքով։ Կա նաև այս ֆունկցիայի տարբերակ, որը վերցնում է javax.sql.DataSource, այնպես որ կարող եք այն կարգավորել տվյալների բազայի միացումների pooling-ի հայտնի գրադարանների ավելի առաջադեմ հնարավորություններով և այլն։

Եվ վերջ. Exposed-ն այժմ կարող է խոսել ձեր տվյալների բազայի հետ։

Spring – Hibernate

Hibernate-ը Spring-ի (Boot) հետ համադրված՝ շատ տարածված կոնֆիգուրացիա է, որը հանդիպում է բազմաթիվ ձեռնարկությունային հավելվածներում։ Վեբը լի է նյութերով, որոնք բացատրում են, թե ինչպես կարգավորել այն։ Այդուհանդերձ, ես կարծեցի, որ արժե այստեղ ընդգրկել այն՝ պատկերը լրացնելու համար։

Ինչպես միշտ, սկսում ենք Gradle-ի կախվածություններից.

dependencies {
   implementation(platform("org.springframework.boot:spring-boot-starter-parent:3.4.4"))

   implementation("org.springframework.boot:spring-boot-starter-data-jpa")
   implementation("org.postgresql:postgresql:42.7.5")
}

Դրանք տեղում լինելու դեպքում կարող եք կարգավորել տարբեր տվյալների աղբյուրներ և Hibernate-ի հատկություններ application.yaml կամ application.properties ֆայլում.

spring:
 datasource:
   url: "jdbc:postgresql://localhost:5432/boardgames"
   username: bgamer
   password: pass

 jpa:
   hibernate:
     ddl-auto: create

Ձեր տվյալների աղբյուրը աջակցում է շատ ավելի հատկությունների։ Դրանցից որոշներին ծանոթանալու համար տե՛ս Spring Boot-ի պաշտոնական փաստաթղթերում հավելվածը, որը թվարկում է հավելվածի ընդհանուր հատկությունները, և փնտրեք spring.datasource նախածանցով սկսվող հատկությունները։

Այս պահից սկսած կարող եք ներարկել SessionFactory ձեր persistence շերտ՝ տվյալների բազայի հետ աշխատելու համար։ Ինչպես գուցե արդեն գիտեք, Spring-ը տրամադրում է տվյալների բազայի փոխազդեցության համար ավելի բարձր մակարդակի API-ներ, քան հում SessionFactory-ն, բայց դրանք կքննարկվեն շարքի հաջորդ հոդվածում։

Spring – Exposed

Exposed-ը աշխատում է նաև Spring հավելվածներում։ JetBrains-ը մշակել է հատուկ Spring Boot starter Exposed-ի համար։ Exposed-ը ձեր Spring Boot նախագծում օգտագործելու համար ավելացրեք այս starter-ը մի քանի այլ կախվածությունների հետ ձեր build.gradle.kts ֆայլում.

dependencies {
   implementation(platform("org.springframework.boot:spring-boot-starter-parent:3.4.4"))

   implementation("org.jetbrains.exposed:exposed-spring-boot-starter:0.61.0")
   implementation("org.postgresql:postgresql:42.7.5")
}

Ինչպես կսպասեիք, տվյալների բազայի միացումն այժմ կարելի է կարգավորել application.yaml (կամ .properties) ֆայլում։ Ինչպես նշվեց, Exposed-ը կարելի է կարգավորել ստանդարտ javax.sql.DataSource-ով, ուստի հատկությունները շատ ծանոթ կլինեն, այսպես.

spring:
 datasource:
   url: "jdbc:postgresql://localhost:5432/boardgames"
   username: bgamer
   password: pass

 exposed:
  generate-ddl: true

Այժմ պատրաստ եք օգտագործել Exposed DSL կամ DAO դասերը ձեր հավելվածի կոդում։

Ktor – Hibernate

Spring-ի դեպքում կարող էի հանգիստ ենթադրել, որ ֆրեյմվորքն այնքան հայտնի և տարածված է, որ ներածության կարիք չունի։ Սակայն Ktor-ի պարագայում կարող է այլ պատմություն լինել։ Այս հոդվածը Ktor-ի մասին չէ և նպատակ չունի մանրամասնորեն անդրադառնալ այս վեբ ֆրեյմվորքին։

Երբ վեբում փնտրում եք Ktor-ի Hibernate-ի հետ ինտեգրման օրինակներ, առաջին բանը, որ հավանաբար կնկատեք, այն է, որ… դրանք գրեթե չկան։ Մի խոսքով, Ktor-ը և Hibernate-ը կարծես այնքան անսովոր զույգ են, որ փաստաթղթեր, բլոգային գրառումներ կամ կիրառության դեպքեր առցանց դժվար է գտնել։ Գուցե դա պայմանավորված է նրանով, որ Hibernate-ն այնքան սերտ կապված է JPA ստանդարտի հետ, որ ավելի տանը է զգում Spring-ի հետ, քան Ktor-ի։ Դա կարող է պայմանավորված լինել նաև (սփոյլեր!) Ktor-ի և Exposed-ի իրար լավ համապատասխանելով, ինչպես կտեսնեք հաջորդ բաժնում։ Ամեն դեպքում Hibernate-ի օգտագործումը Ktor հավելվածներում սովորական պրակտիկա չէ։ Այս տողերը գրելու պահին Ktor-ը Hibernate-ի համար plugin չի տրամադրում։

Ուրեմն ի՞նչ խորհուրդ կտայի, եթե ուզում եք Hibernate ձեր Ktor նախագծում։ Պարզապես վերադարձեք այս հոդվածի ավելի վաղ բաժին՝ «Hibernate պարզ JVM նախագծում», և հետևեք այնտեղ նկարագրված քայլերին։ Ktor նախագիծը, ի վերջո, պարզապես ևս մեկ JVM նախագիծ է, ուստի Hibernate-ի պարզ կարգավորումը այնտեղ նույնպես կաշխատի։ Կամ… կարող եք գրել ձեր սեփական Ktor plugin Hibernate-ի համար։

Ktor – Exposed

Նախորդ բաժնում ես նշեցի, որ Ktor-ը և Hibernate-ը չունեն պաշտոնական աջակցություն և համատեղելիություն։ Այս բաժինը ճիշտ հակառակն է։ Եթե ուզում եք Exposed Ktor նախագծում, բախտավոր եք. երկուսը ապրում են կատարյալ սիմբիոզով։ Գոյություն ունի պաշտոնական Exposed plugin Ktor-ի համար, որը հասանելի է Ktor Project Generator-ում։ Exposed-ի փաստաթղթերը նաև ներառում են կոդի օրինակներ, որոնք ցույց են տալիս, թե ինչպես ինտեգրել Exposed-ը Ktor-ի հետ։ Դրանից բացի՝ այս թեմայով կգտնեք բազմաթիվ հոդվածներ, բլոգային գրառումներ, ձեռնարկներ և այլն։

Exposed-ը Ktor-ին ավելացնելը բոլորովին բնական է զգացվում։ Սկսելու ամենապարզ եղանակը վերը նշված Ktor Project Generator-ն է, որտեղ կարող եք ընտրել Exposed plugin-ը։ Նրա ստեղծած նախագծի կմախքն արդեն կներառի պահանջվող Gradle կախվածությունները։ Տեղեկանքի համար՝ ահա դրանք.

dependencies {
   implementation("org.jetbrains.exposed:exposed-core:$exposed_version")
   implementation("org.jetbrains.exposed:exposed-jdbc:$exposed_version")

   implementation("com.h2database:h2:$h2_version")

   ...
}

Generator-ը կավելացնի այլ կախվածություններ, բայց սրանք Exposed-ի համար էականներն են։

Լռելյայն Ktor Project Generator-ը ավելացնում է H2 տվյալների բազայի դրայվերի կախվածություն, բայց բնականաբար կարող եք այն փոխարինել ցանկացած JDBC դրայվերով, որը նախընտրում եք։

Նախնական նախագծի կառուցվածքը ձեզ տալիս է նաև Databases մոդուլ Databases.kt ֆայլում, տվյալների բազայի արդեն սահմանված միացումով.

fun Application.configureDatabases() {
   val database = Database.connect(
       url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
       user = "root",
       driver = "org.h2.Driver",
       password = "",
   )
  ...
}

Կրկին՝ Database կարգավորումը լռելյայն ուղղված է H2-ին, բայց կարող եք այն փոխել՝ համապատասխանեցնելով ձեր նախագծի օգտագործած տվյալների բազային։

Հավանաբար կգտնեք նաև լրացուցիչ ստեղծված կոդ, օրինակ՝ UserService, բայց դա միայն օրինակ է, որը ցույց է տալիս, թե ինչպես աշխատել DB-ի հետ Exposed API-ի միջոցով, և կարող եք այն ջնջել կամ հարմարեցնել ըստ կարիքի։

Ինչպես տեսնում եք, ստեղծված կոդը կոշտ կոդավորում է միացման տվյալները, բայց դուք կարող եք դրանք փոխարենը ներարկել հատկությունների միջոցով։

Վերջին քայլը (որը նույնպես անում է Ktor Generator-ը) Database մոդուլը Application-ում կարգավորելն է։ Դա տեղի է ունենում Application.kt ֆայլում.

fun Application.module() {
   ...
   configureDatabases()
   ...
}

Այնտեղ կարող են կարգավորվել նաև այլ մոդուլներ։

Եվ սա ամենն է, ինչ պետք է Exposed-ը Ktor-ի հետ Kotlin նախագծում կարգավորելու համար։

Mapping և սխեմայի սահմանում

Ցանկացած persistence ֆրեյմվորք տվյալների կառուցվածքներ է պահանջում՝ աշխատելու համար։ Ռելյացիոն տվյալների բազաներն ունեն աղյուսակներ, բայց persistence ֆրեյմվորքները հազվադեպ են ուղղակիորեն աշխատում հում աղյուսակների հետ։ Դրանք սովորաբար պահանջում են վերացարկում՝ շերտավորված դրանց վրա։ Hibernate-ը և Exposed-ը բացառություն չեն։ Այս բաժնում ես ցույց կտամ, թե ինչպես է դրանցից յուրաքանչյուրը վերացարկում տվյալների բազայի աղյուսակները և ներկայացնում ձեր տվյալների սխեման։

Hibernate entity-ներ

Hibernate-ը object-relational mapping ֆրեյմվորք է և լուրջ է վերաբերվում այդ դերին։ Տվյալների բազայի աղյուսակները ներկայացնում են ռելյացիոն կողմը, իսկ Hibernate-ը ապահովում է, որ ձեր կոդը գործ ունենա օբյեկտների հետ՝ թաքցնելով տվյալների բազայի կառուցվածքը ներքևում։ Դրա համար Hibernate-ը մեծապես ապավինում է entity-ներին. սովորական Java (կամ այստեղ՝ Kotlin) օբյեկտներ, որոնք ներկայացնում են տվյալների բազայի աղյուսակները։ Entity-ները Hibernate-ի հիմնական հասկացություն են։

Ահա օրինակ entity, որը ներկայացնում է տվյալների բազայի աղյուսակը երևակայական սեղանի խաղերի խանութում.

@Entity
@Table(name = "board_games")
open class BoardGame(
   @Column(name = "title", nullable = false)
   open var title: String,

   @Column(name = "min_players", nullable = false)
   open var minPlayers: Int,

   @Column(name = "max_players", nullable = false)
   open var maxPlayers: Int,

   @Column(name = "playtime_minutes", nullable = false)
   open var playTimeInMinutes: Int,

   @OneToMany(mappedBy = "boardGame", cascade = [CascadeType.ALL], orphanRemoval = true)
   open val ratings: MutableSet<Rating> = mutableSetOf(),

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   @Column(name = "id", nullable = false)
   open var id: Long? = null
) {
   constructor() : this("", 0, 0, 0) 
}

Hibernate entity-ների առանցքային հատկանիշն այն է, որ դրանք պարզապես սովորական օբյեկտներ են։ Դրանք պարտադիր չէ ժառանգեն որոշակի բազային դասեր կամ պարունակեն ֆրեյմվորքին հատուկ որևէ այլ կոդ։ Annotation-ներն են դրանք դարձնում Hibernate entity-ներ։ Սա Hibernate-ի փիլիսոփայության հիմքում է. չխանգարել ձեր դոմենային կոդին և չպարտադրել որոշակի ժառանգման հիերարխիաներ կամ ֆրեյմվորքին հատուկ կառուցվածքներ (բացի annotation-ներից, որոնք ավելի շատ մետատվյալների դեր են կատարում, քան իրական տրամաբանության)։

Նկատի ունեցեք, որ թեև Kotlin-ը շատ սեղմ լեզու է, JPA entity-ներ սահմանելը ստիպում է զոհաբերել նրա շարահյուսական շաքարի մի մասը։ JPA-ն պարտադրում է մի քանի սահմանափակում, օրինակ.

  • Entity դասը պետք է տրամադրի առանց արգումենտների կոնստրուկտոր
  • Entity դասը չի կարող լինել final։
  • Entity դասի ոչ մի մեթոդ կամ persistent instance փոփոխական չի կարող լինել final։

Թեև այս բոլորը գալիս են JPA-ի սպեցիֆիկացիայից, Hibernate-ը խստորեն պարտադրում է միայն առաջինը։ Առանց կոնստրուկտորի առանց արգումենտների՝ Hibernate-ը նետում է org.hibernate.InstantiationException, երբ փորձում է entity-ն բեռնել տվյալների բազայից։

Ինչ վերաբերում է մյուս երկու կանոններին, Hibernate-ը կարող է պահպանել և բեռնել final դաս final հատկություններով, բայց չի կարող դրա ենթադաս ստեղծել կամ վերասահմանել նրա getter/setter-ները։ Արդյունքում Hibernate-ը չի կարող ստեղծել proxy-ներ lazy loading-ի համար։ Գործնականում, ուրեմն, դուք դեռ պետք է յուրաքանչյուր Hibernate entity-ն և նրա հատկությունները նշեք որպես open և հեռու մնաք Kotlin data class-ներից (որոնք չեն կարող լինել open)։

Եթե բայթկոդի փոքր կախարդանքը ձեզ չի անհանգստացնում, Gradle-ի և Maven-ի plugin-ները կարող են օգնել։ no-arg plugin-ը (փաթաթված kotlin-jpa plugin-ով) ստեղծում է առանց արգումենտների կոնստրուկտորներ յուրաքանչյուր համապատասխան դասի համար։ all-open plugin-ը (փաթաթված kotlin-spring plugin-ով) համապատասխան դասերը և դրանց անդամները դարձնում է open։ Երկու plugin-ներն էլ դա իրականացնում են՝ փոփոխելով ձեր հավելվածի բայթկոդը։

Hibernate entity-ների մասին ավելին իմանալու համար տե՛ս Hibernate-ի պաշտոնական փաստաթղթերի Domain Model բաժինը։

Hibernate-ի սխեմայի ստեղծումը

Entity-ները սահմանելուց հետո Hibernate-ը կարող է ստեղծել տվյալների բազայի աղյուսակները ձեզ համար entity դասերի և դրանց հատկությունների annotation-ների հիման վրա։ Hibernate-ն այդ նպատակով ունի ներկառուցված մեխանիզմ, որն աշխատում է և՛ պարզ JVM նախագծում, և՛ Spring-ի հետ։ Hibernate-ի սխեմայի ավտոմատ ստեղծումը կարող է գործել մի քանի մակարդակներով.

  • create – ջնջում է սխեման և հետո նորից ստեղծում
  • create_drop – ջնջում է սխեման, երբ SessionFactory-ն անջատվում է, և նորից ստեղծում, երբ SessionFactory-ն սկսվում է
  • create_only – պարզապես ստեղծում է սխեման (առանց ջնջելու)
  • drop – պարզապես ջնջում է սխեման
  • update – փոփոխում է գոյություն ունեցող սխեման
  • validate – միայն ստուգում է սխեման entity-ների համեմատ
  • none – գուցե անսպասելիորեն, սխեման թողնում է անփոփոխ

Սխեմայի ավտոմատ ստեղծումը կարգավորվում է կամ hibernate.config ֆայլում՝ hibernate.hbm2ddl.auto հատկությամբ, կամ Spring նախագծի application.properties (կամ .yaml) ֆայլում՝ jpa.hibernate.ddl-auto հատկությամբ։

Hibernate User Guide-ն ունի սխեմայի ստեղծմանը նվիրված բաժին, եթե ցանկանում եք թեմայի մեջ ավելի խորանալ։

Exposed աղյուսակներ

Տվյալների վերացարկման շերտի համար Exposed-ը մի փոքր այլ կերպ է մոտենում, քան Hibernate-ը։ Մինչ Hibernate-ն ամբողջությամբ կառուցված է entity-ների վրա, Exposed-ը տվյալների բազայի աղյուսակները մոդելավորում է որպես… իրական աղյուսակներ։

Exposed-ում աղյուսակը հիմնականում օբյեկտ է, որը ժառանգում է կամ Table, կամ IdTable դասերից մեկը։ Այս բազային դասերի տրամադրած ֆունկցիաներով սահմանում եք ձեր աղյուսակի սյուները, ինդեքսները և սահմանափակումները։

Ահա, թե ինչ տեսք կարող է ունենալ մեր սեղանի խաղերի խանութի աղյուսակը Exposed-ում.

object BoardGamesTable: LongIdTable("board_games") {
   val title = varchar("name", 256)
   val minPlayers = integer("min_players")
   val maxPlayers = integer("max_players")
   val playTimeInMinutes = integer("playtime_minutes")
}

BoardGamesTable օբյեկտը սահմանում է board_games database աղյուսակի յուրաքանչյուր սյուն, որը մեզ պետք է։ Բացահայտ id սյուն չկա, քանի որ բազային LongIdTable դասն այն արդեն հայտարարում է։

Գուցե նկատել եք, որ այստեղ ratings հավաքածու չկա։ Պատճառն այն է, որ Exposed աղյուսակները արտացոլում են իրական տվյալների բազայի աղյուսակները սյուն առ սյուն։ Քանի որ board_games – ratings կապը one-to-many է, ratings աղյուսակը սեփականատեր կողմն է, ուստի հղման սյունը գտնվում է հենց այնտեղ։

Ահա RatingsTable-ի սահմանումը, որպեսզի տեսնեք, թե ինչպես է կապը հայտարարվում.

object RatingsTable: LongIdTable("ratings") {
   val rating = integer("rating")
   val comment = varchar("comment", 256).nullable()
   val ratingDate = timestamp("rating_date")
   val boardGameId = reference("board_game_id", BoardGamesTable)
}

boardGameId հատկությունը ներկայացնում է board_game_id սյունը և մատնանշում է BoardGamesTable.id հատկությունը։

Exposed աղյուսակների մասին ավելին կարելի է գտնել Exposed-ի պաշտոնական փաստաթղթերի համապատասխան բաժնում։

Exposed DAO

Թեև Table օբյեկտները Exposed-ում տվյալների բազայի աղյուսակների հետ աշխատելու լռելյայն և ամենահիմնական եղանակն են, ընտրովի մոդուլը Exposed-ը վերածում է նաև թեթև ORM-ի։ Դիտարկենք Exposed DAO մոդուլը հիմա։

DAO մոդուլը թույլ է տալիս սահմանել entity-ներ, որոնք տվյալների բազայի աղյուսակների գրառումները արտապատկերում են Kotlin օբյեկտների վրա։ Entity-ները Exposed IdTables-ի վրա ավելացնում են ևս մեկ վերացարկման շերտ։ Այլ կերպ ասած՝ ձեզ դեռ պետք են նախորդ բաժնի Table-ները, և դրանց վրա սահմանում եք համապատասխան entity-ներ։

Ահա, թե ինչպես կարող է entity-ն հետագայում վերացարկել մեր BoardGamesTable-ը.

class BoardGame(id: EntityID<Long>): LongEntity(id) {
   companion object: LongEntityClass<BoardGame>(BoardGamesTable)

   var title by BoardGamesTable.title
   var minPlayers by BoardGamesTable.minPlayers
   var maxPlayers by BoardGamesTable.maxPlayers
   var playTimeInMinutes by BoardGamesTable.playTimeInMinutes
   val ratings by Rating referrersOn RatingsTable.boardGameId
}

Ուրեմն ի՞նչ է կատարվում այս կոդում։ Վերլուծենք։

Կա BoardGame դաս, որը ժառանգում է org.jetbrains.exposed.dao.LongEntity բազային դասը։

Նրա companion object-ը, LongEntityClass տիպի, տրամադրում է հարմար ֆունկցիաներ այս տիպի entity-ների վրա CRUD գործողությունների համար (որոնք կքննարկվեն շարքի հաջորդ հոդվածում)։ Այն նաև կապում է entity դասը համապատասխան Exposed Table օբյեկտի հետ։

Entity դասի հատկությունները ներկայացնում են հիմքում ընկած աղյուսակի սյուները և իրականացվում են by հիմնաբառով։ Այլ կերպ ասած՝ BoardGame-ի հատկությունները պատվիրակում են BoardGamesTable-ի հատկություններին։

Սակայն այս անգամ մենք սահմանափակված չենք հիմքում ընկած աղյուսակի սյուներով։ Ինչպես գուցե տեսել եք, BoardGame entity-ն ունի ratings հատկություն, որը ներկայացնում է one-to-many կապը BoardGame և Rating entity-ների միջև։ Հիշեք, որ այսպիսի հատկությունը, որը փաթաթված է referrersOn ֆունկցիայով, պետք է լինի անփոփոխ – ուստի հայտարարեք այն որպես val, ոչ թե var։ Մնացած հատկությունները կարող են լինել կա՛մ val, կա՛մ var՝ կախված այն բանից, թե պետք է անփոփոխ լինեն, թե փոփոխական։

Exposed-ի պաշտոնական փաստաթղթերը պարունակում են ամբողջական խորը բաժին DAO-ների և entity-ների մասին, որը արժե ուսումնասիրել։

Exposed-ի սխեմայի ստեղծումը

Ինչպես ցանկացած ամուր persistence ֆրեյմվորք պետք է անի, Exposed-ը թույլ է տալիս ոչ միայն կոդում մոդելավորել գոյություն ունեցող տվյալների բազայի սխեման, այլև ստեղծել սխեման ձեր դասերից։

Դրա համար օգտագործում եք SchemaUtils օբյեկտը, որն առաջարկում է տվյալների բազայի սխեմայի հետ աշխատելու հարմար ֆունկցիաների շարք։

Ամենատիպիկ օգտագործումը հիմքում ընկած տվյալների բազայում որոշակի աղյուսակներ ստեղծելն է.

SchemaUtils.create(BoardGamesTable, RatingsTable)

Դրանից բացի՝ այն տրամադրում է ֆունկցիաներ բազմաթիվ այլ խնդիրների համար. աղյուսակների ջնջում, ինդեքսների ստեղծում, սահմանափակումների ավելացում, ամբողջ սխեմայի ստեղծում, դրա վավերացում, աղյուսակների կապերում ցիկլերի հայտնաբերում և շատ ավելին։

Լրացուցիչ մանրամասների համար տե՛ս Exposed-ի փաստաթղթերը սխեմաների հետ աշխատելու մասին։ Կարող եք նաև թերթել հենց SchemaUtils օբյեկտը՝ տեսնելու, թե ինչ ֆունկցիաներ է այն առաջարկում։

Ամփոփում. Hibernate թե՞ Exposed

Կարծում եմ՝ սա բավականին խորը սուզում էր։ Հուսով եմ՝ ճանապարհին ընտրել եք շատ հետաքրքիր և գործնական բաներ։ Արագ ամփոփենք, թե ինչ ընդգրկեցինք։

Փիլիսոփայություն և նախագծման նպատակներ

Hibernate-ը հասուն, լիարժեք ORM է՝ ուժեղ JPA արմատներով և տվյալների բազաների լայն աջակցությամբ։ Նրա փիլիսոփայությունը կենտրոնանում է SQL-ը Java/Kotlin օբյեկտների հետևում թաքցնելու վրա։

Exposed-ը, ընդհակառակը, բնիկ է Kotlin-ի համար և նպատակ ունի լինել թեթև և թափանցիկ։ Այն ձեզ տալիս է ավելի շատ վերահսկողություն և պատկերացում իրականում կատարվող SQL-ի վրա։

Կարգավորում և էկոհամակարգին համապատասխանություն

Hibernate-ը գերազանցում է JPA-կենտրոն էկոհամակարգերում, ինչպիսին Spring-ն է, ապավինելով ամուր գործիքակազմին և լայն կիրառմանը։ Ktor-ում կամ պարզ JVM կոնֆիգուրացիաներում, սակայն, այն որոշ չափով անհարմար է զգացվում։

Exposed-ը, մյուս կողմից, բնականորեն համապատասխանում է Ktor-ին և լավ է աշխատում մինիմալիստական կամ Kotlin-first ստեկերում։ Այն աջակցում է նաև Spring-ին, թեև այդ օգտագործումը, թերևս, ավելի շատ նիշային է։

Mapping և սխեմայի սահմանում

Hibernate-ի JPA մոդելը շատ բնական չի համընկնում Kotlin-ի հետ (օր.՝ առանց արգումենտների կոնստրուկտորներ, open դասեր), ինչը կարող է հակասել իդիոմատիկ Kotlin կոդի հետ։

Exposed-ի DSL և DAO մոդուլները խաղում են Kotlin-ի ուժեղ կողմերի վրա, թեև DAO entity-ները կարող են ի վերջո ամուր կապված լինել persistence տրամաբանության հետ։

Ուրեմն ո՞վ է հաղթում։ Դեռ շատ վաղ է ասելու։