springboot 集成redis
maven引入redis,以及工具类
<!-- Redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- JSON工具类 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.6.2</version>
</dependency>
<!-- 阿里JSON解析器 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.66</version>
</dependency>
由于 Spring Boot 2.X 默认集成了 Lettuce ,所以无需导入。
配置文件配置
#spring 配置
spring:
#redis配置
redis:
#数据库索引
database: 0
#redis 服务器地址
host: localhost
#redis 端口
port: 6379
#redis 密码 默认为空
password: 123456
# 链接超时时间
connect-timeout: 10s
#lettuce连接池配置
lettuce:
pool:
# 链接池中最小的空闲链接 默认为0
min-idle: 0
# 链接池中最大的空闲连接 默认为 8
max-idle: 8
#连接池中最大数据库链接数 默认为8
max-active: 8
#连接池最大阻塞等待时间 负值表示没有限制
max-wait: -1ms
定制redis序列化
redis正常存储数据使用了默认的jdk 存储二进制方式,不利用我们观看,我们可以使用官方提供的json序列化方式 也可以使用自己定制的.
/**
* redis 使用fastjson 序列化
*
*
*/
public class FastJsonRedis<T> implements RedisSerializer<T> {
private ObjectMapper objectMapper = new ObjectMapper();
public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
private Class<T> clazz;
public FastJsonRedis(Class<T> clazz){
this.clazz = clazz;
}
static{
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
}
@Override
public byte[] serialize(T t) throws SerializationException {
if(t==null){
return new byte[0];
}
return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
}
@Override
public T deserialize(byte[] bytes) throws SerializationException {
if(bytes == null|| bytes.length<=0){
return null;
}
String str= new String(bytes,DEFAULT_CHARSET);
return JSON.parseObject(str,clazz);
}
public void setObjectMapper(ObjectMapper objectMapper){
this.objectMapper=objectMapper;
}
}
配置redistemplate 的序列化方式
/**
* redis 配置
*/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
//修改缓存存储的序列化方式
@Bean
public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory connectionFactory){
RedisTemplate<Object,Object> template= new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
// key的序列化采用StringRedisSerializer
template.setKeySerializer(new StringRedisSerializer());
template.setHashKeySerializer(new StringRedisSerializer());
// value的序列化采用fastjson
FastJsonRedis<Object> fastJsonRedis = new FastJsonRedis<>(Object.class);
//设置ObjectMapper
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
fastJsonRedis.setObjectMapper(mapper);
// 设置value序列化
template.setValueSerializer(fastJsonRedis);
template.setHashValueSerializer(fastJsonRedis);
template.afterPropertiesSet();
return template;
}
}
创建redis工具类 ,为我们更好的使用
里面操作的参数都是 final类型,是因为缓存时,不能在修改缓存数据了。
@Component
public class RedisCache {
@Autowired
public RedisTemplate redisTemplate;
/**
* 缓存的基本对象,Integer,String,实体类
*
*/
public <T> void setCacheObject(String key,final T value){
redisTemplate.opsForValue().set(key,value);
}
/**
* 设置有效时间
* 时间单位:秒
*/
public boolean expire(final String key,final long timeout){
return expire(key,timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
* @param key
* @param timeout
* @param unit
* @return
*/
public boolean expire(final String key,final long timeout,final TimeUnit unit){
return redisTemplate.expire(key,timeout,unit);
}
/**
* 获得缓存的基本对象
*/
public <T> T getCacheObject(final String key){
ValueOperations<String,T> operations=redisTemplate.opsForValue();
return operations.get(key);
}
/**
* 删除单个对象
*
*/
public boolean deleteObject(final String key){
return redisTemplate.delete(key);
}
/**
* 删除集合对象
*/
public long deleteObject(final Collection collection){
return redisTemplate.delete(collection);
}
/**
* 缓存list对象
* @param key
* @param dataList
* @param <T>
* @return
*/
public <T> long setCacheList(final String key,final List<T> dataList){
//Long 类型
Long count = redisTemplate.opsForList().rightPushAll(key,dataList);
return count==null?0:count;
}
/**
* 获得缓存的list对象
* @param key
* @param <T>
* @return
*/
public <T> List<T> getCacheList(final String key){
return redisTemplate.opsForList().range(key,0,-1);
}
/**
* 缓存 map
* @param key
* @param dataMap
* @param <T>
*/
public <T> void setCacheMap(final String key ,final Map<String,T> dataMap){
if(dataMap != null){
redisTemplate.opsForHash().putAll(key,dataMap);
}
}
/**
* entries
* 用于以Map的格式获取一个Hash键的所有值。
* 获取缓存的map
* @param key
* @param <T>
* @return
*/
public <T> Map<String,T> getCacheMap(final String key){
return redisTemplate.opsForHash().entries(key);
}
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
{
BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
Iterator<T> it = dataSet.iterator();
while (it.hasNext())
{
setOperation.add(it.next());
}
return setOperation;
}
/**
* 获得缓存的set
*
* @param key
* @return
*/
public <T> Set<T> getCacheSet(final String key)
{
return redisTemplate.opsForSet().members(key);
}
/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public Collection<String> keys(final String pattern)
{
return redisTemplate.keys(pattern);
}
}