Começando do zero: entendendo os conceitos básicos e usos do Redis

introdução

Redis (Remote Dictionary Server) é um banco de dados de armazenamento de par chave-valor de alto desempenho e código aberto. É amplamente utilizado em cenários como aceleração de cache, gerenciamento de sessão e análise de dados em tempo real, e é popular por seu excelente desempenho e diversas estruturas de dados. Este blog irá levá-lo do zero para explorar os conceitos básicos e usos do Redis, incluindo estrutura de dados, aceleração de cache, persistência, implementação de cluster, etc.

1. O conceito básico do Redis

Redis é um sistema de armazenamento de dados na memória que suporta uma variedade de estruturas de dados, incluindo strings, hashes, listas, conjuntos e conjuntos classificados. Aqui está uma breve introdução a essas estruturas de dados:

1. Cordas

String é a estrutura de dados mais simples do Redis, ela pode armazenar qualquer tipo de dado, como texto, números, objetos serializados, etc. Aqui estão alguns exemplos comuns de manipulação de strings:

# 设置一个键为"username"的字符串值
SET username "alice"

# 获取键为"username"的字符串值
GET username

2. Hashes

Um hash é uma coleção de pares chave-valor, adequados para armazenar propriedades de objetos. Cada chave corresponde a uma tabela de hash contendo vários campos e valores. Aqui está um exemplo:

# 设置一个键为"user:1"的哈希值
HSET user:1 name "Alice"
HSET user:1 age 30

# 获取键为"user:1"的哈希值的特定字段
HGET user:1 name

3. Listas

Uma lista é uma lista ordenada de strings que podem ser inseridas e excluídas em ambas as extremidades da lista. Isso é muito útil para implementar cenários como filas de mensagens. Aqui está um exemplo:

# 在列表"messages"的右侧插入一条消息
RPUSH messages "Hello, World!"
RPUSH messages "How are you?"

# 从列表"messages"的左侧弹出一条消息
LPOP messages

4. Conjuntos

Um conjunto é uma coleção de strings não ordenada e não repetitiva. É adequado para armazenar um conjunto de valores exclusivos. Aqui está um exemplo:

# 向集合"tags"添加一些标签
SADD tags "redis"
SADD tags "caching"
SADD tags "database"

# 获取集合"tags"中的所有标签
SMEMBERS tags

5. Conjuntos Ordenados

Um conjunto ordenado é semelhante a um conjunto, mas cada membro está associado a uma pontuação, que pode ser usada para coisas como tabelas de classificação. Aqui está um exemplo:

# 向有序集合"leaderboard"添加玩家得分
ZADD leaderboard 100 "Alice"
ZADD leaderboard 150 "Bob"
ZADD leaderboard 200 "Charlie"

# 获取前两名玩家和他们的得分
ZREVRANGE leaderboard 0 1 WITHSCORES

Em segundo lugar, o uso do Redis

1. Aceleração do cache

Um dos usos mais comuns do Redis é como uma camada de cache. Os aplicativos podem armazenar dados acessados ​​com frequência no Redis para aumentar a velocidade de leitura e reduzir a carga no banco de dados. Quando o aplicativo precisa de determinados dados, ele primeiro tenta obtê-lo do cache Redis, se não existir no cache, obtém do banco de dados e armazena os dados obtidos no cache para uso futuro. Esse método é especialmente eficaz em cenários com mais leituras e menos gravações.

Etapas detalhadas e amostras de código :

1.1 Inicialize a conexão Redis:

Uma biblioteca de cliente Redis apropriada precisa ser usada para se conectar ao servidor Redis. Em Java, isso pode ser obtido usando a biblioteca do cliente Jedis.

import redis.clients.jedis.Jedis;

// 连接到本地的Redis服务器
Jedis jedis = new Jedis("localhost");

1.2 Cache de consulta:

Antes de tentar obter dados do banco de dados, verifique se os dados necessários existem no cache.

String userId = "123";
String cachedData = jedis.get("user:" + userId);
if (cachedData != null) {
    
    
    // 数据存在于缓存中，直接返回
    return cachedData;
}

1.3 Consultar o banco de dados:

Se os dados não existirem no cache, os dados serão consultados no banco de dados.

String userData = fetchDataFromDatabase(userId);

1.4 Armazenar em cache:

Armazene os dados obtidos do banco de dados no cache Redis para uso futuro.

jedis.setex("user:" + userId, 3600, userData);

2. Persistência

Quando se trata de persistência do Redis, existem duas maneiras principais: RDB (Redis Database) e AOF (Append-Only File). O principal objetivo da persistência é restaurar os dados e evitar a perda de dados após a reinicialização do servidor Redis. A seguir apresentará esses dois métodos de persistência e métodos de configuração em detalhes.

2.1 Persistência RDB (Redis Database)

A persistência RDB é obtida gravando periodicamente instantâneos do conjunto de dados Redis no disco. Esses instantâneos contêm uma cópia dos dados em um determinado momento. Você pode configurar a persistência RDB no arquivo de configuração do Redis.

A seguir está um exemplo de configuração para persistência RDB:

# 使用RDB持久化
save 900 1        # 在900秒内，如果至少有1个键被更改，则进行快照
save 300 10       # 在300秒内，如果至少有10个键被更改，则进行快照
save 60 10000     # 在60秒内，如果至少有10000个键被更改，则进行快照

Na configuração acima, savea diretiva define que dentro do intervalo de tempo especificado, se pelo menos o número especificado de chaves for modificado, a operação de captura instantânea será executada. Esses instantâneos serão salvos no sistema de arquivos do servidor Redis para que possam ser carregados após a reinicialização do servidor.

2.2 Persistência de AOF (Arquivo Somente Anexo)

A persistência AOF é obtida registrando cada operação de gravação. Todas as gravações no Redis são anexadas a um arquivo que registra todas as gravações que ocorreram desde que o servidor foi iniciado. Quando o servidor precisar ser reiniciado, ele poderá recuperar os dados executando novamente essas gravações.

A seguir está um exemplo de configuração de persistência AOF:

# 使用AOF持久化
appendonly yes

Na configuração acima, você ativou a persistência AOF appendonlydefinindo o item de configuração como .yes

3. Alta disponibilidade e implantação de cluster

O Redis pode obter alta disponibilidade por meio da replicação mestre-escravo, em que um nó atua como o nó mestre para aceitar operações de gravação e um ou mais nós escravos replicam os dados do nó mestre. Além disso, o Redis também suporta sharding e modo de cluster para fornecer expansão horizontal e alta disponibilidade. Aqui está um exemplo simples de replicação mestre-escravo:

# 主节点配置
bind 127.0.0.1
port 6379
...

# 从节点配置
bind 127.0.0.1
port 6380
slaveof 127.0.0.1 6379

3. Etapas da operação

Nesta seção, detalharemos como instalar, iniciar e operar o Redis e como implementar a aceleração de cache em seu aplicativo.

1. Instale o Redis

A instalação do Redis é muito simples, dependendo do seu sistema operacional, você pode escolher diferentes métodos para instalá-lo.

As etapas de instalação do Redis são diferentes para diferentes sistemas operacionais. A seguir estão as etapas de instalação detalhadas para diferentes sistemas:

Linux (por exemplo, Ubuntu)

1. Abra um terminal.
2. Atualizar lista de pacotes:

sudo apt-get update

3. Instale o Redis:

sudo apt-get install redis-server

4. Após a conclusão da instalação, o Redis iniciará automaticamente como um serviço do sistema.

Mac OS

1. Abra um terminal.
2. Se você não tiver o Homebrew instalado, execute o seguinte comando para instalar o Homebrew:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

3. Instale o Redis:

brew install redis

4. Após a conclusão da instalação, você pode iniciar o Redis com o seguinte comando:

brew services start redis

janelas

1. Acesse a página de download do site oficial do Redis: https://redis.io/download
2. Na seção "MSI Installer for Windows", baixe o instalador MSI apropriado para o seu sistema.
3. Execute o instalador baixado e siga as instruções para instalar.
4. Após a conclusão da instalação, você pode encontrar a pasta "Redis" no menu Iniciar e executar "Servidor Redis" para iniciar o servidor Redis.

Escolha o método de instalação apropriado de acordo com o sistema operacional que você está usando e siga as etapas acima. Após a conclusão da instalação, você pode continuar a operar o Redis de acordo com as etapas fornecidas anteriormente.

2. Inicie o servidor Redis

Abra uma janela de terminal e execute o seguinte comando para iniciar o servidor Redis:

redis-server

3. Conecte-se ao Redis

Em outra janela de terminal, execute o seguinte comando para se conectar ao servidor Redis iniciado:

redis-cli

4. Tente diferentes operações de estrutura de dados

Na linha de comando do Redis, você pode experimentar várias operações de estrutura de dados, como strings, hashes, listas, conjuntos e conjuntos classificados. Aqui estão alguns exemplos de ações:

# 设置一个字符串键值对
SET username "alice"

# 获取字符串键的值
GET username

# 设置一个哈希键的字段和值
HSET user:1 name "Alice"
HSET user:1 age 30

# 获取哈希键的字段值
HGET user:1 name

# 在列表中添加元素
RPUSH messages "Hello, World!"
RPUSH messages "How are you?"

# 弹出列表左侧的元素
LPOP messages

# 向集合中添加元素
SADD tags "redis"
SADD tags "caching"
SADD tags "database"

# 获取集合中的所有元素
SMEMBERS tags

# 向有序集合中添加元素
ZADD leaderboard 100 "Alice"
ZADD leaderboard 150 "Bob"
ZADD leaderboard 200 "Charlie"

# 获取有序集合中的前几名元素
ZREVRANGE leaderboard 0 1 WITHSCORES

5. Persistência da configuração

No arquivo de configuração Redis (geralmente redis.conf), você pode configurar a persistência RDB e AOF. Dependendo de suas necessidades, você pode ajustar a estratégia de salvamento do RDB ou habilitar o AOF para registrar todas as operações de gravação. Após modificar o arquivo de configuração, certifique-se de reiniciar o servidor Redis para que as alterações entrem em vigor.

6. Realize a aceleração do cache

Em seu aplicativo, você pode usar a biblioteca do cliente Redis para se conectar ao servidor Redis e usar SET, GET e outros comandos quando apropriado para obter aceleração do cache de dados. Dependendo da sua linguagem de programação, você precisa escolher uma biblioteca cliente apropriada, como Jedis (Java), redis-py (Python), StackExchange.Redis (C#), etc.

A descrição acima é uma série de etapas detalhadas sobre como instalar, iniciar, conectar e operar o Redis. Por meio da operação prática, você terá uma compreensão mais profunda dos conceitos básicos e do uso do Redis.

4. Conclusão

Como um banco de dados de armazenamento de memória de alto desempenho, o Redis fornece estruturas e funções de dados ricas e é adequado para vários cenários de aplicativos. Ao aprender estruturas e operações básicas de dados e obter uma compreensão profunda de conceitos como aceleração de cache, persistência e alta disponibilidade, você pode fazer melhor uso do Redis para melhorar o desempenho e a confiabilidade do aplicativo. Espero que este blog possa ajudá-lo a entender os fundamentos e usos do Redis e aplicar o que você aprendeu em projetos reais.