Radix – acessando Redis com Go Language

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