Go è un linguaggio di programmazione open source sviluppato su Google e progettato per aiutare a costruire semplici sistemi software affidabili. Il punto di forza di Go sono i meccanismi di concorrenza che rendono più semplice scrivere software, sfruttare architetture multi-core.

È un linguaggio compilato, fortemente staticamente digitato, concorrente e garbage-collected.

È una lingua molto interessante, moderna, a causa di alcune delle scelte che sono state fatte durante il suo design. Ad esempio, il sistema di tipi, sebbene Go abbia metodi e anche uno stile di programmazione OO, non esiste una gerarchia di tipi. L'unico modo per ottenere ciò è attraverso le interfacce.

Come va diverso dagli altri

Si dovrebbe leggere le specifiche del linguaggio per ottenere una migliore comprensione degli elementi di progettazione della lingua. È davvero conciso e aiuta a far emergere alcuni dettagli davvero interessanti. Il modo in cui Go si differenzia dagli altri linguaggi di programmazione tipici è che ha caratteristiche diverse da altre lingue OO:

• Nessuna ereditarietà del tipo
• Nessun sovraccarico di metodi e operatori
• Costruito in primitive di concorrenza, che lo rendono davvero distinguibile dalla massa. Condivide la memoria comunicando e non viceversa.
• Una toolchain che utilizza un modello tradizionale di compilazione e collegamento per generare binari senza dipendenze esterne.
• Le mappe sono integrate.

Organizzazione del codice

Il codice Go è tenuto sotto le aree di lavoro. È solo una gerarchia di directory, come segue:

• src - contiene i file di origine Go come pacchetti
• pkg - contiene oggetti pacchetto
• bidone - contiene eseguibili

Lo strumento Vai crea i pacchetti sorgente e installa i binari risultanti in bidone e pkg directory.

Un'applicazione Web semplice che utilizza Go

Costruiamo un sito statico e poi procediamo a migliorarlo in modo che si comporti in modo molto più dinamico, in base all'input dell'utente.

Il sito statico

La struttura del codice per il sito statico è così:

Quindi, in sostanza, si vorrebbe creare una struttura simile all'immagine sopra o come mostrato nel repository. Questa struttura repo si troverebbe a sua volta sotto il spazio di lavoro . Leggi la struttura Go Code per maggiori informazioni.

Ora quello che vogliamo fare è servire un file HTML che risiede nella directory pubblica.

Il index.html i contenuti sono i seguenti:

       
Sviluppo del sito web usando Go
 
Sono una pagina statica, che ti viene servita con l'aiuto di Go lang.
   

Ed ecco il programma Go per servire i file staticamente dalla cartella pubblica:

pacchetto main import ("net / http") func main () fs: = http.FileServer (http.Dir ("public")) http.ListenAndServe (": 8080", fs)

Consentitemi di spiegare:

• net / http - questo pacchetto fornisce implementazioni client e server HTTP.
• FileServer: questa funzione restituisce un gestore che serve le richieste HTTP con i contenuti del file system.

Questo è tutto. Davvero semplice e al punto. È possibile eseguire il codice utilizzando quanto segue: vai a correre a gostatic.go.

Una soluzione migliore

Tuttavia, questa soluzione non separa chiaramente il routing e le preoccupazioni di servizio e, quindi, una soluzione migliore sarebbe sulla falsariga di:

pacchetto main import ("net / http" "log") func main () fs: = http.FileServer (http.Dir ("public")) http.Handle ("/", fs) log.Println ("Ascolto ... ") err: = http.ListenAndServe (": 8080 ", nil) se err! = Nil log.Fatal (" ListenAndServe: ", err) 

ListenAndServe avvia un server HTTP sull'indirizzo TCP specificato e quindi chiama Serve con un gestore. Questo gestore è in genere nullo, quindi il router predefinito (nel caso di Go il DefaultServerMux può subentrare).

Ora per quanto riguarda DefaultServeMux - Facciamo una breve deviazione per capire come Go esegue l'elaborazione HTTP. Lo fa con l'aiuto di due cose primarie.

• ServerMuxes - (Router) È un multiplexer - essenzialmente un router HTTP, che confronta le richieste in arrivo con l'elenco definito e quindi chiama il gestore associato.
• handlers - Questi sono responsabili della "gestione" della richiesta, come rispondere con le intestazioni, il corpo, ecc. Appropriati. Qualsiasi oggetto che obbedisce all'interfaccia del Gestore può agire come un unico.

Vai avanti ed esegui l'app web di esempio come fatto prima e dovresti vedere l'output!

Siti dinamici - Aggiunta di un Timestamp su ogni aggiornamento

Successivamente, scriviamo l'applicazione in modo che stampi l'ora corrente, implicando che ad ogni aggiornamento si ottiene un risultato diverso. Il codice Go dovrebbe essere così:

pacchetto main import ("fmt" "net / http" "time") func main () http.HandleFunc ("/", gestore) log.Println ("listening ...") err: = http.ListenAndServe (": 8080 ", nil) se err! = nil panic (err) gestore di func (w http.ResponseWriter, r * http.Request) fmt.Fprintf (w," Ciao. Il tempo è: "+ time.Now ( ) .Format (time.RFC850)) 

Qui abbiamo importato FMT lavorare con alcune funzioni di stampa. Il fmt implementa le funzioni di I / O formattate lungo le linee di C stdio biblioteca.

Abbiamo anche fatto uso di HandleFunc che registra il percorso dell'URL con la funzione di gestore nel file DefaultServeMux. Il gestore di funzioni è del tipo http.HandlerFunc. Ci vuole un http.ResponseWriter e http.Request come i suoi argomenti. Le persone che hanno familiarità con i servlet Java ricorderebbero di averlo fatto!

Per stampare il tempo, importiamo il "tempo" dal pacchetto standard e lo usiamo per rispondere all'oggetto del writer di risposta. Scrivendo a http.ResponseWriter oggetto possiamo inviare la risposta al cliente.

http.Request è la struttura che rappresenta la richiesta HTTP e quindi ha i dati dell'intera richiesta. Per accedere al percorso dell'URL che facciamo r.URL.path.

Quando si esegue questo e poi l'accesso localhost: 8080 dovresti vedere l'ora corrente ad ogni aggiornamento.

Accettare l'input dell'utente

Ora scriviamo un'applicazione che accetta un nome utente nella pagina indice e quindi quando il modulo viene inviato, saluta l'utente nella pagina successiva.

Ecco la nostra struttura del codice Go:

Innanzitutto creiamo un file HTML contenente il modulo all'interno della directory pubblica.

       
Vai Greeter
 
   
   

Questo modulo, su submit, reindirizzerà a /salutare. Scriviamo anche i contenuti del greet.html file all'interno della directory pubblica, che verrebbe visualizzato quando arriva la richiesta /salutare.

       
Ciao .
   

Il codice Go è il seguente:

pacchetto main import ("log" "net / http" "html / template") func main () http.HandleFunc ("/", root) http.HandleFunc ("/ greet", greeter) log.Println ("Ascolto ... ") err: = http.ListenAndServe (": 8080 ", nil) se err! = Nil log.Fatal (" ListenAndServe: ", err) func root (w http.ResponseWriter, r * http.Request) t, _: = template.ParseFiles ("public / index.html") t.Execute (w, nil) func greeter (w http.ResponseWriter, r * http.Request) username: = r.FormValue (" username ") t, _: = template.ParseFiles (" public / greeter.html ") err: = t.Execute (w, username) se err! = nil http.Error (w, err.error (), http .StatusInternalServerError) 

Noi abbiamo usato html / template per mantenere il codice HTML nei modelli e quindi utilizzarli per il rendering, su richiesta.

C'è un aspetto curioso . nel greeter.html file. Il html / template il pacchetto presuppone che venga sempre prodotto un testo semplice. Aggiunge escaping ovunque sia necessario per incorporare in modo sicuro quella stringa semplice nel contesto corretto. Quando un valore di dati non è un testo semplice, possiamo assicurarci che non sia sfuggito specificandone il tipo. Quindi essenzialmente, Hey, .! può essere invocato usando tmpl.Execute (out, HTML ('Nishant')) produrre Hey, Nishant!. Vai avanti, prova!

Poiché l'applicazione di base ora funziona, possiamo finalmente distribuirla su Heroku.

Distribuzione a Heroku

Una volta che hai il Heroku-toolbelt configurazione corretta e il repository gestito tramite Git, possiamo distribuirlo seguendo queste linee.

L'unico cambiamento che dovremmo fare nel codice per la distribuzione in Heroku, è cambiare la linea in cui siamo noi ascolta su una porta specifica.

Modificare:

 http.ListenAndServe (": 8080", ...) 

a:

http.ListenAndServe ( ":" + os.getenv ( "porto"), ... .

Installazione di Heroku

Per dispiegare su Heroku, avrai bisogno di un account utente Heroku. Avrai anche bisogno di un client da riga di comando Heroku. Scaricalo installando il Heroku Toolbelt se non lo è già.

Una volta installato, accedi usando l'account Heroku dicendo login heroku, e quindi caricare la chiave SSH. Con queste cose a posto, dovresti essere pronto a schierarti su Heroku.

Distribuzione dell'applicazione

Per poter essere distribuiti su Heroku, abbiamo bisogno che l'app sia archiviata in Git.

git init. git add -A. git commit -m 'first heroku go app' 

Avremo anche bisogno di un Procfile per dire a Heroku che il comando che deve eseguire per il processo web è la nostra app.

echo 'web: gogreeter'> Procfile

Le dipendenze del pacchetto Go sono gestite su Heroku con l'aiuto di Godep pacchi.

Installa Godep e salva le tue dipendenze usando quanto segue:

vai a get github.com/kr/godep godep save 

Aggiungi questi nuovi file a Git:

git add -A. git commit -m 'godep' 

Infine, crea l'applicazione Heroku. Può essere fatto in questo modo:

heroku crea -b https://github.com/kr/heroku-buildpack-go.git 

Questo dovrebbe creare un telecomando Git nel tuo repository con il nome di Heroku. Sei pronto per la distribuzione ora! Esegui il seguente:

git push heroku master

Una volta completato il comando precedente, l'app dovrebbe essere attiva e funzionante!

Vai a visitare l'URL dicendo heroku aperto oppure visitando direttamente l'URL dell'app che vedi nella console.

Questo è tutto. Ora hai un'applicazione Go attiva e funzionante su Heroku!

Sommario

In questo tutorial abbiamo appreso quanto sia facile sviluppare un'applicazione web Go e distribuirla su Heroku. Al giorno d'oggi lo sviluppo del web dipende in gran parte dalle strutture che si usano. Per esplorare alcune di queste opzioni, è necessario verificare alcuni di questi progetti.

• Hugo
• Martini
• baldoria
• Gorilla web toolkit
• Hastie - Generatore di siti statici in Go