Redis相关-02
一、Redis实现基本的事务操作
1、什么是事务？
百度百科：
事务（Transaction），一般是指要做的或所做的事情。
在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)
例如：在关系型数据库中，执行一条SQL命令或者一组SQL命令、整个程序都可以被称为事务
2、事务的特点？
事务是恢复和并发控制的基本单位。
事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。
- 原子性：事务中的操作，要么一起成功，要么一起失败
- 一致性：事务必须是使数据库从一个一致性状态变到另一个一致性状态，与上面的原子性紧密相连
- 隔离性：一个事务的执行不能被其他事务干扰
- 持久性：一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响
3、Redis事务
-
在Redis中，事务就是指一组命令的集合
-
Redis单条命令保证原子性，但是事务（一组命令）不保证原子性！
-
即单条命令执行时若有语法错误，则事务不会执行，也就保证了原子性
127.0.0.1:6379> set k1 v1 ee (error) ERR syntax error
-
-
Redis事务没有隔离的概念
4、Redis事务操作：
- 事务开启（multi）
- 命令入队（set，get等一系列命令）
- 取消/终止事务（discard）
- 事务执行（exec）
一段正常的Redis事务：
127.0.0.1:6379> multi #开启事务
OK
127.0.0.1:6379(TX)> set key1 v1
QUEUED
127.0.0.1:6379(TX)> set key2 v2
QUEUED
127.0.0.1:6379(TX)> set key3 v3
QUEUED
127.0.0.1:6379(TX)> EXEC #事务执行
1) OK
2) OK
3) OK
127.0.0.1:6379> keys *
1) "key1"
2) "key3"
3) "key2"
事务开启后取消事务：
127.0.0.1:6379> multi #开启事务
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> DISCARD #事务取消/终止
OK
127.0.0.1:6379> keys *
(empty array)
事务当中如果有一条命令异常，那么整个事务将不会被执行（编译型异常）
127.0.0.1:6379> multi #开启事务
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> lpush k3 1 2 3 4 5
QUEUED
127.0.0.1:6379(TX)> ladd k4 23
(error) ERR unknown command `ladd`, with args beginning with: `k4`, `23`,
127.0.0.1:6379(TX)> lrange k3 0 -1
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> exec #事务执行
(error) EXECABORT Transaction discarded because of previous errors. #其他命令执行失败
127.0.0.1:6379> keys *
(empty array)
事务当中如果一条命令语法正常，但是出现了诸如1/0这样的错误，在事务执行时才会出现异常，但是不影响其他命令的执行：（运行时异常）
127.0.0.1:6379> multi #开启事务
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set v2 v2
QUEUED
127.0.0.1:6379(TX)> getset k1 v3
QUEUED
127.0.0.1:6379(TX)> incr k1 #对字符串加一操作会失败
QUEUED
127.0.0.1:6379(TX)> get k1
QUEUED
127.0.0.1:6379(TX)> exec #事务执行
1) OK
2) OK
3) "v1"
4) (error) ERR value is not an integer or out of range
5) "v3"
二、Redis实现乐观锁
1、乐观锁？悲观锁？
- 悲观锁：指数据被外界修改时持保守态度
- 比如说这儿有一个公共厕所（数据库），前面一个人（操作者）进去了就直接把门锁住了（数据加锁），其他人进不来（一个人独占了整个厕所！），直到前面这个人解锁（释放锁），其他人才能进入。因此悲观锁虽然保证了数据的正确性和独占性，但是每次请求都会先对数据进行加锁， 然后进行数据操作，最后再解锁，而加锁释放锁的过程会造成消耗，所以性能不高，不适合多个事务并行的情况。
- 特点：可以完全保证数据的独占性和正确性，因为每次请求都会先对数据进行加锁， 然后进行数据操作，最后再解锁，而加锁释放锁的过程会造成消耗，所以性能不高;
- 乐观锁：乐观锁是对于数据冲突保持一种乐观态度，操作数据时不会对操作的数据进行加锁（这使得多个任务可以并行的对数据进行操作），只有到数据提交的时候才通过一种机制来验证数据是否存在冲突(一般实现方式是通过加版本号然后进行版本号的对比方式实现)。
- 比如说银行工作人员A对一位用户的账户余额率先进行了读取，读取的时候会将版本号（version假设为1）一起同余额读取出来，这时，银行工作人员B也对同一位用户的账户余额进行了读取，同样与版本号（version此时还是为1）一起读取出来，然后银行工作人员A完成了对账户余额的修改，他将该事务提交，因为此时提交的version与数据库中的version相同，故数据库接受了此次修改并将version变为2，这时，银行工作人员B也完成了对用户余额的操作，将其提交，经过比对后发现version对不上，因此就拒绝了此次修改。
- 特点：乐观锁是一种并发类型的锁，其本身不对数据进行加锁通而是通过业务实现锁的功能，不对数据进行加锁就意味着允许多个请求同时访问数据，同时也省掉了对数据加锁和解锁的过程，这种方式因为节省了悲观锁加锁的操作，所以可以一定程度的的提高操作的性能，不过在并发非常高的情况下，会导致大量的请求冲突，冲突导致大部分操作无功而返而浪费资源，所以在高并发的场景下，乐观锁的性能却反而不如悲观锁。
2、使用watch可以实现Redis的乐观锁操作
127.0.0.1:6379> set balance 100
OK
127.0.0.1:6379> watch balance #监视money
OK
127.0.0.1:6379> multi #开启事务
OK
127.0.0.1:6379(TX)> decrby balance 30 #减30块钱
QUEUED
127.0.0.1:6379(TX)>
此时我们再去开一个redis-cli服务，直接将money设置为300块钱：
root@iZ2ze14yiifo950a7hayzhZ:~# redis-cli
127.0.0.1:6379> get balance
"100"
127.0.0.1:6379> set balance 300
OK
127.0.0.1:6379>
此时我们再执行事务就会失败：
127.0.0.1:6379> set balance 100
OK
127.0.0.1:6379> watch balance #监视money
OK
127.0.0.1:6379> multi #开启事务
OK
127.0.0.1:6379(TX)> decrby balance 30 #减30块钱
QUEUED
127.0.0.1:6379(TX)> exec #执行事务
(nil) #执行失败
127.0.0.1:6379>
此时我们可以unwatch取消监视，重新对balance进行监视获取最新的值后再进行修改即可
127.0.0.1:6379> get balance
"300"
127.0.0.1:6379> unwatch #取消监视
OK
127.0.0.1:6379> watch balance #重新监视
OK
127.0.0.1:6379> multi #开启事务
OK
127.0.0.1:6379(TX)> INCRBY balance 40
QUEUED
127.0.0.1:6379(TX)> exec #执行事务
1) (integer) 340 #执行成功
127.0.0.1:6379>
三、通过Jedis操作Redis
导入相关依赖：
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<!--Jedis依赖-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.1.1</version>
</dependency>
<!--FastJson 可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.79</version>
</dependency>
开启Redis：
1、Windows下开启：
这样就算开启成功了：
2、Linux下开启并要求能支持远程连接：
找到redis.conf文件，做出如下更改：
- 将 bind 127.0.0.1注释掉
- 找到daemonize设置为yes
完成之后执行如下命令，重启redis服务：
redis-server ./redis.conf
然后在你的云服务器安全组防火墙中开放6379端口即可
3、Jedis试连接：
public class TestJedis {
public static void main(String[] args) {
//Windows下连接Redis
//Jedis jedis_windows = new Jedis("localhost",6379);
//Linux下连接Redis
Jedis jedis_linux = new Jedis("xxx.xxx.xxx.xxx", 6379);
System.out.println(jedis_linux.ping());
jedis_linux.set("k1","v1");
System.out.println(jedis_linux.get("k1"));
}
}
输出：
Jedis操作：
基本上和在Linux命令行下操作没什么两样：
public class TestJedis {
public static void main(String[] args) {
Jedis jedis_linux = new Jedis("xxx.xxx.xxx.xxx", 6379);
System.out.println("连接状态："+(jedis_linux.ping().equals("PONG")?"连接成功":"连接失败"));
jedis_linux.set("k1","v1");
System.out.println("k1的值:"+ jedis_linux.get("k1"));
jedis_linux.mset("k2","v2","k3","v3","k4","v4");
System.out.println("k1,k2,k3,k4的值："+jedis_linux.mget("k1", "k2", "k3", "k4"));
jedis_linux.expire("k3", Long.parseLong("3"));
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("k3的值："+jedis_linux.get("k3"));
System.out.println("所有的key："+jedis_linux.keys("*"));
System.out.println("k1的类型："+jedis_linux.type("k1"));
jedis_linux.setbit("keykey", 1L, true);
System.out.println(jedis_linux.getbit("keykey", 1L));
jedis_linux.close();
}
}
输出：
通过Jedis理解事务
public class TestJedisByTX {
public static void main(String[] args) {
Jedis jedis_linux = new Jedis("xxx.xxx.xxx.xxx", 6379);
System.out.println("连接状态："+(jedis_linux.ping().equals("PONG")?"连接成功":"连接失败"));
JSONObject jsonObject = new JSONObject();
jsonObject.put("name","zhangsan");
jsonObject.put("age",12);
jsonObject.put("sex","female");
Transaction multi = jedis_linux.multi();
String res = jsonObject.toJSONString();
multi.set("user1",res);
multi.set("user2",res);
multi.get("user1");
multi.exec();
System.out.println(jedis_linux.get("user1"));
jedis_linux.close();
}
}
输出：
四、 SpringBoot集成Redis
新建一个SpringBoot项目并勾选所需依赖：
找到相关包点击展开
进入RedisAutoConfiguration类：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uFSXOdTJ-1645279711268)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20220219133846705.png)]](https://i-blog.csdnimg.cn/blog_migrate/b806a81de843f88bf4fd7f72accb9675.png)
进入RedisProperties类看看我们到底能配置什么东西：
可以看到我们可以以spring.redis作为前缀在application.properties配置文件中配置Redis的相关信息
测试环境下只需下面两个配置即可：
spring.redis.host = xxx.xxx.xxx.xxx (你的公网IP或者localhost)
spring.redis.port= 6379
再次查看RedisAutoConfiguration类：
可以看到有个RedisTemplate模板类，我们可以自己写个模板类去替代这个默认的模板类，其中所有的关于Redis操作都可以通过这个模板类去实现。
redis配置好了之后我们来进行单元测试：
redisTemplate以ops为前缀区分要操作的对象，我们可以看到有我们熟悉的数据类型：
- opsForGeo：Geospatial
- opsForHash：Hash
- opsForHyperLogLog：HyperLogLog
- opsForList：List
- opsForSet：Set
- opsForValue：String
- opsForZSet：ZSet
- …
如果上面的ops前缀操作不爽的话,我们可以获取一个redis连接对象,通过连接对象我们可以做出同样的操作:
单元测试:
class Redis02ApplicationTests {
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
//获取Redis连接对象
// RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
// connection.flushDb();
// connection.close();
redisTemplate.opsForList().leftPush("k1","v1");
System.out.println(redisTemplate.opsForList().leftPop("k1"));
}
}
输出:
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0kr8A7GL-1645279711272)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20220219140159120.png)]](https://i-blog.csdnimg.cn/blog_migrate/6fa2025894ce86e49d4567065051b830.png)
集成完毕,但还需要自定义Template模板类
五、自定义RedisTemplate
为什么我们要去自定义RedisTemplate?
因为默认的模板类不满足我们的要求,一般我们需要用<String,Object>的方式来传输数据,而默认的为<Object,Object>,同时我们一般用来存储POJO对象时都需要序列化,因此需要自定义Template模板类来满足我们真实的需求
1、新建一个软件包config下面创建出我们的RedisConfig类来自定义RedisTemplate类
@Configuration
public class RedisConfig {
@Bean
@SuppressWarnings("all")
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
//Json序列化配置
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
//String的序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//key采用String序列化方式
template.setKeySerializer(stringRedisSerializer);
//value也采用String序列化方式
template.setValueSerializer(jackson2JsonRedisSerializer);
//hash的key用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
//hash的value用Jackson的序列化方式
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();;
return template;
}
}
2、POJO下的实体类实现序列化
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
private String name;
private int age;
}
3、单元测试：
@Test
public void testRedis(){
User user = new User("jack", 788);
redisTemplate.opsForValue().set("user",user);
System.out.println(redisTemplate.opsForValue().get("user"));
}
输出：
4、封装工具类（简化开发）
RedisUtil：
package com.jack.redis02.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Component
@SuppressWarnings("all")
public class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
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;
}
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
}
}
}
// ============================String=============================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public 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;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public 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;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public 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;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public 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 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
*/
public 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;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public 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;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public 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 0;
}
}
}
工具类常用方法总结：
expire(String key, long time) //指定缓存失效时间
getExpire(String key) //根据key 获取过期时间
hasKey(String key) //判断key是否存在
del(String... key) //删除缓存
get(String key) //获取值
set(String key, Object value) //设置值
set(String key, Object value, long time) //放入值并设置过期时间
incr(String key, long delta) //递增 参数：delta 增加几
decr(String key, long delta) //递减
单元测试：
@Autowired
private RedisUtil redisUtil;
@Test
public void testRedis(){
User user = new User("mary", 999);
redisUtil.set("user1",user);
System.out.println(redisUtil.get("user1"));
}
输出：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h5jGi9sT-1645279711273)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20220219150519525.png)]](https://i-blog.csdnimg.cn/blog_migrate/b509950d70fd5fce2d2e143f18527e36.png)
扫一扫
1709
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
