Redis2020最新简易图文教程(下)【内含学习视频】

SpringDataRedis

创建项目

Redis2020最新简易图文教程(下)【内含学习视频】_第1张图片

Redis2020最新简易图文教程(下)【内含学习视频】_第2张图片

Redis2020最新简易图文教程(下)【内含学习视频】_第3张图片

Redis2020最新简易图文教程(下)【内含学习视频】_第4张图片

添加依赖


    
    
        org.springframework.boot
        spring-boot-starter-data-redis
    
    
    
        org.apache.commons
        commons-pool2
    
    
    
        org.springframework.boot
        spring-boot-starter-web
    
    
    
        org.springframework.boot
        spring-boot-starter-test
        test
    

添加application.yml配置文件

spring:
  redis:
    # Redis服务器地址
    host: 192.168.10.100
    # Redis服务器端口
    port: 6379
    # Redis服务器端口
    password: root
    # Redis服务器端口
    database: 0
    # 连接超时时间
    timeout: 10000ms
    jedis:
      pool:
        # 最大连接数,默认8
        max-active: 1024
        # 最大连接阻塞等待时间,单位毫秒,默认-1ms
        max-wait: 10000ms
        # 最大空闲连接,默认8
        max-idle: 200
        # 最小空闲连接,默认0
        min-idle: 5

Lettuce和Jedis的区别

 Jedis 是一个优秀的基于 Java 语言的 Redis 客户端,但是,其不足也很明显:Jedis 在实现上是直接连接 Redis-Server,在多个线程间共享一个 Jedis 实例时是线程不安全的,如果想要在多线程场景下使用 Jedis,需要使用连接池,每个线程都使用自己的 Jedis实例,当连接数量增多时,会消耗较多的物理资源。

 Lettuce 则完全克服了其线程不安全的缺点:Lettuce 是基于 Netty 的连接(StatefulRedisConnection),

 Lettuce 是一个可伸缩的线程安全的 Redis 客户端,支持同步、异步和响应式模式。多个线程可以共享一个连接实例,而不必担心多线程并发问题。它基于优秀 Netty NIO 框架构建,支持 Redis 的高级功能,如 Sentinel,集群,流水线,自动重新连接和 Redis 数据模型。

测试环境测试环境是否搭建成功

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringDataRedisApplication.class)
public class SpringDataRedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void initconn() {
        ValueOperations ops = stringRedisTemplate.opsForValue();
        ops.set("username","lisi");
        ValueOperations value = redisTemplate.opsForValue();
        value.set("name","wangwu");
        System.out.println(ops.get("name"));
    }
}

自定义模板解决序列化问题

 默认情况下的模板 RedisTemplate,默认序列化使用的是JdkSerializationRedisSerializer,存储二进制字节码。这时需要自定义模板,当自定义模板后又想存储 String 字符串时,可以使StringRedisTemplate的方式,他们俩并不冲突。

序列化问题:

​ 要把 domain object 做为 key-value 对保存在 redis 中,就必须要解决对象的序列化问题。Spring Data Redis给我们提供了一些现成的方案:

JdkSerializationRedisSerializer 使用JDK提供的序列化功能。 优点是反序列化时不需要提供类型信息(class),但缺点是序列化后的结果非常庞大,是JSON格式的5倍左右,这样就会消耗 Redis 服务器的大量内存。

Jackson2JsonRedisSerializer使用 Jackson 库将对象序列化为JSON字符串。优点是速度快,序列化后的字符串短小精悍。但缺点也非常致命,那就是此类的构造函数中有一个类型参数,必须提供要序列化对象的类型信息(.class对象)。通过查看源代码,发现其只在反序列化过程中用到了类型信息。

GenericJackson2JsonRedisSerializer通用型序列化,这种序列化方式不用自己手动指定对象的 Class。

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate redisTemplate(LettuceConnectionFactory redisConnectionFactory){
        RedisTemplate redisTemplate = new RedisTemplate<>();
        //为string类型key设置序列器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //为string类型value设置序列器
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        //为hash类型key设置序列器
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //为hash类型value设置序列器
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }
}
//序列化
@Test
public void testSerial(){
    User user = new User();
    user.setId(1);
    user.setUsername("张三");
    user.setPassword("111");
    ValueOperations value = redisTemplate.opsForValue();
    value.set("userInfo",user);
    System.out.println(value.get("userInfo"));
}

操作string

// 1.操作String
@Test
public void testString() {
    ValueOperations valueOperations = redisTemplate.opsForValue();

    // 添加一条数据
    valueOperations.set("username", "zhangsan");
    valueOperations.set("age", "18");

    // redis中以层级关系、目录形式存储数据
    valueOperations.set("user:01", "lisi");
    valueOperations.set("user:02", "wangwu");

    // 添加多条数据
    Map userMap = new HashMap<>();
    userMap.put("address", "bj");
    userMap.put("sex", "1");
    valueOperations.multiSet(userMap);

    // 获取一条数据
    Object username = valueOperations.get("username");
    System.out.println(username);


    // 获取多条数据
    List keys = new ArrayList<>();
    keys.add("username");
    keys.add("age");
    keys.add("address");
    keys.add("sex");
    List resultList = valueOperations.multiGet(keys);
    for (Object str : resultList) {
        System.out.println(str);
    }

    // 删除
    redisTemplate.delete("username");
} 
 

操作hash

// 2.操作Hash
@Test
public void testHash() {
    HashOperations hashOperations = redisTemplate.opsForHash();

    /*
     * 添加一条数据
     *     参数一:redis的key
     *     参数二:hash的key
     *     参数三:hash的value
     */
    hashOperations.put("userInfo","name","lisi");

    // 添加多条数据
    Map map = new HashMap();
    map.put("age", "20");
    map.put("sex", "1");
    hashOperations.putAll("userInfo", map);

    // 获取一条数据
    String name = hashOperations.get("userInfo", "name");
    System.out.println(name);

    // 获取多条数据
    List keys = new ArrayList<>();
    keys.add("age");
    keys.add("sex");
    List resultlist =hashOperations.multiGet("userInfo", keys);
    for (String str : resultlist) {
        System.out.println(str);
    }

    // 获取Hash类型所有的数据
    Map userMap = hashOperations.entries("userInfo");
    for (Entry userInfo : userMap.entrySet()) {
        System.out.println(userInfo.getKey() + "--" + userInfo.getValue());
    }

    // 删除 用于删除hash类型数据
    hashOperations.delete("userInfo", "name");
}

操作list

// 3.操作list
@Test
public void testList() {
ListOperations listOperations = redisTemplate.opsForList();

// 左添加(上)
//        listOperations.leftPush("students", "Wang Wu");
//        listOperations.leftPush("students", "Li Si");

// 左添加(上) 把value值放到key对应列表中pivot值的左面,如果pivot值存在的话
//listOperations.leftPush("students", "Wang Wu", "Li Si");

// 右添加(下)
//        listOperations.rightPush("students", "Zhao Liu");

// 获取 start起始下标 end结束下标 包含关系
List students = listOperations.range("students", 0,2);
for (Object stu : students) {
System.out.println(stu);
}

// 根据下标获取
Object stu = listOperations.index("students", 1);
System.out.println(stu);

// 获取总条数
Long total = listOperations.size("students");
System.out.println("总条数:" + total);

// 删除单条 删除列表中存储的列表中几个出现的Li Si。
listOperations.remove("students", 1, "Li Si");

// 删除多条
redisTemplate.delete("students");
} 
 

操作set

// 4.操作set-无序
@Test
public void testSet() {
    SetOperations setOperations = redisTemplate.opsForSet();
    // 添加数据
    String[] letters = new String[]{"aaa", "bbb", "ccc", "ddd", "eee"};
    //setOperations.add("letters", "aaa", "bbb", "ccc", "ddd", "eee");
    setOperations.add("letters", letters);

    // 获取数据
    Set let = setOperations.members("letters");
    for (Object letter: let) {
        System.out.println(letter);
    }

    // 删除
    setOperations.remove("letters", "aaa", "bbb");
} 
 

操作sorted set

// 5.操作sorted set-有序
@Test
public void testSortedSet() {
    ZSetOperations zSetOperations = redisTemplate.opsForZSet();

    ZSetOperations.TypedTuple objectTypedTuple1 =
            new DefaultTypedTuple("zhangsan", 7D);
    ZSetOperations.TypedTuple objectTypedTuple2 =
            new DefaultTypedTuple("lisi", 3D);
    ZSetOperations.TypedTuple objectTypedTuple3 =
            new DefaultTypedTuple("wangwu", 5D);
    ZSetOperations.TypedTuple objectTypedTuple4 =
            new DefaultTypedTuple("zhaoliu", 6D);
    ZSetOperations.TypedTuple objectTypedTuple5 =
            new DefaultTypedTuple("tianqi", 2D);
    Set> tuples = new HashSet>();
    tuples.add(objectTypedTuple1);
    tuples.add(objectTypedTuple2);
    tuples.add(objectTypedTuple3);
    tuples.add(objectTypedTuple4);
    tuples.add(objectTypedTuple5);

    // 添加数据
    zSetOperations.add("score", tuples);

    // 获取数据
    Set scores = zSetOperations.range("score", 0, 4);
    for (Object score: scores) {
        System.out.println(score);
    }

    // 获取总条数
    Long total = zSetOperations.size("score");
    System.out.println("总条数:" + total);

    // 删除
    zSetOperations.remove("score", "zhangsan", "lisi");
} 
 

获取所有key&删除

// 获取所有key
@Test
public void testAllKeys() {
    // 当前库key的名称
    Set keys = redisTemplate.keys("*");
    for (String key: keys) {
        System.out.println(key);
    }
}

// 删除
@Test
public void testDelete() {
    // 删除 通用 适用于所有数据类型
    redisTemplate.delete("score");
}

设置key的失效时间

@Test
public void testEx() {
    ValueOperations valueOperations = redisTemplate.opsForValue();
    // 方法一:插入一条数据并设置失效时间
    valueOperations.set("code", "abcd", 180, TimeUnit.SECONDS);
    // 方法二:给已存在的key设置失效时间
    boolean flag = redisTemplate.expire("code", 180, TimeUnit.SECONDS);
    // 获取指定key的失效时间
    Long l = redisTemplate.getExpire("code");
}

Redis2020最新简易图文教程(下)【内含学习视频】_第5张图片

SpringDataRedis整合使用哨兵机制

application.yml

spring:
    redis:
        # Redis服务器地址
        host: 192.168.10.100
        # Redis服务器端口
        port: 6379
        # Redis服务器端口
        password: root
        # Redis服务器端口
        database: 0
        # 连接超时时间
        timeout: 10000ms
        lettuce:
            pool:
                # 最大连接数,默认8
                max-active: 1024
                # 最大连接阻塞等待时间,单位毫秒,默认-1ms
                max-wait: 10000ms
                # 最大空闲连接,默认8
                max-idle: 200
                # 最小空闲连接,默认0
                min-idle: 5
        #哨兵模式
        sentinel:
            #主节点名称
            master: mymaster
            #节点
            nodes:  192.168.10.100:26379,192.168.10.100:26380,192.168.10.100:26381

Bean注解配置

@Bean
public RedisSentinelConfiguration redisSentinelConfiguration(){
    RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
            // 主节点名称
            .master("mymaster")
            // 主从服务器地址
            .sentinel("192.168.10.100", 26379)
            .sentinel("192.168.10.100", 26380)
            .sentinel("192.168.10.100", 26381);
    // 设置密码
    sentinelConfig.setPassword("root");
    return sentinelConfig;
}

如何应对缓存穿透、缓存击穿、缓存雪崩问题

Key的过期淘汰机制

 Redis可以对存储在Redis中的缓存数据设置过期时间,比如我们获取的短信验证码一般十分钟过期,我们这时候就需要在验证码存进Redis时添加一个key的过期时间,但是这里有一个需要格外注意的问题就是:并非key过期时间到了就一定会被Redis给删除。

定期删除

 Redis 默认是每隔 100ms 就随机抽取一些设置了过期时间的 Key,检查其是否过期,如果过期就删除。为什么是随机抽取而不是检查所有key?因为你如果设置的key成千上万,每100毫秒都将所有存在的key检查一遍,会给CPU带来比较大的压力。

惰性删除

 定期删除由于是随机抽取可能会导致很多过期 Key 到了过期时间并没有被删除。所以用户在从缓存获取数据的时候,redis会检查这个key是否过期了,如果过期就删除这个key。这时候就会在查询的时候将过期key从缓存中清除。

内存淘汰机制

 仅仅使用定期删除 + 惰性删除机制还是会留下一个严重的隐患:如果定期删除留下了很多已经过期的key,而且用户长时间都没有使用过这些过期key,导致过期key无法被惰性删除,从而导致过期key一直堆积在内存里,最终造成Redis内存块被消耗殆尽。那这个问题如何解决呢?这个时候Redis内存淘汰机制应运而生了。Redis内存淘汰机制提供了6种数据淘汰策略:

  • volatile-lru:从已设置过期时间的数据集中挑选最近最少使用的数据淘汰。
  • volatile-ttl:从已设置过期时间的数据集中挑选将要过期的数据淘汰。
  • volatile-random:从已设置过期时间的数据集中任意选择数据淘汰。
  • allkeys-lru:当内存不足以容纳新写入数据时移除最近最少使用的key。
  • allkeys-random:从数据集中任意选择数据淘汰。
  • no-enviction(默认):当内存不足以容纳新写入数据时,新写入操作会报错。

 一般情况下,推荐使用volatile-lru策略,对于配置信息等重要数据,不应该设置过期时间,这样Redis就永远不会淘汰这些重要数据。对于一般数据可以添加一个缓存时间,当数据失效则请求会从DB中获取并重新存入Redis中。

缓存击穿

 首先我们来看下请求是如何取到数据的:当接收到用户请求,首先先尝试从Redis缓存中获取到数据,如果缓存中能取到数据则直接返回结果,当缓存中不存在数据时从DB获取数据,如果数据库成功取到数据,则更新Redis,然后返回数据

Redis2020最新简易图文教程(下)【内含学习视频】_第6张图片

 定义:高并发的情况下,某个热门key突然过期,导致大量请求在Redis未找到缓存数据,进而全部去访问DB请求数据,引起DB压力瞬间增大。

 解决方案:缓存击穿的情况下一般不容易造成DB的宕机,只是会造成对DB的周期性压力。对缓存击穿的解决方案一般可以这样:

  • Redis中的数据不设置过期时间,然后在缓存的对象上添加一个属性标识过期时间,每次获取到数据时,校验对象中的过期时间属性,如果数据即将过期,则异步发起一个线程主动更新缓存中的数据。但是这种方案可能会导致有些请求会拿到过期的值,就得看业务能否可以接受,
  • 如果要求数据必须是新数据,则最好的方案则为热点数据设置为永不过期,然后加一个互斥锁保证缓存的单线程写。

缓存穿透

 定义:缓存穿透是指查询缓存和DB中都不存在的数据。比如通过id查询商品信息,id一般大于0,攻击者会故意传id为-1去查询,由于缓存是不命中则从DB中获取数据,这将会导致每次缓存都不命中数据导致每个请求都访问DB,造成缓存穿透。

 解决方案

  • 利用互斥锁,缓存失效的时候,先去获得锁,得到锁了,再去请求数据库。没得到锁,则休眠一段时间重试
  • 采用异步更新策略,无论key是否取到值,都直接返回。value值中维护一个缓存失效时间,缓存如果过期,异步起一个线程去读数据库,更新缓存。需要做缓存预热(项目启动前,先加载缓存)操作。
  • 提供一个能迅速判断请求是否有效的拦截机制,比如,利用布隆过滤器,内部维护一系列合法有效的key。迅速判断出,请求所携带的Key是否合法有效。如果不合法,则直接返回。
  • 如果从数据库查询的对象为空,也放入缓存,只是设定的缓存过期时间较短,比如设置为60秒。

缓存雪崩

 定义:缓存中如果大量缓存在一段时间内集中过期了,这时候会发生大量的缓存击穿现象,所有的请求都落在了DB上,由于查询数据量巨大,引起DB压力过大甚至导致DB宕机。

 解决方案

  • 给缓存的失效时间,加上一个随机值,避免集体失效。如果Redis是集群部署,将热点数据均匀分布在不同的Redis库中也能避免全部失效的问题
  • 使用互斥锁,但是该方案吞吐量明显下降了。
  • 设置热点数据永远不过期。
  • 双缓存。我们有两个缓存,缓存A和缓存B。缓存A的失效时间为20分钟,缓存B不设失效时间。自己做缓存预热操作。然后细分以下几个小点

    1. 从缓存A读数据库,有则直接返回
    2. A没有数据,直接从B读数据,直接返回,并且异步启动一个更新线程。
    3. 更新线程同时更新缓存A和缓存B。

Redis学习视频!!!

你可能感兴趣的:(redis,java,asm)