Incominciamo instanziando il server e implementando un servizio di keepalive che serve a stabilire se il server è attivo regolarmente.

http.HandleFunc("/isAlive", isAlive)
	log.Fatal(http.ListenAndServe(":10000", nil))

La funzione HandleFunc definisce il path e il relativo handler. Per handler si intende la funzione che verrà eseguita dal server in corrispondenza della richiesta riceveuta.

func isAlive(response http.ResponseWriter, request *http.Request) {
	fmt.Fprintf(response, "alive")
}

Se abbiamo fatto tutto bene invocando il servizio http://localhost:10000/isAlive riceveremo un 200 ok con testo alive.

A questo punto supponiamo di voler gestire una rubrica dei contatti e pertanto definiamo prima di tutto la nostra struct Contatto

type contatto struct {
	Nome    string `json:"Nome"`
	Cognome string `json:"Cognome"`
}

La struct presenta 2 parametri Nome e Cognome e relative regole di trascodifica in json. Definiamo l’elenco dei contatti e lo inizializziamo con dei dati di prova, simulando la presenza di un database

var contatti []contatto
func main() {

	contatti = []contatto{
		contatto{Nome: "nome 1", Cognome: "Cognome 1"},
		contatto{Nome: "nome 2", Cognome: "Cognome 2"},
	}

Infine definiamo l’handler relativo

func elencoContatti(response http.ResponseWriter, request *http.Request) {
	json.NewEncoder(response).Encode(contatti)
}

func main() {
        http.HandleFunc("/contatti", elencoContatti)
}

In tal modo invocando l’url http://localhost:10000/contatti otterremo il seguente json [{“Nome”:”nome 1″,”Cognome”:”Cognome 1″},{“Nome”:”nome 2″,”Cognome”:”Cognome 2″}]

Di seguito il codice completo

package main

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

type contatto struct {
	Nome    string `json:"Nome"`
	Cognome string `json:"Cognome"`
}

func isAlive(response http.ResponseWriter, request *http.Request) {
	fmt.Fprintf(response, "alive")
}

func elencoContatti(response http.ResponseWriter, request *http.Request) {
	json.NewEncoder(response).Encode(contatti)
}

var contatti []contatto

func main() {

	contatti = []contatto{
		contatto{Nome: "nome 1", Cognome: "Cognome 1"},
		contatto{Nome: "nome 2", Cognome: "Cognome 2"},
	}

	fmt.Println("Http server up ")
	http.HandleFunc("/isAlive", isAlive)
	http.HandleFunc("/contatti", elencoContatti)

	log.Fatal(http.ListenAndServe(":10000", nil))
}

Il package http ci ha consentito di tirare su il server e configurare delle risposte su dei path statici. Il package ha dei limiti, non ci permette di configurare degli endpoint variabili ed esplicitare il metodo http supportato. Per superare questo limite ci viene in soccorso un nuovo package “github.com/gorilla/mux”. Il package va installato con il comando

go get -u github.com/gorilla/mux

A questo per tirare su il server e configurare opportunamente gli endpoint possiamo scrivere

myRouter := mux.NewRouter().StrictSlash(true)
	myRouter.HandleFunc("/isAlive", isAlive).Methods("GET")
	myRouter.HandleFunc("/contatti", elencoContatti).Methods("GET")
	myRouter.HandleFunc("/contatti/{id}", singoloContatto).Methods("GET")
	myRouter.HandleFunc("/contatti", creaContatto).Methods("POST")
	myRouter.HandleFunc("/contatti/{id}", eliminaContatto).Methods("DELETE")
	log.Fatal(http.ListenAndServe(":10000", myRouter))

Il packge ci mette a disposizione l’oggetto router che consente per ogni handler di definire maggiori proprietà per meglio mappare il comportamento

func singoloContatto(response http.ResponseWriter, request *http.Request) {
	vars := mux.Vars(request)
	key := vars["id"]
	for index, contatto := range contatti {
		fmt.Println(index, " ", key)
		i, _ := strconv.Atoi(key)
		if index == i {
			json.NewEncoder(response).Encode(contatto)
			return
		}
	}
	response.WriteHeader(http.StatusNotFound)
}

Il package ci consente agevolmente di leggere le path variable e superare i limiti del package net/http.

Di seguito il codice completo per l’analisi dei metodi restanti

package main

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

	"github.com/gorilla/mux"
)

type contatto struct {
	Nome    string `json:"Nome"`
	Cognome string `json:"Cognome"`
}

func isAlive(response http.ResponseWriter, request *http.Request) {
	fmt.Fprintf(response, "alive")
}

func elencoContatti(response http.ResponseWriter, request *http.Request) {
	json.NewEncoder(response).Encode(contatti)
}

func creaContatto(response http.ResponseWriter, request *http.Request) {
	var contatto contatto
	json.NewDecoder(request.Body).Decode(&contatto)
	contatti = append(contatti, contatto)
	json.NewEncoder(response).Encode(contatti)
}

func singoloContatto(response http.ResponseWriter, request *http.Request) {
	vars := mux.Vars(request)
	key := vars["id"]
	for index, contatto := range contatti {
		fmt.Println(index, " ", key)
		i, _ := strconv.Atoi(key)
		if index == i {
			json.NewEncoder(response).Encode(contatto)
			return
		}
	}
	response.WriteHeader(http.StatusNotFound)
}

func eliminaContatto(response http.ResponseWriter, request *http.Request) {
	vars := mux.Vars(request)
	key := vars["id"]
	for index := range contatti {
		fmt.Println(index, " ", key)
		i, _ := strconv.Atoi(key)
		if index == i {
			contatti = append(contatti[:index], contatti[index+1:]...)
			response.WriteHeader(http.StatusOK)
			return
		}
	}
	response.WriteHeader(http.StatusNotFound)
}

var contatti []contatto

func main() {

	contatti = []contatto{
		contatto{Nome: "nome 1", Cognome: "Cognome 1"},
		contatto{Nome: "nome 2", Cognome: "Cognome 2"},
	}

	fmt.Println("Http server up ")
	//http.HandleFunc("/isAlive", isAlive)
	//http.HandleFunc("/contatti", elencoContatti)

	myRouter := mux.NewRouter().StrictSlash(true)
	myRouter.HandleFunc("/isAlive", isAlive).Methods("GET")
	myRouter.HandleFunc("/contatti", elencoContatti).Methods("GET")
	myRouter.HandleFunc("/contatti/{id}", singoloContatto).Methods("GET")
	myRouter.HandleFunc("/contatti", creaContatto).Methods("POST")
	myRouter.HandleFunc("/contatti/{id}", eliminaContatto).Methods("DELETE")
	log.Fatal(http.ListenAndServe(":10000", myRouter))
}

Alla prossima