Redis工具类：RedisTemplate

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;

}

}

第四步：创建JSON工具类

---

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;

}

}

第三步：Redis工具类：

---

接口

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<String, E> 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<String, E> map);

/**

• HashSet 并设置时间

• @param key 键

• @param map 对应多个键值

• @param time 时间(秒)

• @return true成功 false失败

*/

boolean hmset(String key, Map<String, E> map, long time);

/**

• HashGet

• @param key 键 不能为null

• @param item 项 不能为null

• @return 值

*/

E hget(String key, String item);

/**

• 获取hashKey对应的所有键值

• @param key 键

• @return 对应的多个键值

*/

Map<String, V> 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<时，-，表尾，-倒数第二个元素，依次类推

• @return

*/

Object lGetIndex(String key, long index);

/**

• 根据索引修改list中的某条数据

• @param key 键

• @param index 索引

• @param value 值

• @return

*/

boolean lUpdateIndex(String key, long index, E value);

/**

• 移除N个值为value

• @param key 键

• @param count 移除多少个

• @param value 值

• @return 移除的个数

*/

long lRemove(String key, long count, E value);

}

实现类

@Component

public final class RedisServiceImpl implements RedisService {

@Resource

private RedisTemplate<String, E> redisTemplate;

// =common

@Override

public Set keys(String pattern) {

try {

Set keys = redisTemplate.keys(pattern);

return keys;

} catch (Exception e) {

e.printStackTrace();

return null;

}

}

@Override

public 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;

}

}

@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<String, E> 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) {

throw new RuntimeException(“递增因子必须大于”);

}

return redisTemplate.opsForValue().increment(key, delta);

}

@Override

public long decr(String key, long delta) {

if (delta < 0) {

throw new RuntimeException(“递减因子必须大于”);

}

return redisTemplate.opsForValue().increment(key, -delta);

}

// Map/hash=

//注：Redis的hash的entryKey的类型必须为String类型

@Override

public boolean hset(String key, String entryKey, E entryValue) {

try {

redisTemplate.opsForHash().put(key, entryKey, entryValue);

return true;

} catch (Exception e) {

e.printStackTrace();

return false;

}

}

@Override

public boolean hset(String key, String entryKey, E entryValue, long time) {

try {

redisTemplate.opsForHash().put(key, entryKey, entryValue);

if (time > 0) {

expire(key, time);

}

return true;

} catch (Exception e) {

e.printStackTrace();

return false;

}

}

@Override

public boolean hmset(String key, Map<String, E> map) {

try {

redisTemplate.opsForHash().putAll(key, map);

return true;

} catch (Exception e) {

e.printStackTrace();

return false;

}

}

@Override

public boolean hmset(String key, Map<String, E> map, long time) {

try {

redisTemplate.opsForHash().putAll(key, map);

if (time > 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<String, V> hmget(String key) {

HashOperations<String, String, V> 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;

}

}

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（资料价值较高，非无偿）

前端面试题汇总

---

前端面试题是我面试过程中遇到的面试题，每一次面试后我都会复盘总结。我做了一个整理，并且在技术博客找到了专业的解答，大家可以参考下：

由于篇幅有限，只能分享部分面试题，完整版面试题及答案可以【点击我】阅读下载哦~

感悟

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;

}

}

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-GaDGR6WD-1711721468506)]

[外链图片转存中…(img-JQO9He3O-1711721468507)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

[外链图片转存中…(img-eCapXYxO-1711721468507)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（资料价值较高，非无偿）

前端面试题汇总

---

前端面试题是我面试过程中遇到的面试题，每一次面试后我都会复盘总结。我做了一个整理，并且在技术博客找到了专业的解答，大家可以参考下：

由于篇幅有限，只能分享部分面试题，完整版面试题及答案可以【点击我】阅读下载哦~

感悟

春招面试的后期，运气和实力都很重要，自己也是运气比较好，为了回馈粉丝朋友们（毕竟自己也玩了这么久哈哈哈），整理个人感悟和总结以上。最后祝愿大家能够收获理想offer！！