Go: Organizando e usando pacotes.

Em um post anterior, falei em como criar pacotes com Go, mas muito superficialmente. De uns tempos pra cá, venho tendo a necessidade de criar estruturas para aplicações de larga escala, criando bibliotecas reutilizáveis e claro, usando pacotes de terceiros. Nesse post vou mostrar um pouco como organizar e reutilizar esses pacotes.

Toda aplicação Go é contida dentro de um pacote (package). Todo pacote deve estar dentro do $GOPATH e são nomeados de acordo com a pasta e arquivo em que está. Para carrega-lo em nosso código usamos import.

 1 package main
 2 import (
 3   "fmt"
 4   "os"
 5   "strings"
 6  )
 7 
 8 func main() {
 9   who := "World"
10   if len(os.Args) > 1 {
11     who = strings.Join(os.Args[1:], "")
12   }
13   fmt.Println("Hello", who)
14 }

Nesse exemplo fizemos o import de 3 pacotes da biblioteca padrão do Go. Podemos notar o uso do metodo Join, do pacote strings e Args, do pacote os.

Agora vamos criar nossos próprios pacotes. O primeiro passo é criar um workspace. Dentro desse workspace vamos ter 3 pastas: bin: Aqui ficaram os executáveis. src: É onde seus pacotes vão sobreviver. Todo código .go vai ficar aqui. pkg: Algum pacote extra do SO.

Quando você importa um pacote, o Go vai atras do pacote em cada workspace declarado no $GOPATH. O meu $GOPATH está setado para ~/go

Dentro de ~/go/src crie foo/foo.go, o abra em seu editor e edite:

1 package foo
2 
3 import "fmt"
4 
5 func Bar() {
6   fmt.Println("Bar")
7 }

Geralmente, os arquivos que contem o pacote são nomeados de acordo com a pasta (o pacote e a pasta chamam-se foo e o arquivo foo.go).

Agora, vamos criar um programa que vai fazer uso desse pacote que criamos.

Crie uma pasta fooz e um arquivo fooz.go e vamos edita-lo:

1 package main
2 
3 import (
4   "foo"
5 )
6 
7 func main() {
8   foo.Bar()
9 }

Para fazer o build desse código, basta rodar go build, que vai gerar um binario executavel fooz. Basta você rodar ./fooz que o resultado será bar impresso no terminal. Já para instalar o pacote e deixa-lo disponível globalmente, temos que executar go install. O pacote estará em $GOPATH/bin/fooz.

Para usar pacotes de terceiro, vamos usar o comando go get, que baixa a dependencia e a coloca dentro do nosso workspace. Vamos ver um exemplo com o Martini web framework.

1 go get github.com/go-martini/martini

Edite o arquivo foo.go e adicione:

 1 package main
 2 
 3 import "github.com/go-martini/martini"
 4 
 5 func main() {
 6   m := martini.Classic()
 7   m.Get("/", func() string {
 8     return "Hello world!"
 9   })
10   m.Run()
11 }

E execute go run foo.go, que já faz o build e executa o binário.

Bom, era mais ou menos isso que eu tinha pra falar. Vamos fazer mais coisas alem de scripts!