Golang para desenvolvedores pragmáticos parte 2

GO Lang para
desenvolvedores
pragmáticos - parte 2
Wilson Júnior

Wilson Júnior
Desenvolvedor
/Globocom/Rio/Backstage
Apaixonado por Tecnologia, Pessoas,
e aprender novas nerdices.

Vamos começar o projeto
● Faça o fork do projeto em
github.com/wpjunior/go-course-2
● brew install go # 1.8
● Baixe seu projeto com `go get
github.com/SEU-USUARIO-GITHUB/go-cour
se-2`
Esperamos que vocês já tenham configurado o
projeto mais ou menos assim

Preparados para a segunda batalha ?!

Entre no diretório de batalha!
cd ~/go/src/github.com/SEU-GITHUB/go-course-2

HTTP Server
simples
# já vão rodando um:
$ pushd 1-http-server

HTTP Server simples
Library: net/http
Documentação: godoc.org/net/http

Lesson 1 - Simple http server
package main
import (
"log"
"net/http"
)
func main() {
addr := "127.0.0.1:8081"
log.Printf("Running web server on: http://%sn", addr)
log.Fatal(http.ListenAndServe(addr, nil))
}

Exemplos de Listening addresses
Addr Descrição
"127.0.0.1:8081" Rodará em apenas no
endereço 127.0.0.1 na porta
8081, os outros endereços
disponíveis da máquina não
acessarão a porta 8081
":8081" Rodará em todos os endereços
da máquina na porta 8081
"0.0.0.0:8081" Rodará em todos os endereços
da máquina na porta 8081

HTTP Server
avançado
$ pushd 2-advc-http-server

Lesson 2 - HTTP Server avançado - Exemplo
package main
import (
"log"
"net/http"
"time"
)
func main() {
server := &http.Server{
Addr: "127.0.0.1:8081",
Handler: nil,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
IdleTimeout: time.Second,
}

Lesson 2 - HTTP Server avançado - Exemplo
log.Printf("Running web server on: http://%sn", server.Addr)
log.Fatal(server.ListenAndServe())
}

Escrevendo o
primeiro handler
$ pushd 3-handler

O que é um http handler
Como descobrir:
https://godoc.org/net/http#Handler

type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}

O que é o ResponseWriter ?

Lesson 3 - Escrevendo o primeiro handler - Exemplo
package main
import (
"fmt"
"log"
"net/http"
)
type MyHandler struct{}
func (h *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)
{
fmt.Fprintf(w, "Hello warriors")
}

Lesson 3 - Escrevendo o primeiro handler - Exemplo
func main() {
addr := "127.0.0.1:8081"
handler := &MyHandler{}
log.Fatal(http.ListenAndServe(addr, handler))
}

Escrevendo
testes para o
meu handler
$ pushd 4-handler-test

Como testaremos nosso handler
Library: net/http/httptest
Documentação: godoc.org/net/http/httptest

Lesson 4 - Testando meu http handler - Exemplo
type MyHandlerSuite struct {
handler http.Handler
}
...
func (s *MyHandlerSuite) SetUpSuite(c *check.C)
{
s.handler = &MyHandler{}
}

func (s *MyHandlerSuite) TestOK(c *check.C) {
w := httptest.NewRecorder()
r, _ := http.NewRequest(http.MethodGet, "/", nil)
s.handler.ServeHTTP(w, r)
c.Assert(w.Code, check.Equals, http.StatusOK)
c.Assert(w.Body.String(), check.Equals, "Hello warriors")
}

func (s *MyHandlerSuite) TestFail(c *check.C) {
w := httptest.NewRecorder()
r, _ := http.NewRequest(http.MethodGet, "/", nil)
s.handler.ServeHTTP(w, r)
c.Check(w.Code, check.Equals, http.StatusNotFound)
c.Assert(w.Body.String(), check.Equals, "Fail")
}

Encodando JSON
$ pushd 5-encode-json

Encodando JSON
Library: encoding/json
Documentação: godoc.org/encoding/json

Lesson 5 - Encodando um JSON - Exemplo
type Person struct {
FirstName string
LastName string
Age int
}

func (h *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
person := &Person{
FirstName: "Wilson",
LastName: "Júnior",
Age: 24,
}
encoder := json.NewEncoder(w)
err := encoder.Encode(person)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}

Executem e abram o
browser
http://localhost:8081

Como colocar os
campos como nomes
diferentes.

FirstName string `json:"firstName"`
LastName string `json:"lastName"`
Age int `json:"age"`
}

FirstName string `json:"firstName"`
LastName string
`json:"lastName,omitempty"`
Age int `json:"age"`
}

{
"firstName": "Wilson",
"lastName": "Júnior",
"age": 24
}

Decodando JSON
$ pushd 6-decode-json

Lesson 6 - Decodando um JSON - Exemplo
func (h *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
person := &Person{}
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(person)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
fmt.Fprintln(w, "Recebemos o json!")
fmt.Fprintf(w, "first name: %sn", person.FirstName)
fmt.Fprintf(w, "last name: %sn", person.LastName)
fmt.Fprintf(w, "age: %dn", person.Age)
}

curl -i http://127.0.0.1:8081
-d'{"firstName": "Kaio",
"lastName": "Vinicius", "age": 24}'

Existem outros
encoders/decoders
sem ser JSON!

Outros encoders/decoders
XML encoding/xml
CSV encoding/csv
MessagePack github.com/vmihail
enco/msgpack

Mas, Wilson, o net/http suporta
só um Handler ?, como faço para
ter várias rotas diferentes na
minha aplicação ?

O Router também é um Handler!

Alguns http routers famosos
Pacote Pós Const
net/http#ServeMux Vem na standard library, pode
atender casos simples de uso.
Não permite casos como
roteamento por template, regex,
nem por verbo http
httptreemux Utiliza um algoritmo usando
radix, é rápido e possui
roteamento por verbos http.
Mais um pacote para manter, no
meio a tantos pacotes de
routing.
Outros routers https://github.com/avelino/awesome-go#web-frameworks

Usando o Roteador HTTP standard
net/http#ServerMux
$ pushd 7-simple-http-decoder

Lesson 7 - Usando o roteador HTTP standard - Exemplo
func main() {
addr := "127.0.0.1:8081"
router := http.NewServeMux()
router.Handle("/g1", &G1Handler{})
router.Handle("/gshow", &GShowHandler{})
log.Fatal(http.ListenAndServe(addr, router))
}

Abram as duas rotas:
http://localhost:8081/g1
http://localhost:8081/gshow

Usando o httptreemux
$ pushd 8-http-treemux

HTTPTreeMux
Library:
github.com/dimfeld/httptreemux
Documentação:
godoc.org/github.com/dimfeld/httptreemux

Lesson 8 - Usando o httptreemux - Exemplo
func main() {
addr := "127.0.0.1:8081"
router := httptreemux.NewContextMux()
router.Handler(http.MethodGet, "/cars/:id", &GetCarHandler{})
router.Handler(http.MethodPut, "/cars/:id", &UpsertCarHandler{})
log.Fatal(http.ListenAndServe(addr, router))
}

type UpsertCarHandler struct{}
func (h *UpsertCarHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
params := httptreemux.ContextParams(r.Context())
fmt.Fprintf(w, "Eu deveria criar um carro chamado: %s!", params["id"])
fmt.Fprintln(w, "Não crio por que sou mal!")
}

type GetCarHandler struct{}
func (h *GetCarHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
params := httptreemux.ContextParams(r.Context())
fmt.Fprintf(w, "Eu deveria buscar um carro chamado: %s!", params["id"])
fmt.Fprintln(w, "Não busco por que estou com preguiça!")
}

Execute os dois comandos!
curl http://localhost:8081/cars/gol
curl -XPUT http://localhost:8081/cars/fusca
-d'{"name": 1}'

Realizando requests http
$ pushd 9-http-client

Que tal se consultarmos uma API
do github ?

https://api.github.com/users/wpjunio
r

Lesson 9 - Realizando requests HTTP
type User struct {
Name string `json:"name"`
Company string `json:"company"`
}

func GetGithubUser(username string) (*User, error) {
url := fmt.Sprintf("https://api.github.com/users/%s", username)
req, _ := http.NewRequest(http.MethodGet, url, nil)
res, err := http.DefaultClient.Do(req)
if err != nil {
return nil, err
}
defer res.Body.Close()

user := &User{}
err = json.NewDecoder(res.Body).Decode(user)
return user, err
}

func main() {
user, err := GetGithubUser(MyUsername)
if err == nil {
log.Printf("Temos o usuário: %#vn", user)
} else {
log.Println("Falha ao buscar usuário: ", err)
}
}

Conectando no MongoDB
$ pushd 10-mongodb

Conectando no MongoDB
Library: gopkg.in/mgo.v2
Documentação: godoc.org/gopkg.in/mgo.v2

Inicialize o mongod
$ mongod --config /usr/local/etc/mongod.conf

Lesson 10 - MongoDB
Id string `bson:"_id"`
Name string `bson:"name"`
Inative bool `bson:inative`
}

Lesson 10 - MongoDB
type PersonRepository struct {
session *mgo.Session
}

Lesson 10 - MongoDB
func NewPersonRepository(session *mgo.Session) *PersonRepository
{
return &PersonRepository{session}
}

Lesson 10 - MongoDB
func (r *PersonRepository) Create(p *Person) error {
session := r.session.Clone()
defer session.Close()
collection := session.DB("").C(PersonCollection)
err := collection.Insert(p)
if mongoErr, ok := err.(*mgo.LastError); ok {
if mongoErr.Code == 11000 {
return ErrDuplicatedPerson
}
}
return err
}

Lesson 10 - MongoDB
func (r *PersonRepository) Update(p *Person) error {
return collection.Update(bson.M{"_id": p.Id}, p)
}

Lesson 10 - MongoDB
func (r *PersonRepository) Remove(id string) error {
return collection.Remove(bson.M{"_id": id})
}

Lesson 10 - MongoDB
func (r *PersonRepository) FindAllActive() ([]*Person, error) {
query := bson.M{"inative": false}
documents := make([]*Person, 0)
err := collection.Find(query).All(&documents)
return documents, err
}

Lesson 10 - MongoDB
func (r *PersonRepository) FindById(id string) (*Person, error) {
query := bson.M{"_id": id}
person := &Person{}
err := collection.Find(query).One(person)
return person, err
}

Lesson 10 - MongoDB
func main() {
session, err := mgo.Dial("localhost:27017/go-course")
if err != nil {
log.Fatal(err)
}
repository := NewPersonRepository(session)

Lesson 10 - MongoDB
// creating a person
person := &Person{Id: "123", Name: "Juliana"}
err = repository.Create(person)
if err == ErrDuplicatedPerson {
log.Printf("%s is already createdn", person.Name)
} else if err != nil {
log.Println("Failed to create a person: ", err)
}

Lesson 10 - MongoDB
// updating a person
person.Name = "Juliana updated"
err = repository.Update(person)
if err != nil {
log.Println("Failed to update a person: ", err)
}
repository.Create(&Person{Id: "124", Name: "Marcos"})
repository.Create(&Person{Id: "125", Name: "Kaio", Inative: true})
repository.Create(&Person{Id: "126", Name: "Gabriel"})
repository.Create(&Person{Id: "127", Name: "Maisa"})

Lesson 10 - MongoDB
// findAll
people, err := repository.FindAllActive()
if err != nil {
log.Println("Failed to fetch people: ", err)
}
for _, person := range people {
log.Printf("Have in database: %#vn", person)
}

Golang para desenvolvedores pragmáticos parte 2

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Golang para desenvolvedores pragmáticos parte 2

Similar to Golang para desenvolvedores pragmáticos parte 2 (20)

More from Wilson Júnior

More from Wilson Júnior (6)

Golang para desenvolvedores pragmáticos parte 2