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

Introduction to Caching in Kotlin

Modern Kotlin applications, whether server-side backend solutions or Android clients, often face performance issues when working with data. Repeated requests to databases, external APIs, or heavy computations can significantly slow down the system. Caching is an effective way to reduce load and speed up application responses. In this article, we will look at three main approaches to caching in the Kotlin ecosystem: using Redis, Memcached, and built-in in-memory solutions. You will learn how to choose the right tool and implement it in your project.

What is caching and why is it needed in Kotlin?

Caching is the process of storing frequently requested data in a temporary storage with fast access. Instead of performing an expensive operation (database query, network call) every time, the application first checks the cache. If the data is there (cache hit), it is returned instantly. If not (cache miss), the main operation is performed, and the result is saved to the cache for future requests.

Main advantages of caching in Kotlin:

• Reduced response time — data from the cache is returned in milliseconds.
• Reduced load on the database and external services.
• Resource savings — fewer CPU and network operations.
• Scalability — distributed caches (Redis, Memcached) are easily scalable.

In Kotlin, thanks to its compatibility with Java and powerful coroutines, caching is implemented particularly elegantly.

Built-in solutions for caching in Kotlin

For small projects or local caching within a single JVM process, you can use built-in tools. They do not require installing external services and are ideal for prototyping.

Simple in-memory cache with ConcurrentHashMap

The simplest way is to use ConcurrentHashMap with TTL (time-to-live) support. Here is an example implementation:

import java.util.concurrent.ConcurrentHashMapimport java.util.concurrent.TimeUnit

class SimpleCache<K, V>(private val ttlMillis: Long) {    private val cache = ConcurrentHashMap<K, CacheEntry<V>>()

    private data class CacheEntry<V>(val value: V, val expiryTime: Long)

    fun put(key: K, value: V) {        val expiryTime = System.currentTimeMillis() + ttlMillis        cache[key] = CacheEntry(value, expiryTime)    }

    fun get(key: K): V? {        val entry = cache[key] ?: return null        if (System.currentTimeMillis() > entry.expiryTime) {            cache.remove(key)            return null        }        return entry.value    }

    fun invalidate(key: K) {        cache.remove(key)    }

    fun clear() {        cache.clear()    }}

// Usagefun main() {    val cache = SimpleCache<String, String>(TimeUnit.MINUTES.toMillis(5))    cache.put("user_42", "{\\"name\\":\\"Alice\\"}")    val user = cache.get("user_42")    println(user) // Will output the JSON string}

This approach is simple but not suitable for distributed systems.

Using Caffeine — an advanced library

For more complex scenarios, the Caffeine library is recommended. It provides a high-performance cache with automatic eviction, statistics, and asynchronous loading. Add the dependency to build.gradle.kts:

implementation("com.github.ben-manes.caffeine:caffeine:3.1.8")

Example of using Caffeine with coroutines:

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

data class Product(val id: Int, val name: String, val price: Double)

class ProductService {    private val ca