spring boot + redis 配置

最新推荐文章于 2023-04-25 19:45:21 发布

xiazep521

最新推荐文章于 2023-04-25 19:45:21 发布

阅读量436

点赞数 1

分类专栏： linux

linux 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.引入reids包

spring-boot-starter-redis(springboot版本1.4版本前)，spring-boot-starter-data-redis（1.4版本后）

选择合适的API：

这个主要是根据redis存储的数据类型需求决定，key一般都是String，但是value可能不一样，一般有两种，String和 Object；
如果k-v都是String类型，我们可以直接用 StringRedisTemplate，这个是官方建议的，也是最方便的，直接导入即用，无需多余配置！
如果k-v是Object类型，则需要自定义 RedisTemplate，在这里我们都研究下！

2.配置文件application.yml中redis的配置信息

redis:
host: 127.0.0.1
port: 6379
#连接超时时间(毫秒)
timeout: 2000
pool:
#最大连接数(负数表示没有限制)
max-active: 100
#最大空闲连接
max-idle: 10
#最大阻塞等待时间(负数表示没有限制)
max-wait: 100000
database: 0

3.Redis配置类

@Configuration
@EnableCaching //配置cache Manager
//继承CachingConfigurerSupport类是为了自定义redis key的生成策略（复写keyGenerator方法）
public class RedisConfig extends CachingConfigurerSupport{
//从配置文件中读取配置信息
@Value("${redis.timeout}")
private Long redisTimeout;
/*生成key的策略根据类名+方法名+所有参数的值生成唯一的一个key **/
@Bean
@Override
public KeyGenerator keyGenerator() {
return new KeyGenerator() {
public Object generate(Object target, Method method, Object... params) {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(method.getName());
for (Object obj : params) {
sb.append(obj.toString());
}
return sb.toString();
}
};
}
/**
* 管理缓存
* @param redisTemplate
* @return
*/
@Bean
public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
//设置redis缓存过期时间
cacheManager.setDefaultExpiration(redisTimeout);
return cacheManager;
}
/**
* RedisTemplate配置
* jdk序列方式，用来保存对象(key=对象)
* @param factory
* @return
*/
/*@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//自定义的redis序列化工具类（对object序列化）
RedisObjectSerializer redisObjectSerializer = new RedisObjectSerializer();
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(factory);
template.setKeySerializer(stringRedisSerializer);
template.setValueSerializer(redisObjectSerializer);
return template;
} */
/**
* RedisTemplate配置
* string的序列化方式，存储string格式（key=value）
* @param factory
* @return
*/
/*@Bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
stringRedisTemplate.setConnectionFactory(factory);
setSerializer(stringRedisTemplate);
stringRedisTemplate.afterPropertiesSet();
return stringRedisTemplate;
}*/
/*private void setSerializer(StringRedisTemplate template){
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
template.setValueSerializer(jackson2JsonRedisSerializer);
}*/
/**
* redis模板，存储关键字是字符串，值是Jdk序列化,这个写法和我com.jary.util中的RedisObjectSerializer写法更简单，测试后选择使用那个
* @Description:
* @param factory
* @return
*/
@Bean
public RedisTemplate<?,?> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<?,?> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(factory);
//key序列化方式;但是如果方法上有Long等非String类型的话，会报类型转换错误；
RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型不可以会出现异常信息;
redisTemplate.setKeySerializer(redisSerializer);
redisTemplate.setHashKeySerializer(redisSerializer);
//JdkSerializationRedisSerializer序列化方式;
JdkSerializationRedisSerializer jdkRedisSerializer=new JdkSerializationRedisSerializer();
redisTemplate.setValueSerializer(jdkRedisSerializer);
redisTemplate.setHashValueSerializer(jdkRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}

里面写的有点乱，主要是使用几种序列化的方式不同，不用的都注释掉了，其中有一个<String，Object>的RedisTemplate，里面使用了自定义的序列化方式工具类redisObjectSerializer:

/**
* @Author: jaryle
* @CreateDate: 2018/6/3 14:24
* @Version: 1.0
*/
public class RedisObjectSerializer implements RedisSerializer<Object> {
static final byte[] EMPTY_ARRAY = new byte[0];
@Override
public Object deserialize(byte[] bytes) {
if (isEmpty(bytes)) {
return null;
}
ObjectInputStream oii = null;
ByteArrayInputStream bis = null;
bis = new ByteArrayInputStream(bytes);
try {
oii = new ObjectInputStream(bis);
Object obj = oii.readObject();
return obj;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Override
public byte[] serialize(Object object) {
if (object == null) {
return EMPTY_ARRAY;
}
ObjectOutputStream obi = null;
ByteArrayOutputStream bai = null;
try {
bai = new ByteArrayOutputStream();
obi = new ObjectOutputStream(bai);
obi.writeObject(object);
byte[] byt = bai.toByteArray();
return byt;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
private boolean isEmpty(byte[] data) {
return (data == null || data.length == 0);
}
}

刚开始使用此方法进行测试的，测试成功，后来觉得太麻烦，还要自己写个序列化工具类，就使用现在没有注释的RedisTemplate<?,?>更简单一些，功能也可以实现。

4.编写一个 redis封装工具类：（内部导入的是StringRedisTemplate，RedisTemplate也可以）

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
/**
* @Author: jaryle
* @Date: 2018/08/08 17:30
*/
@Service
@Slf4j
public class IRedisService {
//这里我们注入了我自定义的Redistemplate,而且支持<String,Object>存储，上面写出自定义序列化
@Autowired
protected RedisTemplate redisTemplate;
private final static Logger log = LoggerFactory.getLogger(RedisUtils.class);
/**
* 写入redis缓存（不设置expire存活时间）
* @param key
* @param value
* @return
*/
public boolean set(final String key, String value){
boolean result = false;
try {
ValueOperations operations = redisTemplate.opsForValue();
operations.set(key, value);
result = true;
} catch (Exception e) {
log.error("写入redis缓存失败！错误信息为：" + e.getMessage());
}
return result;
}
/**
* 写入redis缓存（设置expire存活时间）
* @param key
* @param value
* @param expire
* @return
*/
public boolean set(final String key, String value, Long expire){
boolean result = false;
try {
ValueOperations operations = redisTemplate.opsForValue();
operations.set(key, value);
redisTemplate.expire(key, expire, TimeUnit.SECONDS);
result = true;
} catch (Exception e) {
log.error("写入redis缓存（设置expire存活时间）失败！错误信息为：" + e.getMessage());
}
return result;
}
/**
* 读取redis缓存
* @param key
* @return
*/
public Object get(final String key){
Object result = null;
try {
ValueOperations operations = redisTemplate.opsForValue();
result = operations.get(key);
} catch (Exception e) {
log.error("读取redis缓存失败！错误信息为：" + e.getMessage());
}
return result;
}
/**
* 判断redis缓存中是否有对应的key
* @param key
* @return
*/
public boolean exists(final String key){
boolean result = false;
try {
result = redisTemplate.hasKey(key);
} catch (Exception e) {
log.error("判断redis缓存中是否有对应的key失败！错误信息为：" + e.getMessage());
}
return result;
}
/**
* redis根据key删除对应的value
* @param key
* @return
*/
public boolean remove(final String key){
boolean result = false;
try {
if(exists(key)){
redisTemplate.delete(key);
}
result = true;
} catch (Exception e) {
log.error("redis根据key删除对应的value失败！错误信息为：" + e.getMessage());
}
return result;
}
/**
* redis根据keys批量删除对应的value
* @param keys
* @return
*/
public void remove(final String... keys){
for(String key : keys){
remove(key);
}
}
}

上面代码，都是key=value形式的操作。如果key=value（object）,stringRedisTemplate就不能使用了，我们要自定义一个redisTemplate来处理。

springboot也提供了RedisTemplate

定义了对5种数据结构操作：

redisTemplate.opsForValue();//操作字符串

redisTemplate.opsForHash();//操作hash

redisTemplate.opsForList();//操作list

redisTemplate.opsForSet();//操作set

redisTemplate.opsForZSet();//操作有序set

5.使用的是mybatis,持久层我就不上代码了，直接上service吧

@ComponentScan({"com.jary.mapper"})
@Service
public class UserServiceImpl implements UserService {
@Resource
UserMapper userMapper;
@Autowired
RedisUtils redisUtis;
@Override
public List<User> getUsers() {
return userMapper.getUsers();
}
@Override
public User getUserById(User user) {
// TODO Auto-generated method stub
return null;
}
@Override
public User selectUser(String user_name) {
User usr = userMapper.selectUser(user_name);
//把usr信息写入缓存中
redisUtis.set("usr_id", usr);
return usr;
}

6.controller层也不用写了吧，太简单浪费时间，直接上测试结果

7.最后说说StringRedisTemplate 和 RedisTemplate 对比分析

总结了一下区别和联系主要有四点：

第一点，StringRedisTemplate继承了RedisTemplate。

第二点，RedisTemplate是一个泛型类，而StringRedisTemplate则不是。

第三点，StringRedisTemplate只能对key=String，value=String的键值对进行操作，RedisTemplate可以对任何类型的key-value键值对操作。

第四点，是他们各自序列化的方式不同，但最终都是得到了一个字节数组，殊途同归，StringRedisTemplate使用的是StringRedisSerializer类；RedisTemplate使用的是JdkSerializationRedisSerializer类。反序列化，则是一个得到String，一个得到Object

8。源码分析：

先看 StringRedisTemplate：

StringRedisTemplate 是继承 RedisTemplate的，一般来说子类继承父类，应该能实现更多的功能，但是此处我们发现 StringRedisTemplate 继承的是 RedisTemplate的泛型类，指定了String-String的泛型！故功能只专注于String类型！

è¿éåå¾çæè¿°