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

التعرّف على Ktor من منظور Spring Boot. الجزء 1

يستهدف هذا المقال المطوّرين الذين يعرفون Spring Boot ويريدون دخول عالم Ktor بالبناء على ما يعرفونه. بمقارنة المفاهيم الأساسية مثل إعداد التطبيق والتوجيه (routing) وحقن الاعتماديات، سنرى كيف يعمل Ktor من الداخل وكيف يتوافق تصميمه مع أساليب Kotlin.

13 دقائق قراءة
Spring BootKotlinKtorKotlinServerSide

عندما تنتقل من Java إلى Kotlin، قد تبدأ بالبحث عن أطر عمل مبنية أصلًا لـ Kotlin. وبفضل قابلية التشغيل البيني الممتازة في Kotlin، لا بأس إطلاقًا في استخدام أدوات Java الموجودة لديك، لكنك قد ترغب أيضًا في تجربة شيء جديد يستفيد استفادة كاملة مما تقدمه Kotlin.

لتطوير تطبيقات الويب، يمكنك الاختيار بين البقاء مع Spring Boot الموثوق الذي يعمل بسلاسة مع Kotlin، أو القفز إلى Ktor، وهو إطار عمل صُمّم منذ البداية حول ميزات Kotlin وأساليبها المميزة.

يهدف الإطاران إلى تبسيط تطوير الويب، لكن فلسفتيهما ونهجيهما تختلفان من بعض النواحي. يقدّم Spring Boot مجموعة أدوات قوية ذات توجهات محددة مسبقًا وموجّهة لتطبيقات بأي حجم، بينما Ktor إطار عمل خفيف ومرن مبني لـ Kotlin مع التركيز على تجربة المطوّر.

يستهدف هذا المقال المطوّرين الذين يعرفون Spring Boot ويريدون دخول عالم Ktor بالبناء على ما يعرفونه. بمقارنة المفاهيم الأساسية مثل إعداد التطبيق والتوجيه (routing) وحقن الاعتماديات، سنرى كيف يعمل Ktor من الداخل وكيف يتوافق تصميمه مع أساليب Kotlin. وسننظر أيضًا في أوجه الاختلاف والتشابه بين الإطارين، لتصبح منتجًا بسرعة دون أن تُرهَق.

ملاحظة: نظرًا لاتساع الموضوع، قسّمت المقال إلى جزأين. يتناول الأول بالتفصيل إعداد التطبيق (Application Setup) ومحركات الخادم (Server Engines) والإعدادات (Configuration) وحقن الاعتماديات (Dependency Injection). ويغطي الثاني معالجة طلبات HTTP ومعالجة الاستثناءات وعملاء HTTP والاختبار.

إذا كنت ترغب في تعلّم Ktor عبر ربطه بما تعرفه بالفعل، فهذا المقال موجّه إليك. هيا نبدأ ونرى كيف يجلب Ktor أسلوب Kotlin الوظيفي إلى تطوير الويب.

إعداد التطبيق

من أولى التحديات التي يواجهها المطوّرون عند بناء تطبيقات الويب إنشاء المشروع وتشغيل التطبيق بالإعدادات التي يحتاجها. ويشمل ذلك تشغيل محرك الـ servlet الأساسي، وإعداد الاعتماديات، وتعريف وحدات التطبيق. يتيح لك كل من Spring Boot وKtor الانطلاق بسرعة، لكن كلًّا منهما يفعل ذلك بطريقة مختلفة جدًا.

Spring boot

يسترشد Spring Boot بمبدأ «الاصطلاح قبل الإعداد» (convention over configuration)، الذي يُبقي الشيفرة التمهيدية اللازمة لتشغيل التطبيق عند حدها الأدنى. يبدأ تطبيق Spring Boot النموذجي بصنف نقطة دخول موسوم بـ @SpringBootApplication:

@SpringBootApplication 
class MyApp 

fun main(args: Array<String>) { 
    runApplication<MyApp>(*args) 
}

يفعّل هذا التعليق التوضيحي الواحد الميزات التالية:

  • يحدد الصنف مصدرًا لتعريفات الـ bean
  • يفعّل آلية الإعداد التلقائي (auto-configuration) في Spring Boot
  • يفحص التسلسل الهرمي لحزم التطبيق بحثًا عن المكونات

يأتي سحر Spring Boot من الإعداد التلقائي، الذي يُنشئ الـ beans تلقائيًا بحسب الاعتماديات الموجودة في classpath. ونتيجة لذلك، لا تحتاج عادةً إلى أي إعداد ضمني – يكفي أن تضيف الاعتماديات المناسبة إلى المشروع.

ولبدء مشروع جديد بالاعتماديات المناسبة، يمكنك استخدام تطبيق ويب مخصص كمولّد يجعل ذلك سهلًا: start.spring.io. فهو ينتج مشروعًا جاهزًا للاستخدام بناءً على إصدار Spring Boot الذي تستهدفه واللغة وأداة البناء والاعتماديات التي تختارها.

Ktor

أما Ktor، فيسلك طريقًا أكثر وضوحًا وتجزئة إلى وحدات، معتمدًا على إمكانات DSL في Kotlin. فيما يلي تطبيق Ktor بسيط:

fun main() { 
  embeddedServer(Netty, port = 8080) { 
    routing { 
      get("/hello") { 
        call.respondText("Hello, World!") 
      } 
    } 
  }.start(wait = true) 
}

فلسفة Ktor هي «بلا سحر»: تدفق التطبيق أكثر شفافية، لكن عليك أن تضبط الإعدادات بشكل أوضح، باستخدام ميزات Kotlin الوظيفية مع بُناة (builders) آمنة من حيث الأنواع. كل شيء اختياري ويجب التصريح عنه صراحةً عند الحاجة إليه. ولا تُستخدم التعليقات التوضيحية ولا الانعكاس (reflection).

عندما تريد إضافة وظائف إلى تطبيقك – مثل تعريف المسارات وكشف نقاط النهاية، أو تفعيل حقن الاعتماديات، أو استخدام عميل HTTP – فإنك تضيف عادةً الاعتماديات ذات الصلة وتثبّت الإضافة (plugin) المطابقة. الإضافة مكوّن وحدوي يوسّع ما يستطيع خادم Ktor وعميله فعله. فلتفعيل التوجيه مثلًا، تضيف الاعتمادية io.ktor:ktor-server-core وتثبّت إضافة Routing.

وكما هو الحال في Spring Boot، يقدم Ktor مولّد تطبيقات عبر الإنترنت: start.ktor.io، يسهّل اختيار الاعتماديات والإضافات المناسبة. فإلى جانب الأساسيات (إصدار Ktor المستهدف ونظام البناء والمحرك وغيرها)، عليك اختيار الإضافات التي سيستخدمها تطبيقك.

محركات الخادم

في تطبيقات الويب، يمثل محرك الخادم أساس بيئة تشغيل التطبيق. ويتعامل Spring Boot وKtor مع إعداد محرك الخادم بشكل مختلف. فـ Spring Boot يخفي معظم تفاصيل تنفيذ الخادم، بينما يجعل Ktor المطوّرين يقررون صراحةً أي محرك سيشغّل تطبيقهم.

Spring Boot

يستخدم Spring Boot الخادم 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. وبناءً على تلك الخصائص، يضبط الإطار الخادم المضمَّن تلقائيًا، فيمكنك تعديل أمور مثل أرقام المنافذ ومجمّعات الخيوط (thread pools) وSSL دون كتابة أي شيفرة.

Ktor

يأتي Ktor مع عدة محركات خادم، منها Tomcat وNetty وJetty. ولديه أيضًا محرك يسمى CIO (Coroutine I/O) – وهو محرك Ktor الخاص بـ Kotlin، صُمّم من الصفر حول الكوروتينات (coroutines) لتحقيق إدخال/إخراج غير حاجب بكفاءة عالية جدًا، مما يجعله مناسبًا جدًا للتطبيقات المبنية على نموذج التزامن في 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) ويُشغَّل عبر دالة main يوفرها Ktor. وهذا يفصل الشيفرة عن الإعدادات بوضوح، وهو مفيد جدًا في البيئات التي تتغير فيها معاملات النشر.

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)، وهي أكثر مرونة وتدعم ميزات مثل تضمين ملفات أخرى والاستبدالات والسلاسل النصية متعددة الأسطر. فيما يلي ملف إعدادات HOCON بسيط.

ktor {
    deployment {
        port = 8080
    }

    application {
        modules = [ pl.rmaciak.ApplicationKt.module ]
    }
}

database {
    url = "jdbc:postgresql://localhost:5432/myapp"
    username = "postgres"
}

logging {
    level = "INFO"
}

يحمّل Ktor إعداداته من 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، تُعالَج الإعدادات الخاصة بكل بيئة عادةً باستخدام الملفات الشخصية (profiles)، التي تتيح لك تقديم إعدادات منفصلة لكل بيئة. وتفعل ذلك بإنشاء ملفات application- .properties، where هو اسم الملف الشخصي – وهو عادةً اسم البيئة. فمثلًا، للفصل بين إعدادات 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). وفي الإنتاج، ينبغي ضبط KTOR_ENV على “prod”، كي يُلتقط الملف application-prod.conf الذي يحتوي على الإعدادات الخاصة بالإنتاج.

حقن الاعتماديات

مع حقن الاعتماديات، تُعطى المكونات اعتمادياتها (الكائنات التي تحتاجها لتعمل) بدلًا من أن تنشئها بنفسها، مما يشجع على الارتباط الضعيف ويسهّل الاختبار. وإذا كنت قادمًا من Spring Boot، فقد تفاجئك حقيقة أن Ktor لا يملك حاوية IoC جاهزة. فهو يفضّل الوضوح بأن يجعلك تنشئ المكونات مباشرةً في الشيفرة، أو يمكنك اختيار إحدى الإضافات أو أطر العمل التي تضيف قدرات DI إلى Ktor.

Spring Boot

يقوم Spring Boot على حاوية انعكاس التحكم (IoC) في Spring، التي تتولى إنشاء الكائنات ودورة حياتها وتعتمد بشكل كبير على الانعكاس والتعليقات التوضيحية. ولتعريف صنف على أنه bean (كائن تديره حاوية IoC ويمكن حقنه في كائنات أخرى)، تستخدم أحد هذه التعليقات التوضيحية – @Component أو @Service أو @Repository أو @Controller – بحسب الطبقة التي ينتمي إليها الصنف. توجد عدة أساليب للحقن، لكن الحقن عبر المُنشئ (constructor injection) هو الموصى به.

فمثلًا، لتحويل 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 حقن اعتماديات مدمجًا. بل يروّج للبرمجة الوظيفية بدلًا من ذلك، عبر تركيب الدوال وDSLs وإنشاء الكائنات عند الطلب. أحد الخيارات مع Ktor هو الاستغناء عن DI كليًا وتعريف الاعتماديات صراحةً وبرمجيًا. وهذا ينجح بشكل خاص عندما لا تحتاج من انعكاس التحكم إلا إلى إدارة الـ singletons – فـ Kotlin لا تحتاج إلى إطار عمل لذلك. يكفي التصريح عن object لضمان نسخة واحدة من الصنف.

object UserService {

    fun createUser() {
       //... some logic here
    }
}

لكن لهذا النهج حدودًا، لأن الكائنات (objects) لا يمكنها التصريح عن اعتماديات عبر المُنشئ. لذلك ستظل عمليًا بحاجة عادةً إلى إطار عمل DI. ولحسن الحظ، يتكامل Ktor بسهولة مع مجموعة من أطر عمل DI:

  • Koin – إطار عمل DI عملي وخفيف مكتوب بـ Kotlin بالكامل، يستخدم الحل الوظيفي دون وسطاء (proxies) أو انعكاس.
  • Kodein – حاوية لاسترجاع الاعتماديات أصلية في Kotlin، تركّز على أمان الأنواع وسهولة القراءة مع بقائها صغيرة، وهي مناسبة للمشاريع متعددة المنصات.
  • Dagger – إطار عمل لحقن الاعتماديات وقت الترجمة يولّد شيفرة لضمان أمان الأنواع؛ أداؤه جيد جدًا لكنه أصعب في التعلم ويحتاج إعدادات أكثر إسهابًا.
  • Guice – إطار عمل DI ناضج من Google مبني على Java، يوفر مرونة وقت التشغيل وربطًا ديناميكيًا، رغم أنه أثقل من الخيارات الخاصة بـ Kotlin عند استخدامه مع Ktor.

هنا، سأوضح كيف تفعّل حقن الاعتماديات في Ktor باستخدام Koin.

استخدام Koin مع Ktor لحقن الاعتماديات

لإدخال Koin إلى تطبيق Ktor، أضف الاعتماديات المناسبة وثبّت إضافة Koin:

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 حول الوحدات (modules) – وهي حاويات تُعرَّف فيها اعتماديات Koin. وبحسب ما تحتاجه، تصرّح بجميع الـ beans في وحدة واحدة أو عدة وحدات.

يأتي Koin بنطاقات (scopes) معرّفة مسبقًا للـ beans أقل مما في Spring Boot:

  • Single – نسخة واحدة طوال عمر الحاوية (ما يعادل Singleton في Spring Boot)
  • Factory – نسخة جديدة في كل مرة تُطلب فيها
  • Scoped – نسخة مرتبطة بدورة حياة نطاق يعرّفه المستخدم

ورغم أن Koin يملك نطاقات مدمجة أقل من Spring Boot، فإن تعريف scoped فيه مرن جدًا. يمكنك تعريف نطاقاتك الخاصة، مما يجعل Koin أقوى وأكثر قابلية للتكيف في بعض حالات الاستخدام.

بعض الأمثلة على تعريفات الـ beans في Koin:

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() }
}

يمكن حقن الـ beans في تطبيقك بالطرق التالية:

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: يتبع نهجًا صريحًا ووحدويًا قائمًا على DSL في Kotlin، دون انعكاس أو تعليقات توضيحية

محركات الخادم (Server Engines)

  • Spring Boot: يستخدم Tomcat افتراضيًا ويمكنه التبديل بسهولة إلى Jetty/Undertow عبر الاعتماديات
  • Ktor: يقدّم عدة محركات، منها محرك Coroutine I/O (CIO) الخاص به، وتُضبط برمجيًا أو تصريحيًا

الإعدادات (Configuration)

  • Spring Boot: يعتمد على ملفات YAML/properties مع الحقن القائم على التعليقات التوضيحية والملفات الشخصية (profiles)
  • Ktor: يعتمد على YAML أو HOCON، مع وصول مباشر إلى الخصائص ووراثة للإعدادات الخاصة بكل بيئة (HOCON فقط)

حقن الاعتماديات (Dependency Injection)

  • Spring Boot: حاوية IoC مدمجة تعتمد على التعليقات التوضيحية
  • Ktor: لا يوجد DI مدمج؛ يمكنك استخدام كائنات Kotlin أو حلول من جهات خارجية (Koin وKodein وغيرهما)

ومع اقتراب نهاية هذا الجزء الأول من «تعلّم Ktor عبر عدسة Spring Boot»، آمل أن يكون قد منحك أساسًا متينًا لفهم كيف تقابل ميزات Ktor الأساسية مفاهيم Spring Boot المألوفة. إنها خطوة نحو اعتماد حلول أصلية في Kotlin مع الاستفادة مما تعرفه بالفعل.