第一步：Maven依赖
com.fasterxml.jackson.core
jackson-core
2.10.1
com.fasterxml.jackson.core
jackson-databind
2.10.1
com.fasterxml.jackson.core
jackson-annotations
2.10.1
org.springframework.boot
spring-boot-starter-data-redis
org.apache.commons
commons-pool2
在application.yml文件中添加如下内容：
spring:
# 配置redis
redis:
database: 0
host: 127.0.0.1
port: 6379
# password: 1234
timeout: 10000ms # 超时时间
lettuce:
pool:
max-idle: 8 # 最大空闲连接数，默认值为8
max-wait: -1ms # 最大连接阻塞等待时间，默认值-1
min-idle: 2 # 最小空闲连接数
max-active: 20 #最大连接数
@Configuration
public class RedisConfig {
private StringRedisSerializer keySerializer = new StringRedisSerializer();
//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
private Jackson2JsonRedisSerializer valueSerializer = new Jackson2JsonRedisSerializer(Object.class);
/**
* 在SpringBoot2.0之后，spring容器自动的生成了StringRedisTemplate和RedisTemplate，可以直接注入
* 但是在实际使用中，大多不会直接使用RedisTemplate，而是会对key,value进行序列化，所以我们还需要新增一个配置类
* 换句话说，由于原生的redis自动装配，在存储key和value时，没有设置序列化方式，故自己创建redisTemplate实例
*
* @param factory
* @return
*/
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
RedisTemplate template = new RedisTemplate();
template.setConnectionFactory(factory);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
// 日期和时间格式化
JavaTimeModule javaTimeModule = new JavaTimeModule();
// 设置LocalDateTime的序列化格式
javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
om.registerModule(javaTimeModule);
valueSerializer.setObjectMapper(om);
// key采用String的序列化方式
template.setKeySerializer(keySerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(keySerializer);
// value序列化方式采用jackson
template.setValueSerializer(valueSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(valueSerializer);
template.afterPropertiesSet();
return template;
}
}
public class JsonUtil {
private static ObjectMapper objectMapper = new ObjectMapper();
public static String convertObj2String(Object object) {
String s = null;
try {
s = objectMapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return s;
}
public static T convertString2Obj(String s, Class clazz) {
T t = null;
try {
t = objectMapper.readValue(s, clazz);
} catch (IOException e) {
e.printStackTrace();
}
return t;
}
}
package com.hc.common.service;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @author hecai
* @date 2021/12/21 9:08
*/
public interface RedisService {
/**
* 四周
*/
long WEEK_SECONDS = 4 * 7 * 24 * 60 * 60;
/**
* 列举出所有符合指定模式的key的集合
*
* @param pattern 模式
* @return
*/
Set keys(String pattern);
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
boolean expire(String key, long time);
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回代表为永久有效
*/
long getExpire(String key);
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
boolean exists(String key);
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
void del(String... key);
/**
* 普通缓存放入，设置永不过期
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean setNeverExpire(String key, E value);
/**
* 普通缓存放入，使用系统默认的过期时间
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
boolean set(String key, E value);
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param expireTime 时间(秒) time要大于 如果time小于等于 将设置无限期
* @return true成功 false 失败
*/
boolean set(String key, E value, long expireTime);
boolean multiSet(Map map);
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
E get(String key);
/**
* 普通缓存获取
*
* @param keys 键
* @return 值
*/
List multiGet(Collection keys);
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于)
* @return
*/
long incr(String key, long delta);
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于)
* @return
*/
long decr(String key, long delta);
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param entryKey 项
* @param entryValue 值
* @return true 成功 false失败
*/
boolean hset(String key, String entryKey, E entryValue);
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param entryKey 项
* @param entryValue 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
boolean hset(String key, String entryKey, E entryValue, long time);
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
boolean hmset(String key, Map map);
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
boolean hmset(String key, Map map, long time);
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
E hget(String key, String item);
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
Map hmget(String key);
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param entryKey 项 可以使多个 不能为null
*/
void hdel(String key, String... entryKey);
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param entryKey 项 不能为null
* @return true 存在 false不存在
*/
boolean hHasKey(String key, String entryKey);
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param entryKey 项
* @param by 要增加几(大于)
* @return
*/
double hincr(String key, String entryKey, double by);
/**
* hash递减
*
* @param key 键
* @param entryKey 项
* @param by 要减少记(小于)
* @return
*/
double hdecr(String key, String entryKey, double by);
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
long sSet(String key, E... values);
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
long sSet(String key, long time, E... values);
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return
*/
Set sGet(String key);
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
boolean sHasKey(String key, E value);
/**
* 获取set缓存的长度
*
* @param key 键
* @return
*/
long sGetSetSize(String key);
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
long setRemove(String key, E... values);
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
boolean lSet(String key, E value);
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
boolean lSet(String key, E value, long time);
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
boolean lSets(String key, List value);
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
boolean lSets(String key, List value, long time);
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 到 -代表所有值
* @return
*/
List lGet(String key, long start, long end);
/**
* 获取list缓存的长度
*
* @param key 键
* @return
*/
long lGetListSize(String key);
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=时， 表头， 第二个元素，依次类推；index 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
@Override
public boolean exists(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(Arrays.stream(key).collect(Collectors.toList()));
}
}
}
// ============================String=============================
@Override
public boolean setNeverExpire(String key, E value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public boolean set(String key, E value) {
try {
redisTemplate.opsForValue().set(key, value, WEEK_SECONDS, TimeUnit.SECONDS);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public boolean set(String key, E value, long expireTime) {
try {
if (expireTime > 0) {
redisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public boolean multiSet(Map map) {
try {
redisTemplate.opsForValue().multiSet(map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public E get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
@Override
public List multiGet(Collection keys) {
return redisTemplate.opsForValue().multiGet(keys);
}
@Override
public long incr(String key, long delta) {
if (delta 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public E hget(String key, String item) {
return (E) redisTemplate.opsForHash().get(key, item);
}
@Override
public Map hmget(String key) {
HashOperations hashOperations = redisTemplate.opsForHash();
return hashOperations.entries(key);
}
@Override
public void hdel(String key, String... entryKey) {
redisTemplate.opsForHash().delete(key, entryKey);
}
@Override
public boolean hHasKey(String key, String entryKey) {
return redisTemplate.opsForHash().hasKey(key, entryKey);
}
@Override
public double hincr(String key, String entryKey, double by) {
return redisTemplate.opsForHash().increment(key, entryKey, by);
}
@Override
public double hdecr(String key, String entryKey, double by) {
return redisTemplate.opsForHash().increment(key, entryKey, -by);
}
// ============================set=============================
@Override
public long sSet(String key, E... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
@Override
public long sSet(String key, long time, E... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0) {
expire(key, time);
}
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
@Override
public Set sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@Override
public boolean sHasKey(String key, E value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
@Override
public long setRemove(String key, E... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
@Override
public boolean lSet(String key, E value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public boolean lSet(String key, E value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public boolean lSets(String key, List value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public boolean lSets(String key, List value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public List lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@Override
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
@Override
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@Override
public boolean lUpdateIndex(String key, long index, E value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public long lRemove(String key, long count, E value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
@SpringBootTest
class RedisServiceImplDeptTest {
@Resource
private RedisService redisService;
@Test
public void fun() {
System.out.println(redisService);
}
//普通
@Test
void keys() {
Set keys = redisService.keys("*");
keys.forEach(System.out::println);
}
@Test
void expire() {
boolean res = redisService.expire("pcc::city", -1);
System.out.println(res);
}
@Test
void getExpire() {
long res = redisService.getExpire("pcc::province");
System.out.println(res);
}
@Test
void exists() {
boolean res = redisService.exists("pcc:city");
System.out.println(res);
}
@Test
void del() {
redisService.del("dept1", "dept2");
}
//string
@Test
void set() {
Dept dept = new Dept(10, "sales", "CHICAGO");
redisService.set("dept1", dept);
}
@Test
void set2() {
Dept dept = new Dept(10, "sales", "CHICAGO");
boolean res = redisService.set("dept2", dept, -1);
System.out.println(res);
}
@Test
void setNeverExpire() {
Dept dept = new Dept(10, "sales", "CHICAGO");
redisService.setNeverExpire("aa", dept);
}
@Test
void multiSet() {
HashMap map = new HashMap();
map.put("dept3", new Dept(10, "sales", "CHICAGO"));
map.put("dept4", new Dept(20, "research", "NEWYORK"));
map.put("dept5", new Dept(30, "analysis", "DALARS"));
boolean res = redisService.multiSet(map);
System.out.println(res);
}
@Test
void get() {
Dept dept = redisService.get("dept3");
System.out.println(dept);
}
@Test
void incr() {
long res = redisService.incr("k1", 8);
System.out.println(res);
}
@Test
void decr() {
long res = redisService.decr("k1", 4);
System.out.println(res);
}
//map-hash
@Test
void hset() {
boolean res = redisService.hset("hdept", "dept1", new Dept(30, "analysis", "DALARS"));
System.out.println(res);
}
@Test
void testHset() {
boolean res = redisService.hset("hdept", "30", new Dept(30, "analysis", "DALARS"), 120);
System.out.println(res);
}
@Test
void hmset() {
HashMap map = new HashMap();
map.put("dept10", new Dept(10, "sales", "CHICAGO"));
map.put("dept20", new Dept(20, "research", "NEWYORK"));
map.put("dept30", new Dept(30, "analysis", "DALARS"));
boolean res = redisService.hmset("hdept", map);
System.out.println(res);
}
@Test
void testHmset() {
HashMap map = new HashMap();
map.put("10", new Dept(10, "sales", "CHICAGO"));
map.put("20", new Dept(20, "research", "NEWYORK"));
map.put("30", new Dept(30, "analysis", "DALARS"));
boolean res = redisService.hmset("hdept", map, 120);
System.out.println(res);
}
@Test
void hget() {
Dept res = redisService.hget("hdept", "dept1");
System.out.println(res);
}
@Test
void hmget() {
Map res = redisService.hmget("hdept");
res.forEach((k, v) -> System.out.println(k + "\t" + v));
}
@Test
void hdel() {
redisService.hdel("hdept", "dept30", "dept20");
}
@Test
void hHasKey() {
boolean res = redisService.hHasKey("hdept", "dept10");
System.out.println(res);
}
@Test
void hincr() {
double res = redisService.hincr("p", "age", 20);
System.out.println(res);
}
@Test
void hdecr() {
double res = redisService.hdecr("p", "age", 30);
System.out.println(res);
}
//set
@Test
void sSet() {
long res = redisService.sSet("sdept", new Dept(10, "sales", "CHICAGO"), new Dept(20, "research", "NEWYORK"), new Dept(30, "analysis", "DALARS"));
System.out.println(res);
}
@Test
void sSetWithExpire() {
long res = redisService.sSet("sdept", 120, new Dept(10, "sales", "CHICAGO"), new Dept(20, "research", "NEWYORK"));
System.out.println(res);
}
@Test
void sGet() {
Set res = redisService.sGet("sdept");
res.forEach(System.out::println);
}
@Test
void sHasKey() {
boolean res = redisService.sHasKey("sdept", new Dept(10, "sales", "CHICAGO"));
System.out.println(res);
}
@Test
void sGetSetSize() {
long res = redisService.sGetSetSize("sdept");
System.out.println(res);
}
@Test
void setRemove() {
long res = redisService.setRemove("sdept", new Dept(10, "sales", "CHICAGO"));
System.out.println(res);
}
// list
@Test
void lSet() {
boolean res = redisService.lSet("ldept", new Dept(10, "sales", "CHICAGO"));
System.out.println(res);
}
@Test
void testLSet() {
boolean res = redisService.lSet("ldept", new Dept(20, "research", "NEWYORK"), 240);
System.out.println(res);
}
@Test
void testLSets() {
List list = new ArrayList();
list.add(new Dept(30, "sales", "CHICAGO"));
list.add(new Dept(40, "research", "NEWYORK"));
boolean res = redisService.lSets("ldept", list);
System.out.println(res);
}
@Test
void testLSets1() {
List list = new ArrayList();
list.add(new Dept(50, "sales", "CHICAGO"));
list.add(new Dept(60, "research", "NEWYORK"));
boolean res = redisService.lSets("ldept", list, 240);
System.out.println(res);
}
@Test
void lGet() {
List res = redisService.lGet("ldept", 0, -1);
System.out.println(res);
}
@Test
void lGetListSize() {
long res = redisService.lGetListSize("ldept");
System.out.println(res);
}
@Test
void lGetIndex() {
Object res = redisService.lGetIndex("ldept", 3);
System.out.println(res);
}
@Test
void lUpdateIndex() {
boolean res = redisService.lUpdateIndex("ldept", 3, new Dept(60, "****", "NEWYORK"));
System.out.println(res);
}
@Test
void lRemove() {
long res = redisService.lRemove("ldept", 3, new Dept(60, "****", "NEWYORK"));
System.out.println(res);
}
}
