我导入的是reddison包。没有导入reddison场景启动器
一.自定义fastjson2编码器
redisson配置类
<!--redisson客户端-->
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>${redisson.version}</version>
</dependency>
/**
* @author WangYuanJie
* @description: test
* @ClassName RedissonConfig
* @date 2022/3/5 10:11
*/
@Configuration
@Slf4j
@ConfigurationProperties(prefix = "redisson")
@Data
public class RedissonConfig {
private String host;
private String password;
@Bean(destroyMethod = "shutdown")
RedissonClient redisson() {
Config config = new Config();
//config.useClusterServers().addNodeAddress("127.0.0.1:6379").setPassword("123456");
config.useSingleServer()
.setAddress("redis://"+ this.getHost())
.setPassword(this.getPassword())
.setSubscriptionConnectionMinimumIdleSize(1)
.setSubscriptionConnectionPoolSize(50)
.setConnectionMinimumIdleSize(32)
.setConnectionPoolSize(64)
.setDnsMonitoringInterval(5000)
.setIdleConnectionTimeout(10000)
.setConnectTimeout(10000)
.setTimeout(3000)
.setRetryAttempts(3)
.setRetryInterval(1500)
.setDatabase(1)
.setSubscriptionsPerConnection(5);
config.setCodec(new FastJson2Codec());
return Redisson.create(config);
}
}
查Config源码
我们只要继承重写他的编码器注入就可以了
自定义fastjson2编码器
package com.vector.framework.config;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONReader;
import com.alibaba.fastjson2.JSONWriter;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.buffer.ByteBufInputStream;
import io.netty.buffer.ByteBufOutputStream;
import org.redisson.client.codec.BaseCodec;
import org.redisson.client.protocol.Decoder;
import org.redisson.client.protocol.Encoder;
import java.io.IOException;
public class FastJson2Codec extends BaseCodec {
private final Encoder encoder = in -> {
ByteBuf out = ByteBufAllocator.DEFAULT.buffer();
try {
ByteBufOutputStream os = new ByteBufOutputStream(out);
JSON.writeTo(os, in, JSONWriter.Feature.WriteClassName);
return os.buffer();
} catch (Exception e) {
out.release();
throw new IOException(e);
}
};
private final Decoder<Object> decoder = (buf, state) ->
JSON.parseObject(new ByteBufInputStream(buf), Object.class, JSONReader.Feature.SupportAutoType);
@Override
public Decoder<Object> getValueDecoder() {
return decoder;
}
@Override
public Encoder getValueEncoder() {
return encoder;
}
}
二.redisson操作工具类封装
package com.vector.common.core.redis;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.redisson.api.*;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* spring redis 工具类
*
* @author vector
**/
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedissonCache {
@Resource
public RedissonClient redissonClient;
/**
* 缓存基本的对象,Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public <T> void setCacheObject(final String key, final T value) {
redissonClient.getBucket(key).set(value);
}
/**
* 缓存基本的对象,Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
redissonClient.getBucket(key).set(value, timeout, timeUnit);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功;false=设置失败
*/
public boolean expire(final String key, final long timeout) {
return redissonClient.getBucket(key).expire(timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功;false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit) {
return redissonClient.getBucket(key).expire(timeout, unit);
}
/**
* 获取有效时间
*
* @param key Redis键
* @return 有效时间
*/
public long getExpire(final String key) {
return redissonClient.getBucket(key).getExpireTime();
}
/**
* 判断 key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public Boolean hasKey(String key) {
return redissonClient.getBucket(key).isExists();
}
/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public <T> T getCacheObject(final String key) {
return (T) redissonClient.getBucket(key).get();
}
/**
* 删除单个对象
*
* @param key
*/
public boolean deleteObject(final String key) {
return redissonClient.getBucket(key).delete();
}
/**
* 删除集合对象
*
* @param collection 多个对象
* @return
*/
public boolean deleteObject(final Collection collection) {
return redissonClient.getKeys().delete((RObject) collection) > 0;
}
/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public <T> long setCacheList(final String key, final List<T> dataList) {
boolean b = redissonClient.getList(key).addAll(dataList);
return b ? 0 : dataList.size();
}
/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public <T> List<T> getCacheList(final String key) {
return (List<T>) redissonClient.getList(key).range(0, -1);
}
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public <T> Set<Object> setCacheSet(final String key, final Set<T> dataSet) {
RSet<Object> set = redissonClient.getSet(key);
set.addAll(dataSet);
return set.readAll();
}
/**
* 获得缓存的set
*
* @param key
* @return
*/
public <T> Set<T> getCacheSet(final String key) {
return (Set<T>) redissonClient.getSet(key).readAll();
}
/**
* 缓存Map
*
* @param key
* @param dataMap
*/
public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
if (dataMap != null) {
redissonClient.getMap(key).putAll(dataMap);
}
}
/**
* 获得缓存的Map
*
* @param key
* @return
*/
public <T> Map<String, T> getCacheMap(final String key) {
RMap<String, T> map = redissonClient.getMap(key);
return map.readAllMap();
}
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
redissonClient.getMap(key).put(hKey,value);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public <T> T getCacheMapValue(final String key, final String hKey) {
return (T) redissonClient.getMap(key).get(hKey);
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
return (List<T>) redissonClient.getListMultimap(key).getAll(hKeys);
}
/**
* 删除Hash中的某条数据
*
* @param key Redis键
* @param hKey Hash键
* @return 是否成功
*/
public boolean deleteCacheMapValue(final String key, final String hKey) {
return redissonClient.getMap(key).fastRemove(hKey) > 0;
}
/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public Collection<String> keys(final String pattern) {
return (Collection<String>) redissonClient.getKeys().getKeysByPattern(pattern);
}
}