redisson提供了很多对象类型的api，下面介绍下一些常用的对象api。
RBucket
可操作任何对象的api，前提是要确定好泛型，方法比较少。大小限制为512Mb。
java
RBucket<AnyObject> bucket = redisson.getBucket("anyObject");
bucket.set(new AnyObject(1));
AnyObject obj = bucket.get();
bucket.trySet(new AnyObject(3));
bucket.compareAndSet(new AnyObject(4), new AnyObject(5));
bucket.getAndSet(new AnyObject(6));RMap
专门操作map的对象，实现了ConcurrentMap接口，并且put、set操作直接作用于redis。
java
RMap<String, SomeObject> map = redisson.getMap("anyMap");
SomeObject prevObject = map.put("123", new SomeObject());
SomeObject currentObject = map.putIfAbsent("323", new SomeObject());
SomeObject obj = map.remove("123");
// use fast* methods when previous value is not required
map.fastPut("a", new SomeObject());
map.fastPutIfAbsent("d", new SomeObject());
map.fastRemove("b");
RFuture<SomeObject> putAsyncFuture = map.putAsync("321");
RFuture<Void> fastPutAsyncFuture = map.fastPutAsync("321");
map.fastPutAsync("321", new SomeObject());
map.fastRemoveAsync("321");RList
专门操作list的对象，实现了java.util.List， add、set等方法直接作用于redis。
java
RList<SomeObject> list = redisson.getList("anyList");
list.add(new SomeObject());
list.get(0);
list.remove(new SomeObject());自定义工具类代码
java
package com.springboot.demo.base.utils;
import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.apache.commons.lang3.ObjectUtils;
import org.redisson.api.RBucket;
import org.redisson.api.RList;
import org.redisson.api.RLock;
import org.redisson.api.RMap;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* @description: redisson工具类 <br>
* @author: 小花卷的Dad <br>
* @create: 2023/8/24 <br>
*/
@Component
public class RedissonUtil {
private static RedissonClient redissonClient;
/**
* 锁默认释放时间
*/
private static final long default_lease_time = 5L;
@Autowired
public void setRedissonClient(RedissonClient redissonClient) {
RedissonUtil.redissonClient = redissonClient;
}
/**
* key是否存在
* @param key
* @return
*/
public static boolean isExists(String key){
return redissonClient.getBucket(key).isExists();
}
/**
* 获取生命周期
* @param key
* @return
*/
public static long getExpireTime(String key){
return redissonClient.getBucket(key).remainTimeToLive();
}
/**
* 设置生命周期
* @param key
* @param time(毫秒)
* @return
*/
public static boolean setExpireTime(String key, Long expire){
return redissonClient.getBucket(key).expire(Duration.ofMillis(expire));
}
public static boolean delete(String key){
if(!isExists(key)){
return true;
}
return redissonClient.getBucket(key).delete();
}
/**
* 保存字符串
* @param key
* @param value
*/
public static void setStr(String key, String value){
RBucket<String> rBucket = redissonClient.getBucket(key);
rBucket.set(value);
}
/**
* 保存字符串
* @param key
* @param value
* @param expire
*/
public static void setStr(String key, String value, Long expire){
RBucket<String> rBucket = redissonClient.getBucket(key);
rBucket.set(value, Duration.ofMillis(expire));
}
/**
* 查询字符串
* @param key
* @return
*/
public static String getStr(String key){
if(isExists(key)){
return null;
}
RBucket<String> rBucket = redissonClient.getBucket(key);
return rBucket.get();
}
/**
* 保存对象
* @param key
* @param value
* @param <T>
*/
public static <T> void setObject(String key, T value){
RBucket<T> rBucket = redissonClient.getBucket(key);
rBucket.set(value);
}
/**
* 保存对象
* @param key
* @param value
* @param expire
* @param <T>
*/
public static <T> void setObject(String key, T value, Long expire){
RBucket<T> rBucket = redissonClient.getBucket(key);
rBucket.set(value, Duration.ofMillis(expire));
}
/**
* 查询对象
* @param key
* @return
*/
public static <T> T getObject(String key){
RBucket<T> rBucket = redissonClient.getBucket(key);
return rBucket.get();
}
/**
* map.get
* @param key
* @param mapKey
* @param <T>
* @return
*/
public static <T> T mapGet(String key, String mapKey){
if(!isExists(key)){
return null;
}
Map<String, T> rMap = redissonClient.getMap(key);
return rMap.get(mapKey);
}
/**
* 查询map
* @param key
* @param <T>
* @return
*/
public static <T> Map<String, T> mapGetAll(String key){
RMap<String, T> rMap = redissonClient.getMap(key);
return rMap.readAllMap();
}
/**
* map.put
* @param key
* @param mapKey
* @param mapValue
* @param <T>
*/
public static <T> void mapPut(String key, String mapKey,T mapValue){
RMap<String, T> rMap = redissonClient.getMap(key);
rMap.put(mapKey, mapValue);
}
/**
* map.putAll
* @param key
* @param map
* @param <T>
*/
public static <T> void mapPutAll(String key, Map<String, T> map){
RMap<String, T> rMap = redissonClient.getMap(key);
rMap.putAll(map);
}
/**
* map.contains
* @param key
* @param mapKey
* @return
*/
public static boolean mapContains(String key, String mapKey){
if(!isExists(key)){
return false;
}
Map<String, Object> rMap = redissonClient.getMap(key);
return rMap.containsKey(mapKey);
}
/**
* list.get
* @param key
* @param listIndex
* @param <T>
* @return
*/
public static <T> T listGet(String key, int listIndex){
if(!isExists(key)){
return null;
}
if(listIndex < 0){
return null;
}
RList<T> rList = redissonClient.getList(key);
if(rList.size()-1 < listIndex){
return null;
}
return rList.get(listIndex);
}
/**
* list.getAll
* @param key
* @param <T>
* @return
*/
public static <T> List<T> listGetAll(String key){
RList<T> rList = redissonClient.getList(key);
return rList.readAll();
}
/**
* list.add
* @param key
* @param addValue
* @param <T>
*/
public static <T> void listAdd(String key, T addValue){
RList<T> rList = redissonClient.getList(key);
rList.add(addValue);
}
/**
* list.add
* @param key
* @param addList
* @param <T>
*/
public static <T> void listAddAll(String key, List<T> addList){
RList<T> rList = redissonClient.getList(key);
rList.addAll(addList);
}
/**
* list.set
* @param key
* @param listIndex
* @param setValue
* @param <T>
*/
public static <T> void listSet(String key, int listIndex, T setValue){
RList<T> rList = redissonClient.getList(key);
if(rList.size()-1 < listIndex){
return;
}
rList.set(listIndex, setValue);
}
}