整合redis
加入依赖：
|
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> |
加入配置：
# 缓存配置 - redis
spring.redis.host=192.168.6.119
spring.redis.port=6380
# 连接超时时间（毫秒）
spring.redis.timeout=3000
spring.redis.database=0
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=600
spring.redis.jedis.pool.max-idle=300
spring.redis.jedis.pool.min-idle=300
spring.redis.jedis.pool.max-wait=1000加入工具类：
package com.dongao.common.util;
import java.io.Serializable;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
/**
* redis操作类
*
*/
@Component
public class RedisUtils {
private static final Logger logger = LoggerFactory.getLogger(RedisUtils.class);
@Autowired
private RedisTemplate redisTemplate;
//值默认的序列化策略为JdkSerializationRedisSerializer
/**
* 向redis写入数据，不限制过期时间
* @param key
*/
public void set(final String key, Object value){
try {
redisTemplate.setKeySerializer(new StringRedisSerializer());
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
} catch (Exception e) {
logger.error("redis写入失败",e);
}
}
/**
* 向redis写入数据，限制过期时间，单位毫秒
*/
public void set(final String key, Object value, Long expireTime){
try {
redisTemplate.setKeySerializer(new StringRedisSerializer());
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
} catch (Exception e) {
logger.error("redis写入失败",e);
}
}
/**
* 清除指定key的redis缓存
*/
public void remove(final String key) {
if (exists(key)) {
redisTemplate.delete(key);
logger.info("删除redis缓存key:{}",key);
}
}
/**
* 判断指定key的缓存是否存在
*/
public boolean exists(final String key) {
return redisTemplate.hasKey(key);
}
/**
* 读取redis缓存
*/
public <T> T get(final String key,Class<T> type) {
Object result = null;
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
result = operations.get(key);
return result == null ? null : (T) result;
}
/**
* 供计数器使用
* 不用配合add和get使用，如要使用，请配置相同的序列化策略
*计数器+1
*/
@SuppressWarnings("unchecked")
public Long incr(String key){//不进行处理异常，出现异常作为系统异常处理
try {
//这里动态的设置为String的 序列化策略，防止ERR value is not an integer or out of range
//new GenericToStringSerializer<Long>(Long.class)
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringRedisSerializer);
redisTemplate.setValueSerializer(stringRedisSerializer);
Long value = redisTemplate.opsForValue().increment(key, 1);
return value;
} catch (Exception e) {
logger.error("incr操作失败", e);
}
return null;
}
/**
* 获取incr里设置的值
*
* @param key
* @return
*/
public Long getIncrValue(String key) {
try {
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringRedisSerializer);
redisTemplate.setValueSerializer(stringRedisSerializer);
Object obj = redisTemplate.opsForValue().get(key);
logger.info(">>>>>>>>>>>>>>>>>>>>>>{}:从计数器中获取到的值为：{}", key,obj);
return obj == null?0l:Long.parseLong((String) obj);
} catch (Exception e) {
logger.error("获取计数器里的值失败", e);
}
return null;
}
}
