Redis相关知识点

Redis

一.Redis简介

1.1 概念解释

Redis是nosql，意思不仅仅是sql

泛指非关系数据库

key - vaule

解决功能性、解决扩展性、解决性能问题、解决io压力

1.2 使用场景

对数据高并发的读写。 海量数据的读写 对数据高可扩展性

二.Redis 底层架构

单线程加多路IO复用

三. Linux—redis安装

3.1 下载

[root@redis opt]# mkdir /application
[root@redis opt]#  
[root@redis opt]# cd /application
[root@redis application]#  
[root@redis application]# wget http://download.redis.io/releases/redis-7.0.11.tar.gz

3.2 解压安装

tar xzvf redis-7.0.11.tar.gz

解压tar xzf redis-7.0.11.tar.gz

进入 redis目录

make && make install

安装成功在 /usr/local/bin目录

3.3后台启动

在 /usr/local/bin 目录下启动

./redis-server /opt/module/redis-6.2.6/redis.conf

config set requirepass 

测试是否连接成功

docker安装

## 拉取
docker search redis
## 安装
docker run \
-p 6379:6379 \
--name redis \
-v /docker/redis/redis.conf:/etc/redis/redis.conf \
-v /docker/redis/data:/data \
--restart=always \
-d \
redis:latest \
redis-server /etc/redis/redis.conf



docker run \
-p 6379:6379 --name redis \
-v /root/redis/redis.conf:/etc/redis/redis.conf \
-v /root/redis/data:/data \
-d redis:latest redis-server  \
/etc/redis/redis.conf \
--appendonly yes \
--requirepass "leadnews" 

四.Redis基本操作

4.1 通用命令

# 查看所有
keys *
# 删除
del [key]
# 判断是否存在key
exists [key]
# 设置过期时间
expire [key] [time]
# 查看过期时间
ttl [key]

4.2 String

String类型有三种格式

• 字符串

• int

• float

# 设置key 和 value
> set name jack
# 一次设置多个键值对
> mset k1 v1 k2 v2 k3 v3
# 一次获取多个键值对
> mget k2 name
# 实现数值类型的自增
> incr age
# 实现数值类型的自增步长
> incrby age 2
# 新增不存在的key 如果 存在则原有的value不变
> setnx name kk
0
# 设置string类型过期有效时间
> set name jack ex 4

4.3 key的层级格式

# 项目名：业务名：类型：id
set guo: user: 1 '{"name": , "id":}

4.4 Hash类型

# 设置hash类型   name是key vlaue是jj
> hset guo:user:1 name jj
> hset guo:user:1 age 18
# get值 单值
> hmget guo:user:1 name
# get值 多值
> hmget guo:user:1 name age
jj
18
# get所有值
> hgetall guo:user:1

4.5 List类型

# 从左边打入元素
> lpush key 12 23 34
# 从右边打入元素
> rpush key 45
# 查看打入的元素
> lrange key 0 4
34
23
12
45
# LPOP 从左边打出一个元素
> lpop key

4.6 Set类型

# 添加  set1 集合 
> sadd set1 a b c f d
# 移除
> srem set1 f
# 返回集合中的个数
> scard set1
4
# 是否是在set中
> sismember set1 f
0
> sismember set1 a
# 查看集合所有元素
> smembers set1

4.7 SortedSet 类型

五.基础篇

5.1 搭建

依赖配置

      <!--redis 依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
      <!--连接池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

配置文件

spring:
  redis:
    host: 192.168.58.137
    port: 6379
    database: 0
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 100ms

测试

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testString() {
        redisTemplate.opsForValue().set("name","涛哥");

        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name="+name);

    }

序列化配置类

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        // 创建r t对象
        RedisTemplate<String, Object> template = new RedisTemplate<>();

        // 设置连接工厂
        template.setConnectionFactory(redisConnectionFactory);
        // 创建json序列化器
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // 设置key的序列化
        template.setKeySerializer(RedisSerializer.string());
        // 设置value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashKeySerializer(jsonRedisSerializer);
        return template;
    }
}

六.实战篇

6.1 Redis 代替session实现登陆

发送验证码逻辑

 @Override
    public Result sendCode(String phone, HttpSession session) {
        // 1.校验手机号
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.符合，生成验证码
        String code = RandomUtil.randomNumbers(6);

        // 4.保存验证码到 redis  *** 本来保存在session 改成redis ***                  // 有效期 ！！！
        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);

        // 5.发送验证码
        log.debug("发送短信验证码成功，验证码：{}", code);
        // 返回ok
        return Result.ok();
    }

发短信方法，这里将login:code:手机号 作为key,拿到的code作为value。

登录逻辑

 public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1.校验手机号
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.从redis获取验证码并校验  ** 这里从redis里面取
        String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
        String code = loginForm.getCode();
        if (cacheCode == null || !cacheCode.equals(code)) {
            // 不一致，报错
            return Result.fail("验证码错误");
        }

        // 4.一致，根据手机号查询用户 select * from tb_user where phone = ?
        User user = query().eq("phone", phone).one();

        // 5.判断用户是否存在
        if (user == null) {
            // 6.不存在，创建新用户并保存
            user = createUserWithPhone(phone);
        }

        // 7.保存用户信息到 redis中
        // 7.1.随机生成token，作为登录令牌
        String token = UUID.randomUUID().toString(true);
        // 7.2.将User对象转为HashMap存储
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
                CopyOptions.create()
                        .setIgnoreNullValue(true)
                        .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
        // 7.3.存储 完后 设置有效期
        String tokenKey = LOGIN_USER_KEY + token;
        stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
        // 7.4.设置token有效期
        stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);

        // 8.返回token
        return Result.ok(token);
    }

拦截器

public class LoginInterceptor implements HandlerInterceptor {

    private StringRedisTemplate stringRedisTemplate;

    public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.获取请求头中的token
        String token = request.getHeader("authorization");

        if (StrUtil.isBlank(token)) {
            // 没有获取到 返回false
            response.setStatus(401);
            return false;
        }
        // 取key
        Map<Object, Object> useMap = stringRedisTemplate.opsForHash().
                entries(RedisConstants.LOGIN_USER_KEY + token);
        //3.判断用户是否存在
        if (useMap.isEmpty()) {
            // 没有，需要拦截，设置状态码
            response.setStatus(401);
            // 拦截
            return false;
        }

       // 5将查询的hash数据转回为UserDto对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(useMap, new UserDTO(), false);
        // 6将保存用户信息到ThreadLocal里
        UserHolder.saveUser(userDTO);
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
        // 有用户，则放行
        return true;
    }
}

解决状态登录刷新的问题

两个拦截器进行解决，一个负责拦截所有，一旦拦截就刷新。第二个拦截登录即可。

# 第一个拦截器

public class RefreshTokenInterceptor implements HandlerInterceptor {

    private StringRedisTemplate stringRedisTemplate;

    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.获取请求头中的token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            return true;
        }
        // 2.基于TOKEN获取redis中的用户
        String key  = LOGIN_USER_KEY + token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
        // 3.判断用户是否存在
        if (userMap.isEmpty()) {
            return true;
        }
        // 5.将查询到的hash数据转为UserDTO
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        // 6.存在，保存用户信息到 ThreadLocal
        UserHolder.saveUser(userDTO);
        // 7.刷新token有效期
        stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.MINUTES);
        // 8.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserHolder.removeUser();
    }
}

# 第二个拦截器

public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.判断是否需要拦截
        if (UserHolder.getUser()==null) {
            response.setStatus(401);
            return false;
        }
        return true;
    }
}

# 拦截器设置

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 第二个 登录拦截器
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                ).order(1);
        // 第一个拦截器 token刷新的拦截器
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);//顺序
    }
}

6.2 查询缓存

添加Redis缓存

七.常见问题解决方案

7.1 缓存穿透

就是说跳过缓存直接干数据库，一直请求，直到干崩溃

​ 1.redis 查询不到数据

​ 2.出现很多非正常的url访问

​ 解决方法：

​ 1.对空值缓存

​ 并不是很好～

​ 2.设置可访问的名单

​ bitmap类型，bitmap里面的id进行比较，如果访问id不再bitmap进行拦截访问，并不是很好～

​ 3.布隆过滤器

​ 底层是优化的bitmap数据结构。

​ 4.进行实时监控

​ 命中率开始降低，需要排查访问对象和访问的数据。

​ 终极目的是访问的攻击，不进入服务器中拦截住

​

7.2 缓存雪崩

​ 数据库压力大，服务崩溃。在极短时间段，查询大量key的集中过期情况。

​ 解决方法：

​ 1.构建多集缓存架构：nginx缓存+redis缓存+其他缓存

​ 2.使用锁或队列

​ 不适合高并发情况

​ 3.设置过期标志更新缓存

​ 记录缓存数据是否过期

​ 4.将缓存失效时间分散开

​ 随机数生成过期时间

7.3 缓存击穿

​ 数据库访问瞬时增加。redis正常运行，redis某个key国旗，大量访问

解决方法

​ 1.预先设置热门数据：在redis高峰访问之前，把热门数据提前存入redis，增加key的时长

​ 2.实时调整：调整key的过期时长

​ 3.使用锁：

​

​