欢迎关注个人公众号【好好学技术】交流学习
1.redis定义
Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多 种类型的数据结构，如 字符串（strings）、散列（hashes）、 列表（lists）、 集合（sets）、 有序集合（sorted sets）等。
2.redis是单线程的吗？
我们通常说Redis是单线程的。主要指的是Redis的网络IO和键值对读写是由一个线程来完成的。但像持久化、异步删除、集群数据同步等等，其实是由其他的线程执行的。Redis工作线程是单线程的。但是，对于整个Redis来说，是多线程的。
3.redis为什么这么快
- 纯内存操作
redis的数据都是保存到内存中的，绝大部分请求都是纯内存操作。跟传统的mysql等持久化db相比，避免了通过磁盘IO读取到内存的开销。
- 数据结构简单
Redis 的数据结构是专门设计的，而这些简单的数据结构的查找和操作的时间大部分复杂度都是 O(1)，因此性能比较高
- 单线程
避免了上下文切换和线程竞争加锁等问题，也不会存在死锁问题，避免了很多性能上的消耗。
- IO多路复用
Redis使用 I/O多路复用功能来监听多个客户端的socket连接，这样就可以使用一个线程连接来处理多个请求，减少线程切换带来的开销，同时也避免了 I/O 阻塞操作。
4.redis6以后为什么要增加多线程模型
单线程虽然快，但是也有一些弊端。比如在删除大key的时候，非常耗时。而redis又是单线程的，所以就会导致整个程序阻塞，进而无法使用。
需要注意的是在Redis6.0中，默认是关闭多线程的，如果需要使用，需要修改redis.conf中的io-thread-do-reads配置项为yes，表示启动多线程。设置线程个数。关于线程数的设置，官方的建议是如果为 4 核的 CPU，建议线程数设置为 2 或 3，如果为 8 核 CPU 建议线程数设置为 6，线程数并不是越大越好。
5.redis数据结构
redis一共有九种数据结构，但是常用的只有String, hash,list,set,zset五种。
String类型
set/get
设置key对应的值为String类型的value
获取key对应的值
mget
批量获取多个key的值，如果可以不存在则返回nil
incr && incrby
incr对key对应的值进行加加操作，并返回新的值;incrby加指定值
incr && incrby
incr对key对应的值进行加加操作，并返回新的值;incrby加指定值
setnx
设置key对应的值为String类型的value，如果key已经存在则返回0
setex
设置key对应的值为String类型的value，并设定有效期
其他命令
getrange 获取key对应value的子字符串
mset 批量设置多个key的值，如果成功表示所有值都被设置，否则返回0表示没有任何值被设置
msetnx，同mset，不存在就设置，不会覆盖已有的key
getset 设置key的值，并返回key旧的值
append：给指定key的value追加字符串，并返回新字符串的长度
hash类型
类似于java的Map<String, Map<String, Object»
- Hash是一个String类型的field和value之间的映射表
- redis的Hash数据类型的key（hash表名称）对应的value实际的内部存储结构为一个HashMap
- Hash特别适合存储对象
- 相对于把一个对象的每个属性存储为String类型，将整个对象存储在Hash类型中会占用更少内存。
- 所存储的成员较少时数据存储为zipmap，当成员数量增大时会自动转成真正的HashMap,此时encoding为ht。
- 运用场景： 如用一个对象来存储用户信息，商品信息，订单信息等等。
hset——设置key对应的HashMap中的field的value hget——获取key对应的HashMap中的field的value hgetall——获取key对应的HashMap中的所有field的value hlen--返回key对应的HashMap中的field的数量
list类型
lpush——在key对应的list的头部添加一个元素
lrange——获取key对应的list的指定下标范围的元素，-1表示获取所有元素
lpop——从key对应的list的尾部删除一个元素，并返回该元素
rpush——在key对应的list的尾部添加一个元素
rpop——从key对应的list的尾部删除一个元素，并返回该元素
set类型
sadd——在key对应的set中添加一个元素
smembers——获取key对应的set的所有元素
spop——随机返回并删除key对应的set中的一个元素
suion——求给定key对应的set并集
sinter——求给定key对应的set交集
ZSet类型
- set的基础上又增加了顺序score，再根据score进行排序
zadd ——在key对应的zset中添加一个元素 zrange——获取key对应的zset中指定范围的元素，-1表示获取所有元素 zrem——删除key对应的zset中的一个元素 zrangebyscore——返回有序集key中，指定分数范围的元素列表,排行榜中运用 zrank——返回key对应的zset中指定member的排名。其中member按score值递增(从小到大）； 排名以0为底，也就是说，score值最小的成员排名为0,排行榜中运用 set是通过hashmap存储，key对应set的元素，value是空对象 sortset是怎么存储并实现排序的呢，hashmap存储，还加了一层跳跃表 跳跃表：相当于双向链表，在其基础上添加前往比当前元素大的跳转链接
bitmap类型
# 指定key的offset位置赋值value
setbit key offset value
# 获取key的offset位置的值
getbit key offset
# 返回key 从start 到 end 中值为1 的数量
bitcount key start end
# 进行位运算（and, or, not）
bittop operation destkey key
- BitMap（2.2 版新增）：二值状态统计的场景，比如签到、判断用户登陆状态、连续签到用户总数等；
- bitmap非常节省内存，按年去存储一个用户签到情况，365天就是 365/8 ≈ 46Byte, 1000万用户一年也才44M就够了。
hyperloglog类型
127.0.0.1:6379> pfadd uv zhangsan (integer) 1 127.0.0.1:6379> pfadd uv lisi (integer) 1 127.0.0.1:6379> pfadd uv wangwu (integer) 1 127.0.0.1:6379> pfcount uv (integer) 3 - HyperLogLog（2.8 版新增）：海量数据基数统计的场景，比如百万级网页 UV 计数等； HyperLogLog统计并不精确，有0.81%的误差。
geo类型
#添加坐标
127.0.0.1:6379> geoadd shanxi 123.11 45.11 xian
(integer) 1
127.0.0.1:6379> geoadd shanxi 123.11 46.11 dayanta
(integer) 1
#获取指定坐标的位置
127.0.0.1:6379> geopos shanxi dayanta
1) 1) "123.11000078916549683"
2) "46.11000102930120192"
#获取两个坐标的距离 单位默认米
127.0.0.1:6379> geodist shanxi xian dayanta
"111226.3808"
#获取两个坐标的距离 单位千米
127.0.0.1:6379> geodist shanxi xian dayanta km
"111.2264"
#坐标123.11 45.10 半径50千米内的数据
127.0.0.1:6379> georadius shanxi 123.11 45.10 50 km
1) "xian"
127.0.0.1:6379>
- GEO（3.2 版新增）：存储地理位置信息的场景，比如滴滴叫车；
Stream类型
- Stream（5.0 版新增）：消息队列，相比于基于 List 类型实现的消息队列，有这两个特有的特性：自动生成全局唯一消息ID，支持以消费组形式消费数据。
这个用的比较少，可以用(rabbitmq、rocketmq、kafka等替代)。
redis案例
1.redis作为mybatis二级缓存整合
- 1.引入pom.xml依赖 org.springframework.boot spring-boot-starter-cache
- 2.开启缓存注解： @EnableCaching
- 3.在方法上面加入SpEL
@CacheConfig(cacheNames=”userInfoCache”) 在同个redis里面必须唯一
@Cacheable(查) ： 来划分可缓存的方法 - 即，结果存储在缓存中的方法，以便在后续调用（具有相同的参数）时，返回缓存中的值而不必实际执行该方法
@CachePut（修改、增加） ： 当需要更新缓存而不干扰方法执行时，可以使用@CachePut注释。也就是说，始终执行该方法并将其结果放入缓存中（根据@CachePut选项）
@CacheEvict（删除） ： 对于从缓存中删除陈旧或未使用的数据非常有用，指示缓存范围内的驱逐是否需要执行而不仅仅是一个条目驱逐
- 4.springboot cache 存在什么问题 – 1.生成key过于简单，容易冲突userCache::3 自定义KeyGenerator – 2.无法设置过期时间，默认过期时间为永久不过期 自定义cacheManager，设置缓存过期时间 – 3.配置序列化方式，默认的是序列化JDKSerialazable 自定义序列化方式，Jackson ``` package com.fandf.redis.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import org.springframework.cache.CacheManager; import org.springframework.cache.annotation.EnableCaching; import org.springframework.cache.interceptor.KeyGenerator; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.cache.RedisCacheConfiguration; import org.springframework.data.redis.cache.RedisCacheManager; import org.springframework.data.redis.cache.RedisCacheWriter; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer; import org.springframework.data.redis.serializer.RedisSerializationContext;
import java.time.Duration; import java.util.HashMap; import java.util.Map;
/**
- @author fandongfeng
-
@description */ @Configuration @EnableCaching @EnableRedisHttpSession(maxInactiveIntervalInSeconds= 50) public class RedisConfig {
@Bean public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory){ RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>(); redisTemplate.setConnectionFactory(factory); return redisTemplate; }
/**
- 生成key名，类名+方法+参数 UserInfoList::UserService.findByIdTtl[1]
-
@return */ @Bean public KeyGenerator simpleKeyGenerator() { return (o, method, objects) -> { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append(o.getClass().getSimpleName()); stringBuilder.append(“.”); stringBuilder.append(method.getName()); stringBuilder.append(“[”); for (Object obj : objects) { stringBuilder.append(obj.toString()); } stringBuilder.append(“]”);
return stringBuilder.toString(); }; }
/**
- 自定义cacheManager，设置缓存过期时间
- @param redisConnectionFactory
- @return */ @Bean public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { return new RedisCacheManager( RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory), this.getRedisCacheConfigurationWithTtl(600), // 默认策略，未配置的 key 会使用这个 this.getRedisCacheConfigurationMap() // 指定 key 策略 ); }
/**
- 初始化map
- @return */ private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() { Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>(); redisCacheConfigurationMap.put(“UserInfoList”, this.getRedisCacheConfigurationWithTtl(100)); redisCacheConfigurationMap.put(“UserInfoListAnother”, this.getRedisCacheConfigurationWithTtl(18000)); return redisCacheConfigurationMap; }
private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) { Jackson2JsonRedisSerializer
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig(); redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith( RedisSerializationContext .SerializationPair .fromSerializer(jackson2JsonRedisSerializer) ).entryTtl(Duration.ofSeconds(seconds)); return redisCacheConfiguration; }
}
二级缓存查询
/**
* 从二级缓存中获取数据
* @param id
* @return
*/
@RequestMapping("/getByCache")
@ResponseBody
public User getByCache(String id) {
User user = userService.findById(id);
return user;
}
@Nullable
@Cacheable(key="#p0", unless = "#result == null") // @Cacheable 会先查询缓存，如果缓存中存在，则不执行方法
public User findById(String id){
System.err.println("根据id=" + id +"获取用户对象，从数据库中获取");
Assert.notNull(id,"id不用为空");
return this.userMapper.find(id);
}
// 因为必须要有返回值，才能保存到数据库中，如果保存的对象的某些字段是需要数据库生成的，
// 那保存对象进数据库的时候，就没必要放到缓存了
@CachePut(key="#p0.id") //#p0表示第一个参数
//必须要有返回值，否则没数据放到缓存中
public User insertUser(User u){
this.userMapper.insert(u);
//u对象中可能只有只几个有效字段，其他字段值靠数据库生成，比如id
return this.userMapper.find(u.getId());
}
@CachePut(key="#p0.id")
public User updateUser(User u){
this.userMapper.update(u);
//可能只是更新某几个字段而已，所以查次数据库把数据全部拿出来全部
return this.userMapper.find(u.getId());
}
@CacheEvict(key="#p0") //删除缓存名称为userInfoCache,key等于指定的id对应的缓存
public void deleteById(String id){
this.userMapper.delete(id);
}
//清空缓存名称为userInfoCache（看类名上的注解)下的所有缓存
//如果数据失败了，缓存时不会清除的
@CacheEvict(allEntries = true)
public void deleteAll(){
this.userMapper.deleteAll();
}
/**
* 指定生成key的格式
* @param id
* @return
*/
@Nullable
@Cacheable(value = "UserInfoList", keyGenerator = "simpleKeyGenerator") // @Cacheable 会先查询缓存，如果缓存中存在，则不执行方法
public User findByIdTtl(String id){
System.err.println("根据id=" + id +"获取用户对象，从数据库中获取");
Assert.notNull(id,"id不用为空");
return this.userMapper.find(id);
} ``` ## 2.redis实现分布式集群环境session共享 - cookie与session > Cookie是什么？ Cookie 是一小段文本信息，伴随着用户请求和页面在 Web 服务器和浏览器之间传递。 Cookie 包含每次用户访问站点时 Web 应用程序都可以读取的信息，我们可以看到在服务器写的cookie， 会通过响应头Set-Cookie的方式写入到浏览器
HTTP协议是无状态的，并非TCP一样进行三次握手，对于一个浏览器发出的多次请求，WEB服务器无法 区分是不是来源于同一个浏览器。所以服务器为了区分这个过程会通过一个 sessionid来区分请求，而这个 sessionid是怎么发送给服务端的呢。cookie相对用户是不可见的，用来保存这个sessionid是最好不过了
- redis实现分布式集群配置过程 org.springframework.session spring-session-data-redis @EnableRedisHttpSession 开启redis session缓存 maxInactiveIntervalInSeconds指定缓存的时间 spring:session:sessions:expires:+‘sessionId’的过期时间 ``` package com.fandf.redis.controller;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest; import java.util.HashMap; import java.util.Map;
/**
- @author fandongfeng
-
@description */ @RestController public class SessionController {
@PostMapping(value = “/setSession”) public Map<String, Object> setSession (HttpServletRequest request){ Map<String, Object> map = new HashMap<>(); request.getSession().setAttribute(“request Url”, request.getRequestURL()); map.put(“request Url”, request.getRequestURL()); return map; }
@GetMapping(value = “/getSession”) public Object getSession (HttpServletRequest request){ Map<String, Object> map = new HashMap<>(); map.put(“sessionIdUrl”,request.getSession().getAttribute(“request Url”)); map.put(“sessionId”, request.getSession().getId()); return map; } } ```
3.redis实现排行榜功能
- 1.初始化加载数据 implements InitializingBean 接口 实现afterPropertiesSet()方法 初始化将用户积分加载到redis缓存中
- 2.方法介绍
zset方法简单介绍
private static final String RANKGNAME = "user_score"; private static final String SALESCORE = "sale_score_rank:"; /** * 添加积分 * uid = 1 score = 1 * uid = 2 score = 2 * uid = 3 score = 3 * @param uid * @param score * @return */ @ResponseBody @RequestMapping("/addScore") public String addRank(String uid, Integer score) { rankingService.rankAdd(uid, score); return "success"; } public void rankAdd(String uid, Integer score) { redisService.zAdd(RANKGNAME, uid, score); } /** * 有序集合添加 * * @param key * @param value * @param scoure */ public void zAdd(String key, Object value, double scoure) { ZSetOperations<String, Object> zset = redisTemplate.opsForZSet(); zset.add(key, value, scoure); }/** * 添加指定分数 * @param uid * @param score * @return */ @ResponseBody @RequestMapping("/increScore") public String increScore(String uid, Integer score) { rankingService.increSocre(uid, score); return "success"; } public void increSocre(String uid, Integer score) { redisService.incrementScore(RANKGNAME, uid, score); } /** * 有序集合添加指定分数 * * @param key * @param value * @param scoure */ public void incrementScore(String key, Object value, double score) { ZSetOperations<String, Object> zset = redisTemplate.opsForZSet(); zset.incrementScore(key, value, score); }/** * 排序，从0开始,正序 * uid=1 0 * @param uid * @return */ @ResponseBody @RequestMapping("/rank") public Map<String, Long> rank(String uid) { Map<String, Long> map = new HashMap<>(); map.put(uid, rankingService.rankNum(uid)); return map; } public Long rankNum(String uid) { return redisService.zRank(RANKGNAME, uid); } /** * 有序集合获取排名 * @param key 集合名称 * @param value 值 */ public Long zRank(String key, Object value) { ZSetOperations<String, Object> zset = redisTemplate.opsForZSet(); return zset.rank(key,value); }/** * 查看自己分数 * @param uid * @return */ @ResponseBody @RequestMapping("/score") public Long rankNum(String uid) { return rankingService.score(uid); } public Long score(String uid) { Long score = redisService.zSetScore(RANKGNAME, uid).longValue(); return score; } public Double zSetScore(String key, Object value) { ZSetOperations<String, Object> zset = redisTemplate.opsForZSet(); return zset.score(key,value); }/** * 正序排名，分数低的在前面 * // http://localhost:8080/scoreByRange?start=0&end=2 * * [ * { * "score": 1.0, * "value": "1" * }, * { * "score": 2.0, * "value": "2" * }, * { * "score": 3.0, * "value": "3" * } * ] * @param start * @param end * @return */ @ResponseBody @RequestMapping("/scoreByRange") public Set<ZSetOperations.TypedTuple<Object>> scoreByRange(Integer start, Integer end) { return rankingService.rankWithScore(start,end); } public Set<ZSetOperations.TypedTuple<Object>> rankWithScore(Integer start, Integer end) { return redisService.zRankWithScore(RANKGNAME, start, end); } /** * 有序集合获取排名 * * @param key */ public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start,long end) { ZSetOperations<String, Object> zset = redisTemplate.opsForZSet(); Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key,start,end); return ret; }``` /**
- 倒序查询排行榜,分数大的靠前
- @param start
- @param end
- @return */ @ResponseBody @RequestMapping(“/sale/top”) public List<Map<String,Object» reverseZRankWithRank(long start,long end) { return rankingService.reverseZRankWithRank(start,end); }
public List<Map<String, Object» reverseZRankWithRank(long start, long end) { Set<ZSetOperations.TypedTuple
/** * 与下面方法都可实现排名 * 有序集合获取排名 * @param key */ public Set<ZSetOperations.TypedTuple
/**
* 有序集合获取排名
* @param key
*/
public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) {
ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
return ret;
} ```
4.redis使用bitmap实现签到统计功能
package com.fandf.test.redis;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import org.springframework.data.redis.connection.BitFieldSubCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;
/**
* @author fandongfeng
*/
@Service
public class SignService {
@Resource
RedisTemplate<String, Object> redisTemplate;
private static final String USER_SIGN_KEY = "sign:";
/**
* 当日签到接口
*/
public Boolean sign() {
// 1.获取当前登录用户
long userId = 123L;
// 2.获取日期
LocalDateTime now = LocalDateTime.now();
// 3.拼接key
String keySuffix = DateUtil.format(now, ":yyyyMM");
String key = USER_SIGN_KEY + userId + keySuffix;
// 4.获取今天是本月的第几天
int dayOfMonth = now.getDayOfMonth();
//bitmap 坐标从0开始， 所以 offset 为 dayOfMonth - 1
redisTemplate.opsForValue().setBit(key, dayOfMonth - 1, true);
return true;
}
/**
* 指定日期签到, 补签
*/
public Boolean signDate(String date) {
// 1.获取当前登录用户
long userId = 123L;
// 2.获取日期
LocalDateTime signDate = Convert.toLocalDateTime(date);
// 3.拼接key
String keySuffix = DateUtil.format(signDate, ":yyyyMM");
String key = USER_SIGN_KEY + userId + keySuffix;
// 4.获取今天是本月的第几天
int dayOfMonth = signDate.getDayOfMonth();
//bitmap 坐标从0开始， 所以 offset 为 dayOfMonth - 1
redisTemplate.opsForValue().setBit(key, dayOfMonth - 1, true);
return true;
}
/**
* 当月连续签到次数 BITFIELD key GET u[dayOfMonth] 0
*/
public Integer signCount() {
// 1.获取当前登录用户
long userId = 123L;
// 2.获取日期
LocalDateTime now = LocalDateTime.now();
// 3.拼接key
String keySuffix = DateUtil.format(now, ":yyyyMM");
String key = USER_SIGN_KEY + userId + keySuffix;
// 4.获取今天是本月的第几天
int dayOfMonth = now.getDayOfMonth();
// 5.获取本月截止今天为止的所有的签到记录，返回的是一个十进制的数字 BITFIELD sign:123:202303 GET u24 0
List<Long> result = redisTemplate.opsForValue().bitField(key, BitFieldSubCommands.create().get(BitFieldSubCommands.BitFieldType.unsigned(dayOfMonth)).valueAt(0));
if (result == null || result.isEmpty()) {
// 没有任何签到结果
return 0;
}
Long num = result.get(0);
if (num == null || num == 0) {
return 0;
}
// 6.循环遍历
int count = 0;
while (true) {
// 6.1.让这个数字与1做与运算，得到数字的最后一个bit位
// 判断这个bit位是否为0
if ((num & 1) == 0) {
// 如果为0，说明未签到，结束
break;
} else {
// 如果不为0，说明已签到，计数器+1
count++;
}
// 把数字右移一位，抛弃最后一个bit位，继续下一个bit位
num >>>= 1;
}
return count;
}
/**
* 统计指定月总共签到次数
*/
public Integer signCountByMonth(String date) {
long userId = 123L;
LocalDateTime dateOfSign = Convert.toLocalDateTime(date);
String keySuffix = DateUtil.format(dateOfSign, ":yyyyMM");
String key = USER_SIGN_KEY + userId + keySuffix;
Long count = redisTemplate.execute((RedisCallback<Long>) redisConnection -> redisConnection.bitCount(key.getBytes()));
return count == null ? 0 : count.intValue();
}
}
