Agora que já conhecemos um pouco mais sobre o Redis, e já vimos como utilizar o CLI para acessá-lo, vamos agora ver como utilizar o Radix, um client Redis para Go Language.
O primeiro passo, é baixar e instalar o Radix, e fazemos isso da seguinte forma:
go get github.com/mediocregopher/radix.v2/...
Isso vai fazer com que seja feito o download e a instalação do Radix, em sua pasta “src”. Para mais detalhes sobre a instalação e estrutura de pastas do Go, clique aqui. Ao final da execução, você deve enxergar essa pasta em sua máquina:
Go\src\github.com\mediocregopher\radix.v2
Agora, que já temos o client do Redis instalado, ver como utilizamos o Radix para executar alguns comandos no Redis, a primeira coisa que devemos fazer, é importar o Radix, e fazemos isso da seguinte forma:
import ( "github.com/mediocregopher/radix.v2/redis" )
Para conectar no Redis, fazemos:
client, err := redis.Dial("tcp", "localhost:13919") if err != nil { //tratamento do erro }
Ao chamar redis.Dial, temos dois retornos, um struct do tipo redis.Client que representa o client de conexão com o Redis, e é através dele que enviaremos todos os comandos para o Redis, e err, que apenas será preenchida quando um erro ocorrer.
Se o Redis que estamos acessando possuir senha, precisamos nos autenticar, antes de executar qualquer comando, caso não tenha senha, podemos pular essa etapa. Para autenticar basta fazer:
err := client.Cmd("AUTH", "senhadoredis").Err if err != nil { //tratamento do erro }
Qualquer comando que queremos enviar ao Redis, deve ser enviado usando client.Cmd, e o primeiro parâmetro é sempre o nome do comando que queremos executar, seguido de seus parâmetros. Nesse caso, queríamos autenticar, e para isso usamos o comando AUTH, e passamos como parâmetro a senha. Se ocorrer qualquer problema, ou a senha for inválida, a função retornará um erro para a variável err, que devemos tratar.
Agora que estamos conectados e autenticados (se necessário), vamos colocar uma chave e seu valor no Redis, para isso, fazemos:
err := client.Cmd("SET", "admin_sistema", "Desenvolvedor Ninja").Err if err != nil { //tratamento do erro }
Repare que utilizamos novamente a instrução client.Cmd, da mesma forma que para autenticar, mas dessa vez, passamos o comando SET como parâmetro para o comando que queremos executar, e passamos “admin_sistema” como parâmetro para o nome da chave e “Desenvolvedor Ninja” como parâmetro para o valor. Será retornado um erro que precisa ser tratado caso ocorra alguma problema.
Agora que temos a chave definida, vamos consultá-la?
chave, err := client.Cmd("GET", "admin_sistema").Str() if err != nil { //tratamento do erro } fmt.Printf(chave)
Utilizamos novamente o client.Cmd, e um ponto importante, é que utilizamos .Str() no final, e não .Err. Fizemos isso pois o valor de nossa chave é do tipo string, e queremos atribuí-lo à variável chave. Caso a chave não seja encontrada, um erro será gerado, e deve ser tratado, caso a chave exista, seu valor será atribuído na variável chave. No final mandamos imprimir o conteúdo da nossa variável.
Nós vimos aqui, recentemente como expirar uma chave no Redis, então vamos ver como fazemos isso usando o Radix:
err := client.Cmd("EXPIRE", "admin_sistema", "600").Err if err != nil { //tratamento do erro }
Usamos novamente client.Cmd, e dessa vez usamos o comando EXPIRE como primeiro parâmetro, depois passamos nossa chave, e por fim passamos o tempo em segundos que queremos que a chave leve para expirar, no nosso caso 600.
Para consultar o tempo que falta para uma chave expirar, usamos o comando TTL e passamos como parâmetro a chave que queremos consultar:
tempo, err := client.Cmd("TTL", "admin_sistema").Int() if err != nil { //tratamento do erro } fmt.Printf("%d\n", tempo)
Teremos como retorno um inteiro com o tempo em segundos que a chave irá levar para expirar. Nós atribuímos esse retorno na variável tempo, e imprimimos seu conteúdo no final.
Para remover o tempo de expiração da chave, devemos usar o comando PERSIST, e passar a chave como parâmetro, da seguinte forma:
err = client.Cmd("PERSIST", "admin_sistema").Err if err != nil { //tratamento do erro }
E por fim, se quisermos apagar uma chave, basta usarmos o comando DEL, e passar a chave como parâmetro, dessa forma:
err = client.Cmd("DEL", "admin_sistema").Err if err != nil { //tratamento do erro }
E por fim, quando quisermos fechar a conexão com o Redis, basta chamar:
client.Close()
Simples não? Um ponto interessante, é que independente do comando que queremos usar, trabalhamos da mesma maneira, usamos sempre client.Cmd, e passamos o comando que desejamos, e seus parâmetros, como se estivéssemos no CLI.
A página no GitHub do Radix é: https://github.com/mediocregopher/radix.v2
Você pode encontrar a documentação do Radix em: https://godoc.org/github.com/mediocregopher/radix.v2/redis
Segue abaixo uma aplicação de exemplo, usando os comandos que vimos nesse post:
package main import ( "fmt" "github.com/mediocregopher/radix.v2/redis" "os" ) func main() { client, err := redis.Dial("tcp", "localhost:13919") if err != nil { fmt.Printf("Erro na conexão com o Redis\n") os.Exit(1) } err = client.Cmd("AUTH", "senhadoredis").Err if err != nil { fmt.Printf("Erro ao autenticar\n" + err.Error() + "\n") client.Close() os.Exit(1) } err = client.Cmd("SET", "admin_sistema", "Desenvolvedor Ninja").Err if err != nil { fmt.Printf("Erro ao definir chave\n" + err.Error() + "\n") client.Close() os.Exit(1) } chave, err := client.Cmd("GET", "admin_sistema").Str() if err != nil { fmt.Printf("Erro ao pesquisar chave\n") client.Close() os.Exit(1) } fmt.Printf(chave + "\n") err = client.Cmd("EXPIRE", "admin_sistema", "600").Err if err != nil { fmt.Printf("Erro ao definir tempo de expiração\n") client.Close() os.Exit(1) } tempo, err := client.Cmd("TTL", "admin_sistema").Int() if err != nil { fmt.Printf("Erro ao obter tempo de expiração\n") client.Close() os.Exit(1) } fmt.Printf("%d\n", tempo) err = client.Cmd("PERSIST", "admin_sistema").Err if err != nil { fmt.Printf("Erro ao retirar tempo de expiração\n") client.Close() os.Exit(1) } err = client.Cmd("DEL", "admin_sistema").Err if err != nil { fmt.Printf("Erro ao apagar chave\n") client.Close() os.Exit(1) } client.Close() }
Ou se preferir, o código está disponível no GitHub: https://github.com/desenvolvedorninja/radix-redis-com-golang

Quase 20 anos de experiência no mercado de TI.
Atuação em grandes empresas como Netshoes, Borland, JBS, Bradesco, Hospital das Clínicas, Rede, Prodam, HSPE, Instituto Ayrton Senna, e também em empresas internacionais como Delta Dental, T-Mobile, Pepsi e Mckesson.
Fundador da TecPrime Solutions, administrador da comunidade nopCommerce Brasil, e autor dos sites InvestFacil.net e Desenvolvedores.ninja
1 thought on “Radix – acessando Redis com Go Language”