Redis基本数据类型

Redis作为内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。它的value支持多种类型的数据结构，基本数据结构包含：字符串（strings）、散列（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）五种。

1. 字符串 (strings)

1.1. 类型介绍

字符串是Redis最简单的存储类型，它存储的值可以是字符串、整数、或者浮点数，对整个字符串或者字符串的其中一部分执行操作；对整数或者浮点数执行自增(increment) 或者自减 (decrement) 操作。

Redis的字符串是一个由字节组成的序列，跟java里面的ArrayList有点类似，采用预分配冗余空间的方式来减少内存的频繁分配，内部为当前字符串实际分配的空间capacity一般要高于实际字符串的长度len。当字符串长度小于1M时，扩容都是加倍现有的空间，如果超过1M，扩容时一次只会多扩容1M的空间。需要注意的是字符串的最大长度为512M。

1.2. 应用场景

字符串类型在工作中使用广泛，主要用于缓存数据，提高查询性能。比如存储登陆用户信息、电商中存储商品信息、可以做计数器（想知道什么时候封锁一个IP地址（访问超过几次)）等等

1.3. 操作指令

set key value: 添加一条Strin类型数据 set username zhangsan
get key: 获取一条String类型数据 get username
set key value: set dbc:users:1 xierenwen 层级关系
get key: get dbc:users:1
keys * 统计所有的keys
info 查看redis相关信息
FLUASHALL 清除所有keys，谨慎使用
mset key1 value1 key2 value2:添加多条String类型数据
mget key1 key2: 获取多条String类型数据
incr key: 自增(+1)
incrby key step:按照步长(step)自增，比如incrby number 2
decr key:自减(-1)
decrby key step: a按照步长(step)递减
del key:删除一条String类型的数据

2. 散列 (hashes)

2.1. 类型介绍

散列相当于Java中的HashMap，内部是无序字典。实现原理跟HashMap一致。一个哈希表有多个节点，每个节点保存一个键值对。

与Java中的HashMap不同的是,rehash的方式不一样，因为Java的HashMap在字典很大时，rehash是个耗时的操作，需要一次性全部rehash。Redis为来高性能，不能赌赛服务，所以采用了渐进式rehash策略。

渐进式rehash会在rehash的同时，保留新旧两个hash结构，查询时会同时查询两个hash结构，然后在后续的定时任务中以及hash操作指令中，循序渐进地将旧hash的内容一点点迁移到新的hash结构中。当搬迁完成了，就会使用新的hash结构取而代之。

当hash移除了最后一个元素之后，该数据结构自动被删除，内存被回收。

2.2. 应用场景

Hash也可以用于对象存储，比如存储用户信息，与字符串不一样的是，字符串是需要将对象进行序列化（比如json序列化）之后才能保存，而Hash则可以将用户对象的每个字段单独存储，这样就能节省序列化和反序列化的时间。

此外还可以保存用户的购买记录，比如key为用户id,field为商品id,value为商品数量。同样还可以用于购物车数据的存储，比如key用户id,field为商品id,value为购买数量等等。

2.2.3 操作指令

#设置属性
#在这之前HSET只能设置单个键值对，同时设置多个时必须使用HMSET。而现在hset也允许接受多个键值对作为参数了。
hset keyname field1 value1 field2 value2
#获取某个属性值
het keyname field1
#获取多个属性值
hmget keyname field1 field2
#获取所有的属性值
hgetall keyname
#获取属性个数
hlen keyname
#自增,指定步长
hincrby keyname field1 step
#删除
del keyname
#删除某一个属性
hdel keyname field1

3. 列表（lists）

3.1. 类型介绍

Redis中的lists上相当于Java中的LinkedList，实现原理是一个双向链表（其底层是一个快速列表），既可以支持反向查找和遍历，更方便操作。插入和删除操作非常快时间复杂度为o(1)，但是索引定位很慢，时间复杂度为o(n).

3.2. 应用场景

lists的应用场景非常多，可以利用它轻松实现热销榜；可以实现工作队列（利用lists的push操作，将任务存在lists中，然后工作线程再用pop操作将任务取出进行执行）；可以实现最新列表，比如最新评论等。

3.3. 操作指令

# 左进
lpush key value1 value2 value3...
# 左出
lpop key
# 右进
rpush key value1 value2 value3...
# 右出
rpop key
# 从左边读取 start和end是下标
lrange key start end

4. 集合（sets）

4.1. 类型介绍

集合类似Java中的HashSet,内部实现是一个value永远为null的HashMap，实际就是通过计算hash的方式来快速排重的这也是set能提供判断一个成员是否在集合内的原因。

4.2. 应用场景

Redis的sets类型是使用哈希表构造的，因此复杂度是o(1),它支持集合内的增删改查，并且支持多个集合建的交集、并集、差集操作。可以利用这些集合操作，解决程序开发过程当中很多数据集合间的问题。比如计算网站独立ip,用户画像中的用户标签，共同好友等功能。

4.3. 操作指令

# 添加内容
sadd key value1 value2
# 查询key里所有的值
smembers key
# 移除key里面的某个value
srem key value
# 随机移除某个value
spop key
# 返回两个set的并集
sunion key1 key2
# 返回key踢出交集的那部分（差集）
sdiff key1 key2
# 跟sdiff相反，返回交集
sinter key1 key2

5. 有序集合（sortedsets）

5.1. 类型介绍

sorted sets是Redis类似于SortedSet和HashMap的结合体，一方面它是一个set,保证了内部value的唯一性，另一方面它可以给每个value赋予一个score，代表这个value的排序权重。内部使用HashMap和跳跃表（skipList）来保证数据的存储和有序，HashMap里放的是成员到score的映射，而跳跃表里存放的是所有的成员，排序依据是HashMap里存的score，使用跳跃表的结构可以获得比较高的查询效率，并且在实现上比较简单。sorted sets中最后一个value被移除后，数据结构自动删除，内存被回收。

5.2. 应用场景

主要应用于根据某个权重进行排序的队列的场景，比如游戏积分排行榜，设置优先级的任务列表，学生成绩表。

5.3 操作指令

# 添加元素,每一个value都会有一个score属性
zadd key score value [score value...] #zadd rank 66 zhangsan 88 lisi 77 wangwu 99 zhouliu
# 获取集合的值并按照score从小到大排序，最小的是最上面
zrange key start end
# 返回有序集key中所有score值介于min和max之间（包括等于min或max）的成员。有序集成员按score值递增（从小到大）次序排列，最小的是最上面
zrangebyscore key 77 99
# 删除
zrem key zhouliu
# 获取key里面元素的个数
zcard key
# 统计从小到大有多少个元素
zcount key 77 88
# 获取value所在位置
zrank key wangzhou
# 获取一个value的所在位置的反转
zrevrank key zhangsan

6. JAVA使用redis

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置连接信息

### REDIS (RedisProperties)
spring.redis.database=0
spring.redis.host=192.168.0.114
spring.redis.port=6379
#spring.redis.password=P@ssw0rd
spring.redis.jedis.pool.max-active=10000
spring.redis.jedis.pool.max-wait=-1
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.min-idle=1
spring.redis.timeout=5000

配置序列化

@Configuration
@EnableCaching
public class RedisConfig {

    @Bean
    public GenericJackson2JsonRedisSerializer makeSerial() {

        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        //  om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）

        return new GenericJackson2JsonRedisSerializer(om);
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(connectionFactory);


        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                ObjectMapper.DefaultTyping.NON_FINAL);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        GenericJackson2JsonRedisSerializer jacksonSerial = new GenericJackson2JsonRedisSerializer(om);

        // 值采用json序列化
        template.setValueSerializer(jacksonSerial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSerial);
        template.afterPropertiesSet();

        return template;
    }

    /**
     * 对hash类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 对redis字符串类型数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     * 对链表类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 对无序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     * 对有序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

使用lua

@Bean
public DefaultRedisScript<Long> stockScript() {
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
    //放在和application.yml 同层目录下
    redisScript.setLocation(new ClassPathResource("stock.lua"));
    redisScript.setResultType(Long.class);
    return redisScript;
}

Long amount = (Long) redisTemplate.execute(defaultRedisScript, keys);

使用RedisLock

@Resource
private RedisTemplate redisTemplate;

@Bean
public RedisLock redisLock() {
    RedisLock redisLock = new RedisLock(redisTemplate);
    return redisLock;
}

@Getter
@Setter
public class RedisLock {

    private RedisTemplate redisTemplate;
    private DefaultRedisScript<Long> lockScript;
    private DefaultRedisScript<Object> unlockScript;

    public RedisLock(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
        // 加载释放锁的脚本
        this.lockScript = new DefaultRedisScript<>();
        this.lockScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lock.lua")));
        this.lockScript.setResultType(Long.class);
        // 加载释放锁的脚本
        this.unlockScript = new DefaultRedisScript<>();
        this.unlockScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("unlock.lua")));
    }

    /**
     * 获取锁
     * @param lockName 锁名称
     * @param releaseTime 超时时间(单位:秒)
     * @return key 解锁标识
     */
    public String tryLock(String lockName, long releaseTime) {
        // 存入的线程信息的前缀，防止与其它JVM中线程信息冲突
        String key = UUID.randomUUID().toString();

        // 执行脚本
        Long result = (Long)redisTemplate.execute(
                lockScript,
                Collections.singletonList(lockName),
                key + Thread.currentThread().getId(), releaseTime);

        // 判断结果
        if(result != null && result.intValue() == 1) {
            return key;
        }else {
            return null;
        }
    }
    /**
     * 释放锁
     * @param lockName 锁名称
     * @param key 解锁标识
     */
    public void unlock(String lockName, String key) {
        // 执行脚本
        redisTemplate.execute(
                unlockScript,
                Collections.singletonList(lockName),
                key + Thread.currentThread().getId(), null);
    }
}

使用Redisson

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.13.6</version>
</dependency>

public String doSeckillRedisson(Integer voucherId,Integer dinerId){
    AssertUtil.isTrue(voucherId==null || voucherId< 0 ,"请选择抢购的代金券");
    String key = RedisKeyConstant.seckill_vouchers.getKey() + voucherId;
    Map<String, Object> map = redisTemplate.opsForHash().entries(key);
    SeckillVouchers seckillVouchers = BeanUtil.mapToBean(map, SeckillVouchers.class, true, null);

    Date now=new Date();
    AssertUtil.isTrue(now.before(seckillVouchers.getStartTime()),"抢购未开始");
    AssertUtil.isTrue(now.after(seckillVouchers.getEndTime()),"抢购已结束");

    AssertUtil.isTrue(seckillVouchers.getAmount()<1,"抢完了");
    Diners dinerInfo=dinersMapperRepository.findById(dinerId).orElseThrow();
    VoucherOrders orders = voucherOrdersRepository.findTopByFkDinerIdAndFkVoucherIdAndIsValidAndStatusIsBetween(dinerInfo.getId(), seckillVouchers.getFkVoucherId(), true, 0, 1);
    AssertUtil.isTrue(orders!=null,"已拥有该券");

    String lockName = RedisKeyConstant.lock_key.getKey() + dinerInfo.getId() + ":" + voucherId;
    long expireTime = seckillVouchers.getEndTime().getTime() - now.getTime();
    RLock lock = redissonClient.getLock(lockName);
    Try.run(()->{
        boolean tryLock = lock.tryLock(expireTime, TimeUnit.MILLISECONDS);
        if (tryLock){
            List<String> keys=new ArrayList<>();
            keys.add(key);
            keys.add("amount");
            Long execute = (Long) redisTemplate.execute(defaultRedisScript, keys);
            AssertUtil.isTrue(execute==null||execute<1,"卖完了");
            VoucherOrders voucherOrders=new VoucherOrders();
            voucherOrders.setFkDinerId(dinerInfo.getId());
            voucherOrders.setFkVoucherId(seckillVouchers.getFkVoucherId());
            String orderNo = IdUtil.getSnowflake(1, 1).nextIdStr();
            voucherOrders.setOrderNo(orderNo);
            voucherOrders.setOrderType(1);
            voucherOrders.setStatus(0);
            VoucherOrders save = voucherOrdersRepository.save(voucherOrders);
            AssertUtil.isTrue(save==null,"抢购失败");
        }
    }).onFailure(e->lock.unlock()).getOrElseThrow(()->new ParameterException("卖完了"));
    return "抢购成功";
}