Go este un limbaj de programare open source dezvoltat la Google și conceput pentru a ajuta la crearea unor sisteme simple de software fiabile. Puterea nucleului Go este mecanismele sale concurente care simplifică scrierea de software, exploatarea arhitecturilor multi-core.

Este un limbaj compilat, puternic compozit, concurent și cu gunoi.

Este o limbă foarte interesantă și modernă, datorită unor alegeri care au fost făcute în timpul designului. De exemplu, sistemul de tip, deși Go are metode și un stil de programare OO, nu există o ierarhie de tip. Singura modalitate de a realiza acest lucru este prin interfețe.

Cum merg diferiți de la alții

Trebuie să citiți specificația de limbă pentru a înțelege mai bine elementele de design ale limbii. Este într-adevăr concis și ajută să aducă niște detalii interesante. Modul Go diferă de alte limbi de programare tipice, este că are caracteristici diferite de alte limbi OO:

• Nicio moștenire de tip
• Nu se supraîncarcă metodele și operatorii
• Construite în primitive de concurrency, care o fac într-adevăr să iasă din mulțime. Își împărtășește memoria comunicând și nu invers.
• Un lanț de instrumente care utilizează un model tradițional de compilare și de legare pentru a genera binare fără dependențe externe.
• Hărțile sunt construite în.

Organizarea codului

Codul Go este păstrat sub spații de lucru. Este doar o ierarhie de directoare, după cum urmează:

• src - conține fișiere sursă Go ca pachete
• PKG - conține obiecte pachet
• cos - conține executabile

Instrumentul Go construiește pachetele sursă și instalează binarele rezultate în cos și PKG directoare.

O aplicație Web simplă utilizând Go

Să construim un site static și apoi să îl îmbunătățim astfel încât acesta să se comporte mult mai dinamic, pe baza datelor introduse de utilizator.

Site-ul static

Structura codului pentru site-ul static arată astfel:

Deci, în mod esențial, ați dori să creați o structură asemănătoare imaginii de mai sus sau așa cum este prezentată în depozit. Această structură de repo va fi ea însăși sub spațiu de lucru . Citiți despre Structura codului Go pentru mai multe informații.

Acum, ceea ce dorim să facem este să difuzați un fișier HTML rezident în directorul public.

index.html conținutul este după cum urmează:

       
Dezvoltarea site-ului utilizând Go
 
Sunt o pagină statică, fiind servită pentru tine cu ajutorul lui Go lang.
   

Iată programul Go pentru a servi fișierele static din folderul public:

pachetul principal de import ("net / http") func principal () fs: = http.FileServer (http.Dir ("public")) http.ListenAndServe (": 8080")

Permiteți-mi să explic:

• net / http - acest pachet oferă implementări client și server HTTP.
• FileServer - această funcție returnează un handler care servește cererilor HTTP cu conținutul sistemului de fișiere.

Asta e. Foarte simplu și la punct. Puteți rula codul folosind următoarele: du-te run gostatic.go.

O soluție mai bună

Cu toate acestea, această soluție nu separă în mod clar preocupările de rutare și de servire și, prin urmare, o soluție mai bună ar fi în concordanță cu:

pachetul principal de import ("net / http" "log") func main () fs: = http.FileServer (http.Dir ("public")) http.Handle (" ... ") err: = http.ListenAndServe (": 8080 ", nul) dacă err! = Nil log.Fatal (" ListenAndServe: ", err) 

ListenAndServe pornește un server HTTP pe adresa TCP dată și apoi apelează Servi cu un handler. Acest handler este tipic zero, astfel încât routerul implicit (în Go's case DefaultServerMux poate prelua).

Acum, în ceea ce privește DefaultServeMux - Să facem un ocol scurt pentru a înțelege modul în care Go procesează HTTP. Ea face acest lucru cu ajutorul a două lucruri primare.

• ServerMuxes - (Router) Este un multiplexor - în esență un router HTTP, care compară cererile primite împotriva listei definite și apoi îl apelează pe handler asociat.
• Handlere - Acestea sunt responsabile de "manipularea" solicitării, cum ar fi răspunsul la anteturile corespunzătoare, corp etc. Orice obiect supus interfeței Handler poate acționa ca unul.

Mergeți mai departe și rulați aplicația web exemplu așa cum ați făcut mai devreme și ar trebui să vedeți ieșirea!

Site-uri dinamice - Adăugarea unui marcaj de timp la fiecare actualizare

Apoi, scrieți aplicația astfel încât să imprime ora curentă, ceea ce înseamnă că la fiecare reîmprospătare obțineți o ieșire diferită. Codul Go ar arăta astfel:

pachetul principal de import ("fmt" "net / http" "timpul") func main () http.HandleFunc ("/", handler) log.Printin ("ascultare ...") err: = http.ListenAndServe ", nil) dacă err! = nil panic (err) func handler (w http.ResponseWriter, r * http.Request) fmt.Fprintf (w," Hello. ) .Format (timp.RFC850)) 

Aici am importat FMT pentru a lucra cu unele funcții de imprimare. Funcția fmt implementează funcțiile I / O formatate pe liniile lui C stdio bibliotecă.

De asemenea, am făcut uz de HandleFunc care înregistrează calea URL cu funcția de manipulare în DefaultServeMux. Funcționatorul de funcții este de tip http.HandlerFunc. Este nevoie de un http.ResponseWriter și http.Request ca argumente. Oamenii familiarizați cu servlets Java ar aminti să facă acest lucru!

Pentru a imprima timpul, vom importa "timpul" din pachetul standard și îl vom folosi pentru a răspunde înapoi la obiectul scriitorului de răspuns. Prin scrierea la http.ResponseWriter obiect putem trimite răspunsul clientului.

http.Request este structura care reprezintă solicitarea HTTP și, prin urmare, are toate datele solicitate. Pentru a accesa calea de URL pe care o facem r.URL.path.

Când rulați acest lucru și apoi accesați localhost: 8080 ar trebui să vedeți ora curentă la fiecare actualizare.

Acceptarea intrării de utilizator

Acum, să scriem o aplicație care acceptă a nume de utilizator pe pagina de index și atunci când formularul este trimis, îl întâmpină pe utilizator pe pagina următoare.

Iată structura codului Go:

Mai întâi creați un fișier HTML care conține formularul din directorul public.

       
Du-te la Greeter
 
   
   

Acest formular, la trimitere, va redirecționa către / salut. Să scriem, de asemenea, conținutul greet.html fișier în interiorul directorului public, pe care l-am face atunci când cererea vine / salut.

       
Salut .
   

Codul Go este următorul:

pachetul principal de import ("log" "net / http" "html / template") func main () http.HandleFunc ("/", root) http.HandleFunc (" ... ") err: = http.ListenAndServe (": 8080 ", nil) dacă 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 (" numele de utilizator) t, _: = template.ParseFiles ("public / greeter.html") err: = t.Execute (w, username) .StatusInternalServerError) 

Am folosit-o html / șablon să păstrați codul HTML în șabloane și apoi să le folosiți pentru a le oferi, la cerere.

Există un aspect curios . în greeter.html fişier. html / șablon pachetul presupune că textul simplu este întotdeauna produs. Se adaugă scăparea ori de câte ori este necesar pentru a încorpora în siguranță acest șir simplu în context corect. Atunci când o valoare a datelor nu este un text simplu, putem să ne asigurăm că nu va scăpa prin specificarea tipului. Atât de esențial, Hei, .! pot fi invocate prin utilizarea tmpl.Execute (out, HTML ('Nishant„)) a produce Hei, Nishant!. Dă-i drumul, încearcă asta!

Deoarece aplicația de bază funcționează acum, putem să o implementăm în cele din urmă la Heroku.

Deplasarea la Heroku

Odată ce ai Heroku-pentru bara de instrumente configurarea corectă și gestionarea repo prin Git, o putem implementa pe aceste linii.

Singura schimbare pe care ar trebui să o facem în codul de implementare a lui Heroku este schimbarea liniei în care ne aflăm asculta pe un anumit port.

Schimbare:

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

la:

http.ListenAndServe ( ":" + os.Getenv ( "port"), ... .

Setarea Heroku

Pentru a vă deplasa la Heroku, veți avea nevoie de un cont de utilizator Heroku. Veți avea nevoie și de un client de linie de comandă Heroku. Obțineți-o instalând Heroku Toolbelt dacă nu deja.

Odată instalat, conectați-vă folosind contul Heroku spunând autentificare heroku, apoi încărcați cheia SSH. Cu aceste lucruri în loc, ar trebui să fii gata să te duci la Heroku.

Implementarea aplicației

Pentru a fi implementat la Heroku, avem nevoie ca aplicația să fie stocată în Git.

git init. git adăugați -A. git comită -m 'primul heroku go app' 

Vom avea de asemenea nevoie de un Procfile pentru a spune lui Heroku că comanda pe care trebuie să o execute pentru procesul web este aplicația noastră.

ecou 'web: gogreeter'> Procfile

Go dependentele de pachete sunt gestionate pe Heroku cu ajutorul lui Godep pachete.

Instalați Godep și salvați dependențele utilizând următoarele:

accesați github.com/kr/godep godep salvați 

Adăugați aceste fișiere noi în Git:

git adăugați -A. git commit -m 'godep' 

În cele din urmă, creați aplicația Heroku. Se poate face așa:

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

Aceasta ar trebui să creeze o distanță Git în depozitul dvs. cu numele de Heroku. Sunteți gata să desfășurați acum! Rulați următoarele:

git push master heroku

După terminarea comenzii de mai sus, aplicația trebuie să funcționeze!

Mergeți să vizitați adresa URL spunând heroku deschis sau vizitând direct adresa URL a aplicației pe care o vedeți în consola.

Asta e. Acum aveți o aplicație Go, care rulează pe Heroku!

rezumat

În acest tutorial am învățat cât de ușor este să dezvolți o aplicație web Go și să o implementați și pe Heroku. Aceste zile, dezvoltarea web depinde în mare măsură de cadrele folosite. Pentru a explora unele dintre aceste opțiuni, ar trebui să verificați cu siguranță unele dintre aceste proiecte.

• Hugo
• Martini
• Revel
• Galeria de instrumente Gorilla
• Hastie - Site generator static în Go