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 "抢购成功";
}
评论区