POM依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 用于序列化 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.62</version>
</dependency>
</dependencies>
配置文件application.yaml
一般初始化一个Spring Boot项目后默认配置文件application.properties格式，直接重命名为application.yaml，个人比较喜欢用这个格式。
server:
port: 8888
# Redis相关配置
spring:
redis:
# 数据库 默认就是0
database: 0
# 主机IP
host: 47.100.254.31
# 端口
port: 6379
# 密码
password: 9TR6aCyZEjxmGtUwup
# 连接超时时间，单位毫秒
timeout: 1000
jedis:
pool:
# 连接池最大连接数（使用负值表示没有限制
max-active: 600
# 连接池中的最大空闲连接
max-idle: 100
# 连接池最大阻塞等待时间（使用负值表示没有限制）
max-wait: 1000
# 连接池中的最小空闲连接
min-idle: 0
创建一个FastJson序列化类
这里纯粹是个人爱好，一直都在用FastJson，习惯了，你也可以使用Spring Boot自带的JackSon或者谷歌出品的Gson。
public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
private Class<T> clazz;
private static final byte[] EMPTY_ARRAY = new byte[0];
private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
public FastJsonRedisSerializer(Class<T> clazz) {
this.clazz = clazz;
}
@Override
public byte[] serialize(T t) throws SerializationException {
if (t == null) {
return EMPTY_ARRAY;
}
try {
try {
return JSONObject.toJSONString(t).getBytes(DEFAULT_CHARSET);
} catch (Exception e) {
return String.valueOf(t).getBytes(DEFAULT_CHARSET);
}
} catch (Exception e) {
throw new SerializationException("无法写入Json：" + e.getMessage(), e);
}
}
@Override
@SuppressWarnings("unchecked")
public T deserialize(byte[] bytes) throws SerializationException {
if (bytes == null || bytes.length == 0) {
return null;
}
try {
String str = new String(bytes, DEFAULT_CHARSET);
try {
JSONObject json = JSONObject.parseObject(str);
return JSONObject.toJavaObject(json, clazz);
} catch (Exception e) {
return (T) str;
}
} catch (Exception e) {
throw new SerializationException("无法读取Json：" + e.getMessage(), e);
}
}
}
Redis配置类
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
// 初始化一个RedisTemplate 不配置序列化默认使用String
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
// Fastjson序列化
FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
// 字符串系列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringRedisSerializer);
redisTemplate.setHashKeySerializer(stringRedisSerializer);
redisTemplate.setValueSerializer(fastJsonRedisSerializer);
redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
// 开启事务
redisTemplate.setEnableTransactionSupport(true);
redisTemplate.setConnectionFactory(redisConnectionFactory);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
@Bean(name = "redisUtil")
public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
RedisUtil redisUtil = new RedisUtil();
redisUtil.setRedisTemplate(redisTemplate);
return redisUtil;
}
}
Redis工具类
其实这个东西封装好的方法一大堆，随便找一篇博文就可以使用，你也可以直接复制我的，基本的String，Hash，Set，List我都有封装好方法。这类封装大同小异，基本都相差不多，有一些我没有封装的可根据自己使用封装进去。
public class RedisUtil {
private static RedisTemplate redisTemplate;
public void setRedisTemplate(RedisTemplate redisTemplate) {
RedisUtil.redisTemplate = redisTemplate;
}
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 失效时间，单位秒
* @return 返回true，添加成功，false添加失败
* @date 2019/11/28 15:27
*/
public static boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key获取过期时间
*
* @param key 键
* @return 返回0代表永久失效（单位秒）
* @date 2019/11/28 15:29
*/
public static long getExpire(String key) {
return redisTemplate.getExpire(key);
}
/**
* 判断指定key是否存在
*
* @param key 键
* @return 返回true存在，返回false不存在
* @date 2019/11/28 15:31
*/
public static boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除指定的key
*
* @param keys 一个或多个键
* @date 2019/11/28 15:33
*/
@SuppressWarnings("unchecked")
public static void del(String... keys) {
if (keys != null && keys.length > 0) {
if (keys.length == 1) {
redisTemplate.delete(keys);
} else {
redisTemplate.delete(Arrays.asList(keys));
}
}
}
/**
* 根据指定key获取value
*
* @param key 键
* @return 返回value
* @date 2019/11/28 15:35
*/
public static Object get(String key) {
if (key == null) {
return null;
}
return redisTemplate.opsForValue().get(key);
}
/**
* 根据指定key获取value(转换为指定类型)
*
* @param key 键
* @return 返回指定类型数据
* @date 2019/11/28 15:38
*/
@SuppressWarnings("unchecked")
public static <T> T hget(String key, Class<T> clazz) {
Object obj = get(key);
if (obj == null) {
return null;
}
if (obj instanceof JSON) {
return ((JSON) obj).toJavaObject(clazz);
}
return (T) obj;
}
/**
* 存入指定的key，value
*
* @param key 键
* @param value 值
* @return true存入成功，false存入失败
* @date 2019/11/28 15:40
*/
public static boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 存入指定的key，value，并设置缓存时间
*
* @param key 键
* @param value 值
* @param time 时间 单位秒
* @return
* @date 2019/11/28 15:43
*/
public static boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 指定key递增
*
* @param key 键
* @param delta 因子(要增加多少)
* @return 返回递增后的值
* @date 2019/11/28 15:46
*/
public static long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递归因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 指定key递减
*
* @param key 键
* @param delta delta 因子(要减少多少)
* @return 返回递减后的值
* @date 2019/11/28 15:49
*/
public static long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递归因子必须大于0");
}
return redisTemplate.opsForValue().decrement(key, delta);
}
/**
* 根据指定的key和item获取value（一般叫大key和小key）
*
* @param key 键
* @param item 项
* @return 返回指定的值
* @date 2019/11/28 15:51
*/
public static Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 根据指定的key和item获取value（转换为指定类型）
*
* @param key 键
* @param item 项
* @param clazz 转换类
* @return 返回指定类型
* @date 2019/11/28 15:54
*/
public static <T> T hget(String key, String item, Class<T> clazz) {
Object obj = hget(key, item);
if (obj == null) {
return null;
}
if (obj instanceof JSON) {
return ((JSON) obj).toJavaObject(clazz);
}
return (T) obj;
}
/**
* 根据指定的key获取所有hash的键值
*
* @param key 键
* @return 返回所有hash键值
* @date 2019/11/28 15:56
*/
public static Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* 根据指定的key存储hashmap
*
* @param key 键
* @param map 多个键值
* @return true存入成功，false存入失败
* @date 2019/11/28 15:58
*/
public static boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据指定的key存储hashmap，设置过期时间
*
* @param key 键
* @param map 多个键值
* @param time 过期时间，单位秒
* @return true存入成功，false存入失败
* @date 2019/11/28 16:00
*/
public static boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据指定key和item向指定hash插入数据
*
* @param key 键
* @param item 项
* @param value 值
* @return true存入成功，false存入失败
* @date 2019/11/28 16:02
*/
public static boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 据指定key和item向指定hash插入数据，并添加过期时间
*
* @param key 键
* @param item 项
* @param value 值
* @param time 过期时间，单位秒
* @return true存入成功，false存入失败
* @date 2019/11/28 16:04
*/
public static boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据指定的key和item删除hash中的数据
*
* @param key 键
* @param items 值
* @date 2019/11/28 16:07
*/
public static void hdel(String key, Object... items) {
redisTemplate.opsForHash().delete(key, items);
}
/**
* 根据指定的key和item判断hash中数据是否存在
*
* @param key 键
* @param item 项
* @return 存在返回true，失败返回false
* @date 2019/11/28 16:08
*/
public static boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* 根据key获取set中的所有值
*
* @param key 键
* @return 返回set集合
* @date 2019/11/28 16:10
*/
public static Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据指定的key和value查询在set中是否存在
*
* @param key 键
* @param value 值
* @return 返回true存在，返回false不存在
* @date 2019/11/28 16:12
*/
public static boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据指定key在set中存入一个或多个key
*
* @param key 键
* @param values 值，一个或多个
* @return 返回成功个数
* @date 2019/11/28 16:14
*/
public static long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0L;
}
}
/**
* 根据指定key在set中存入一个或多个key
*
* @param key 键
* @param time 过期时间，单位秒
* @param values 值，一个或多个
* @return 返回成功个数
* @date 2019/11/28 16:17
*/
public static long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0) {
expire(key, time);
}
return count;
} catch (Exception e) {
e.printStackTrace();
return 0L;
}
}
/**
* 根据指定key获取set缓存长度
*
* @param key 键
* @return 返回长度
* @date 2019/11/28 16:19
*/
public static long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0L;
}
}
/**
* 根据指定的key移除set中的value
*
* @param key 键
* @param values 值
* @return 移除个数
* @date 2019/11/28 16:20
*/
public static long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0L;
}
}
/**
* 根据指定的key获取指定的setart和end之间的值
*
* @param key 键
* @param start 开始
* @param end 结束
* @return 值
* @date 2019/11/28 16:21
*/
public static List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据指定key获取list的长度
*
* @param key 键
* @return 返回list长度
* @date 2019/11/28 16:23
*/
public static long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0L;
}
}
/**
* 根据指定key和索引获取list中的值
*
* @param key 键
* @param index 索引 index大于0. 0表头，1第二个元素；index小于0, -1 表尾，-2 倒数第二个元素；
* @return 返回value
* @date 2019/11/28 16:24
*/
public static Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据指定key存入list
*
* @param key 键
* @param value 值
* @return true存入成功，false存入失败
* @date 2019/11/28 16:25
*/
public static boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据指定key存入list，并指定过期时间
*
* @param key 键
* @param value 值
* @param time 过期时间，单位秒
* @return true存入成功，false存入失败
* @date 2019/11/28 16:27
*/
public static boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据指定key存入list
*
* @param key 键
* @param value list值
* @return true存入成功，false存入失败
* @date 2019/11/28 16:28
*/
public static boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据指定key存入list
*
* @param key 键
* @param value list值
* @param time 过期时间，单位秒
* @return true存入成功，false存入失败
* @date 2019/11/28 16:28
*/
public static boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据指定key和索引修改list中的数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return true修改成功，false修改失败
* @date 2019/11/28 16:29
*/
public static boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据指定key移除指定数量的值
*
* @param key 键
* @param count 数量
* @param value 值
* @return 移除个数
* @date 2019/11/28 16:30
*/
public static long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0L;
}
}
}
自定义全局返回结果类
纯粹的个人习惯，虽然是写个例子，但是也要统一格式的返回结果
public class Result implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 状态码
*/
private int code;
/**
* 响应消息
*/
private String message;
/**
* 响应数据
*/
private Object data;
public Result(int code, String message) {
this.code = code;
this.message = message;
}
public Result(int code, String message, Object data) {
this.code = code;
this.message = message;
this.data = data;
}
// 省略下面的Getter和Setter方法
}
创建一个Controller层进行测试
由于是测试就不每个方法都进行测试了
@RestController
@RequestMapping("/redis")
public class RedisController {
@PostMapping("/set")
public Result set(String key, String value) {
boolean setStatus = RedisUtil.set(key, value);
if (setStatus) {
return new Result(200, "存入成功");
}
return new Result(-1, "存入失败");
}
@GetMapping("/get")
public Result get(String key) {
Object data = RedisUtil.get(key);
return new Result(200, "获取成功", data);
}
}
测试结果：
添加
查询
