🤳🏻 🐞 🎖️ Jetbrains KTor और R2DBC के उदाहरण पर प्रतिक्रियाशील डेटा के प्रति दृष्टिकोण ☃️ 🧑🏽‍🤝‍🧑🏻 👘

कोरुटिन से डेटाबेस तक प्रतिक्रियाशील पहुंच का उपयोग करने के बारे में एक लेख। वसंत सब कुछ सरल करता है, लेकिन यह आवेदन की वास्तविक प्रक्रियाओं की समझ को प्रभावित नहीं करता है। प्रदर्शन के लिए, केटर फ्रेमवर्क को चुना गया था (सिर्फ इसलिए कि मुझे यह देखना पसंद है कि जेटब्रेन क्या करता है), जो गहन रूप से कोरटाइन का उपयोग करता है - ताकि रिएक्टिव स्ट्रीम और इन समान कोरआउटों के संयोजन का कार्य ब्याज जोड़ता है। इस प्रक्रिया में, यह स्पष्ट हो गया कि जो कुछ हो रहा था वह समझ में आने वाली अनिवार्य प्रोग्रामिंग के लिए एक समझ से परे जेट स्ट्रीम के परिवर्तन का एक स्पष्ट उदाहरण था, जिस पर हमने एक कुत्ता खाया था। मुझे जेट चेन पसंद है, लेकिन सेना के आदेश से प्यार करने वालों को खुश क्यों नहीं करते?

जेट अनुप्रयोगों ने कई डेवलपर्स के दिल और नसों को जीत लिया है, और ये सेट स्पष्ट रूप से प्रतिच्छेद करते हैं। वे और भी अधिक लगाए गए होते, यदि विशिष्ट समुदायों के रचनाकारों के मन की विशुद्ध धारा को सुपाच्य पुस्तकालयों में ढालने वाले समुदायों के प्रयासों के लिए नहीं। यह R2DBC विनिर्देश और स्प्रिंग (बूट) ढांचे के साथ हुआ - डेवलपर पहले से ही परिचित प्रतिक्रिया डेटा प्रकारों के साथ परिचित स्प्रिंग डेटा एपीआई देख सकता है। हालाँकि, स्प्रिंग का उपयोग न करने के कुछ कारण हैं: आप स्प्रिंग नहीं चाहते हैं और आप कुछ नया चाहते हैं। खैर, अभी भी विरासत कोड है, लेकिन इस मामले में आपके पास प्रतिक्रियाशील डेटा पहुंच की संभावना नहीं है।

इस मामले में, आपको R2DBC को बिना लाइसेंस के देखना होगा । और यह उम्मीद की जाएगी कि हम तैयार ढांचे में जो पेशकश करते हैं उससे बहुत अलग हैं - ठीक उसी तरह जैसे कि जेडीबीसी स्प्रिंग डेटा जेपीए से अलग है। प्लस प्रतिक्रिया। और प्रतिक्रियाशील धाराओं विनिर्देश के अनुसार प्रतिक्रियाशीलता। और हम कोरटाइन सुनते हैं। भविष्य किस तरह का है और अभी भी उन्हें फिर से लिखना है।

आप मुख्य विधि से मैन्युअल रूप से कोरआउट करना शुरू कर सकते हैं , लेकिन आइए कल्पना करने की कोशिश करें कि हमें वास्तव में समानता और प्रतिस्पर्धा की आवश्यकता है - अर्थात, उच्च भार (प्रति घंटे एक अनुरोध!) और हमने गंभीरता से इसे बिना वसंत के लिखने का फैसला किया। लेकिन यहां, यह पता चला है, हमारे पास पूरी तरह से कोटलिन में लिखा गया एक हल्का एनालॉग है, और यहां तक कि भाषा के रचनाकारों से भी, और यहां तक कि हम जिस कोरटाइन पर सपना देखते हैं।

हम एक प्रोजेक्ट तैयार कर रहे हैं

, - ( IntelliJ IDEA).

https://start.ktor.io :

Call Logging: ,
Routing: (endpoint URI)
Gson: .

, — OAuth, JWT, LDAP , .

. , IntelliJ IDEA Community Edition.

H2, build.gradle

    implementation "io.r2dbc:r2dbc-h2:0.8.1.RELEASE"

    implementation "io.r2dbc:r2dbc-pool:0.8.1.RELEASE"

Reactive Streams, R2DBC , Reactor Kotlin, :

    implementation "io.projectreactor.kotlin:reactor-kotlin-extensions:1.0.2.RELEASE"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-reactor:1.3.5"

: JVM 1.8. , - native Java. .

build.gradle

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

— Application.kt, . , , :

fun Application.module(testing: Boolean = false) {
    //       
initDatabase@

    //   

applicationStarted@
    //       

boringStandardInitialization@
    //   ,   
    install(ContentNegotiation) {
        gson {
        }
    }

    install(CallLogging) {
        level = Level.INFO
        filter { call -> call.request.path().startsWith("/") }
    }

    routing {
        get("/") {
showTables@
            //       
            call.respondText("HELLO WORLD!", contentType = ContentType.Text.Plain)
        }

        get("/json/gson") {
showPool@            
            //      
            call.respond(mapOf("hello" to "world"))
        }
    }
}

, application.conf ktor.deployment port . , :

        watch = [ /home/votez/cc/ktor-reactive-db/build/classes/kotlin/main/ ]

— , devtools, . , .

initDatabase ( ) .

initDatabase@
    "" // ,        
    val connectionFactory = H2ConnectionFactory(
        H2ConnectionConfiguration.builder()
            .inMemory("users")
            .property(H2ConnectionOption.DB_CLOSE_DELAY, "-1")
            .build()
    )

    val poolConfig = ConnectionPoolConfiguration.builder(connectionFactory)
        .maxIdleTime(10.seconds.toJavaDuration()) //     @ExperimentalTime
        .maxSize(20)
        .build()

    val pool = ConnectionPool(poolConfig)

@ExperimentalTime — API.

, ( ) . , . :

applicationStarted@
    //       
    environment.monitor.subscribe(ApplicationStarted) {
        launch {
            val defer : Mono<Int> = pool.warmup()
            defer.awaitFirst()                             //   
            log.debug("Pool is hot, welcome!") //    
        }
    }

— launch . , , — , . - ! "" (awaitFirst Kotlin), . : Reactor- Mono Flux ? . " -"? , — . — . , , Reactor RxJava . — "!" " !". , , - . — RxJava Reactor — !

, . , .

CRUD , , , H2 : TABLES. - :

data class Tables(    val catalog: String?,    val schema: String?,    val tableName: String?,    val tableType: String?,    val storageType: String?,    val id: String?,    val typeName: String?,    val tableClass: String?,    val rowCountEstimate: Long?)

typealias , IDE

typealias R2DBCResult = io.r2dbc.spi.Result

. , R2DBC:

get("/tables") {
            showTables@
            //       
            ""
            val connection = pool.create().awaitSingle() //    -  
            val list = try { 
                val result: List<R2DBCResult> = connection.createStatement(
                        """
                            select 
                                TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE, STORAGE_TYPE, SQL, ID, TYPE_NAME, TABLE_CLASS, ROW_COUNT_ESTIMATE
                            from 
                                INFORMATION_SCHEMA.TABLES
                                """.trimIndent()
                    )
                    .execute()  //    
                    .toFlux()   //      Reactor Flux
                    .collectList()  //             
                    .awaitFirst()   // ,    -    .
   convertData@
                ""
                TODO() //    ,    
            } finally {
                connection
                    .close()    //   
                    .awaitFirstOrNull() //   null -    .
            }

            call.respond(list)
        }

, Reactor map/flatMap . map/flatMap , , . finally — ( ) doFinally . , README conn.close(), . — , — . , map await, .

awaitFirstOrNull() Mono, onNext() .

, — , , .

R2DBC - (map) . companion object -:

 companion object DB{
        fun ofRow(r: Row, unused: RowMetadata) = Tables(
            r.get("TABLE_CATALOG", String::class.java),
            r.get("TABLE_SCHEMA", String::class.java),
            r.get("TABLE_NAME", String::class.java),
            r.get("TABLE_TYPE", String::class.java),
            r.get("STORAGE_TYPE", String::class.java),
            r.get("ID", Integer::class.java)?.toString(),
            r.get("TYPE_NAME", String::class.java),
            r.get("TABLE_CLASS", String::class.java),
            r.get("ROW_COUNT_ESTIMATE", java.lang.Long::class.java)?.toLong() ?: 0 //     Java ,     
        )
    }

, JDBC .

map Reactor, ReactiveStream Java Stream, R2DBC.

   convertData@
                result.flatMap {//      .  -   ,    
                    it
                        .map(Tables.DB::ofRow)  //     
                        .toFlux()               //      Reactor Flux 
                        .collectList()          //             
                        .awaitFirst()          // ,    -    .
                }

, :

curl http://localhost:8080/tables

यदि JSON बदसूरत है, तो यह एप्लिकेशन के गॉन सेक्शन ( setPrettyPrinting ) में कॉन्फ़िगर किया गया है ।

हम पूल के आंकड़े देते हैं

अच्छी तरह से और सुंदरता के लिए (चूंकि हम मैट्रिक्स के मानक मॉड्यूल को कनेक्ट नहीं करते थे) हम पूल आँकड़ों को देखने के लिए एक बिंदु जोड़ देंगे। टेम्प्लेट इंजन हमारे लिए बहुत अच्छा है, क्योंकि हमारी भाषा उपकरण हमें इसकी अनुमति देते हैं:

        get("/pool") {
            showPool@
            //      
            call.respondText {
                (pool.metrics.map {
                    """
                Max allocated size:                 ${it.maxAllocatedSize}
                Max pending size  :                 ${it.maxPendingAcquireSize}
                Acquired size     :                 ${it.acquiredSize()}
                Pending acquire size:               ${it.pendingAcquireSize()}
                Allocated size    :                 ${it.allocatedSize()}
                Idle size         :                 ${it.idleSize()}\n
            """.trimIndent()
                }.orElse("NO METRICS"))
            }
        }

बेशक, यदि आप चाहें, तो आप इसे HTML डीएसएल के माध्यम से दे सकते हैं।

जाँच - परिणाम

आप प्रतिक्रियाशील प्रवाह के साथ कोरटाइन बना सकते हैं, लेकिन आपको प्रतिक्रियाशील और अनिवार्य शैलियों के बीच स्विच करने की आवश्यकता है - अधिमानतः कम अक्सर और एक शैली का पालन करने का प्रयास करें।

केवल एक वसंत नहीं!

प्रतिक्रियात्मक डेटाबेस एक्सेस स्प्रिंग डेटा जेपीए मेकअप के बाद के रूप में सुंदर नहीं है, लेकिन आप इसका उपयोग कर सकते हैं।

Jetbrains KTor और R2DBC के उदाहरण पर प्रतिक्रियाशील डेटा के प्रति दृष्टिकोण

हम एक प्रोजेक्ट तैयार कर रहे हैं

हम पूल के आंकड़े देते हैं

जाँच - परिणाम

More articles: