您好,欢迎访问代理记账网站
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

jedis

Hyperloglog


什么是基数?一组数据中不重复的个数

​ A(1,3,5,7,8,7)B(1,3,5,7,8)

​ 基数 = 5

​ 312312

简介

​ redis2.8.9更新了hyperloglog数据结构!

​ redis Hyperloglog基数统计算法!

​ 优点:占用的内存是固定的,2^64不同的元素的技术,只需要费12KB的内存!如果要从内存的角度来比较 Hyperloglog是首选

​ 注意:0.81%的错误率!统计UV任务,可以忽略不计

​ 如果允许,就一定可以使用HYperloglog

​ 如果不允许,则使用set或自己的数据类型

测试使用

127.0.0.1:6379>PDadd mykey a b c d e f g h i j	# 创建一组数据
127.0.0.1:6379>PDCOUNT mykey 				   # 统计mykey元素的基数数量
127.0.0.1:6379>PDMEGE mykey mykey1 ……		    # 合并,获取并集

Bitmaps


位存储

​ 状态:0 1 0 0 1 0 …… 根据状态判断(两个状态可以使用【统计用户活跃,登录,打卡都可以使用】)

​ Bitmaps用二进制来记录,只有0和1的状态

​ 365天 = 365bit 1字节 = 8bit 46个字节左右

测试使用

127.0.0.1:6379> setbit sign 1 0   # 星期一没有打卡
127.0.0.1:6379> setbit sign 2 1   # 星期二打卡了
…………

127.0.0.1:6379> getbit sign 1 0   # 查看星期一是否打卡
(interger)0

127.0.0.1:6379> bitcount sign    # 统计这周打卡情况
(interger)1

Redis事务


事务的本质:一组命令的集合!一个事务中的所有命令都会被序列化,在事务执行过程中,会按照顺序执行(一次性,顺序性,排他性)

注意:Redis单条命令式保存原子性,但是事务不保存原子性(要么同时执行,要么同时失败),且Reids没有隔离级别的概念,在事务中并没有执行,只有执行命令启动时才执行

步骤:1. 开启事务(multi) 2.命令入队() 3. 执行命令(exec)

测试使用

127.0.0.1:6379> multi		#  开启事务
OK

# 命令入队
127.0.0.1:6379> SET K1 V1
QUEUED
127.0.0.1:6379> SET K2 V2
QUEUED
127.0.0.1:6379> GET K1
QUEUED


127.0.0.1:6379> EXEC	  #执行事务
1)OK
2)OK
3)"v1"

# 执行完事务后,事务就结束了,必须重新开启事务

# 放弃事务
127.0.0.1:6379> DISCARD

# 编译型异常(代码有问题!命令有错!),事务中所有命令不会执行

127.0.0.1:6379> getset k3	# 错误命令
(error)ERR wrong number of arguments for 'getset' command
127.0.0.1:6379> exec	   # 执行事务错误
(error)EXECABORT Transaction discarded bacause of previous errors.

# 运行时异常(1/0),如果事务队列中存在语法问题,那么执行命令的时候,其他命令是可以正常执行的,错误命令抛出问题

127.0.0.1:6379> set k1 "y1"
127.0.0.1:6379> multi 
127.0.0.1:6379> incr k1  # 字符串不能加一
127.0.0.1:6379> set k2 "y2"
127.0.0.1:6379> exec 
1)(error)ERR value is not an Interger or out of range
2)OK

监控

​ 悲观锁:

​ 很悲观,认为什么时候都会出问题,无论做什么都会加锁

​ 乐观锁:

​ 很乐观,认为什么时候都不会出问题,所有不会上锁!更新数据的时候去判断一下在此期间是否有人修改过这个数据

​ 获取version(数据库使用的),更新时比较version

代码测试

# 测试成功
127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 20
OK
127.0.0.1:6379> watch money 	# 监视money对象
OK
127.0.0.1:6379> multi		   # 开始事务
OK
127.0.0.1:6379> DECRBY money 20 
QUEUED
127.0.0.1:6379> INCRBY out 20
QUEUED
127.0.0.1:6379> exec
1)(interger)80
2)(interger)20

# 如果打开了多个线程,在该线程未提交时进行了更新,则会导致事务执行失败
127.0.0.1:6379> exec
(nil)					  # 结束事务失败
127.0.0.1:6379> unwatch		# 放弃监视(可以在放弃监视之后再打开监视进行)

jedis


jedis是Redis官方推荐的java连接工具!使用java操作Redis中间件!

代码测试

  1. 导入jar包
 <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.68</version>
        </dependency>
    </dependencies>
    
  1. 编码测试

    • 连接数据库

      //首页要打开redis服务
      
      public static void main(String[] args) {
      	Jedis jedis = new Jedis("127.0.0.1", 6379);
          //Jedis中有redis的所有命令
      }
      
    • 操作命令

      //测试是否ping通    PONG代表通了
      System.out.println("jedis = " + jedis.ping());
        
      //来选择对应的数据库
      jedis.select(N)
        
      
      //清空数据
      System.out.println(jedis.flushDB());
      
      //判断某个键是否存在  返回boolean
      System.out.println(jedis.exists("name"));
      
      //新增键值对
      System.out.println(jedis.set("name1","n1"));
      System.out.println(jedis.set("name2","n2"));
      
      //查询系统中所有的jian
      Set<String> keys = jedis.keys("*");
      System.out.println("keys = " + keys);
      
      //删除键
      System.out.println(jedis.del("name1"));
      
      //查看键存储的类型
      System.out.println(jedis.type("name2"));
      
      //随机返回一个键
      System.out.println(jedis.randomKey());
      
      //重命名key
      System.out.println(jedis.rename("name2","n2"));
      
      //按索引查询
      System.out.println(jedis.select(0));
      
      //返回当前数据库中键的数量
      System.out.println(jedis.dbSize());
      
      //删除当前数据库中所有的键
      System.out.println(jedis.flushAll());
      
      //list
      //添加一个list
      System.out.println("---------------------  list -----------------------");
      jedis.lpush("clist","MAP","LIST","ARRAYLIST","HASHMAP");
      jedis.lpush("clist","LINKEDLIST");
      
      //获取区间的list  0 -- -1是查询所有
      System.out.println(jedis.lrange("clist",0,-1));
      
      //删除列表中指定的值,第二个参数为删除的个数(有重复性),后新增的值先删除,类似于出栈
      System.out.println(jedis.lrem("clist",2,"HASHMAP"));
      
      //删除指定区间外的值
      System.out.println(jedis.ltrim("clist",0,3));
      
      //获取集合最左端的值
      System.out.println("lpop:"+jedis.lpop("clist"));
      
      //获取集合最右端的值
      System.out.println("rpop:"+jedis.rpop("clist"));
      
      //修改指定下标的值
      System.out.println(jedis.lset("clist",0,"大魔王"));
      
      //获取集合的长度
      System.out.println(jedis.llen("clist"));
      
      //获取指定下标的元素
      System.out.println(jedis.lindex("clist",0));
      
      //将集合进行排序
      //jedis.lpush("list","2000","20","10","1","3");
      System.out.println("排序前:"+jedis.lrange("list",0,-1));
      System.out.println(jedis.sort("list"));
      System.out.println("排序后:"+jedis.lrange("list",0,-1));
      
      //------------   SET  ------------
      //创建一个set
      System.out.println(jedis.sadd("eset","e1","e2","e3"));
      
      //查询所有set元素
      System.out.println(jedis.smembers("eset"));
      
      //删除一个元素
      System.out.println(jedis.srem("eset","e1"));
      
      //随机移除一个元素
      System.out.println(jedis.spop("eset"));
      
      //查询set中包含的个数
      System.out.println(jedis.scard("eset"));
      
      //判断值是否在set中存在
      System.out.println(jedis.sismember("eset","e2"));
      
      //将e3在eset中删除存入eset01
      System.out.println(jedis.smove("eset","eset01","e3"));
      
      //计算交集
      System.out.println(jedis.sinter("eset","eset01"));
      
      //计算并集
      System.out.println(jedis.sunion("eset","eset01"));
      
      //计算差集
      System.out.println(jedis.sdiff("eset","eset01"));
      
      //计算交集,并且把并集存入e2
      System.out.println(jedis.sinterstore("e2","eset","eset01"));
      
      //----------  事务  ----------------
      //开启事务
      Transaction multi = jedis.multi();
      
      //命令入队
      multi.set("u1","u1");
      
      //执行事务
      

multi.exec();

 ```
  • 断开连接

    jedis.close();
    

SpringBoot集成Redis


springboot操作数据的:springdata,jpa,jdbc,mongodb,redis

说明:在springboot2.x之后,原来使用的jedis被替换成了lettuce?

jedis:采用直连,多个线程操作的话,是不安全的,如果想要避免不安全,使用jedis pool连接池!更像BIO模式

lettuce:采用netty,实例可以在多个线程中进行共享,不存在线程不安全的情况!,可以减少线程数据了,更像NIO模式

springboot项目中都会有一个自动配置类

步骤:

image-20201103164504476

然后找到 autoconfig

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w3yhxBxP-1621867446407)(C:\Users\8888\AppData\Roaming\Typora\typora-user-images\image-20201103172735791.png)]

最后在spring.factories中查找

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5PqPI91t-1621867446410)(C:\Users\8888\AppData\Roaming\Typora\typora-user-images\image-20201103164556506.png[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6gacdmFw-1621867447222)(C:\Users\8888\AppData\Roaming\Typora\typora-user-images\image-20201103172726414.png)]]

例:org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\

测试代码

//依赖jar包
 <!-- 操作Redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
     
  //application.properties
     spring.redis.host: 127.0.0.1
     spring.redis.port: 6379
     
  //yml
spring:
  redis:
    host: 127.0.0.1
    port: 6379
        
  //Test
        
   @Autowired
    private RedisTemplate redisTemplate;


 /**
         *  redisTemplate 操作不同的数据类型,api和指令是一样的
         *  opsForValue 操作字符串,类似string
         *  opsForList  操作List,类似List
         *  opsforset
         *  opsforhash
         *  opsforzset
         *  opsforgeo
         *  opsforgyperloglog
         *
         *  除了基本的操作,常用的方法都可以直接进行操作,比如事务等,基本的crud(增删改查)
         *
         *  获取连接对象
         *   redisTemplate.getConnectionFactory().getConnection()
         *   flushAll()     flushDB()  CLOSE()
         */

        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();

        ValueOperations valueOperations = redisTemplate.opsForValue();
		//尽量不要写中文,虽然控制台会返回中文,但是redis数据库会进行转义
        valueOperations.set("mykey","哈哈哈");
        System.out.println(valueOperations.get("mykey"));

在RedisTemplate<K, V> 类中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zy5GWtbk-1621867446421)(C:\Users\8888\AppData\Roaming\Typora\typora-user-images\image-20201103180437622.png)]

	//设置序列化
	@Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
            throws UnknownHostException {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        //配置序列化方式
        //设置json类型的序列化对象
        Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        objectJackson2JsonRedisSerializer.setObjectMapper(om);

        //设置string类型序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        //key采用string的序列化
        template.setKeySerializer(stringRedisSerializer);
        //hash的key采用string的序列化
        template.setHashKeySerializer(stringRedisSerializer);
        //value 序列化采用jackson
        template.setKeySerializer(objectJackson2JsonRedisSerializer);
        //hash的value采用string的序列化
        template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
// redis工具类

package com.util;

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.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key  键
     * @param time 时间(秒)
     */
    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(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(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;
    }

}

}



分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进