Redis笔记

ss1、redis-benchmark

redis-benchmark 是一个压力测试工具

官方自带的性能测试工具

redis-benchmark+命令参数

简单测试：

a.测试：100个并发连接， 100000请求

redis-benchmark -h localhost -p 6379 -c 100 -n 100000

从上图可知：

对100000个请求进行写入测试

100个并发客户端

每次写入3个字节

只有一台服务器来处理这些请求

所有请求在2毫秒内处理完成

每秒处理70472.16个请求

2、Redis基本知识

默认有16个数据库，默认使用的第0个数据库。可以使用select来切换数据库

如：切换到第3个数据库

127.0.0.1:6379> SELECT 3         #切换数据库
OK
127.0.0.1:6379[3]> dbsize        #查看DB大小
(integer) 0
127.0.0.1:6379[3]> set name y
OK
127.0.0.1:6379[3]> dbsize
(integer) 1

keys * 查看当前数据库中所有的key

127.0.0.1:6379[3]> keys *
1) "name"

flushdb 清空当前库

127.0.0.1:6379[3]> flushdb
OK
127.0.0.1:6379[3]> dbsize
(integer) 0
127.0.0.1:6379[3]> keys *
(empty list or set)

flushall 清空全部数据库

127.0.0.1:6379[3]> select 0
OK
127.0.0.1:6379> keys *
1) "key:__rand_int__"
2) "name"
3) "mylist"
4) "counter:__rand_int__"
5) "myset:__rand_int__"
127.0.0.1:6379> SELECT 3
OK
127.0.0.1:6379[3]> keys *
(empty list or set)
127.0.0.1:6379[3]> flushall
OK
127.0.0.1:6379[3]> select 0
OK
127.0.0.1:6379> keys *
(empty list or set)

Redis是单线程的

Redis是很快的，官方表示：Redis是基于内存操作，cpu不是Redis的性能瓶颈，Redis的性能瓶颈是根据机器内存和网络带宽来的。

Redis是c语言写的，官方提供的数据为100000+的qps，不比同样使用key-value的Memecache差。

Redis为什么是单线程还这么快

1.误区：高性能的服务器一定为多线程的。

2.误区：多线程（cpu会上下文切换）一定比单线程效率高。

核心：

1. 内存存储：Redis 主要将数据存储在内存中，这使得它能够快速读写数据。与传统的基于磁盘存储的数据库相比，内存存储可以极大地提高读写性能。

2. 非阻塞 I/O：Redis 使用了多路复用技术来实现非阻塞的 I/O 操作，这意味着即使是单线程，它也可以同时处理多个客户端请求而无需阻塞等待 I/O 完成。

3. 基于事件驱动：Redis 是基于事件驱动的模型，它使用了事件循环机制来处理客户端请求和网络 I/O，这种机制可以高效地处理大量的并发连接。

4. 精简的数据结构操作：Redis 提供了丰富的数据结构操作（如字符串、哈希、列表、集合、有序集合等），这些操作都经过精心设计和优化，使得 Redis 在处理各种数据操作时能够做到高效快速。

5. 单线程的优势：虽然 Redis 是单线程的，但这也带来了一些优势，比如避免了线程切换和同步的开销，简化了代码设计和维护，同时也减少了锁竞争的情况。

总的来说，Redis 能够如此快速高效地运行，主要得益于其内存存储、非阻塞 I/O、事件驱动、优化的数据结构操作以及单线程模型所带来的种种优势。这些方面的综合作用使得 Redis 成为一个性能出色的内存数据库系统。

3、五大基本数据类型

Redis是一个开源的，先进的key-value持久化产品。它通常被称为数据结构服务器，它的值可以是字符串（String）、哈希（Map）、列表（List）、集合（Sets）和有序集合（Sorted sets）等类型。可以在这些类型上面做一些原子操作，如：字符串追加、增加Hash里面的值、添加元素到列表、计算集合的交集，并集和差集；或者区有序集合中排名最高的成员。为了取得好的性能，Redis是一个内存型数据库。不限于此，Redis也可以把数据持久化到磁盘中，或者把数据操作指令追加了一个日志文件，把它用于持久化。也可以用Redis容易的搭建master-slave架构用于数据复制。其它让它像缓存的特性包括，简单的check-and-set机制，pub/sub和配置设置。Redis可以用大部分程序语言来操作：C、C++、C#、Java、Node.js、php、ruby等等。Redis是用ANSIC写的，可以运行在多数POSIX系统，如：Linux，*BSD，OS X和Soloris等。官方版本不支持Windows下构建，可以选择一些修改过的版本，照样可以使用Redis。

3.1Redis-Key

3.2 String（字符串）

String类型的使用场景：value除了可以是字符串也可以是数字

计数器

统计数量

粉丝数

对象缓存存储

3.3 List

在rides里面可以将list当作 栈、队列、阻塞队列

小结：list 实际上是一个链表，before node after ， left ，right两边都可以进行插入值。

如果key 不存在就创建一个新链表

如果key 存在，新增内容

如果移除了所有值，空链表，也代表不存在

在两边插入修改值，效率最高，中间元素效率较低。

队列（lpush ，rpop）、栈（lpush ，lpop）

3.4 Set

set中的值不能重复

3.5 Hash（哈希）

Redis hash 是一个 string 类型的 field（字段） 和 value（值） 的映射表，hash 特别适合用于存储对象。

Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿）。

Map集合，key -map 这时候的值是Map集合

3.6  Zset（有序集合）

在set的基础上增加了一个值，set k1 v1     zset k1 score v1

Redis 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员。

不同的是每个元素都会关联一个 double 类型的分数。redis 正是通过分数来为集合中的成员进行从小到大的排序。

有序集合的成员是唯一的,但分数(score)却可以重复。

集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

案例思路：set 排序 

带权重进行判断   普通信息 1    重要信息 2

排行榜应用实现，取top n 测试

4 三种特殊数据类型

4.1 geospatial 地理位置

应用场景：朋友定位，附近人，打车距离计算

Redis Geo

geospatial底层实现原理为Zset，所以可以用Zset命令进行操作

附近人？（获取所有附近人的地址，定位！）通过半径来查询

127.0.0.1:6379> geoadd zg 116.397128 39.916527 beijing
(integer) 1
127.0.0.1:6379> geoadd zg 106.54041 29.40268 chongqing
(integer) 1
127.0.0.1:6379> geoadd zg 104.10194 30.65984 chengdu
(integer) 1
127.0.0.1:6379> geoadd zg 121.48941 31.40527 shanghai
(integer) 1
127.0.0.1:6379> GEOADD zg 113.27324 23.15792 guangzhou
(integer) 1
127.0.0.1:6379> GEOADD ZG 120.21201 30.2084 hangzhou
(integer) 1
127.0.0.1:6379> geoadd zg 118.8921 31.32751 nanjing
(integer) 1
127.0.0.1:6379> geopos zg chengdu
1) 1) "104.10194188356399536"
   2) "30.65983886217613019"
127.0.0.1:6379> geodist zg chengdu beijing
"1515821.0032"
127.0.0.1:6379> geodist zg chongqing shanghai km
"1450.0760"
127.0.0.1:6379> GEORADIUS zg 110 30  1000 km
1) "chongqing"
2) "chengdu"
3) "guangzhou"
4) "nanjing"
127.0.0.1:6379> GEORADIUS zg 110 30 500 km
1) "chongqing"
127.0.0.1:6379> GEORADIUS zg 110 30 500 km withcoord withdist
1) 1) "chongqing"
   2) "340.7667"
   3) 1) "106.54040783643722534"
      2) "29.40268053517299762"
127.0.0.1:6379> GEORADIUSBYMEMBER zg beijing 1000 km
1) "beijing"
2) "nanjing"
 

4.2 HyperLogLog 

什么为基数？

不重复的元素
A{1，2，3，4，8，9}        B{4，5，9，7，2，1}

基数为{3，8}

HyperLogLog 是做基数统计的算法

优点：占用的内存是固定的，2^64不同元素的基数，只需要12kb的内存。从内存角度比较HyperLogLog为首选。

网页的访问量uv（一个人多次访问一个网站多次也只算一个人）

传统方式，set保存用户id 统计set中的数量作为标准判断。

这个方式如果保存大量用户id就会比较麻烦，目的是为了计数不是为了保存用户id

0.81%的错误率！统计UV的任务，可以忽略不计的。

127.0.0.1:6379> pfadd k a b c d e f g a b
(integer) 1
127.0.0.1:6379> pfcount k
(integer) 7
127.0.0.1:6379> PFADD k2  q w e r t y u i
(integer) 1
127.0.0.1:6379> PFCOUNT k2
(integer) 8
127.0.0.1:6379> PFMERGE kk k k2
OK
127.0.0.1:6379> count kk
(error) ERR unknown command `count`, with args beginning with: `kk`, 
127.0.0.1:6379> pfcount kk
(integer) 13

4.3 Bitmaps

位运算

场景：

统计用户信息，活跃  不活跃    登录 未登录    打卡，365天打卡

两个状态的都可以使用Bitmaps

Bitmaps位图，数据结构，都是操作二进制位进行记录，只有0和1两个状态

365天=365bit   1字节=8bit        46个字节左右

使用Bitmaps来记录周一到周天的打卡记录

查看某一天是否打卡

统计多少天打卡

5.事务

MySQL：ACID

要么全部成功，要么全部失败，原子性！

Redis事务：本质一组命令集合。一个事务中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行。

一次性、顺序性、排它性。

Redis单条命令保持原子性，但是事务不保持原子性

Redis没有隔离级别的概念（所有的命令在事务中，并没有直接执行，只有在执行命令时才会执行  exec）

Redis的事务：

a.开启事务（ multi）

b.命令入队（其他命令）

c.执行事务（exec）

d.放弃事务（discard）

锁：Redis可以实现乐观锁

正常执行事务：

127.0.0.1:6379> clear
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> get k2 
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> exec
1) OK
2) OK
3) "v2"
4) OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set k4 v4 
QUEUED
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v3
QUEUED
127.0.0.1:6379> DISCARD
OK
127.0.0.1:6379> get k4
(nil)
 

类比java

编译型异常（代码有问题，命令错误），事务中的命令不会被执行

运行时异常，如果事务中队列存在语法错误，执行命令时，该条命令不执行，其他命令正常执行（无原子性）

6.监控 watch

java中

悲观锁：认为无论什么时候都会出问题，故无论什么时候都加锁。

乐观锁：认为什么时候都不会出问题，故不会上锁，在更新数据时会进行判断在此期间是否有人修改过数据。

获取version

更新时比较version

Redis中

正常执行成功

测试多线程修改值，使用watch当作乐观锁进行操作

在线程1 这个事务执行前，线程2 先一步修改m的值，线程1 中的事务执行失败。

如果修改失败，获取最新值即可

7.Jedis

我们使用Java来操作Redis

什么是Jedis 是Redis官方推荐的Java连接开发工具，使用Java操作Redis的中间件，如果想用Java操作Redis，一定要对Jedis熟悉

7.1导入依赖

 
    <dependencies>
        <!--导入jedis包-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>
        <!--导入fastjson包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.78</version>
        </dependency>
 
    </dependencies>

7.2尝试远程连接服务器中redis

public class Test01 {
    public static void main(String[] args) {
        //1.new 一个jedis对象即可
        Jedis jedis = new Jedis("ip",6379);
        jedis.auth("password");
        System.out.println(jedis.ping());
    }
}

7.2常用API

String

List

Set

Zset

Hash

所有的API命令和上面reids的指令一样。

7.3事务

正常执行

package com.yang;
 
import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
 
/**
 * @author yzh
 * @date 2024-02-21
 */
 
public class Test01 {
    public static void main(String[] args) {
        //1.new 一个jedis对象即可
        Jedis jedis = new Jedis("ip", 6379);
        jedis.auth("password");
 
        JSONObject jsonObject1 = new JSONObject();
        JSONObject jsonObject2 = new JSONObject();
        jsonObject1.put("hello", "world");
        jsonObject2.put("name", "yzh");
        //开启事务
        Transaction multi = jedis.multi();
        String s1 = jsonObject1.toJSONString();
        String s2 = jsonObject2.toJSONString();
        try {
            multi.set("user1", s1);
            multi.set("user2", s2);
            multi.exec();//执行事务
        }catch (Exception e){
            multi.discard();//放弃事务
            e.printStackTrace();
        }finally {
            jedis.close();//关闭连接
        }
        System.out.println(jedis.get("user1"));
        System.out.println(jedis.get("user2"));
    }
}

模拟失败

package com.yang;
 
import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
 
/**
 * @author yzh
 * @date 2024-02-21
 */
 
public class Test01 {
    public static void main(String[] args) {
        //1.new 一个jedis对象即可
        Jedis jedis = new Jedis("ip", 6379);
        jedis.auth("password");
        jedis.flushDB();
        JSONObject jsonObject1 = new JSONObject();
        JSONObject jsonObject2 = new JSONObject();
        jsonObject1.put("hello", "world");
        jsonObject2.put("name", "yzh");
        //开启事务
        Transaction multi = jedis.multi();
        String s1 = jsonObject1.toJSONString();
        String s2 = jsonObject2.toJSONString();
        try {
            multi.set("user1", s1);
            multi.set("user2", s2);
            int i = 1/0;//代码抛出异常，事务执行失败
            multi.exec();//执行事务
        }catch (Exception e){
            multi.discard();//放弃事务
            e.printStackTrace();
        }finally {
            jedis.close();//关闭连接
        }
        System.out.println(jedis.get("user1"));
        System.out.println(jedis.get("user2"));
    }
}

8. SpringBoot整合

SpringBoot操作数据:spring-data jpa jdbc mongodb redis 

在SpringBoot2.x之后，原来使用的jedis被替换为了lettuce

jedis：采用的直连，多个线程操作的话，是不安全的。如果要避免不安全，要使用jedis pool连接池，更像BIO。

lettuce：采用Netty，实例可以在多个线程中共享，不存在线程不安全的情况。可以减少线程数据，更像NIO。

8..1 源码分析

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    ) //我们可以自己定义一个redisTemplate来替换这个默认的
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        //默认的redisTemplate，没有过多的配置，redis对象需要序列化
        //两个泛型都是Object，Object类型，我们后面使用需要强制转换为
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
 
    //由于String类型是redis中最常使用的类型，所以单独提出一个bean
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return new StringRedisTemplate(redisConnectionFactory);
    }

8.2 导入依赖

        
            org.springframework.boot
            spring-boot-starter-data-redis
        

8.3 配置文件

#springboot所有的配置类，都有一个自动配置类     RedisAutoConfiguration
#自动配置类都会绑定一个properties配置文件       RedisProperties
# 应用服务 WEB 访问端口
server:
  port:8080
spring:
  redis:
    host:ip
    port: 6379
    password: mypassword
 
 

8.4 测试

package com.yang;
 
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
 
@SpringBootTest
class Redis02SpringbootApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void contextLoads() {
        //redisTemplate 操作不同的数据类型
        //opsForValue  操作字符串 类似String
        //opsForList 操作List
        //opsForSet
        //opsForHash
        //opsForGeo  操作地理位置
        //除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务，和基本的cRUD
        ValueOperations string = redisTemplate.opsForValue();
        string.set("k1","v1");
        string.set("k2","你好啊！");
        System.out.println(string.get("k1"));
        System.out.println(string.get("k2"));
        
        //获取redis的连接对象
        // RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        // connection.flushDb();
        // connection.flushAll();
 
 
    }
 
}

8.5 序列化配置

默认序列化方式,是用jdk进行序列化，我们可能使用json进行序列化。

传递对象需要序列化，

8.6 编写自己的redisTemplate

package com.yang.config;
 
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisSerializer;
 
/**
 * @author yzh
 * @date 2024-02-24
 */
@Configuration
public class RedisCconfig {
 
    //编写我们自己的redisTemplate
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate myRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        //为了开发方便 一般使用
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
 
        //Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
 
        //key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value的序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value序列化方式采用jackson
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
 
        return template;
    }
}

8.7 RedisUtils工具类

package com.yang.utils;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
 
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
 
/**
 * Redis工具类，使用之前请确保RedisTemplate成功注入
 *
 * @author yzh
 * @date 2024-02-24
 */
@Component
public class RedisUtils {
 
    @Autowired
    @Qualifier("myRedisTemplate")
    private RedisTemplate redisTemplate;
 
    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
 
        return expire(key, timeout, TimeUnit.SECONDS);
    }
 
    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
 
        Boolean ret = redisTemplate.expire(key, timeout, unit);
        return ret != null && ret;
    }
 
    /**
     * 删除单个key
     *
     * @param key 键
     * @return true=删除成功；false=删除失败
     */
    public boolean del(final String key) {
 
        Boolean ret = redisTemplate.delete(key);
        return ret != null && ret;
    }
 
    /**
     * 删除多个key
     *
     * @param keys 键集合
     * @return 成功删除的个数
     */
    public long del(final Collection keys) {
 
        Long ret = redisTemplate.delete(keys);
        return ret == null ? 0 : ret;
    }
 
    /**
     * 存入普通对象
     *
     * @param key   Redis键
     * @param value 值
     */
    public void set(final String key, final Object value) {
 
        redisTemplate.opsForValue().set(key, value, 1, TimeUnit.MINUTES);
    }
 
    // 存储普通对象操作
 
    /**
     * 存入普通对象
     *
     * @param key     键
     * @param value   值
     * @param timeout 有效期，单位秒
     */
    public void set(final String key, final Object value, final long timeout) {
 
        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }
 
    /**
     * 获取普通对象
     *
     * @param key 键
     * @return 对象
     */
    public Object get(final String key) {
 
        return redisTemplate.opsForValue().get(key);
    }
 
    // 存储Hash操作
 
    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public void hPut(final String key, final String hKey, final Object value) {
 
        redisTemplate.opsForHash().put(key, hKey, value);
    }
 
    /**
     * 往Hash中存入多个数据
     *
     * @param key    Redis键
     * @param values Hash键值对
     */
    public void hPutAll(final String key, final Map values) {
 
        redisTemplate.opsForHash().putAll(key, values);
    }
 
    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public Object hGet(final String key, final String hKey) {
 
        return redisTemplate.opsForHash().get(key, hKey);
    }
 
    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public List