Ծանոթություն Ktor-ին Spring Boot-ի տեսանկյունից։ Մաս 1
Այս հոդվածը նախատեսված է այն մշակողների համար, ովքեր գիտեն Spring Boot և ուզում են անցնել Ktor-ին՝ հիմնվելով արդեն ծանոթ գիտելիքների վրա։ Համեմատելով հիմնական հասկացությունները, ինչպիսիք են հավելվածի կարգավորումը, ռոութինգը և dependency injection-ը, մենք կտեսնենք, թե ինչպես է Ktor-ն աշխատում ներսից և ինչպես է նրա դիզայնը համապատասխանում Kotlin-ի իդիոմներին։
Երբ Java-ից անցնում եք Kotlin, կարող եք սկսել ուսումնասիրել Kotlin-ի համար բնիկ կառուցված ֆրեյմվորքերը։ Kotlin-ի գերազանց ինտեգրելիության շնորհիվ ձեր արդեն ունեցած Java գործիքներն օգտագործելը լիովին նորմալ է, բայց կարող եք նաև ցանկանալ փորձել մի նոր բան, որն ամբողջությամբ օգտագործում է Kotlin-ի առաջարկած հնարավորությունները։
Վեբ հավելվածների մշակման համար կարող եք ընտրել՝ մնալ ժամանակի փորձությունն անցած Spring Boot-ի վրա, որը հարթ աշխատում է Kotlin-ի հետ, թե՞ անցնել Ktor-ին՝ ֆրեյմվորքի, որը սկզբից նախագծված է Kotlin-ի առանձնահատուկ հնարավորությունների և իդիոմների շուրջ։
Երկու ֆրեյմվորքերն էլ նպատակ ունեն պարզեցնել վեբ մշակումը, սակայն որոշ առումներով նրանց փիլիսոփայություններն ու մոտեցումները տարբերվում են։ Spring Boot-ը առաջարկում է հզոր, սեփական կարծիք ունեցող գործիքակազմ՝ ցանկացած չափի հավելվածների համար, մինչդեռ Ktor-ը թեթև, ճկուն ֆրեյմվորք է, որ կառուցված է Kotlin-ի համար՝ մշակողի փորձառությունը նկատի ունենալով։
Այս հոդվածը նպատակաուղղված է այն մշակողներին, ովքեր գիտեն Spring Boot և ուզում են անցնել Ktor-ին՝ հիմնվելով արդեն գիտեցածի վրա։ Համեմատելով հիմնական հասկացությունները, ինչպիսիք են հավելվածի կարգավորումը, ռոութինգը և dependency injection-ը, մենք կտեսնենք, թե ինչպես է Ktor-ն աշխատում ներսից և ինչպես է նրա դիզայնը համապատասխանում Kotlin-ի իդիոմներին։ Մենք նաև կդիտարկենք, թե որտեղ են նրանք տարբերվում և որտեղ նման, որպեսզի արագ արդյունավետ դառնաք և չծանրաբեռնվեք։
Նշում. Քանի որ թեման շատ լայն է, հոդվածը բաժանել եմ երկու մասի։ Առաջինը մանրամասն անդրադառնում է Application Setup-ին, Server Engines-ին, Configuration-ին և Dependency Injection-ին։ Երկրորդը ներառում է HTTP հարցումների մշակումը և բացառությունների մշակումը, HTTP կլիենտները և թեստավորումը։
Եթե ցանկանում եք սովորել Ktor-ը՝ կապելով այն արդեն գիտեցածի հետ, այս հոդվածը ձեզ համար է։ Սկսենք և տեսնենք, թե ինչպես է Ktor-ը Kotlin-ի ֆունկցիոնալ ոճը բերում վեբ մշակմանը։
Հավելվածի կարգավորումը
Վեբ հավելվածներ կառուցելիս մշակողների առջև ծառացող առաջին մարտահրավերներից մեկը նախագիծը ստեղծելն է և հավելվածը գործարկելը՝ իրեն անհրաժեշտ կարգավորումներով։ Սա ներառում է հիմքում ընկած servlet շարժիչի գործարկումը, կախվածությունների կարգավորումը և հավելվածի մոդուլների սահմանումը։ Spring Boot-ը և Ktor-ը երկուսն էլ թույլ են տալիս արագ սկսել, բայց դա անում են շատ տարբեր ձևերով։
Spring boot
Spring Boot-ը առաջնորդվում է «կոնվենցիան կարգավորումից վեր» սկզբունքով, որը հավելվածը գործարկելու համար անհրաժեշտ boilerplate-ը հասցնում է նվազագույնի։ Տիպիկ Spring Boot հավելվածը սկսվում է մուտքի կետի դասով, որը նշված է @SpringBootApplication-ով՝
@SpringBootApplication
class MyApp
fun main(args: Array<String>) {
runApplication<MyApp>(*args)
}
Այդ մեկ անոտացիան միացնում է հետևյալ հնարավորությունները՝
- Դասը նշանակում է որպես bean-երի սահմանումների աղբյուր
- Միացնում է Spring Boot-ի ավտո-կոնֆիգուրացիայի մեխանիզմը
- Սկանավորում է հավելվածի փաթեթների հիերարխիան՝ կոմպոնենտներ գտնելու համար
Spring Boot-ի «կախարդանքը» գալիս է ավտո-կոնֆիգուրացիայից, որը bean-երը ավտոմատ կարգավորում է՝ կախված այն բանից, թե որ կախվածություններն են գտնվում classpath-ում։ Արդյունքում սովորաբար ձեզ ոչ մի անուղղակի կոնֆիգուրացիա պետք չէ՝ պարզապես նախագծին ավելացնում եք ճիշտ կախվածությունները։
Նոր նախագիծ ճիշտ կախվածություններով սկսելու համար կարող եք օգտագործել հատուկ գեներատոր վեբ հավելված, որը դա հեշտացնում է՝ start.spring.io։ Այն ստեղծում է պատրաստի նախագիծ՝ հիմնվելով ձեր նշած Spring Boot տարբերակի, ընտրած լեզվի, build գործիքի և կախվածությունների վրա։
Ktor
Ktor-ը, ընդհակառակը, ընտրում է ավելի բացահայտ և մոդուլային ճանապարհ՝ հիմնվելով Kotlin-ի DSL հնարավորությունների վրա։ Ահա պարզ Ktor հավելված՝
fun main() {
embeddedServer(Netty, port = 8080) {
routing {
get("/hello") {
call.respondText("Hello, World!")
}
}
}.start(wait = true)
}
Ktor-ի փիլիսոփայությունը «առանց կախարդանքի» է. հավելվածի հոսքն ավելի թափանցիկ է, բայց դուք պետք է ավելի բացահայտ կարգավորեք՝ օգտագործելով Kotlin-ի ֆունկցիոնալ հնարավորությունները type-safe builder-ների հետ։ Ամեն ինչ opt-in է և պետք է բացահայտ հայտարարվի, երբ անհրաժեշտ է։ Անոտացիաներ և ռեֆլեկսիա չեն օգտագործվում։
Երբ ուզում եք հավելվածին ֆունկցիոնալություն ավելացնել՝ օրինակ սահմանել ռոութեր և բացահայտել endpoint-ներ, միացնել dependency injection կամ օգտագործել HTTP կլիենտ, սովորաբար ավելացնում եք համապատասխան կախվածությունները և տեղադրում համապատասխան plugin-ը։ Plugin-ը մոդուլային կոմպոնենտ է, որը ընդլայնում է Ktor սերվերի և կլիենտի հնարավորությունները։ Օրինակ՝ ռոութինգը միացնելու համար ավելացնում եք io.ktor:ktor-server-core կախվածությունը և տեղադրում Routing plugin-ը։
Ինչպես Spring Boot-ը, Ktor-ն էլ առաջարկում է առցանց հավելվածի գեներատոր՝ start.ktor.io, որը հեշտացնում է ճիշտ կախվածությունների և plugin-ների ընտրությունը։ Հիմնական պարամետրերից (Ktor-ի նպատակային տարբերակ, build համակարգ, շարժիչ և այլն) բացի, պետք է ընտրել այն plugin-ները, որոնք հավելվածը կօգտագործի։
Սերվերի շարժիչները
Վեբ հավելվածներում սերվերի շարժիչը հավելվածի runtime միջավայրի հիմքն է։ Spring Boot-ը և Ktor-ը սերվերի շարժիչի կարգավորումը կատարում են տարբեր կերպ։ Spring Boot-ը թաքցնում է սերվերի իրականացման մանրամասների մեծ մասը, մինչդեռ Ktor-ը մշակողներին ստիպում է բացահայտ որոշել, թե որ շարժիչն է աշխատեցնելու իրենց հավելվածը։
Spring Boot
Spring Boot-ը որպես լռելյայն embedded սերվեր օգտագործում է Tomcat-ը, սակայն այն կարելի է հեշտությամբ փոխարինել Jetty-ով կամ Undertow-ով՝ առանց հավելվածի կոդին դիպչելու։ Օրինակ՝ Jetty-ն օգտագործելու համար ձեզ պետք է միայն համապատասխան կախվածությունը։
dependencies {
implementation("org.springframework.boot:spring-boot-starter-web")
// To switch to Jetty
implementation("org.springframework.boot:spring-boot-starter-jetty")
exclude("org.springframework.boot", "spring-boot-starter-tomcat")
}
Սերվերի շարժիչը կարգավորվում է application.properties կամ application.yml ֆայլի հատկությունների միջոցով։ Այդ հատկությունների հիման վրա ֆրեյմվորքն ավտոմատ կարգավորում է embedded սերվերը, այնպես որ կարող եք կոդ չգրելով փոփոխել այնպիսի բաներ, ինչպիսիք են պորտերի համարները, թելերի փուլերը (thread pools) և SSL-ը։
Ktor
Ktor-ը հետ է գալիս մի քանի սերվերի շարժիչներով, այդ թվում՝ Tomcat, Netty և Jetty։ Այն ունի նաև CIO (Coroutine I/O) կոչվող շարժիչ՝ Ktor-ի սեփական, Kotlin-ին հատուկ շարժիչ, որը զրոյից նախագծված է coroutine-ների շուրջ՝ շատ արդյունավետ, չարգելափակող I/O-ի համար, ինչը այն դարձնում է հիանալի ընտրություն Kotlin-ի համաժամանակության մոդելի վրա կառուցված հավելվածների համար։
Հավելվածը տվյալ սերվերի շարժիչով գործարկելու համար ավելացնում եք համապատասխան կախվածությունը։
dependencies {
implementation("io.ktor:ktor-server-core:$ktor_version")
implementation("io.ktor:ktor-server-netty:$ktor_version") // Using Netty
// For other engines:
// implementation("io.ktor:ktor-server-jetty:$ktor_version")
// implementation("io.ktor:ktor-server-tomcat:$ktor_version")
// implementation("io.ktor:ktor-server-cio:$ktor_version")
}
Ktor-ում սերվերը կարգավորելու և գործարկելու երկու եղանակ կա։ embeddedServer-ով դուք սերվերի շարժիչը կարգավորում և գործարկում եք ծրագրային ճանապարհով՝ կոդում, ինչը տալիս է դրա կարգավորման նուրբ վերահսկում և հնարավոր է դարձնում դինամիկ կոնֆիգուրացիան։
fun main() {
embeddedServer(Netty, port = 8080) {
routing {
get("/hello") {
call.respondText("Hello, world!")
}
}
}.start(wait = true)
}
Կարող եք տրամադրել հիմքում ընկած սերվերի շարժիչին հատուկ կարգավորումներ։ Ահա օրինակ Netty սերվերի համար՝
fun main(args: Array<String>) {
embeddedServer(Netty, configure = {
shutdownGracePeriod = 1000
shutdownTimeout = 2000
}) {
routing {
get("/hello") {
call.respondText("Hello, world!")
}
}
}.start(wait = true)
}
EngineMain-ը, ի տարբերություն դրա, ավելի դեկլարատիվ է. սերվերը կարգավորվում է արտաքին application.conf (կամ yaml) ֆայլում և գործարկվում է Ktor-ի տրամադրած main ֆունկցիայի միջոցով։ Սա մաքուր բաժանում է կոդը կոնֆիգուրացիայից, ինչը շատ օգտակար է այն միջավայրերում, որտեղ դեպլոյմենտի պարամետրերը փոխվում են։
fun main(args: Array<String>): Unit = EngineMain.main(args)
fun Application.module() {
routing {
get("/hello") {
call.respondText("Hello, world!")
}
}
}
Այս կարգավորմամբ շարժիչի կոնֆիգուրացիան գտնվում է առանձին ֆայլում՝ application.conf (կամ yaml)՝
ktor {
deployment {
port = 8080
shutdownGracePeriod = 2000
shutdownTimeout = 3000
}
application {
modules = [ pl.rmaciak.ApplicationKt.module ]
}
}
Հավելվածի կոնֆիգուրացիա
Ցանկացած հավելված, որ մենք կառուցում ենք, կարիք ունի կոնֆիգուրացիայի, որը կարելի է հարմարեցնել այն միջավայրին, որտեղ աշխատում է, կամ որոշակի tenant-ի պահանջներին։ Spring Boot-ը և Ktor-ը կոնֆիգուրացիան, այդ թվում՝ միջավայրին հատուկ կարգավորումները, կառավարելու տարբեր մոտեցումներ ունեն։ Տեսնենք, թե ինչպես է յուրաքանչյուր ֆրեյմվորք վարվում հավելվածի կոնֆիգուրացիայի հետ։
Կոնֆիգուրացիոն ֆայլեր
Spring Boot
Spring Boot-ը հիմնականում օգտագործում է երկու տեսակի կոնֆիգուրացիոն ֆայլեր՝ application.yml և application.properties։ Դրանցում կարող եք պահել հավելվածի ամբողջ կոնֆիգուրացիան, այդ թվում՝ սեփական հատկությունները։
Կոդում որոշակի հատկություններ կարդալու համար կարող եք օգտագործել @Value անոտացիան։
@Component
class DatabaseProperties {
@Value("\${spring.datasource.url}")
lateinit var url: String
@Value("\${spring.datasource.username}")
lateinit var username: String
}
Հավելվածի կոնֆիգուրացիային հասանելիության մեկ այլ տարածված եղանակ @ConfigurationProperties-ն է, որը կոնֆիգուրացիայի արժեքները ներարկում է դասի դաշտերի մեջ։
@ConfigurationProperties(prefix = "spring.datasource")
class DataSourceProperties {
var url: String = ""
var username: String = ""
}
Ktor
Ktor-ը օգտագործում է HOCON (Human-Optimized Config Object Notation) ձևաչափը, որն ավելի ճկուն է և աջակցում է այնպիսի հնարավորությունների, ինչպիսիք են այլ ֆայլերի ներառումը, տեղադրումները (substitutions) և բազմատող տողերը։ Ստորև բերված է պարզ HOCON կոնֆիգուրացիոն ֆայլ։
ktor {
deployment {
port = 8080
}
application {
modules = [ pl.rmaciak.ApplicationKt.module ]
}
}
database {
url = "jdbc:postgresql://localhost:5432/myapp"
username = "postgres"
}
logging {
level = "INFO"
}
Ktor-ը բեռնում է իր կոնֆիգուրացիան resources դիրեկտորիայի application.conf-ից (YAML կոնֆիգուրացիան նույնպես աջակցվում է), համակարգային հատկություններից կամ միջավայրի փոփոխականներից։ Կոդում կոնֆիգուրացիայի հատկությունը կարդում եք environment դաշտի միջոցով։
fun Application.module() {
val databaseUrl = environment.config.property("database.url").getString()
val databaseUsername = environment.config.property("database.username").getString()
}
Ktor-ում չկա կոնֆիգուրացիայի հատկությունները օբյեկտի դաշտերում ներարկելու ներկառուցված եղանակ (ինչպես @ConfigurationProperties-ը Spring Boot-ում), բայց դա անելու համար մի քիչ կոդ բավական է։
data class DatabaseConfig(
val url: String,
val username: String,
)
fun Application.configureDatabases() {
val config = environment.config("database")
val databaseConfig = DatabaseConfig(
url = config.property("url").getString(),
username = config.property("username").getString(),
)
}
Միջավայրին հատուկ կոնֆիգուրացիա
Spring Boot
Spring Boot-ում միջավայրին հատուկ կոնֆիգուրացիան սովորաբար կառավարվում է պրոֆիլներով, որոնք թույլ են տալիս յուրաքանչյուր միջավայրի համար առանձին կոնֆիգուրացիա տրամադրել։ Դա արվում է application-{profile}.properties ֆայլեր ստեղծելով, որտեղ {profile}-ը պրոֆիլի անունն է՝ սովորաբար միջավայրի անվանումը։ Օրինակ՝ DEV և PROD կոնֆիգուրացիան իրարից առանձնացնելու համար կունենաք երկու ֆայլ՝ application-dev.properties և application-prod.properties, որոնցից յուրաքանչյուրն ունի հատկությունների իր հավաքածուն՝
# application-dev.properties
server.port=8080
spring.datasource.url=jdbc:h2:mem:myapp
# application-prod.properties
server.port=80
spring.datasource.url=jdbc:postgresql://production-db:5432/myapp
Որոշակի պրոֆիլ ակտիվացվում է spring.profiles.active հատկությունը սահմանելով՝ կա՛մ հրամանի տողի արգումենտով, կա՛մ միջավայրի փոփոխականով։
Ktor
Ktor-ը չունի միջավայրին հատուկ կոնֆիգուրացիայի կոնվենցիա կամ մեխանիզմ, բայց, ինչպես մյուս բնագավառներում, դուք հեշտությամբ կարող եք դրան հասնել բացահայտ ձևով՝ օգտագործելով HOCON-ի ժառանգման և տեղադրման հնարավորությունները՝
# application.conf
database {
url = "jdbc:h2:mem:devdb"
}
# For different environments, you can include environment-specific files
include "application-${?KTOR_ENV}.conf"
# application-prod.conf
database {
url = "jdbc:postgresql://production-db:5432/proddb"
}
Այստեղ հավելվածը միջավայրը որոշում է KTOR_ENV փոփոխականից։ Երբ այն սահմանված չէ, օգտագործվում է լռելյայն կոնֆիգուրացիոն ֆայլը (application.conf)։ Production-ում KTOR_ENV-ը պետք է սահմանված լինի «prod», որպեսզի վերցվի application-prod.conf-ը՝ production-ին հատուկ կոնֆիգուրացիայով։
Dependency injection
Dependency injection-ի դեպքում կոմպոնենտներին տրվում են իրենց կախվածությունները (աշխատելու համար անհրաժեշտ օբյեկտները)՝ դրանք ինքնուրույն ստեղծելու փոխարեն, ինչը խթանում է թույլ կապակցվածությունը և հեշտացնում թեստավորումը։ Spring Boot-ից եկողին կարող է զարմացնել, որ Ktor-ը out of the box IoC կոնտեյներ չունի։ Այն նախընտրում է բացահայտությունը՝ ձեզ ստիպելով կոմպոնենտները ստեղծել անմիջապես կոդում, կամ կարող եք ընտրել plugin-ներից կամ ֆրեյմվորքերից մեկը, որոնք Ktor-ին ավելացնում են DI հնարավորություններ։
Spring Boot
Spring Boot-ը հենվում է Spring-ի Inversion of Control (IoC) կոնտեյների վրա, որը կառավարում է օբյեկտների ստեղծումը և կյանքի ցիկլը և մեծապես կախված է ռեֆլեկսիայից ու անոտացիաներից։ Դասը որպես bean (IoC-ի կառավարվող օբյեկտ, որը կարող է ներարկվել այլ օբյեկտների մեջ) հայտարարելու համար օգտագործում եք այս անոտացիաներից մեկը՝ @Component, @Service, @Repository, @Controller՝ կախված այն բանից, թե որ շերտին է պատկանում դասը։ Գոյություն ունեն ներարկման մի քանի ոճեր, բայց կոնստրուկտորով ներարկումն է խորհուրդ տրվածը։
Օրինակ՝ UserService-ը bean դարձնելու և UserController-ի մեջ ներարկելու համար այն նշում եք որպես @Service և ավելացնում կոնտրոլերի կոնստրուկտորին։ Այնուհետև Spring-ը UserService-ի օրինակը ավտոմատ ներարկում է UserController-ի մեջ։
@Service
class UserService(private val userRepository: UserRepository) {
fun findUser(id: Long): User = userRepository.findById(id).orElseThrow()
}
@RestController
@RequestMapping("/api/users")
class UserController(private val userService: UserService) {
@GetMapping("/{id}")
fun getUser(@PathVariable id: Long): User = userService.findUser(id)
}
Ktor
Ինչպես նշվել է վերևում, Ktor-ը ներկառուցված dependency injection չունի։ Փոխարենը այն առաջ է քաշում ֆունկցիոնալ ծրագրավորումը՝ ֆունկցիաների կոմպոզիցիայի, DSL-ների և օբյեկտների ըստ պահանջի ստեղծման միջոցով։ Ktor-ի մի տարբերակ DI-ն ամբողջությամբ դեն նետելն է և կախվածությունները բացահայտ ու ծրագրային եղանակով սահմանելը։ Սա հատկապես լավ է աշխատում, երբ control inversion-ից ձեզ պետք է միայն singleton-ների կառավարումը. Kotlin-ին դրա համար ֆրեյմվորք պետք չէ։ Օբյեկտ հայտարարելը բավական է դասի մեկ օրինակ երաշխավորելու համար։
object UserService {
fun createUser() {
//... some logic here
}
}
Այս մոտեցումն ունի իր սահմանափակումները, քանի որ օբյեկտները չեն կարող կոնստրուկտորի միջոցով կախվածություններ հայտարարել։ Այսպես որ գործնականում սովորաբար դեռ պետք է DI ֆրեյմվորք։ Բարեբախտաբար, Ktor-ը հեշտությամբ ինտեգրվում է DI ֆրեյմվորքերի մի շարքի հետ՝
- Koin – գործնական, թեթև DI ֆրեյմվորք, գրված զուտ Kotlin-ով, որը օգտագործում է ֆունկցիոնալ resolution՝ առանց proxy-ների կամ ռեֆլեկսիայի։
- Kodein – Kotlin-բնիկ dependency retrieval կոնտեյներ, որը կենտրոնացած է type safety-ի և ընթեռնելիության վրա՝ մնալով փոքր, լավ ընտրություն multiplatform նախագծերի համար։
- Dagger – compile-time dependency injection ֆրեյմվորք, որը գեներացնում է կոդ՝ type safety երաշխավորելու համար. այն շատ լավ է աշխատում, բայց ավելի դժվար է սովորել և պահանջում է ավելի ծավալուն կոնֆիգուրացիա։
- Guice – Google-ի հասուն, Java-ի վրա հիմնված DI ֆրեյմվորք, որն առաջարկում է runtime ճկունություն և դինամիկ binding, թեև Ktor-ի հետ համատեղ այն ավելի ծանր է, քան Kotlin-ին հատուկ տարբերակները։
Այստեղ ցույց կտամ, թե ինչպես միացնել dependency injection-ը Ktor-ում Koin-ով։
Koin-ի օգտագործումը Ktor-ում dependency injection-ի համար
Koin-ը ձեր Ktor հավելվածում օգտագործելու համար ավելացրեք համապատասխան կախվածությունները և տեղադրեք Koin plugin-ը՝
build.gradle.kts
dependencies {
implementation("io.insert-koin:koin-ktor:$koin_version")
// Optional for logging with SLF4J
implementation("io.insert-koin:koin-logger-slf4j:$koin_version")
}
fun Application.main() {
install(Koin) {
slf4jLogger() // Optional for logging with SLF4J
modules(appModule) // Enabling Koin module called appModule
}
}
Koin-ը կառուցված է մոդուլների շուրջ՝ կոնտեյներներ, որոնցում սահմանվում են Koin-ի կախվածությունները։ Կախված ձեր կարիքներից՝ բոլոր bean-երը հայտարարում եք մեկ կամ մի քանի մոդուլում։
Koin-ը Spring Boot-ից ավելի քիչ նախասահմանված bean scope-եր ունի՝
- Single – մեկ օրինակ կոնտեյների ամբողջ կյանքի ընթացքում (համարժեք է Spring Boot-ի Singleton-ին)
- Factory – նոր օրինակ ամեն անգամ, երբ պահանջվում է
- Scoped – օրինակ, որը կապված է օգտագործողի սահմանած scope-ի կյանքի ցիկլին
Թեև Koin-ը Spring Boot-ից ավելի քիչ ներկառուցված scope-եր ունի, նրա scoped սահմանումը շատ ճկուն է։ Կարող եք սահմանել ձեր սեփական scope-երը, ինչը որոշ դեպքերում Koin-ը դարձնում է ավելի հզոր և հարմարվող։
Koin-ում bean-երի սահմանումների մի քանի օրինակ՝
val appModule = module {
// 1. Singleton scope - one instance for the whole application, by deafault
lazy initialized
single<UserRepository> { UserRepositoryImpl() }
// 2. Factory scope - creates a new instance each time it's requested
factory { UserRepositoryImpl() }
// 3. Multiple beans with named qualifiers
single<PaymentGateway>(named("stripe")) { StripePaymentGateway() }
single<PaymentGateway>(named("paypal")) { PaypalPaymentGateway() }
// 4. Creating a bean with constructor parameters
single { DatabaseConnection(get(), get<DatabaseConfig>().url) }
// 5. Lazy singleton - only created when first accessed
single(createdAtStart = false) { ExpensiveResourceManager() }
// 6. Eager singleton - created at Koin startup
single(createdAtStart = true) { SystemInitializer() }
}
Bean-երը կարելի է հավելվածում ներարկել հետևյալ եղանակներով՝
fun Application.configureRouting() {
// 1. Property delegate injection
val userRepository: UserRepository by inject()
// 2. Direct retrieval from KoinComponent resolved by property type
val userRepository: UserRepository = get()
// 3. Direct retrieval from KoinComponent resolved by name
val userRepository = get<UserRepository>(named("fakeUserRepository"))
// 4. Lazy injection
val lazyUserRepository: Lazy<UserRepository> by inject()
// 5. Injecting with parameters
val userRepository = get<UserRepository> { parametersOf("user123") }
}
Մաս 1-ի ամփոփում
Այս մասի նպատակն էր Ktor ֆրեյմվորքի և նրա հնարավորությունների ակնարկ տալ և դրանք կապել Spring Boot-ից ձեզ ծանոթ հասկացությունների հետ, որպեսզի սովորելն ավելի հեշտ լինի։ Ահա նկարագրված և համեմատված կողմերի ամփոփումը՝
Application Setup
- Spring Boot: Հենվում է անոտացիաների վրա՝ ավտո-կոնֆիգուրացիայի և կոմպոնենտների սկանավորման հետ միասին
- Ktor: Ընդունում է բացահայտ, մոդուլային մոտեցում՝ հիմնված Kotlin-ի DSL-ի վրա, առանց ռեֆլեկսիայի կամ անոտացիաների
Server Engines
- Spring Boot: Լռելյայն օգտագործում է Tomcat, և կախվածությունների միջոցով հեշտությամբ կարելի է անցնել Jetty/Undertow-ի
- Ktor: Առաջարկում է մի քանի շարժիչ, այդ թվում՝ սեփական Coroutine I/O (CIO) շարժիչը, կարգավորվում է ծրագրային կամ դեկլարատիվ եղանակով
Configuration
- Spring Boot: Հենվում է YAML/properties ֆայլերի վրա՝ անոտացիաներով ներարկմամբ և պրոֆիլներով
- Ktor: Հենվում է YAML-ի կամ HOCON-ի վրա՝ հատկություններին ուղիղ հասանելիությամբ և միջավայրին հատուկ կոնֆիգուրացիաների համար ժառանգմամբ (միայն HOCON)
Dependency Injection
- Spring Boot: Ներկառուցված IoC կոնտեյներ, որը կառավարվում է անոտացիաներով
- Ktor: Ներկառուցված DI չկա. կարող եք օգտագործել Kotlin-ի օբյեկտներ կամ երրորդ կողմի լուծումներ (Koin, Kodein և այլն)
Քանի որ «Ծանոթություն Ktor-ին Spring Boot-ի տեսանկյունից» շարքի այս առաջին մասը մոտենում է ավարտին, հուսով եմ, այն ձեզ տվել է ամուր հիմք՝ տեսնելու, թե Ktor-ի հիմնական հնարավորություններն ինչպես են համապատասխանում Spring Boot-ի ծանոթ հասկացություններին։ Սա քայլ է դեպի Kotlin-բնիկ լուծումների որդեգրում՝ միաժամանակ օգտագործելով արդեն ունեցած գիտելիքները։