Aula 04 - Golang para Web - Redis
Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook
Link do código fluente no Pinterest
Meus links de afiliados:
Código da aula: Github
Melhore seu NETWORKING
Participe de comunidades de desenvolvedores:
Fiquem a vontade para me adicionar ao linkedin.
E também para me seguir no GITHUB.
Ah, se puder, clica na estrela nos meus repositórios pra dá uma força ao meu perfil no GITHUB
Redis
O
Redis é um armazenamento de estrutura de dados em memória, de código-fonte aberto (licenciado pela
BSD) e usado como banco de dados em cache e intermediário de mensagens.
Ele suporta várias estruturas de dados, como Strings, Hashes, Lists, Sets, etc.
O Redis foi feito usando a linguagem de programação ANSI C e usa a estrutura NoSQL para armazenar dados, o que atualmente o torna bem popular.
Gigantes da tecnologia como
GitHub,
Weibo,
Pinterest,
Snapchat,
Craigslist,
Digg,
StackOverflow,
Flickr, etc. Usam
Redis.
Para prosseguir é necessário ter o
Redis instalado na sua máquina.
Nesse meu post eu explico como instalar:
Uma vez o Redis instalado, inicie o serviço
Redis digitando em outro terminal:
redis-server
Agora o serviço do Redis deve tá rodando!
Com o
Redis instalado e o seu serviço
rodando, podemos agora instalar o pacote que
golang usa para se comunicar com o
Redis.
No terminal, digite o comando abaixo e tecle enter:
go get github.com/go-redis/redis
Pronto, o pacote deve ter sido instalado!
Lembrando que se você tiver optado por clonar o código a partir da branch dessa aula, a branch add_redis, para instalar as dependências do projeto, que até agora são:
Você tem que rodar os seguintes comandos:
Como eu chamei o app de
web_app, então eu executo o comando
go mod init seguido do
nome do
app.
Fica assim:
go mod init web_app
Esse comando vai criar o arquivo
go.mod que vai inicializar o diretório atual como a
raiz do
módulo e nos permitirá gerenciar dependências.
Agora você pode rodar o comando abaixo
go mod tidy.
go mod tidy
O comando
go mod tidy, fará o download das dependências necessárias em seus arquivos de origem e atualizará o arquivo
go.mod com essas dependência.
Voltando ao código.
OBS. MODIFICAÇÃO PÓS-POSTAGEM
A linha que tava assim:
comments, err := client.LRange("comments", 0, 10).Result()
Foi inserido o
client.Context()
comments, err := client.LRange(client.Context(), "comments", 0, 10).Result()
Isso evita o seguinte erro:
not enough arguments in call to client.cmdable.LRange
have (string, number, number)
want (context.Context, string, int64, int64)
Seguindo
O que tá em laranja é o que tá sendo modificado:
my_projects/web_app/main.go
package main
import(
"log"
"net/http"
"github.com/gorilla/mux"
"github.com/go-redis/redis"
"html/template"
)
//globals variables
var client *redis.Client
var templates *template.Template
func main(){
client = redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
templates = template.Must(template.ParseGlob("templates/*.html"))
r := mux.NewRouter()
r.HandleFunc("/contact", contactHandler).Methods("GET")
r.HandleFunc("/about", aboutHandler).Methods("GET")
r.HandleFunc("/", indexHandler).Methods("GET")
http.Handle("/", r)
log.Fatal(http.ListenAndServe(":8000", nil))
}
//request index page handle
func indexHandler(w http.ResponseWriter, r *http.Request){
comments, err := client.LRange(client.Context(), "comments", 0, 10).Result()
if err != nil{
return
}
templates.ExecuteTemplate(w, "index.html", comments)
}}
//request contact page handle
func contactHandler(w http.ResponseWriter, r *http.Request){
templates.ExecuteTemplate(w, "contact.html", "This is the contact page!")
}
//request about page handle
func aboutHandler(w http.ResponseWriter, r *http.Request){
templates.ExecuteTemplate(w, "about.html", "This is the about page!")
}
Fizemos o importe do pacote de comunicação com o
Redis, criamos outra variável global chamada
client, que vai receber a
instância do
cliente Redis, onde nas options tá sendo passado o endereço onde o serviço
Redis está sendo servido.
No nosso caso, tá rodando na nossa
máquina local, na
porta 6379, que é a porta padrão do
Redis.
Na linha:
comments, err := client.LRange(client.Context(), "comments", 0, 10).Result() estamos pegando os 11 últimos comentários.
Veja que esse método retorna dois valores, um contém um array de strings com os comentários, o outro é um objeto de erro ou não, dependendo se a nossa solicitação falhou ou não.
O
client.Context() define o tipo de contexto, ele tem informações de expirações de prazos, sinais de cancelamento e outros valores no escopo das
requests através dos limites da API e entre processos.
Aqui não estamos tratando o erro ainda, se ocorrer algum erro, simplesmente redirecionaremos para o
indexHandler.
Modifique o
my_projects/web_app/templates/index.html para adicionar o
bind no html.
my_projects/web_app/templates/index.html
<html>
<head>
<title>Comments</title>
</head>
<body>
<h1>Comentários</h1>
{{ range . }}
<div>{{ . }}</div>
{{ end }}
</body>
</html>
Agora vamos rodar nossa aplicação:
go run main.go
Acesse:
Veja que não temos nenhum comentário, claro, não criamos nenhum.
Dê um ctrl + c para derrubar o servidor.
Vamos entrar no prompt do
Redis, digite no terminal:
redis-cli
O promp vai mudar para:
127.0.0.1:6379>
Crie alguns comentários:
127.0.0.1:6379>lpush comments "oi, tudo bem?"
127.0.0.1:6379>lpush comments "testando 123"
127.0.0.1:6379>lpush comments "testando 456"
127.0.0.1:6379>lpush comments "outro teste"
Agora vamos rodar nossa aplicação:
go run main.go
Acesse:
Se tudo correu bem, os comentários criados devem aparecer na
index.html!
Por agora é só, nos vemos próxima. ;)
Código da aula: Github
Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook
Link do código fluente no Pinterest
Novamente deixo meus link de afiliados:
Obrigado, até a próxima e bons estudos. ;)
