Recentemente estava precisando subir uma página estática para uma aplicação web. Como estava estudando Go, resolvi realizar essa tarefa com a linguagem.
Segundo uma pesquisa feita pelo StackOverflow, a linguagem de programação Go já é a terceira colocada na lista de linguagens mais desejadas para aprender e vem sendo utilizada por grandes empresas como Uber, Google, Twitch... O próprio Docker, queridinho do mundo dos containers, foi desenvolvido em cima da linguagem.
Um dos elementos que mais chamam a atenção para essa linguagem é sua alta performance, facilidade de trabalhar com concorrência e também é elegante e concisa como Python e rápida como C.
Para comprovar esses fatos, por que não fazer uma aplicação web e exibir uma página? Mas antes de colocar as mãos na massa, é preciso fazer a instalação do Go.
Instalando o Go
Para instalarmos o GO no Linux, basta fazer o download na página da Golang, navegar até a pasta do arquivo pelo terminal com o comando: cd Downloadse executar os comandos :
sudo tar -C /usr/local -xzf go1.12.5.linux-amd64.tar.gz
sudo export PATH=$PATH:/usr/local/go/bin.
No Windows, basta fazer o download e seguir o passo a passo do instalador
Para confirmar que tudo correu sem problemas executamos o comando go version, que vai exibir a versão do Go instalada.
Com o Go instalado já podemos começar a desenvolver nosso servidor.
Colocando a mão na massa
Primeiro criamos uma pasta chamada static, dentro dela vai estar todos os arquivos relacionado ao frontend do site. Logo depois criamos um arquivo chamado main.go. É dentro dele que iremos escrever o código necessário para levantar nossa aplicação web.
Agora, mãos na massa! De início, precisamos informar dentro do arquivo main.go algumas coisas para o Go, como por exemplo qual será o pacote que estamos trabalhando e os pacotes que vamos importar para utilizar. No nosso caso, trabalharemos no pacote main e importaremos o módulo net/http.
O módulo net/http é responsável por nos fornecer os métodos de mapeamento e gerenciamento de requisições e o pacote main será responsável por nos prover as funções para manter a aplicação de pé! Para isso, escreveremos o seguinte trecho de código:
package main
import (
"net/http"
)
Agora, como nos clássicos programas em C, precisamos ter uma função principal que será o ponto de partida da execução do nosso programa. Essa função é a main.
package main
import (
"net/http"
)
func main() {
}
Dentro da main,utilizaremos as funções presentes dentro do pacote net/http que nos possibilita de colocar a aplicação de pé.
Escolhendo a porta com a função ListenAndServe
Uma função bem interessante que podemos utilizar para subir a aplicação é a ListenAndServe, ela será responsável por especificar em qual porta rodará a nossa aplicação e como lidaremos com o servidor da aplicação. Para usá-la, faremos o seguinte:
package main
import (
"net/http"
)
func main() {
http.ListenAndServe(":8080", nil)
}
No caso acima, os parâmetros indicam que estamos subindo a nossa aplicação na porta 8080 e o nil nesse caso informa que utilizaremos a configuração padrão do servidor do Go.
Com o código acima, supostamente já teríamos uma aplicação web pronta para rodar com Go. Porém, ainda precisamos lidar com as requisições que o servidor receberá.
Lidando com as requisições
Para lidar com as requisições, precisamos utilizar um outro método do pacote net/http dentro do nosso main, o HandleFunc.
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
Assim como a função ListenAndServe, a função HandleFunc também recebe dois parâmetros, o primeiro informa que a URL http://localhost:8080 deverá executar determinada ação. O segundo parâmetro indica que chamaremos a função handler ao acessarmos o endereço http://localhost:8080. Mas o que é esse handler??
Entendendo o handler
O handler é uma função que criaremos para executar determinada ação ao acessarmos o caminho http://localhost:8080.
Como será responsável por lidar com as requisições e respostas do servidor, a função handler deverá receber dois parâmetros, um do tipo http.ResponseWriter e outro do tipo *http.Request:
func handler(w http.ResponseWriter, r *http.Request) {
}
Com a adição dos pacotes e funções nosso código ficou assim:
package main
import (
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
O primeiro parâmetro será responsável pela resposta da requisição, enquanto o segundo será responsável pelo tratamento da mesma.Ah, um pequeno detalhe: o nome handler é completamente arbitrário, poderíamos usar o nome que quiséssemos para a função, bastando trocar o nome :)
Voltando ao nosso propósito, vamos finalmente dispor a página web para a nossa aplicação.
Exibindo a página
Para finalmente exibir a página em nosso servidor, podemos utilizar a função http.ServeFile.
Esse tal de http.ServeFile é responsável por dispor um arquivo, ou seja, estamos simplesmente servindo uma página web utilizando nossas variáveis responsáveis por escrever a resposta http e também o nosso request.
Nosso código com a adição do http.ServerFile ficou assim:
package main
import (
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, "./static/index.html")
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
Agora que finalizamos nosso código, vamos executar o nosso programa.
Executando
Para executar o nosso programa, precisamos navegar até a pasta onde está o arquivo pelo terminal:
E executar o comando go run main.go.
Caso tudo tenha dado certo, o terminal vai ficar “travado”. Isso significa que o nosso programa está em execução.
Agora vamos finalmente exibir a página!
Exibindo a página
Ao abrir navegador e acessar a URL http://localhost:8080/. Vamos ver o seguinte resultado:
Conclusão
Com esse simples projeto, vimos que em pouquíssimas linhas de código conseguimos criar uma aplicação web e que o tempo para executá-la é quase instantâneo.
Essa não é nem a ponta do iceberg! Go está crescendo cada vez mais no mercado. O uso para concorrência é ainda mais amplo e profundo do que em outras linguagens, já que Go nos oferece algo chamado goroutines, mas isso é outra história…
E agora que você conheceu um pouco mais sobre a linguagem Go, aqui na Alura temos um curso de Go onde vamos aprender a sobre controle de fluxo, fazer requisições HTTP e muitas outras coisas!
