Unify Docs

Honey's Redis backend is ideal for temporary data, caching, sessions, and real-time messaging via pub/sub.

When to Use

Caching frequently accessed data
Player sessions and temp state
Cross-server communication (Bungee/Velocity networks)
Real-time pub/sub messaging
Leaderboards with sorted sets (via direct Redis)

Key-Value Storage

import me.jordanfails.honey.DataHandler
import me.jordanfails.honey.DataStoreType
import me.jordanfails.honey.connection.dataFramework

dataFramework {
    redis(host = "localhost", port = 6379)
    // or: redis(uri = "redis://localhost:6379")
}

val store = DataHandler.createStoreType<String, PlayerSession>(DataStoreType.REDIS) {
    it.id = "sessions"
}

// Store session
val session = PlayerSession(
    uuid = player.uniqueId.toString(),
    server = "lobby-1",
    joinedAt = System.currentTimeMillis()
)
store.store(session.uuid, session)

// Load session (fast — from memory)
val loaded = store.retrieve(player.uniqueId.toString())

Pub/Sub

Broadcast messages across servers or plugins:

// Subscribe to a channel
DataHandler.createPubSubType<ChatMessage>(
    DataStoreType.REDIS,
    channel = "global-chat"
) { message ->
    Bukkit.broadcastMessage("§8[§c${message.server}§8] §7${message.sender}: §f${message.content}")
}

// Publish a message
DataHandler.publish(
    ChatMessage(
        server = "lobby-1",
        sender = "JordanFails",
        content = "Hello from lobby!"
    ),
    "global-chat"
)

data class ChatMessage(
    val server: String,
    val sender: String,
    val content: String
)

Authentication

dataFramework {
    redis(
        host = "localhost",
        port = 6379,
        password = "secret"
    )
}

Full Example: Cross-Server Staff Chat

class StaffChatPlugin : JavaPlugin() {

    override fun onEnable() {
        dataFramework {
            redis(host = "localhost", port = 6379)
        }

        // Listen for staff messages from any server
        DataHandler.createPubSubType<StaffMessage>(
            DataStoreType.REDIS,
            channel = "staff-chat"
        ) { message ->
            Bukkit.getOnlinePlayers()
                .filter { it.hasPermission("staff.chat") }
                .forEach {
                    it.sendMessage("§c[STAFF] §7${message.server} §8| §f${message.sender}: §7${message.content}")
                }
        }
    }

    fun sendStaffMessage(player: Player, content: String) {
        DataHandler.publish(
            StaffMessage(
                server = Bukkit.getServerName(),
                sender = player.name,
                content = content
            ),
            "staff-chat"
        )
    }

    override fun onDisable() {
        DataHandler.closeAllConnections()
    }
}

data class StaffMessage(
    val server: String,
    val sender: String,
    val content: String
)

TTL / Expiration

Honey does not support TTL directly. Use raw Redis for expiring keys:

val jedis = DataHandler.getRedisConnection()
jedis?.setex("temp-ban:${player.uuid}", 3600, "banned")  // expires in 1 hour

Important Notes

Consideration	Details
Persistence	Redis is in-memory. Configure AOF/RDB for durability
Memory	Redis uses RAM. Don't store large datasets here
Cluster	Use `redis(uri = "redis://...")` with cluster-aware URI
Serialization	Values are JSON strings — keep them small

Redis