通过 Spring Data Redis 的 RedisTemplate 插入值需要根据 数据结构类型 选择对应的操作方法。以下是常见数据类型的插入示例（Kotlin 代码）：
1. 插入字符串（String）
适用于存储简单键值对（如缓存、计数器等）。
// 插入字符串
redisTemplate.opsForValue().set("user:1:name", "张三")// 插入并设置过期时间（30 秒后自动删除）
redisTemplate.opsForValue().set("user:1:token", "abc123", 30, TimeUnit.SECONDS)// 仅当键不存在时插入（原子操作）
redisTemplate.opsForValue().setIfAbsent("user:1:status", "active")
2. 插入哈希（Hash）
适用于存储对象或结构化数据（如用户信息、商品属性等）。
// 插入单个字段
redisTemplate.opsForHash<String, String>().put("user:1", "name", "李四")// 批量插入字段
val userData = mapOf("age" to "28","email" to "lisi@example.com"
)
redisTemplate.opsForHash<String, String>().putAll("user:1", userData)
3. 插入列表（List）
适用于队列、栈或顺序数据（如消息队列、操作日志等）。
// 从左侧插入（LPUSH）
redisTemplate.opsForList().leftPushAll("messages", listOf("msg1", "msg2", "msg3"))// 从右侧插入（RPUSH）
redisTemplate.opsForList().rightPush("tasks", "task_001")
4. 插入集合（Set）
适用于去重集合（如标签、用户兴趣等）。
// 插入单个元素
redisTemplate.opsForSet().add("tags", "科技", "体育")// 批量插入元素
redisTemplate.opsForSet().add("user:1:interests", setOf("音乐", "电影", "旅行"))
5. 插入有序集合（ZSet）
适用于带权重的排序集合（如排行榜、优先级队列等）。
// 插入带分数的元素
redisTemplate.opsForZSet().add("leaderboard", "玩家A", 100.0)
redisTemplate.opsForZSet().add("leaderboard", "玩家B", 85.5)
6. 通用插入方法
如果数据类型未知或需要动态处理，可通过 RedisTemplate 直接操作连接：
redisTemplate.execute { connection ->connection.stringCommands().set("custom_key".toByteArray(),"custom_value".toByteArray())null
}
关键配置
确保 RedisTemplate 已正确配置序列化器（如未配置，插入的值可能无法正确序列化）：
@Configuration
class RedisConfig {@Beanfun redisTemplate(redisConnectionFactory: RedisConnectionFactory): RedisTemplate<String, Any> {val template = RedisTemplate<String, Any>()template.connectionFactory = redisConnectionFactorytemplate.keySerializer = StringRedisSerializer() // 键序列化为字符串template.valueSerializer = GenericJackson2JsonRedisSerializer() // 值序列化为 JSONtemplate.hashKeySerializer = StringRedisSerializer() // Hash 键序列化template.hashValueSerializer = GenericJackson2JsonRedisSerializer() // Hash 值序列化return template}
}
使用场景示例
1. 缓存用户信息
data class User(val id: String, val name: String, val age: Int)val user = User("1", "王五", 30)
redisTemplate.opsForValue().set("user:${user.id}", user)
2. 存储会话信息
val sessionData = mapOf("userId" to "1001","role" to "admin","lastLogin" to "2023-10-05T12:00:00Z"
)
redisTemplate.opsForHash<String, String>().putAll("session:1001", sessionData)
3. 实现简单队列
// 生产者插入任务
redisTemplate.opsForList().rightPush("task_queue", "process_data")// 消费者获取任务
val task = redisTemplate.opsForList().leftPop("task_queue")
注意事项
- 序列化一致性：确保插入和读取时使用相同的序列化方式。
- 键命名规范：使用可读性强的命名（如
user:1:profile），避免特殊字符。 - 过期时间：对缓存数据设置合理的过期时间（如
redisTemplate.expire("key", 60, TimeUnit.SECONDS)）。 - 事务支持：如需原子性操作，可结合
@Transactional使用（需启用事务管理）。
通过以上方法，可以灵活操作 Redis 中的各类数据结构，满足不同业务场景需求。
在 Spring + Kotlin 项目中，通过 org.redisson.api.RedissonClient（Redisson 客户端）可以实现丰富的 分布式系统功能。以下是 RedissonClient 的核心操作及典型场景：
1. 分布式对象与数据结构
Redisson 提供了与 Java 集合高度兼容的分布式对象，支持跨 JVM 共享数据。
(1) 分布式键值对（RMap）
// 获取分布式 Map
val userMap: RMap<String, User> = redissonClient.getMap("userMap")// 写入数据
userMap["user1"] = User("Alice", 30)// 读取数据
val user: User? = userMap["user1"]
(2) 分布式列表（RList）
val taskList: RList<String> = redissonClient.getList("tasks")
taskList.addAll(listOf("task1", "task2", "task3"))
(3) 分布式集合（RSet）
val uniqueTags: RSet<String> = redissonClient.getSet("tags")
uniqueTags.add("tech")
uniqueTags.add("sports")
(4) 分布式锁（RLock）
val lock: RLock = redissonClient.getLock("resourceLock")
lock.lock() // 阻塞直到获取锁
try {// 执行临界区代码
} finally {lock.unlock()
}
2. 高级分布式功能
(1) 分布式原子操作（RAtomicLong）
val counter: RAtomicLong = redissonClient.getAtomicLong("globalCounter")
counter.incrementAndGet() // 原子递增
(2) 发布订阅（RTopic）
// 订阅频道
val topic: RTopic = redissonClient.getTopic("news")
topic.addListener(String::class.java) { channel, msg ->println("收到消息: $msg")
}// 发布消息
topic.publish("Redis 7.0 正式发布！")
(3) 分布式队列（RQueue）
val queue: RQueue<String> = redissonClient.getQueue("messageQueue")
queue.offer("msg1") // 入队
val msg: String? = queue.poll() // 出队
(4) 分布式延迟队列（RDelayedQueue）
val delayedQueue: RDelayedQueue<String> = redissonClient.getDelayedQueue(queue)
delayedQueue.offer("delayedMsg", 10, TimeUnit.SECONDS) // 延迟 10 秒入队
3. 分布式锁进阶
(1) 公平锁
val fairLock: RLock = redissonClient.getFairLock("fairLock")
fairLock.lock()
(2) 联锁（MultiLock）
同时锁定多个资源：
val lock1: RLock = redissonClient.getLock("lock1")
val lock2: RLock = redissonClient.getLock("lock2")
val multiLock = redissonClient.getMultiLock(lock1, lock2)
multiLock.lock()
(3) 红锁（RedLock）
val redLock: RLock = redissonClient.getRedLock(lock1, lock2, lock3)
redLock.lock()
4. 分布式服务
(1) 分布式远程服务（RRemoteService）
实现跨 JVM 的远程方法调用：
// 定义服务接口
interface UserService {fun getUserById(id: String): User
}// 服务端注册
val remoteService: RRemoteService = redissonClient.getRemoteService("userService")
remoteService.register(UserService::class.java, UserServiceImpl())// 客户端调用
val userService = remoteService.get(UserService::class.java)
val user = userService.getUserById("123")
(2) 分布式调度任务（RScheduler）
val scheduler: RScheduler = redissonClient.getScheduler()
scheduler.schedule({ println("定时任务执行") },CronSchedule.of("0 0/5 * * * ?") // 每 5 分钟执行
)
5. 与 Spring 整合
(1) 配置 RedissonClient
在 application.yml 中配置：
spring:redis:redisson:config: |singleServerConfig:address: "redis://localhost:6379"database: 0
或通过 Java/Kotlin 配置类：
@Configuration
class RedissonConfig {@Beanfun redissonClient(): RedissonClient {val config = Config()config.useSingleServer().address = "redis://localhost:6379"return Redisson.create(config)}
}
(2) 注入并使用
@Service
class OrderService(private val redissonClient: RedissonClient
) {fun processOrder(orderId: String) {val lock = redissonClient.getLock("orderLock:$orderId")lock.lock()try {// 处理订单逻辑} finally {lock.unlock()}}
}
6. 典型应用场景
| 场景 | Redisson 功能 | 优势 |
|---|---|---|
| 分布式锁 | RLock、RedLock | 避免资源竞争，保证原子性 |
| 全局计数器 | RAtomicLong | 原子操作，支持高并发 |
| 消息队列 | RQueue、RDelayedQueue | 跨服务任务调度 |
| 缓存共享 | RMap、RBucket | 分布式缓存，数据一致性 |
| 实时通知 | RTopic | 发布订阅模式，解耦系统组件 |
| 分布式任务调度 | RScheduler | 集群环境定时任务协调 |
注意事项
- 依赖版本兼容性：确保 Redisson 版本与 Spring Boot 兼容。
- 锁的释放：务必在
finally块中释放锁，避免死锁。 - 网络超时：合理配置
timeout和retry参数。 - 序列化：默认使用
JsonJacksonCodec，可自定义其他编解码器。
通过 RedissonClient，开发者可以轻松在 Spring + Kotlin 项目中实现复杂的分布式系统逻辑，显著简化分布式环境下的开发难度。