Go is een open source programmeertaal ontwikkeld door Google en ontworpen om te helpen bij het bouwen van eenvoudige, betrouwbare softwaresystemen. De kernkracht van Go is de gelijktijdigheidsmechanismen die het eenvoudiger maken om software te schrijven, om multi-core architecturen te gebruiken.

Het is een gecompileerde, sterk statisch getypeerde, gelijktijdige en vuilnisgezinde taal.

Het is een zeer interessante, moderne dagtaal vanwege een aantal van de keuzes die zijn gemaakt tijdens het ontwerp. Bijvoorbeeld, het Type Systeem, hoewel Go methoden heeft en ook een OO-stijl van programmeren, is er geen typehiërarchie. De enige manier om dat te bereiken is via interfaces.

Hoe gaat het anders dan anderen

Men moet de taalspecificatie lezen om een ​​beter begrip te krijgen van de ontwerpelementen van de taal. Het is echt beknopt en helpt een aantal echt interessante details naar voren brengen. De manier waarop Go verschilt van andere typische programmeertalen, is dat het functies heeft die anders zijn dan in andere OO-talen:

• Geen type-overerving
• Geen overbelasting van methoden en operators
• Gebouwd in concurrency-primitieven, waardoor het echt onderscheidt van de rest. Het deelt het geheugen door te communiceren en niet andersom.
• Een toolchain die een traditioneel model van compileren en koppelen gebruikt om binaries te genereren zonder externe afhankelijkheden.
• Kaarten zijn ingebouwd.

Code Organisatie

De Go-code wordt bewaard onder werkruimten. Het is gewoon een directoryhiërarchie, als volgt:

• src - bevat Go-bronbestanden als pakketten
• pkg - bevat pakketobjecten
• bak - bevat uitvoerbare bestanden

De Go-tool bouwt de bronpakketten en installeert de resulterende binaries in bak en pkg directories.

Een eenvoudige webapplicatie met Go

Laten we een statische site bouwen en deze vervolgens verbeteren zodat deze zich veel dynamischer gedraagt, op basis van gebruikersinvoer.

De statische site

De codestructuur voor de statische site ziet er als volgt uit:

Dus zou je in essentie een structuur willen maken die lijkt op de afbeelding hierboven of zoals wordt getoond in de repository. Deze repo-structuur zou zelf onder de werkruimte . Lees meer over de Go-codestructuur voor meer informatie.

Wat we nu willen doen is een HTML-bestand serveren dat zich in de openbare map bevindt.

De index.html inhoud is als volgt:

       
Website ontwikkelen met Go
 
Ik ben een statische pagina en wordt u aangeboden met de hulp van Go lang.
   

En hier is het Go-programma om bestanden statisch te bedienen vanuit de openbare map:

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

Staat u mij toe om uit te leggen:

• net / http - dit pakket biedt HTTP-client- en serverimplementaties.
• FileServer - deze functie retourneert een handler die HTTP-verzoeken dient met de inhoud van het bestandssysteem.

Dat is het. Echt eenvoudig en to the point. U kunt de code uitvoeren met behulp van het volgende: ga naar gostatic.go.

Een betere oplossing

Deze oplossing scheidt echter niet duidelijk de problemen met routing en serveren en daarom zou een betere oplossing zijn in de trant van:

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

ListenAndServe start een HTTP-server op het opgegeven TCP-adres en belt vervolgens met een handler. Deze handler is meestal nul, zodat de standaard router (in Go's geval de DefaultServerMux kan overnemen).

Nu met betrekking tot DefaultServeMux - Laten we een korte omweg maken om te begrijpen hoe Go de HTTP-verwerking uitvoert. Het doet dit met behulp van twee primaire dingen.

• ServerMuxes - (Router) Het is een multiplexer - in wezen een HTTP-router, die inkomende aanvragen vergelijkt met de gedefinieerde lijst en vervolgens de bijbehorende handler oproept.
• handlers - Deze zijn verantwoordelijk voor het 'afhandelen' van het verzoek, zoals reageren met de juiste headers, body etc. Elk object dat voldoet aan de Handler-interface kan als één handelen.

Ga je gang en voer de voorbeeldwebapp uit zoals eerder gedaan en je zou de uitvoer moeten zien!

Dynamische sites - Een tijdstempel toevoegen bij elke vernieuwing

Laten we vervolgens de applicatie schrijven zodat deze de huidige tijd afdrukt, wat impliceert dat bij elke vernieuwing u een andere output krijgt. De Go-code zou er zo uitzien:

pakket main import ("fmt" "net / http" "time") func main () http.HandleFunc ("/", handler) log.Println ("listening ...") err: = http.ListenAndServe (": 8080 ", nul) if fout! = nihil paniek (err) func-handler (w http.ResponseWriter, r * http.Request) fmt.Fprintf (w," Hallo. De tijd is: "+ time.Now ( ) .Format (time.RFC850)) 

Hier hebben we geïmporteerd fmt om met sommige afdrukfuncties te werken. De fmt implementeert geformatteerde I / O-functies in de trant van C's stdio bibliotheek.

We hebben ook gebruik gemaakt van HandleFunc die het URL-pad registreert met de handlerfunctie in de DefaultServeMux. De functiehandler is van het type http.HandlerFunc. Het kost een http.ResponseWriter en http.Request als zijn argumenten. Mensen die bekend zijn met Java-servlets, herinneren zich dit te doen!

Om tijd af te drukken, importeren we 'tijd' uit het standaardpakket en gebruiken we deze om te reageren op het antwoordschrijfobject. Door te schrijven naar http.ResponseWriter object kunnen we de reactie naar de klant sturen.

http.Request is de structuur die het HTTP-verzoek vertegenwoordigt en heeft daarom de volledige aanvraaggegevens. Om toegang te krijgen tot het URL-pad dat we hebben r.URL.path.

Wanneer u dit uitvoert en vervolgens toegang krijgt localhost: 8080 je zou de huidige tijd bij elke verversing moeten zien.

Gebruikersinvoer accepteren

Laten we nu een applicatie schrijven die a accepteert gebruikersnaam op de indexpagina en vervolgens wanneer het formulier wordt verzonden, wordt de gebruiker op de volgende pagina begroet.

Dit is onze Go-codestructuur:

Laten we eerst een HTML-bestand maken met het formulier in de openbare map.

       
Ga Greeter
 
   
   

Dit formulier, op verzenden, wordt omgeleid naar /begroeten. Laten we ook de inhoud van de greet.html bestand in de openbare map, die we zouden renderen wanneer het verzoek komt /begroeten.

       
Hallo .
   

De Go-code is als volgt:

pakket main import ("log" "net / http" "html / template") func main () http.HandleFunc ("/", root) http.HandleFunc ("/ greet", greeter) log.Println ("Luisteren ... ") err: = http.ListenAndServe (": 8080 ", nihil) if 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 (" gebruikersnaam ") t, _: = template.ParseFiles (" public / greeter.html ") err: = t.Execute (w, gebruikersnaam) if err! = nil http.Error (w, err.Error (), http .StatusInternalServerError) 

We hebben gebruikt html / template om de HTML-code in sjablonen te bewaren en ze vervolgens op verzoek te gebruiken om te renderen.

Er is een nieuwsgierige blik . in de greeter.html het dossier. De html / template pakket gaat ervan uit dat platte tekst altijd wordt geproduceerd. Het voegt waar nodig escaping toe om die eenvoudige reeks veilig in te bedden in de juiste context. Wanneer een gegevenswaarde geen platte tekst is, kunnen we ervoor zorgen dat deze niet wordt geëscaped door het type ervan op te geven. Dus in wezen, Hallo, .! kan worden aangeroepen door te gebruiken tmpl.Execute (out, HTML ('Nishant')) produceren Hallo, Nishant!. Ga je gang, probeer dat eens!

Omdat de basistoepassing nu werkt, kunnen we deze eindelijk in Heroku implementeren.

Implementeren naar Heroku

Zodra u de Heroku-toolbelt correct opgezet en de repo beheerd via Git, kunnen we het op deze manier implementeren.

De enige verandering die we zouden moeten doen in de code voor implementatie in Heroku, is de lijn veranderen waar wij luister op een specifieke poort.

Verandering:

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

naar:

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

Heroku-installatie

Als u zich wilt inzetten voor Heroku, hebt u een Heroku-gebruikersaccount nodig. U hebt ook een opdrachtregelprogramma voor Heroku nodig. Haal het door de Heroku Toolbelt te installeren als dat nog niet het geval is.

Na installatie meldt u zich aan met behulp van het Heroku-account heroku login, en upload vervolgens je SSH-sleutel. Met deze dingen op zijn plaats zou je klaar moeten zijn om je in te zetten voor Heroku.

De toepassing implementeren

Om te kunnen inzetten op Heroku, moeten we de app opslaan in Git.

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

We zullen ook een Procfile nodig hebben om Heroku te vertellen dat de opdracht die het moet uitvoeren voor het webproces onze app is.

echo 'web: gogreeter'> Procfile

Go-pakketafhankelijkheden worden beheerd op Heroku met behulp van Godep pakketjes.

Installeer Godep en bewaar uw afhankelijkheden met behulp van het volgende:

ga github.com/kr/godep godep opslaan 

Voeg deze nieuwe bestanden toe aan Git:

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

Maak tot slot de Heroku-applicatie. Het kan zo worden gedaan:

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

Dit zou een Git-afstandsbediening in je repository met de naam van moeten maken Heroku. U bent nu klaar om te implementeren! Voer het volgende uit:

git push heroku master

Nadat de bovenstaande opdracht is voltooid, moet uw app actief zijn!

Ga naar de URL door te zeggen heroku open of door de app-URL te bezoeken die u in de console ziet.

Dat is het. U hebt nu een Go-toepassing die actief is op Heroku!

Samenvatting

In deze tutorial hebben we geleerd hoe eenvoudig het is om een ​​Go-webtoepassing te ontwikkelen en deze ook op Heroku in te zetten. Tegenwoordig is webontwikkeling grotendeels afhankelijk van de kaders die men gebruikt. Om een ​​aantal van deze opties te verkennen, moet u zeker een aantal van deze projecten bekijken.

• Hugo
• martini
• Revel
• Gorilla web toolkit
• Hastie - Statische site-generator in Go