GoLang Tutorial – Webanwendung Teil 1

GCP-ICON.png

Bookmark and Share
bogotobogo.com site search:

Einführung

In diesem Beitrag werden wir lernen, wie man eine einfache Anwendung erstellt. Sie besteht aus mehreren Teilen und basiert auf https://golang.org/doc/articles/wiki/.

Sie ist eine gute Ergänzung zu den schnellen, grundlegenden Tutorials, die wir bisher geübt haben.

Einstieg

Wir werden ein neues Verzeichnis namens gowiki irgendwo unter $GOTPAH anlegen:

$ echo $GOPATH~/go$ mkdir -p $GOPATH/src/github.com/einsteinish/go_tutorial/gowiki

Erstelle eine Datei wiki.go wie diese:

initial_import.png

Wir importieren die Pakete fmt und ioutil aus der Go-Standardbibliothek. Später, wenn wir zusätzliche Funktionen implementieren, werden wir weitere Pakete zu dieser Import-Deklaration hinzufügen.

Definieren der Datenstrukturen

Ein Wiki besteht aus einer Reihe von Seiten, von denen jede einen Titel und einen Body (den Seiteninhalt) hat. Hier definieren wir Page als struct mit zwei Feldern, die den Titel und den Body repräsentieren.

type Page struct { Title string Body byte}

Der Typ Byte bedeutet eine Byte-Slice.

Das Body-Element ist ein Byte und kein String, weil das der Typ ist, der von den io-Bibliotheken erwartet wird, die wir verwenden werden.

Das Page struct beschreibt, wie die Seitendaten im Speicher gespeichert werden sollen. Aber was ist mit der dauerhaften Speicherung? Wir können das angehen, indem wir eine save()-Methode für Page erstellen:

func (p *Page) save() error { filename := p.Title + ".txt" return ioutil.WriteFile(filename, p.Body, 0600)}

Die save()-Methode sagt: „Dies ist eine Methode namens save, die als Empfänger p, einen Zeiger auf Page, annimmt. Sie nimmt keine Parameter an und gibt einen Wert vom Typ error zurück.“

Beachten Sie, dass (p *Page) die folgende Syntax hat:

receiver_syntax.png

Diese Methode speichert den Body der Page in einer Textdatei. Der Einfachheit halber verwenden wir den Titel als Dateinamen.

Die Speichermethode gibt einen Fehlerwert zurück, da dies der Rückgabetyp von WriteFile ist (eine Funktion der Standardbibliothek, die ein Byte-Slice in eine Datei schreibt). Die Speichermethode gibt den Fehlerwert zurück, damit die Anwendung damit umgehen kann, falls beim Schreiben der Datei etwas schief geht. Wenn alles gut geht, gibt Page.save() nil zurück (den Nullwert für Zeiger, Schnittstellen und einige andere Typen).

Das oktale Ganzzahl-Literal 0600, das als dritter Parameter an WriteFile übergeben wird, zeigt an, dass die Datei nur mit Lese- und Schreibrechten für den aktuellen Benutzer erstellt werden soll.

Neben dem Speichern von Seiten werden wir auch Seiten laden wollen:

func loadPage(title string) *Page { filename := title + ".txt" body, _ := ioutil.ReadFile(filename) return &Page{Title: title, Body: body}}

Die Funktion loadPage konstruiert den Dateinamen aus dem Parameter title, liest den Inhalt der Datei in eine neue Variable body und gibt einen Zeiger auf ein Page-Literal zurück, das mit den richtigen Werten für title und body konstruiert wurde.

Funktionen können mehrere Werte zurückgeben. Die Standardbibliotheksfunktion io.ReadFile gibt Byte und Error zurück. In loadPage wird der Fehler noch nicht behandelt; der „leere Bezeichner“, der durch das Unterstrichsymbol (_) dargestellt wird, wird verwendet, um den Fehlerrückgabewert wegzuwerfen (im Wesentlichen wird der Wert dem Nichts zugewiesen).

Was passiert aber, wenn ReadFile auf einen Fehler stößt? Zum Beispiel könnte die Datei nicht existieren. Solche Fehler sollten wir nicht ignorieren. Ändern wir die Funktion so, dass sie *Page und Fehler zurückgibt.

func loadPage(title string) (*Page, error) { filename := title + ".txt" body, err := ioutil.ReadFile(filename) if err != nil { return nil, err } return &Page{Title: title, Body: body}, nil}

Aufrufer dieser Funktion können nun den zweiten Parameter überprüfen; wenn er gleich Null ist, wurde erfolgreich eine Seite geladen. Wenn nicht, ist es ein Fehler, der vom Aufrufer behandelt werden kann.

An diesem Punkt haben wir eine einfache Datenstruktur und die Möglichkeit, in einer Datei zu speichern und aus einer Datei zu laden. Schreiben wir eine Hauptfunktion, um zu testen, was wir geschrieben haben:

func main() { p1 := &Page{Title: "TestPage", Body: byte("This is a sample Page.")} p1.save() p2, _ := loadPage("TestPage") fmt.Println(string(p2.Body))}

wiki-go-1.png

Nach dem Kompilieren und Ausführen dieses Codes wurde eine Datei namens TestPage.txt erstellt, die den Inhalt von p1 enthält. Die Datei wird dann in die Struktur p2 eingelesen und ihr Body-Element auf dem Bildschirm ausgegeben.

TestPage-text.png

Netz/http-Paket

Lassen Sie uns mit einem einfachen Webserver beginnen, ähnlich dem, den wir zuvor benutzt haben (Web):

Simple_Web_Code.png

Die Hauptfunktion beginnt mit einem Aufruf von http.HandleFunc, der dem http-Paket mitteilt, dass es alle Anfragen an die Web-Root („/“) mit handler behandeln soll.

Dann ruft es http.ListenAndServe auf und gibt an, dass es auf Port 8080 auf einer beliebigen Schnittstelle („:8080“) lauschen soll. (Diese Funktion blockiert, bis das Programm beendet wird.

ListenAndServe() gibt immer einen Fehler zurück, da sie nur zurückkehrt, wenn ein unerwarteter Fehler auftritt. Um diesen Fehler zu protokollieren, verpacken wir den Funktionsaufruf mit log.Fatal. Die Fatal-Funktion ruft os.Exit(1) auf, nachdem sie die Protokollmeldung geschrieben hat.

Der Funktionshandler ist vom Typ http.HandlerFunc. Er nimmt einen http.ResponseWriter und einen http.Request als Argumente an.

Ein http.ResponseWriter-Wert stellt die Antwort des HTTP-Servers zusammen; durch Schreiben in ihn senden wir Daten an den HTTP-Client.

Ein http.Request ist eine Datenstruktur, die die HTTP-Anfrage des Clients darstellt. r.URL.Path ist die Pfadkomponente der Anfrage-URL. Das „trailing“ bedeutet: „Erstelle ein Teilstück von Path vom ersten Zeichen bis zum Ende“. Dadurch entfällt das führende „/“ aus dem Pfadnamen.

Starten Sie dieses Programm und rufen Sie die URL auf:

HiThereIlove.png

Weiter zu Webanwendung Teil 2 (Verwendung von net/http).

  1. GoLang Tutorial – HelloWorld
  2. Arbeitsbereiche
  3. Visual Studio Code
  4. Datentypen und Variablen
  5. Byte und Rune
  6. Pakete
  7. Funktionen
  8. Arrays und Slices
  9. Eine Funktion, die ein Slice nimmt und zurückgibt
  10. Konditionale
  11. Schleifen
  12. Maps
  13. Range
  14. Zeiger
  15. Verschlüsse und anonyme Funktionen
  16. Strukturen und Empfängermethoden
  17. Wert- oder Zeigerempfänger
  18. Schnittstellen
  19. Webanwendung Teil 0 (Einführung)
  20. Webanwendung Teil 1 (Grundlagen)
  21. Webanwendung Teil 2 (Verwendung von net/http)
  22. Webanwendung Teil 3 (Hinzufügen der „Edit“-Fähigkeit)
  23. Webanwendung Teil 4 (Umgang mit nichtexistierende Seiten und Speichern von Seiten)
  24. Webanwendung Teil 5 (Fehlerbehandlung und Template-Caching)
  25. Webanwendung Teil 6 (Validieren des Titels mit einem regulären Ausdruck)
  26. Webanwendung Teil 7 (Funktionsliterale und Closures)
  27. Erstellen eines Docker-Images und Bereitstellen einer Go-Anwendung in einem Kubernetes-Cluster (minikube)
  28. Serverless Framework (Serverless Application Model-SAM)
  29. Serverless Web API mit AWS Lambda
  30. Arrays vs. Slices mit einem Array-Linksrotationsbeispiel
  31. Variadic Functions
  32. Goroutinen
  33. Kanäle (“
  34. Kanäle (“
  35. Kanäle (“
  36. Aufschieben
  37. GoLang Panic und Recover
  38. String Formatierung
  39. JSON
  40. SQLite
  41. Module 1 (Erstellen eines neuen Moduls)
  42. Module 2 (Hinzufügen von Abhängigkeiten)
  43. AWS SDK für Go (S3-Auflistung)
  44. Verknüpfte Liste
  45. Binärer Suchbaum (BST) Teil 1 (Baum/Knotenstrukturen mit Einfüge- und Druckfunktionen)

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.