2024-09-03

Redis是一个开源的使用C语言编写的、支持网络交互的、可基于内存也可持久化的Key-Value数据库。Redis不仅仅支持简单的key-value类型的数据,同时还提供list,set,zset,hash等数据结构的存储。

Redis的五大数据类型分别是:String、Hash、List、Set、Sorted Set(ZSet)。

  1. String

String是最简单的类型,你可以理解成与Memcached一模一个的类型。一个key对应一个value,其上支持的操作与Memcached的操作类似。

使用场景:

  • 缓存用户信息。
  • 缓存Token。
  • 计数器。
  1. Hash

Redis hash是一个键值(key-value)的集合。

使用场景:

  • 存储用户的属性,如用户的昵称、年龄、性别、邮箱等。
  • 缓存用户信息,比如用户的订单信息。
  1. List

Redis的List是简单的字符串列表,按照插入顺序排序。你可以添加一个元素到列表的头部(左边)或者尾部(右边)。

使用场景:

  • 实现消息队列,如Celery使用Redis作为Broker。
  • 实现排行榜应用,如游戏的排行榜。
  1. Set

Redis的Set是String类型的无序集合。

使用场景:

  • 实现共同好友、二度好友。
  • 实现标签系统,如文章的标签。
  • 实现推荐好友系统,如基于标签的推荐。
  1. Sorted Set(ZSet)

Redis的Sorted Set是String类型的有序集合。

使用场景:

  • 实现排行榜应用,如游戏的排行榜。
  • 实现延时任务,如对任务进行排序。

以上就是Redis的五大数据类型以及它们的使用场景,下面我们通过Python代码来实现对这五大数据类型的操作。

Python代码实现:




import redis
 
# 连接Redis
r = redis.Redis(host='localhost', port=6379, db=0)
 
# String
r.set('key', 'value')
print(r.get('key'))
 
# Hash
r.hset('hash_key', 'field', 'value')
print(r.hget('hash_key', 'field'))
 
# List
r.lpush('list_key', 'value1')
r.rpush('list_key', 'value2')
print(r.lrange('list_key', 0, -1))
 
# Set
r.sadd('set_key', 'value1')
r.sadd('set_key', 'value2')
print(r.smembers('set_key'))
 
# Sorted Set
r.zadd('zset_key', {'value1': 1, 'value2': 2})
print(r.zrange('zset_key', 0, -1, withscores=True))

以上代码展示了如何在Python中使用redis库来操作Redis的五大数据类型。首先,我们需要连接到Redis服务器,然后我们可以使用相应的方法来进行数据的添加、获取、删除等操作。

2024-09-03



from redisearch import Client, TextField, NumericField
 
# 创建一个Client实例来定义我们的搜索索引
client = Client('my_index')
 
# 定义文本和数值字段
client.add_document('id', searchable=TextField())
client.add_document('username', searchable=TextField())
client.add_document('join_day', filterable=NumericField())
 
# 连接到Redis服务器
client.connect()
 
# 创建索引
client.create_index(drop_on_exists=True)
 
# 添加文档到索引
client.add_document('user:1', title='Jane Doe', join_day=1)
client.add_document('user:2', title='John Doe', join_day=2)
 
# 执行搜索查询
res = client.search('John')
 
# 打印搜索结果
for doc in res.docs:
    print(doc.id, doc.title, doc.join_day)

这个简单的代码示例展示了如何使用redisearch-py库来创建一个基于Redis的搜索索引,并添加文档进行搜索。首先,我们创建一个Client实例来定义索引的结构,然后连接到Redis服务器。接着,我们创建索引,并添加两个文档。最后,我们执行一个搜索查询,并打印出返回的结果。这个例子是基于文本字段的,但是RedisSearch同样支持其他类型的字段,如标记字段(TagField)和地理空间字段(GeoField)。

2024-09-03

Redis是一个开源的使用C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。

以下是一些Redis的常用命令及其基本使用方法:

  1. SET:为一个键设置值。

    
    
    
    SET key value
  2. GET:获取一个键的值。

    
    
    
    GET key
  3. DEL:删除一个键。

    
    
    
    DEL key
  4. EXPIRE:为一个键设置有效期。

    
    
    
    EXPIRE key seconds
  5. EXISTS:检查一个键是否存在。

    
    
    
    EXISTS key
  6. KEYS:查找符合给定模式的键。

    
    
    
    KEYS pattern
  7. PING:检查Redis服务器是否运行。

    
    
    
    PING
  8. SAVE:同步保存数据到硬盘。

    
    
    
    SAVE
  9. INFO:获取服务器的统计信息。

    
    
    
    INFO
  10. TYPE:返回键的值的类型。

    
    
    
    TYPE key

这些命令的实现原理大部分都涉及到底层的数据结构,如:

  1. 字符串对象的实现:Redis中的字符串对象是由SDS(简单动态字符串)实现的,它具有固定长度的字符串缓冲区,并且可以在需要时自动扩展。
  2. 哈希对象的实现:哈希对象是由哈希表实现的,哈希表是一种数据结构,它通过哈希函数将键映射到哈希表的一个位置来存储数据。
  3. 列表对象的实现:列表对象是由双向链表实现的,它允许在前后快速插入和删除元素。
  4. 集合对象的实现:集合对象是由哈希表实现的,因此可以快速地进行添加、删除和查找操作。
  5. 有序集合对象的实现:有序集合对象是由哈希表和跳跃列表实现的,哈希表用于保存成员到分数的映射,跳跃列表用于保持成员按分数排序。
  6. 发布/订阅机制:Redis的发布/订阅机制是通过一个订阅模式的频道实现的,客户端可以订阅一个或多个频道,一旦有消息发布到这些频道,订阅的客户端就会收到消息。
  7. 持久化:Redis的持久化是通过RDB(快照)和AOF(追加文件)两种机制实现的,可以将数据保存到磁盘上,用于重启后的数据恢复。
  8. 事务:Redis的事务可以一次执行多个命令,它可以保证一系列命令的原子性,要么全部执行,要么全部不执行。
  9. 主从复制:Redis的主从复制是通过发送命令的方式实现的,一个Redis服务器可以有多个从服务器,从服务器会接收主服务器的命令,并执行相同的操作,以保持数据同步。
  10. 缓存淘汰机制:Redis使用LRU(最近最少使用)算法来淘汰过期的键,或者当内存不足以存储新的数据时,Redis会根据最少使用算法来淘汰一部分键。
2024-09-03

Redis和数据库之间的数据同步通常涉及以下几个步骤:

  1. 数据读取:从Redis读取数据。
  2. 数据转换:将Redis数据格式转换为数据库兼容的格式。
  3. 数据写入:将转换后的数据写入数据库。

以下是一个简单的Python示例,演示如何将Redis中的数据同步到MySQL数据库:




import redis
import pymysql
 
# 连接Redis
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)
 
# 连接MySQL
mysql_conn = pymysql.connect(host='localhost', user='your_user', password='your_password', db='your_db')
mysql_cursor = mysql_conn.cursor()
 
# 假设Redis中的数据是以键值对的形式存储的
def sync_data_from_redis_to_mysql(redis_key, mysql_table):
    # 从Redis获取数据
    value = redis_client.get(redis_key)
    
    # 转换数据格式,例如从JSON到MySQL需要的格式
    if value:
        data_to_sync = redis_client.get(redis_key).decode('utf-8')
        data_dict = json.loads(data_to_sync)
        
        # 构建SQL语句
        columns = ', '.join(data_dict.keys())
        values = ', '.join([f"'{str(v).replace("'", "''")}'" if isinstance(v, str) else str(v) for v in data_dict.values()])
        sql = f"INSERT INTO {mysql_table} ({columns}) VALUES ({values})"
        
        # 写入MySQL
        try:
            mysql_cursor.execute(sql)
            mysql_conn.commit()
            print(f"Data synced for key: {redis_key}")
        except Exception as e:
            print(f"Error syncing data: {e}")
            mysql_conn.rollback()
    else:
        print(f"No data found for key: {redis_key}")
 
# 调用函数同步数据
sync_data_from_redis_to_mysql('your_redis_key', 'your_mysql_table')
 
# 关闭MySQL连接
mysql_cursor.close()
mysql_conn.close()

请根据实际情况修改连接参数,并确保Redis和MySQL的表结构是兼容的。这个例子假设Redis中存储的是键值对,且数据可以直接转换为MySQL需要的格式。如果数据格式复杂,转换逻辑需要相应调整。

2024-09-03

解释:

Redis Cluster 是 Redis 的分布式版本,其数据被分布在不同的节点上。为了保证数据均匀分布在不同的节点上,Redis Cluster 采用了哈希槽(hash slot)的概念,其中每个节点负责维护一定数量的哈希槽。当你尝试对不属于同一个哈希槽的键执行操作时(例如:使用 MGET, MSET 等操作跨多个键时),Redis 会返回 CROSSSLOT Keys in request don‘t hash to the same slot 错误。

解决方法:

  1. 使用哈希标签:将相关的键通过使用 {key}:{tag} 的方式来确保它们落在同一个哈希槽中。
  2. 对键进行哈希计算并重新分配:如果键必须分布在不同的节点上,那么需要手动将这些键分配到正确的节点上。
  3. 使用单个键操作:对于需要执行的操作,尽量使用单个键,而不是多个键,以避免跨槽问题。
  4. 使用 Redis 的集群命令:Redis 提供了一些集群命令,如 {},可以用来处理多键操作,这些命令会自动处理跨槽问题。

具体使用哪种方法取决于你的应用需求和数据分布需求。

2024-09-03

在Java中,你可以使用Jedis或Lettuce库来操作Redis。以下是使用Jedis连接Redis并执行一些基本命令的示例代码:




import redis.clients.jedis.Jedis;
 
public class RedisExample {
    public static void main(String[] args) {
        // 连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        System.out.println("连接成功");
        // 设置 redis 字符串数据
        jedis.set("myKey", "myValue");
        // 获取存储的数据并输出
        System.out.println("redis 存储的字符串为: " + jedis.get("myKey"));
        
        // 操作 Redis 列表
        jedis.lpush("myList", "element1");
        jedis.lpush("myList", "element2");
        // 获取列表数据并输出
        System.out.println("redis 列表数据为: " + jedis.lrange("myList", 0, -1));
        
        // 关闭连接
        jedis.close();
    }
}

确保在运行此代码之前,你的机器上已经安装了Redis服务器,并且Jedis库已经添加到项目的依赖中。如果你使用的是Maven,可以在pom.xml中添加如下依赖:




<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>最新版本号</version>
</dependency>

以上代码展示了如何使用Jedis连接Redis,并执行基本的命令,如SET、GET、LPUSH等。在实际应用中,你可能需要处理连接池、异常处理等更复杂的情况,但这是操作Redis的基本模式。

2024-09-03



import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
 
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
 
public class RedisClusterExample {
    public static void main(String[] args) throws IOException {
        // 假设你已经配置好了Redis Cluster,并且知道其中一些节点的地址
        Set<HostAndPort> jedisClusterNodes = new HashSet<>();
        jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7000));
        jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7001));
        // ... 添加更多节点
 
        // 创建JedisCluster对象
        JedisCluster jedisCluster = new JedisCluster(jedisClusterNodes);
 
        // 使用JedisCluster进行操作
        jedisCluster.set("key", "value");
        String value = jedisCluster.get("key");
        System.out.println("获取的值为: " + value);
 
        // 关闭JedisCluster对象
        jedisCluster.close();
    }
}

这段代码展示了如何使用Jedis客户端库来连接Redis Cluster,并执行一个简单的设置和获取操作。在实际应用中,你需要提供正确的Redis Cluster节点地址和端口。这个例子假设你已经有一个运行中的Redis Cluster,并且知道其中一些节点的地址。

2024-09-03



#include "fmacros.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
 
#include "hiredis/hiredis.h"
 
void printSlotsInfo(redisClusterContext *cc) {
    redisClusterNode *node;
    int i;
 
    for (i = 0; i < cc->cluster->size; i++) {
        node = cc->cluster->nodes[i];
        printf("Node %d: ", node->id);
        if (node->fail_state != REDIS_NODE_FAIL_STATE_NONE) {
            printf("has fail state: %d\n", node->fail_state);
        } else {
            printf("is ok\n");
        }
    }
}
 
int main() {
    redisClusterContext *cc = redisClusterConnect("127.0.0.1", 7000);
    redisReply *reply;
    if (cc == NULL) {
        printf("Error in connect\n");
        exit(-1);
    }
 
    // 关闭自动重定向
    cc->flags &= ~(REDIS_CLUSTER_FLAG_NO_REDIRECTION);
 
    // 模拟故障
    system("kill -9 `ps aux | grep redis-server | grep 7000 | awk '{print $2}'`");
    sleep(5); // 等待Redis节点重启
 
    printf("After failure:\n");
    printSlotsInfo(cc);
 
    // 再次尝试执行命令
    reply = redisClusterCommand(cc, "GET foo");
    if (reply == NULL) {
        printf("Execution error\n");
    } else {
        printf("Reply: %s\n", reply->str);
        freeReplyObject(reply);
    }
 
    // 清理
    redisClusterFree(cc);
    return 0;
}

这段代码首先尝试连接到Redis集群,然后关闭自动重定向功能,模拟一个节点宕机,并在宕机后打印出集群的状态信息。最后,再次尝试执行一个命令,并输出结果。这个过程演示了Redis集群在出现故障时的自动故障转移机制。

2024-09-03

Redis 主从同步和哨兵机制是用来保证Redis服务的高可用性和数据备份的。

  1. Redis主从同步

主从同步是指将一个Redis服务器的数据同步到另一个服务器,前者称为主节点(master),后者称为从节点(slave)。

配置主从同步的步骤如下:

  • 在从节点的配置文件中加入 slaveof <master-ip> <master-port> 来指定主节点的IP和端口。
  • 在从节点执行 SLAVEOF <master-ip> <master-port> 命令也可以指定主节点。

例如:




slaveof 192.168.1.100 6379
  1. Redis哨兵机制

当主节点出现故障时,哨兵(sentinel)会检测到并自动将一个从节点提升为新的主节点,继续提供服务。

哨兵机制的配置步骤如下:

  • 在哨兵的配置文件中指定要监控的主节点和其地址。
  • 启动哨兵,使用 redis-sentinel /path/to/your/sentinel.conf 命令。

例如,sentinel.conf 配置文件中可能包含如下内容:




sentinel monitor mymaster 192.168.1.100 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000

mymaster 是主节点的名字,后面是主节点的IP和端口,以及最少需要多少个哨兵同意才进行故障转移。

2024-09-03

JWT(JSON Web Token)是一种用于双方之间传递安全信息的简洁的、URL安全的表示方法。

以下是使用JWT的一般流程:

  1. 用户登录:用户使用用户名和密码登录。
  2. 验证凭据:服务器验证用户名和密码。
  3. 创建JWT:服务器验证成功后,创建一个JWT。
  4. 返回JWT:服务器返回JWT给客户端。
  5. 客户端存储JWT:客户端通常将JWT存储在localStorage或sessionStorage中。
  6. 后续请求:客户端在后续请求中将JWT添加到请求头中。
  7. 服务器验证JWT:服务器检查请求头中的JWT,如果JWT有效,则提供访问权限。

JWT结构通常如下:




Header.Payload.Signature

Header通常指定签名算法:




{
  "alg": "HS256",
  "typ": "JWT"
}

Payload包含实际的声明:




{
  "iss": "Issuer",
  "sub": "Subject",
  "aud": "Audience",
  "exp": "Expiration Time",
  "nbf": "Not Before",
  "iat": "Issued At",
  "jti": "JWT ID"
}

Signature通过以下方式创建:




HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)

以下是一个简单的Java JWT工具类示例:




import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.Claims;
 
public class JwtUtil {
    private static final String SECRET_KEY = "verySecret"; // 应该是一个复杂的密钥
 
    public static String generateToken(User user) {
        return Jwts.builder()
                .setSubject(user.getUsername())
                .setExpiration(new Date(System.currentTimeMillis() + 864000000)) // 有效期10天
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }
 
    public static boolean validateToken(String token, UserDetails userDetails) {
        String username = Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
 
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }
 
    private static boolean isTokenExpired(String token) {
        Date expiration = Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getExpiration();
 
        return expiration.before(new Date());
    }
}

在与Redis结合使用时,可以在用户登录时创建JWT并将其存储在Redis中,并在后续请求中验证Redis中的JWT是否有效。




public String login(User user) {
    String token = JwtUtil.generateToken(user);
    redisTemplate.opsForValue().set(token, user.getUsername(), 10, TimeUnit.DAYS);
    return token;
}
 
public boolean validateToken(String token) {
    boolean isTokenValid = false;
    String username = (String) redisTemplate.opsForValue().get(token);
    if (username != null && !username.isEmpty()) {
        isTokenValid = true;