SpringBoot实践之---集成Redis

1.引入依赖

build.gradle中加入 //redis
compile('org.springframework.data:spring-data-redis:1.8.0.RELEASE')
compile('redis.clients:jedis:2.9.0')

2.配置Redis参数

application.properties中加入#redis
spring.redis.host=172.16.3.72
spring.redis.port=6379
spring.redis.password=
spring.redis.timeout=5000
spring.redis.pool.max-active=1500
spring.redis.pool.max-idle=20
spring.redis.pool.max-wait=5
spring.redis.pool.testOnBorrow=true
spring.redis.pool.testOnReturn=true

3.编写Redis操作工具类

import com.alibaba.fastjson.JSONObject;
import com.my.web.enums.ERedisDomain;
import com.my.web.exception.RedisException;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.util.*;

/**
* Description: 该类主要用于提供操作Redis连接池缓存的工具
**/
public class RedisUtils {

/** jedis连接池 */
private static JedisPool pool;

/**
* 初始化redis连接
*/
static  {
if (pool == null) {
// 创建jedis池配置实例
JedisPoolConfig config = new JedisPoolConfig();
String hostIP = PropertyReaderUtils.getProValue("spring.redis.host"); //Redis主机IP
Integer hostPort = Integer.valueOf(PropertyReaderUtils.getProValue("spring.redis.port")); //Redis主机端口
Integer maxActive = Integer.valueOf(PropertyReaderUtils.getProValue("spring.redis.pool.max-active"));
Integer maxIdle = Integer.valueOf(PropertyReaderUtils.getProValue("spring.redis.pool.max-idle"));
Long maxWait = Long.valueOf(PropertyReaderUtils.getProValue("spring.redis.pool.max-wait"));
Boolean testOnBorrow = Boolean.valueOf(PropertyReaderUtils.getProValue("spring.redis.pool.testOnBorrow"));
Boolean testOnReturn = Boolean.valueOf(PropertyReaderUtils.getProValue("spring.redis.pool.testOnReturn"));
int timeout = Integer.valueOf(PropertyReaderUtils.getProValue("spring.redis.timeout"));
//设置池配置项值
config.setMaxTotal(maxActive);
config.setMaxIdle(maxIdle);
config.setMaxWaitMillis(maxWait);
config.setTestOnBorrow(testOnBorrow);
config.setTestOnReturn(testOnReturn);
//根据配置实例化jedis池
pool = new JedisPool(config, hostIP, hostPort, timeout);
}
}

/**
* 添加单个Redis缓存
*
* @param domain Redis分组
* @param key Redis的组内key
* @param value Redis的组内value
* @return boolean 是否添加成功
*/
public static boolean save(ERedisDomain domain, String key, Object value) {
Jedis jedis = null;
long result = 0l;
try {
jedis = getJedis();
result = jedis.hset(domain.getKey(), key, JSONObject.toJSONString(value));
} catch (Exception e) {
throw new RedisException("unable to save key " + key + " in domain " + domain.getKey(), e);
} finally {
if (null != jedis)
jedis.close(); // 释放资源还给连接池
}
return (result == 1) ? true : false;
}

/**
* 添加单个Redis缓存
*
* @param domain Redis分组
* @param key Redis的组内key
* @param valueJson Redis的组内value(JSON格式)
* @return boolean 是否添加成功
*/
public static boolean save(ERedisDomain domain, String key, String valueJson) {
Jedis jedis = null;
long result = 0l;
try {
jedis = getJedis();
result = jedis.hset(domain.getKey(), key, valueJson);
} catch (Exception e) {
throw new RedisException("unable to save key " + key + " in domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return (result == 1) ? true : false;
}

/**
* 批量添加Redis缓存
*
* @param domain Redis分组
* @param data Redis缓存数据
* @return boolean 是否添加成功
*/
public static boolean batchSave(ERedisDomain domain, Map<String, Object> data) {
Jedis jedis = null;
String result = "fail";
try {
jedis = getJedis();
Map<String, String> jsonData = new HashMap<>(); //json格式的数据
for (String key : data.keySet()) {
jsonData.put(key, JSONObject.toJSONString(data.get(key)));
}
result = jedis.hmset(domain.getKey(), jsonData);
} catch (Exception e) {
throw new RedisException("unable to batch save keys " + data.keySet() + " in domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return ("OK".equalsIgnoreCase(result)) ? true : false;
}

/**
* 批量添加Redis缓存
*
* @param domain Redis分组
* @param data Redis缓存数据（值为json格式）
* @return boolean 是否添加成功
*/
public static boolean batchSaveJson(ERedisDomain domain, Map<String, String> data) {
Jedis jedis = null;
String result = "fail";
try {
jedis = getJedis();
result = jedis.hmset(domain.getKey(), data);
} catch (Exception e) {
throw new RedisException("unable to batch save keys " + data.keySet() + " in domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return ("OK".equalsIgnoreCase(result)) ? true : false;
}

/**
* 获取指定Redis组内的所有缓存数据
*
* @param domain Redis分组
* @return Map 缓存数据，值为json格式
*/
public static Map<String, String> get(ERedisDomain domain) {
Jedis jedis = null;
Map<String, String> maps = null;
try {
jedis = getJedis();
maps = jedis.hgetAll(domain.getKey());
} catch (Exception e) {
throw new RedisException("unable to get data from domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return maps;
}

/**
* 获取指定Redis组内的所有缓存数据
*
* @param domain Redis分组
* @param clazz 缓存对象的类型
* @return Map 缓存数据
*/
public static <T> Map<String, T> get(ERedisDomain domain, Class<T> clazz) {
Jedis jedis = null;
Map<String, T> resultMap = new HashMap<>(); //初始化返回结果
try {
jedis = getJedis();
Map<String, String> data = jedis.hgetAll(domain.getKey()); //json格式的缓存结果
for (String key : data.keySet()) {
JSONObject jsonCacheObj = JSONObject.parseObject(data.get(key));
T cacheData = JSONObject.toJavaObject(jsonCacheObj, clazz);
resultMap.put(key, cacheData);
}
} catch (Exception e) {
throw new RedisException("unable to get data from domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return resultMap;
}

/**
* 获取单个缓存对象
*
* @param domain Redis分组
* @param key 缓存对象的key
* @return String json格式的缓存对象
*/
public static String get(ERedisDomain domain, String key) {
Jedis jedis = null;
String retureValue = null;
try {
jedis = getJedis();
retureValue = jedis.hget(domain.getKey(), key);
} catch (Exception e) {
throw new RedisException("unable to get key " + key + " in domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return retureValue;
}

/**
* 获取单个缓存对象
*
* @param domain Redis分组
* @param key 缓存对象的key
* @param clazz 缓存对象的类型
* @return T 缓存对象
*/
public static <T> T get(ERedisDomain domain, String key, Class<T> clazz) {
Jedis jedis = null;
T retureObj = null;
try {
jedis = getJedis();
String jsonData = jedis.hget(domain.getKey(), key);
JSONObject jsonCacheObj = JSONObject.parseObject(jsonData);
retureObj = JSONObject.toJavaObject(jsonCacheObj, clazz);
} catch (Exception e) {
throw new RedisException("unable to get key " + key + " in domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return retureObj;
}

/**
* 删除给定Redis分组的所有缓存
*
* @param domain Redis分组
* @return boolean 是否删除成功
*/
public static boolean delete(ERedisDomain domain) {
Jedis jedis = null;
long result = 0l;
try {
jedis = getJedis();
result = jedis.del(domain.getKey());
} catch (Exception e) {
throw new RedisException("unable to delete data in domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return (result == 1) ? true : false;
}

/**
* 删除缓存
*
* @param domain 缓存所属分组
* @param keys 缓存对象的key
* @return boolean 是否删除成功
*/
public static boolean delete(ERedisDomain domain, String... keys) {
Jedis jedis = null;
long result = 0l;
try {
jedis = getJedis();
result = jedis.hdel(domain.getKey(), keys);
} catch (Exception e) {
throw new RedisException("unable to delete keys " + keys + " in domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return (result == 1) ? true : false;
}

/**
* 获取给定分组的所有Redis缓存对象
*
* @param domain Redis分组
* @return List json格式的缓存对象列表
*/
public static List<String> getValues(ERedisDomain domain) {
Jedis jedis = null;
List<String> retureList = null;
try {
jedis = getJedis();
retureList = jedis.hvals(domain.getKey());
} catch (Exception e) {
throw new RedisException("unable to delete data in domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return retureList;
}

/**
* 获取给定分组的所有Redis缓存对象
*
* @param domain Redis分组
* @param clazz 缓存对象类型
* @return List 缓存对象列表
*/
public static <T> List<T> getValues(ERedisDomain domain, Class<T> clazz) {
Jedis jedis = null;
List<T> result = new ArrayList<>(); //初始化返回结果
try {
jedis = getJedis();
List<String> cacheObjs = jedis.hvals(domain.getKey());
for (String cache : cacheObjs) {
JSONObject jsonCacheObj = JSONObject.parseObject(cache);
result.add(JSONObject.toJavaObject(jsonCacheObj, clazz));
}
} catch (Exception e) {
throw new RedisException("unable to get data in domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return result;
}

/**
* 获取给定分组的所有Redis缓存key
*
* @param domain Redis分组
* @return Set 缓存key集
*/
public static Set<String> getKeys(ERedisDomain domain) {
Jedis jedis = null;
Set<String> retureSet = null;
try {
jedis = getJedis();
retureSet = jedis.hkeys(domain.getKey());
} catch (Exception e) {
throw new RedisException("unable to get keys in domain " + domain.getKey(), e);
} finally {
close(jedis);// 释放资源还给连接池
}
return retureSet;
}

/**
* 获取Jedis实例
*
* @return
*/
private synchronized static Jedis getJedis() {
if (pool != null) {
return pool.getResource();
} else {
return null;
}
}

/**
* 释放jedis资源
*
* @param jedis
*/
private static void close(final Jedis jedis) {
if (jedis != null) {
jedis.close();
}
}
}

4.实际使用

//取值
Set<String> loginTokens = RedisUtils.getKeys(ERedisDomain.TOKEN_LOGIN_USER);
//存值
RedisUtils.save(ERedisDomain.USER_REQUEST_TIME, userID, currentTimeMillis);