Caching in Kotlin: Redis, Memcached, and Built-in Solutions

Введение в кэширование на Kotlin

In modern Kotlin development, application performance often hinges on data access speed. Caching is a technique of temporarily storing frequently requested data in fast storage, which reduces response time and lowers the load on databases or external APIs. For Kotlin developers, three main approaches are available: using external systems Redis and Memcached, as well as built-in solutions (in-memory cache).

In this article, we will thoroughly examine each of them, provide practical code examples in Kotlin, and help you choose the optimal option for your project. The material will be useful for both beginners and experienced developers striving to optimize their applications.

1. Built-in Caching in Kotlin (In-Memory)

Built-in caching is the simplest way to speed up an application without configuring external services. It is implemented using standard Kotlin collections or specialized libraries such as Caffeine or Guava Cache.

1.1. Simple Caching with HashMap

A basic example is using ConcurrentHashMap to store data:

import java.util.concurrent.ConcurrentHashMap

class SimpleCache<K, V> {    private val cache = ConcurrentHashMap<K, V>()

    fun get(key: K): V? = cache[key]

    fun put(key: K, value: V) {        cache[key] = value    }

    fun remove(key: K) = cache.remove(key)

    fun clear() = cache.clear()}

// Usage examplefun main() {    val cache = SimpleCache<String, String>()    cache.put("user:1", "Alice")    println(cache.get("user:1")) // Output: Alice}

This approach is simple but does not support automatic removal of outdated data (TTL) and can lead to memory leaks.

1.2. Advanced Caching with Caffeine

Caffeine is a high-performance caching library for the JVM, perfectly suited for Kotlin. It supports TTL, automatic eviction, and statistics.

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

fun main() {    val cache = Caffeine.newBuilder()        .expireAfterWrite(10, TimeUnit.MINUTES) // TTL 10 minutes        .maximumSize(100) // Maximum 100 entries        .recordStats() // Enable statistics        .build<String, String>()

    cache.put("session:123", "token_abc")    println(cache.getIfPresent("session:123")) // Output: token_abc

    // Usage statistics    val stats = cache.stats()    println("Hits: ${stats.hitCount()}, Misses: ${stats.missCount()}")}

Built-in caching is excellent for single-threaded or small microservices where synchronization between multiple application instances is not required.

2. Caching with Redis in Kotlin

Redis is an in-memory data store often used as a distributed cache. It supports complex data structures (strings, lists, hashes, sets) and has built-in TTL and persistence mechanisms.

2.1. Connecting Redis to Kotlin

To work with Redis in Kotlin, the Lettuce (asynchronous) or Jedis (synchronous) library is most commonly used. Let's look at an example with Jedis:

// build.gradle.ktsdependencies {    implementation("redis.clients:jedis:5.1.0")}

import redis.clients.jedis.JedisPooled

fun main() {    val jedis = JedisPooled("localhost", 6379)

    // Setting a value with TTL of 60 seconds    jedis.setex("user:42", 60, "Bob")

    // Getting the value    val user = jedis.get("user:42")    println("User: $user") // Output: User: Bob

    // Using hashes    jedis.hset("user:42:profile", mapOf(        "n