Per effettuare una GET si usa la funzione get, che restituisce un oggetto Response e un oggetto Error.

response, err := http.Get("http://www.google.it")
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()
	fmt.Println("Response status:", response.Status)
	body, err := ioutil.ReadAll(response.Body)
	fmt.Println("Response body:", string(body))

Nell’esempio sto invocando la homepage di google, e verifico la presenza di errore e il codice restituito dalla risposta. Successivamente tramite il package ioutil recupero il body della response e lo stampo a video.

Se invece volessi inviare una post Golang mette a disposizione 2 funzioni: post e postForm.

La funzione post riceve in ingresso l’url cui inviare la post, il content type del dato che sto inviando e un reader del package io

response, err = http.Post("http://www.google.it", "image/jpeg", bytes.NewBufferString("prova"))
	if err != nil {
		panic(err)
	}
	fmt.Println("Response status:", response.Status)

La funzione postForm invece riceve in ingresso l’url cui inviare la post e il form dei dati chiave, valore

Le 3 funzioni consentono di inviare get e post, ma qualora volessi usare altri metodi come la put o la delete occorre usare il metodo addNewRequest per creare una request e usare il client http per inviare la richiesta.

request, err := http.NewRequest(http.MethodDelete, "http://www.google.it", bytes.NewBufferString("prova"))
	if err != nil {
		panic(err)
	}
	client := &http.Client{}
	response, err = client.Do(request)
	if err != nil {
		panic(err)
	}
	fmt.Println("Response status:", response.Status)

Per gestire le caratteristiche avanzate delle connessioni Go mette a disposizione l’oggetto Transport che opportunamente configurato consente di definire un proxy per l’invocazione del servizio. Questo caso si presenta quando il nostro client è presente all’interno di una rete il cui accesso ad internet è veicolato dalla presenza di un proxy.

proxyUrl, err := url.Parse("http://user:password@127.0.0.1:3128")
	if err != nil {
		panic(err)
	}
	tr := &http.Transport{
		MaxIdleConns:       10,
		IdleConnTimeout:    30 * time.Second,
		DisableCompression: true,
		Proxy:              http.ProxyURL(proxyUrl),
	}
	client = &http.Client{Transport: tr}
	response, err = client.Do(request)
	if err != nil {
		panic(err)
	}
	fmt.Println("Response status:", response.Status)

Qualora invece il nostro server voglia un certificato occorre caricare il certificato e configurato sempre nel transport affinchè venga usato in trasmissione

caCert, err := ioutil.ReadFile("miocertificato.crt")
	if err != nil {
		log.Fatal(err)
	}
	caCertPool := x509.NewCertPool()
	caCertPool.AppendCertsFromPEM(caCert)
	tr := &http.Transport{
		MaxIdleConns:       10,
		IdleConnTimeout:    30 * time.Second,
		DisableCompression: true,
		TLSClientConfig: &tls.Config{
			RootCAs: caCertPool,
		},
	}
	client = &http.Client{Transport: tr}

Nell’esempio sto leggendo il certificato e lo sto configurando all’interno del transport per poi fornirlo al client.

Abbiamo quindi visto come invocare i vari metodi e come gestire una rete con proxy e una connessione crittografata con invio del certificato.

Alla prossima