Redis工具类：RedisTemplate

• @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 imple

真题解析、进阶学习笔记、最新讲解视频、实战项目源码、学习路线大纲
详情关注公中号【编程进阶路】

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

}

}

}

测试代码

---

@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<String, Dept> 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<String, Dept> 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<String, Dept> 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);

}

最后

今天的文章可谓是积蓄了我这几年来的应聘和面试经历总结出来的经验，干货满满呀！如果你能够一直坚持看到这儿，那么首先我还是十分佩服你的毅力的。不过光是看完而不去付出行动，或者直接进入你的收藏夹里吃灰，那么我写这篇文章就没多大意义了。所以看完之后，还是多多行动起来吧！

可以非常负责地说，如果你能够坚持把我上面列举的内容都一个不拉地看完并且全部消化为自己的知识的话，那么你就至少已经达到了中级开发工程师以上的水平，进入大厂技术这块是基本没有什么问题的了。