Exibir código-fonte para Go: RESTful - um exemplo completo com persistência


Afluentes: [[Sistemas Distribuídos e Mobile]]

= Modelo DAO (<i>Data Access Object</i>) =

* [https://saulo.arisa.com.br/aulas/unisul/bd/java_bd_dao.pdf Slides Modelo DAO]

= Base de Dados =

Para nosso exemplo de CRUD, vamos precisar de um local para armazenar nossas informações de forma persistente. Para isso, criamos uma tabela chamada <code>users</code> no Postgres. Abaixo temos a clausula CREATE TABLE da nossa tabela.

<syntaxhighlight lang=sql>
create table users (
    id integer not null,
    name varchar(50) not null,
    email varchar(50) not null,
    primary key (id)
);
</syntaxhighlight>

Veja que ela é bastante simples, mas já serve como exemplo. Temos os atributros <code>id</code> do tipo <code>integer</code> e dois atributos, <code>name</code> e <code>email</code>, do tipo string, ou melhor, <code>VARCHAR</code>. O <code>id</code> é usado como chave primária.

Para nosso exemplo, criamos a base de dados chamada <code>backendcrud</code>. Fique a vontade para mudar no nome da base de dados, mas lembre-se de alterar no código fonte do arquivo <code>main.go</code> também.

Conforme nosso modelo <code>DAO</code>, essa é nossa <code>FONTE DE DADOS</code>.

= database.go =

Essa classe é meio que um padrão para a conexão com o banco de dados. O constructor, <code>NewDatabase</code> inicializa o objeto, configurando as informações de conexão passadas como parâmetro e retornando o próprio objeto na função (ver mais sobre a criação de objetos em Go). A função <code>Close</code> fecha a conexão com a base de dados.

Agora, a função que mais vamos utilizar é a <code>Get</code>. Toda vez que formos fazer uma operação no nosso banco, vamos usar essa função para pegarmos a nossa conexão. Caso ainda não tenha sido aberta uma conexão, essa conexão é feita e retornada ao usuário, caso contrário, apenas retorna a conexão aberta. Dessa forma, não precisamos ficar abrindo e fechando conexão toda vez que precisarmos fazer uma operação, nem ficar abrindo um monte de conexões, o que seria um problema. :D

<syntaxhighlight lang=go>
package main

import (
	"database/sql"
	"fmt"

	_ "github.com/lib/pq"
)

// Database class
type Database struct {
	connection *sql.DB
	dbtype     string
	info       string
	err        error
}

// NewDatabase Constructor
func NewDatabase(dbhost string, dbtype string, dbname string, dbuser string, dbpass string) *Database {
	db := new(Database)
	db.dbtype = dbtype
	db.info = fmt.Sprintf("user=%s password=%s dbname=%s sslmode=disable", dbuser, dbpass, dbname)
	return db
}

// Get return connection
func (db *Database) Get() *sql.DB {
	if db.connection == nil {
		db.connection, db.err = sql.Open(db.dbtype, db.info)
	}
	return db.connection
}

// Close function
func (db *Database) Close() {
	db.connection.Close()
}
</syntaxhighlight>

= user.go =

A classe <code>User</code> é a classe que representa o nosso objeto da tabela. Observe também que também temos informações nos atributos para fazer a serialização dos objetos para o formato JSON. Os atributos que serão serializados devem ser públicos, ou seja, iniciar com letra maiúscula.

A função <code>NewUser</code> serve para criar um objeto com os dados passados como parâmetro.

<syntaxhighlight lang=go>
package main

type User struct {
	Id    int    `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email"`
}

func NewUser(id int, name string, email string) *User {
	user := new(User)
	user.Id = id
	user.Name = name
	user.Email = email
	return user
}
</syntaxhighlight>

Seguindo nosso modelo <code>DAO</code> essa classe cria nossos <code>OBJETOS DE TRANSFERÊNCIA</code>.

= userdao.go =

A classe <code>UserDAO</code> é, no <code>DAO</code>, nosso <code>OBJETO DE ACESSO</code>, responsável pelas operações com os <code>OBJETOS DE TRANSFERÊNCIA</code> e utilizado pelo <code>OBJETO DE APLICAÇÃO</code>.

Nessa classe temos todas as operações CRUD.

* '''CREATE''': representada aqui pelo método <code>Insert</code>. Ao chamarmos o método, passamos como parâmetro um <code>OBJETO DE TRANSFERÊNCIA</code> do tipo <code>Users</code>. Esse objeto é então gravado na base de dados caso o <code>Id</code> ainda não exista (isso porque é chave primária).
* '''READ''': a leitura dos dados é feita por dois métodos:
** método <code>GetAll</code> que retorna uma lista de todos os dados armazenados na base (o que não é aconselhável caso a base seja grande. O interessante é fazer filtros para trazer parte dos dados apenas. Fiz assim por ser um exemplo simples em sala de aula, buscando diminuir a quantidade de código do exemplo).
** método <code>Get</code> que retorna apenas um objeto. Veja que passamos o <code>Id</code> do objeto que queremos retornar.
* '''UPDATE''': Usamos o método <code>Update</code> para alterar as informações de um registro. Passamos como parâmetro o <code>OBJETO DE TRANSFERÊNCIA</code> que queremos alterar. Veja que ele irá alterar as informações do registro conforme as informações do objeto pelo <code>Id</code> desse objeto.
* '''DELETE''': O método <code>Delete</code>, exclui o registro com o <code>Id</code> passado como parâmetro.

<syntaxhighlight lang=go>
package main

import "fmt"

type UserDAO struct {
	db    *Database
	users []*User
}

func NewUserDAO(db *Database) *UserDAO {
	userdao := new(UserDAO)
	userdao.db = db
	userdao.users = make([]*User, 0)
	return userdao
}

func (userdao *UserDAO) GetAll() []*User {
	userdao.users = make([]*User, 0)
	db := userdao.db.Get()
	rows, err := db.Query("select * from users")
	if err != nil {
		fmt.Println(err.Error())
	}
	for rows.Next() {
		var id int
		var name string
		var email string
		rows.Scan(&id, &name, &email)
		userdao.users = append(userdao.users, NewUser(id, name, email))
	}
	return userdao.users
}

func (userdao *UserDAO) Insert(user *User) {
	db := userdao.db.Get()
	query := "insert into users (id, name, email) values ($1, $2, $3)"
	_, err := db.Query(query, user.Id, user.Name, user.Email)
	if err != nil {
		fmt.Println(err.Error())
	}
}

func (userdao *UserDAO) Get(id string) *User {
	db := userdao.db.Get()
	query := "select * from users where id=$1"
	rows, err := db.Query(query, id)
	if err != nil {
		fmt.Println(err.Error())
	}
	if rows.Next() {
		var id int
		var name string
		var email string
		rows.Scan(&id, &name, &email)
		return NewUser(id, name, email)
	}
	return nil
}

func (userdao *UserDAO) Update(user *User) string {
	db := userdao.db.Get()
	query := "update users set name=$2, email=$3 where id=$1"
	_, err := db.Query(query, user.Id, user.Name, user.Email)
	if err != nil {
		fmt.Println(err.Error())
		return err.Error()
	}
	return "ok"
}

func (userdao *UserDAO) Delete(id string) string {
	db := userdao.db.Get()
	query := "delete from users where id=$1"
	_, err := db.Query(query, id)
	if err != nil {
		fmt.Println(err.Error())
		return err.Error()
	}
	return "ok"
}
</syntaxhighlight>

= main.go =

Finalmente temos agora nosso <code>main</code>. Esse arquivo é o ''daemon'' da nossa aplicação, que, conforme já vimos, irá ficar ouvindo uma porta para receber, tratar e responder às requisições dos clientes.

O que temos de diferente dos exemplos anteriores é que agora, ao invés de alterarmos uma variável ou array ou objeto na memória, estamos usando o <code>DAO</code> para fazer o '''CRUD''' na nossa base de dados.

Outra coisa é que precisamos configurar as mensagens de retorno. Isso porque:
* Precisamos informar ao cliente que tipo de dados estamos enviando;
* Precisamos informar ao '''CORS''' que estamos liberando algumas coisas.

Por exemplo, em todas as funções que tratam as operações do serviço web, informamos que estamos enviando dados no formato JSON e estamos permitindo que a origem do serviço web possa ser em qualquer lugar (asterisco). Na verdade, aqui estamos contornando uma questão de segurança porque muitas vezes estamos desenvolvendo o serviço e o cliente (''full stack'') no nosso próprio computador, então precisamos testar as coisas. Para fazer o ''deployment'' da aplicação real, é melhor pensar na segurança e retringir coisas.

<syntaxhighlight lang=go>
w.Header().Set("Content-Type", "application/json;charset=UTF-8")
w.Header().Set("Access-Control-Allow-Origin", "*")
</syntaxhighlight>

Outra coisa que adicionamos aqui, é o tratamento do método <code>OPTIONS</code> sem e com parâmetro. Nele, adicionamos as seguintes configurações:

<syntaxhighlight lang=go>
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS, PUT, PATCH, DELETE")
w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
</syntaxhighlight>

em que, além das duas configurações dos outros métodos, colocamos mais duas para informar as operações que o servidor permite e que tipo de conteúdos também.

Esse método é importante porque o '''CORS''', antes de requisitar operações como <code>DELETE</code> e PUT, por exemplo, envia uma requisição <code>OPTIONS</code> para verificar o que pode fazer no servidor. Se não tiver as informações de autorização, o CORS já retorna o erro na requisição e não efetua os métodos.

<syntaxhighlight lang=go>
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	db := NewDatabase("localhost", "postgres", "backendcrud", "saulo", "1234")
	defer db.Close()
	dao := NewUserDAO(db)

	router := http.NewServeMux()

	router.HandleFunc("POST /users", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		w.Header().Set("Access-Control-Allow-Origin", "*")
		var user User
		err := json.NewDecoder(r.Body).Decode(&user)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		dao.Insert(NewUser(user.Id, user.Name, user.Email))
	})

	router.HandleFunc("GET /users", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		w.Header().Set("Access-Control-Allow-Origin", "*")
		users := dao.GetAll()
		json.NewEncoder(w).Encode(users)
	})

	router.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		w.Header().Set("Access-Control-Allow-Origin", "*")
		id := r.PathValue("id")
		user := dao.Get(id)
		json.NewEncoder(w).Encode(user)
	})

	router.HandleFunc("PUT /users", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		w.Header().Set("Access-Control-Allow-Origin", "*")
		var user User
		err := json.NewDecoder(r.Body).Decode(&user)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		out := dao.Update(NewUser(user.Id, user.Name, user.Email))
		json.NewEncoder(w).Encode(out)
	})

	router.HandleFunc("DELETE /users/{id}", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		w.Header().Set("Access-Control-Allow-Origin", "*")
		id := r.PathValue("id")
		out := dao.Delete(id)
		json.NewEncoder(w).Encode(out)
	})

	// Vamos precisar do OPTIONS porque o PUT primeiro manda um OPTION
	// Assim, se for localhost, avisamos o CORS que permitimos local
	router.HandleFunc("OPTIONS /users", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		w.Header().Set("Access-Control-Allow-Origin", "*")
		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS, PUT, PATCH, DELETE")
		w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
	})

	// O DELETE também chama o OPTIONS, mas envia também uma informação
	router.HandleFunc("OPTIONS /users/{id}", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		w.Header().Set("Access-Control-Allow-Origin", "*")
		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS, PUT, PATCH, DELETE")
		w.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
	})

	err := http.ListenAndServe("localhost:8080", router)
	if err != nil {
		fmt.Println(err.Error())
	}
}
</syntaxhighlight>

== Alternativa ==
Uma forma alternativa é usar a biblioteca cors como usamos nos outros exemplos. Dessa forma não precisamos controlar o OPTIONS manualmente.<syntaxhighlight lang="go">
package main

import (
	"encoding/json"
	"fmt"
	"net/http"

	"github.com/rs/cors"
)

func main() {
	db := NewDatabase("localhost", "postgres", "backendcrud", "saulo", "1234")
	defer db.Close()
	dao := NewUserDAO(db)

	router := http.NewServeMux()

	router.HandleFunc("POST /users", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		var user User
		err := json.NewDecoder(r.Body).Decode(&user)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		dao.Insert(NewUser(user.Id, user.Name, user.Email))
	})

	router.HandleFunc("GET /users", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		users := dao.GetAll()
		json.NewEncoder(w).Encode(users)
	})

	router.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		id := r.PathValue("id")
		user := dao.Get(id)
		json.NewEncoder(w).Encode(user)
	})

	router.HandleFunc("PUT /users", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		var user User
		err := json.NewDecoder(r.Body).Decode(&user)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		out := dao.Update(NewUser(user.Id, user.Name, user.Email))
		json.NewEncoder(w).Encode(out)
	})

	router.HandleFunc("DELETE /users/{id}", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
		id := r.PathValue("id")
		out := dao.Delete(id)
		json.NewEncoder(w).Encode(out)
	})

	c := cors.AllowAll()
	r := c.Handler(router)

	err := http.ListenAndServe("localhost:8080", r)
	if err != nil {
		fmt.Println(err.Error())
	}
}
</syntaxhighlight>

= Criação do Projeto =

Antes de mais nada, precisamos instalar o Go. Para isso, siga as indicações em: [[Go: Instalação e Configuração]]

Primeiro precisamos criar nossa base de dados no postgres. É importante que o usuário tenha permissão de criação de databases.

 $ createdb backendcrud
 $ psql backendcrud
 backendcrud=> create table users (id integer not null, name varchar(50) not null, email varchar(50) not null, primary key (id));
 backendcrud=> \q

Depois criamos nosso projeto no Go. Lembre-se de colocar em uma subpasta dentro de algo como '''aulas.com''' dentro da subpasta '''src''' do GOPATH. Por exemplo:

 /home/saulo/goprojects/src/aulas.com

sendo que nosso <code>GOPATH</code> seria <code>/home/saulo/goprojects</code>

Depois disso, dentro do local especificado, digitar os comandos para a criação do projeto.

 $ mkdir backendcrud
 $ cd backendcrud
 $ go mod init

Depois de criado o projeto, vamos adicionar a biblioteca para usar o postgres.

 go get github.com/lib/pq

Colocamos então todos os arquivos fonte que mostramos aqui, configuramos, compilamos e rodamos nosso serviço web:

 $ go mod tidy
 $ go build
 $ ./backendcrud

Como aqui estou no linux, a chamada da aplicação foi assim. No windows, basta chamar o arquivo backendcrud.exe criado durante a compilação.
go mod tidy

= Manual de Utilização =

Diferente do padrão <code>[https://pt.wikipedia.org/wiki/SOAP SOAP]</code>, não temos instruções como usar nosso serviço web no próprio serviço, então, ao usar Rest, precisamos informar aos usuários do serviço como o mesmo pode ser utilizado. Segue então nosso breve manual:

;Dados do cadastro de usuários

 Id - inteiro
 Name - string
 email - string

;Listar usuários

 GET /users

;Retornar informações de um usuário pelo ID

 GET /users/ID

;Enviar informações de um novo usuário para armazenar remotamente

 POST /users

Conteúdo JSON do corpo da mensagem (exemplo)

<syntaxhighlight lang=json>
{
   "id": 123,
   "name": "Misato",
   "email": "misato@tokyo3.jp"
}
</syntaxhighlight>

;Alterar informações

 PUT /users

Conteúdo JSON do corpo da mensagem (exemplo)

<syntaxhighlight lang=json>
{
   "id": 123,
   "name": "Katsuragi Misato",
   "email": "misato@tokyo3.com.jp"
}
</syntaxhighlight>

Veja que o Id deve existir para poder alterar

;Excluir um registro

Precisa passar o id do registro que se quer excluir

 DELETE /users/ID