Go ist eine Open-Source-Programmiersprache, die bei Google entwickelt wurde und beim Aufbau einfacher, zuverlässiger Softwaresysteme helfen soll. Die Hauptstärke von Go sind die Parallelitätsmechanismen, die das Schreiben von Software und die Nutzung von Multi-Core-Architekturen vereinfachen.

Es ist eine kompilierte, stark statisch typisierte, gleichzeitige und überflüssige Sprache.

Es ist eine sehr interessante, moderne Sprache aufgrund einiger Entscheidungen, die während des Entwurfs getroffen wurden. Beispielsweise hat das Typsystem, obwohl Go über Methoden und auch einen OO-Programmierstil verfügt, keine Typhierarchie. Dies kann nur über Schnittstellen erreicht werden.

Wie es geht, unterscheidet sich von anderen

Man sollte die Sprachspezifikation lesen, um die Gestaltungselemente der Sprache besser zu verstehen. Es ist wirklich kurz und hilft, einige wirklich interessante Details hervorzuheben. Go unterscheidet sich von anderen typischen Programmiersprachen im Unterschied zu anderen OO-Sprachen:

• Keine Typvererbung
• Keine Überladung von Methoden und Operatoren
• Eingebaute Parallelitäts-Grundelemente, die es wirklich von der Masse abheben. Es teilt das Gedächtnis durch Kommunikation und nicht umgekehrt.
• Eine Toolchain, die ein herkömmliches Kompilier- und Linkmodell verwendet, um Binärdateien ohne externe Abhängigkeiten zu erstellen.
• Karten sind eingebaut.

Code-Organisation

Der Go-Code wird unter Arbeitsbereichen gehalten. Es ist nur eine Verzeichnishierarchie wie folgt:

• src - enthält Go-Quelldateien als Pakete
• pkg - enthält Paketobjekte
• Behälter - enthält ausführbare Dateien

Das Go-Tool erstellt die Quellpakete und installiert die resultierenden Binärdateien in Behälter und pkg Verzeichnisse.

Eine einfache Webanwendung mit Go

Lassen Sie uns eine statische Website erstellen und dann verbessern, um sie auf der Grundlage der Benutzereingaben viel dynamischer zu gestalten.

Die statische Site

Die Codestruktur für die statische Site sieht folgendermaßen aus:

Im Grunde möchten Sie also eine Struktur erstellen, die der obigen Abbildung ähnelt oder im Repository angezeigt wird. Diese Repo-Struktur würde sich selbst unter der Arbeitsplatz . Weitere Informationen finden Sie in der Go-Code-Struktur.

Jetzt möchten wir eine HTML-Datei bereitstellen, die sich im öffentlichen Verzeichnis befindet.

Das index.html Inhalt ist wie folgt:

       
Website mit Go entwickeln
 
Ich bin eine statische Seite, die Ihnen mit Hilfe von Go lang zur Verfügung gestellt wird.
   

Und hier ist das Go-Programm zum statischen Bereitstellen von Dateien aus dem öffentlichen Ordner:

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

Gestatten Sie mir zu erklären:

• net / http - Dieses Paket bietet HTTP-Client- und -Server-Implementierungen.
• Dateiserver - Diese Funktion gibt einen Handler zurück, der HTTP-Anforderungen mit dem Inhalt des Dateisystems bedient.

Das ist es. Wirklich einfach und auf den Punkt. Sie können den Code folgendermaßen ausführen: Starten Sie gostatic.go.

Eine bessere Lösung

Diese Lösung trennt die Bedenken hinsichtlich Routing und Service jedoch nicht eindeutig. Eine bessere Lösung wäre also:

Paket Hauptimport ("net / http" "log") func main () fs: = http.FileServer (http.Dir ("public")) http.Handle ("/", fs) log.Println ("Listening … ") Err: = http.ListenAndServe (": 8080 ", nil) if err! = Nil log.Fatal (" ListenAndServe: ", err) 

ListenAndServe startet einen HTTP-Server an der angegebenen TCP-Adresse und ruft dann Serve mit einem Handler auf. Dieser Handler ist normalerweise null, so dass der Standardrouter (in Gos Fall der DefaultServerMux übernehmen können).

Jetzt in Bezug auf DefaultServeMux - Machen wir einen kurzen Umweg, um zu verstehen, wie Go die HTTP-Verarbeitung durchführt. Dies geschieht mit Hilfe zweier wichtiger Dinge.

• ServerMuxes - (Router) Dies ist ein Multiplexer - im Wesentlichen ein HTTP-Router, der eingehende Anforderungen mit der definierten Liste vergleicht und dann den zugehörigen Handler aufruft.
• Handler - Diese sind für die "Bearbeitung" der Anforderung verantwortlich, z. B. die Antwort mit den entsprechenden Kopfzeilen, dem Rumpf usw. Jedes Objekt, das der Handler-Schnittstelle gehorcht, kann als eine Einheit fungieren.

Führen Sie die Beispiel-Web-App wie zuvor ausgeführt aus, und Sie sollten die Ausgabe sehen!

Dynamische Sites - Hinzufügen eines Zeitstempels bei jeder Aktualisierung

Als Nächstes schreiben wir die Anwendung so, dass sie die aktuelle Uhrzeit ausgibt, was bedeutet, dass Sie bei jeder Aktualisierung eine andere Ausgabe erhalten. Der Go-Code würde so aussehen:

Pakethauptimport ("fmt" "net / http" "time") func main () http.HandleFunc ("/", handler) log.Println ("listen…") err: = http.ListenAndServe (": 8080 ", nil) if err! = nil panic (err) func-Handler (w http.ResponseWriter, r * http.Request) fmt.Fprintf (w," hallo. Die Zeit ist: "+ time.Now ( ) .Format (time.RFC850)) 

Hier haben wir importiert fmt mit einigen Druckfunktionen arbeiten. Das fmt implementiert formatierte E / A-Funktionen entlang der Linien von C stdio Bibliothek.

Wir haben auch Gebrauch gemacht HandleFunc die den URL-Pfad mit der Handler-Funktion in der registriert DefaultServeMux. Der Funktionshandler ist vom Typ http.HandlerFunc. Es braucht eine http.ResponseWriter und http.Anfrage als seine Argumente. Leute, die mit Java-Servlets vertraut sind, werden sich daran erinnern!

Um die Zeit auszudrucken, importieren wir 'time' aus dem Standardpaket und verwenden es, um auf das Response-Writer-Objekt zu antworten. Durch schreiben an http.ResponseWriter Objekt können wir die Antwort an den Client senden.

http.Anfrage ist die Struktur, die die HTTP-Anforderung darstellt und somit die gesamten Anforderungsdaten enthält. Um auf den URL-Pfad zuzugreifen, machen wir r.URL.path.

Wenn Sie dies ausführen und dann zugreifen localhost: 8080 Sie sollten die aktuelle Uhrzeit bei jeder Aktualisierung sehen.

Benutzereingaben akzeptieren

Nun schreiben wir eine Anwendung, die ein akzeptiert Nutzername auf der Indexseite und wenn das Formular gesendet wird, begrüßt es den Benutzer auf der nächsten Seite.

Hier ist unsere Go-Code-Struktur:

Erstellen Sie zunächst eine HTML-Datei, die das Formular im öffentlichen Verzeichnis enthält.

       
Gehen Sie Greeter
 
   
   

Dieses Formular wird beim Senden an weitergeleitet /grüßen. Schreiben wir auch den Inhalt der grüße.html Datei innerhalb des öffentlichen Verzeichnisses, das wir wiedergeben würden, wenn die Anforderung ankommt /grüßen.

       
Hallo .
   

Der Go-Code lautet wie folgt:

Pakethauptimport ("log" "net / http" "html / template") func main () http.HandleFunc ("/", root) http.HandleFunc ("/ greet", greeter) log.Println ("Listening … ") Err: = http.ListenAndServe (": 8080 ", nil) 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) Benutzername: = r.FormValue (" username ") t, _: = template.ParseFiles (" public / greeter.html ") err: = t.Execute (w, Benutzername) wenn err! = nil http.Error (w, err.Error (), http .StatusInternalServerError) 

Wir haben gebraucht HTML / Vorlage um den HTML-Code in Vorlagen beizubehalten und dann auf Anforderung zum Rendern zu verwenden.

Es ist ein neugieriger Blick . in dem greeter.html Datei. Das HTML / Vorlage package geht davon aus, dass immer Klartext erzeugt wird. Es fügt Fluchtpunkte hinzu, wo immer dies erforderlich ist, um diese einfache Zeichenfolge sicher im richtigen Kontext einzubetten. Wenn ein Datenwert kein reiner Text ist, können Sie durch Angabe seines Typs sicherstellen, dass er nicht mit Escapezeichen versehen wird. Also im Wesentlichen, Hallo, .! kann mit aufgerufen werden tmpl.Execute (out, HTML ('Nishant')) produzieren Hallo, Nishant!. Machen Sie weiter, versuchen Sie das!

Da die Basisanwendung jetzt funktioniert, können wir sie endlich bei Heroku implementieren.

Bereitstellung bei Heroku

Sobald Sie die haben Heroku-Werkzeuggürtel Wenn Sie das Setup korrekt einrichten und das Repo über Git verwalten, können wir es entsprechend implementieren.

Die einzige Änderung, die wir im Code für die Bereitstellung bei Heroku vornehmen müssten, ist die Änderung der Zeile, an der wir uns befinden Hör mal zu an einem bestimmten Hafen.

Veränderung:

 http.ListenAndServe (": 8080",…) 

zu:

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

Heroku-Setup

Für die Bereitstellung bei Heroku benötigen Sie ein Heroku-Benutzerkonto. Sie benötigen außerdem einen Heroku-Befehlszeilenclient. Holen Sie sich den Heroku Toolbelt, falls noch nicht vorhanden.

Melden Sie sich nach der Installation mit dem Heroku-Konto an, indem Sie sagen Heroku-Login, und laden Sie dann Ihren SSH-Schlüssel hoch. Mit diesen Dingen sollten Sie bereit sein, sich auf Heroku bereit zu stellen.

Bereitstellung der Anwendung

Um auf Heroku implementieren zu können, müssen wir die App in Git speichern.

git init. git addieren -A. git commit -m 'erste heroku go app' 

Wir benötigen auch ein Procfile, um Heroku mitzuteilen, dass der Befehl, den es für den Web-Prozess ausführen muss, unsere App ist.

echo 'web: gogreeter'> Procfile

Go-Paket-Abhängigkeiten werden auf Heroku mit Hilfe von verwaltet Godep Pakete.

Installieren Sie Godep und speichern Sie Ihre Abhängigkeiten mit den folgenden Anweisungen:

Holen Sie sich github.com/kr/godep godep save 

Fügen Sie diese neuen Dateien zu Git hinzu:

git addieren -A. git begehen -m "Godep" 

Erstellen Sie schließlich die Heroku-Anwendung. Es kann so gemacht werden:

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

Dies sollte ein Git-Remote mit dem Namen von in Ihrem Repository erstellen Heroku. Sie können jetzt bereitstellen! Führen Sie folgendes aus:

git Push Heroku-Meister

Nachdem der obige Befehl ausgeführt wurde, sollte Ihre App betriebsbereit sein!

Besuchen Sie die URL, indem Sie sagen Heroku offen oder indem Sie direkt die App-URL aufrufen, die in der Konsole angezeigt wird.

Das ist es. Auf Heroku ist jetzt eine Go-Anwendung installiert!

Zusammenfassung

In diesem Tutorial haben wir gelernt, wie einfach es ist, eine Go-Webanwendung zu entwickeln und auf Heroku bereitzustellen. Heutzutage hängt die Webentwicklung stark von den verwendeten Frameworks ab. Um einige dieser Optionen zu erkunden, sollten Sie einige dieser Projekte auf jeden Fall überprüfen.

• Hugo
• Martini
• Revel
• Gorilla-Web-Toolkit
• Hastie - Generator für statische Sites in Go