Kotlin में कैशिंग: Redis और अन्य समाधान

Kotlin में कैशिंग: Redis और अन्य समाधान

कैशिंग आधुनिक अनुप्रयोगों में प्रदर्शन अनुकूलन के प्रमुख तंत्रों में से एक है। Kotlin पारिस्थितिकी तंत्र में, Java के साथ पूर्ण संगतता और JVM की समृद्ध लाइब्रेरी बेस के कारण, कैश के साथ काम करने के लिए सभी मुख्य उपकरण उपलब्ध हैं। इस लेख में, हम देखेंगे कि Redis, Caffeine और Ehcache का उपयोग करके Kotlin में कैशिंग कैसे व्यवस्थित करें, और यह भी समझेंगे कि कब कौन सा उपकरण चुनना चाहिए।

कैशिंग की आवश्यकता क्यों है?

कैश बार-बार अनुरोधित डेटा को तेज़ी से सुलभ मेमोरी में संग्रहीत करके एप्लिकेशन प्रतिक्रिया समय को कम करने में मदद करता है। यह विशेष रूप से इसके लिए प्रासंगिक है:

• उच्च-लोड REST API;
• बाहरी API और डेटाबेस के साथ काम करना;
• संसाधन-गहन गणनाएँ;
• उपयोगकर्ताओं का सत्र डेटा।

मुख्य कैशिंग रणनीतियाँ

लाइब्रेरी चुनने से पहले, बुनियादी रणनीतियों को समझना महत्वपूर्ण है:

• Cache-Aside — एप्लिकेशन स्वयं कैश का प्रबंधन करता है: पहले कैश की जाँच करता है, मिस होने पर डेटाबेस से डेटा लोड करता है और उसे कैश में रखता है।
• Read-Through — मिस होने पर कैश स्वचालित रूप से स्रोत से डेटा लोड करता है।
• Write-Through / Write-Behind — डेटा को एक साथ (या एसिंक्रोनस रूप से) कैश और मुख्य स्टोरेज में लिखना।

1. Kotlin से Redis

Redis एक in-memory key-value स्टोर है जिसे अक्सर वितरित कैश के रूप में उपयोग किया जाता है। Kotlin में Redis के साथ काम करने के लिए Lettuce (एसिंक्रोनस, रिएक्टिव) या Jedis (सिंक्रोनस) क्लाइंट का उपयोग किया जाता है।

Lettuce को जोड़ना

// build.gradle.ktsimplementation("io.lettuce:lettuce-core:6.3.2.RELEASE")

Lettuce के माध्यम से Redis के साथ काम करने का उदाहरण (Kotlin)

import io.lettuce.core.RedisClientimport io.lettuce.core.api.coroutines

suspend fun main() {    val client = RedisClient.create("redis://localhost:6379")    val connection = client.connect()    val commands = connection.coroutines() // कोरूटीन API

    // लिखना    commands.setex("user:123:profile", 3600, "{\\"name\\":\\"Alice\\"}")        // पढ़ना    val cached = commands.get("user:123:profile")    println("कैश से: $cached")        connection.close()    client.shutdown()}

Redis का उपयोग कब करें?

• एप्लिकेशन के कई इंस्टेंस के बीच वितरित कैश की आवश्यकता है।
• उच्च दोष सहनशीलता और प्रतिकृति की आवश्यकता है।
• एप्लिकेशन पुनरारंभ के बाद भी डेटा उपलब्ध होना चाहिए (Redis स्थायित्व)।
• जटिल संरचनाओं (सूचियाँ, सेट, कतारें) के समर्थन की आवश्यकता है।

2. Caffeine — उच्च-प्रदर्शन स्थानीय कैश

Caffeine JVM पर in-memory कैशिंग के लिए एक लाइब्रेरी है, जो Java में लिखी गई है। इसका उपयोग अक्सर Spring Boot के साथ किया जाता है, लेकिन यह शुद्ध Kotlin में भी बढ़िया काम करता है। Caffeine पढ़ने पर लगभग शून्य विलंबता सुनिश्चित करता है।

Caffeine को जोड़ना

// build.gradle.ktsimplementation("com.github.ben-manes.caffeine:caffeine:3.1.8")

Kotlin में Caffeine के उपयोग का उदाहरण

import com.github.benmanes.caffeine.cache.Caffeineimport java.util.concurrent.TimeUnit

data class User(val id: Int, val name: String)

fun createCache(): Caffeine<Int, User>.() -> Unit = {    maximumSize(10_000)    expireAfterWrite(10, TimeUnit.MINUTES)    recordStats()}

val userCache = Caffeine.newBuilder()    .maximumSize(10_000)    .expireAfterWrite(10, TimeUnit.MINUTES)    .build<Int, User>()

fun getUserFromCache(id: Int): User? {    return userCache.getIfPresent(id)}

fun putUser(id: Int, user: User) {    userCache.put(id, user)}

// स्वचालित लोडिंग के साथ उदाहरण (LoadingCache)val loadingCache = Caffeine.newBuilder()    .maximumSize(5_000)    .build<Int, User>