GoLang Tutorial – Web App Deel 1

GCP-ICON.png

Bookmark and Share
bogotobogo.com site zoeken:

Inleiding

In dit bericht zullen we leren hoe we een eenvoudige applicatie kunnen maken. Deze zal uit verschillende delen bestaan en is gebaseerd op https://golang.org/doc/articles/wiki/.

Dit zal een goede aanvulling zijn op onze snelle basis tutorials die we tot nu toe hebben geoefend.

Aan de slag

We maken een nieuwe map genaamd gowiki ergens onder $GOTPAH:

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

Maak een bestand wiki.go zoals dit:

initial_import.png

We importeren de pakketten fmt en ioutil uit de Go-standaardbibliotheek. Later, als we extra functionaliteit implementeren, zullen we meer pakketten toevoegen aan deze importdeclaratie.

De gegevensstructuren definiëren

Een wiki bestaat uit een reeks pagina’s, die elk een titel en een body (de pagina-inhoud) hebben. Hier definiëren we Pagina als een struct met twee velden die de titel en de body voorstellen.

type Page struct { Title string Body byte}

Het type byte betekent een byte slice.

Het Body-element is een byte in plaats van een string, omdat dat het type is dat wordt verwacht door de io-bibliotheken die we zullen gebruiken.

De Pagina struct beschrijft hoe de paginagegevens in het geheugen zullen worden opgeslagen. Maar hoe zit het met persistente opslag? Dat kunnen we aanpakken door een save() methode te maken voor Page:

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

De save() methode vertelt “Dit is een methode genaamd save die als ontvanger p neemt, een pointer naar Page. De methode neemt geen parameters aan en retourneert een waarde van het type error.”

Merk op dat de (p *Pagina) de volgende syntaxis heeft:

receiver_syntax.png

Deze methode slaat de body van de pagina op in een tekstbestand. Om het eenvoudig te houden gebruiken we de Titel als bestandsnaam.

De save-methode retourneert een foutwaarde omdat dat het return-type is van WriteFile (een standaard bibliotheek functie die een byte-schijf naar een bestand schrijft). De save methode retourneert de error waarde, om de applicatie dit te laten afhandelen mocht er iets fout gaan tijdens het schrijven van het bestand. Als alles goed gaat, retourneert Page.save() nil (de nul-waarde voor pointers, interfaces, en sommige andere typen).

Het octale gehele getal 0600, doorgegeven als derde parameter aan WriteFile, geeft aan dat het bestand moet worden aangemaakt met alleen lees-schrijf-rechten voor de huidige gebruiker.

Naast het opslaan van pagina’s willen we ook pagina’s laden:

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

De functie loadPage stelt de bestandsnaam samen uit de parameter title, leest de inhoud van het bestand in een nieuwe variabele body, en retourneert een pointer naar een Page-literaal dat is samengesteld met de juiste waarden voor titel en body.

Functies kunnen meerdere waarden retourneren. De standaard bibliotheek functie io.ReadFile retourneert byte en error. In loadPage wordt de fout nog niet behandeld; de “blank identifier”, vertegenwoordigd door het underscore (_)-symbool, wordt gebruikt om de foutretourwaarde weg te gooien (in wezen wordt de waarde aan niets toegewezen).

Maar wat gebeurt er als ReadFile op een fout stuit? Bijvoorbeeld, het bestand zou niet kunnen bestaan. Zulke fouten mogen we niet negeren. Laten we de functie zo wijzigen dat *Pagina en fout worden geretourneerd.

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}

Aanroepers van deze functie kunnen nu de tweede parameter controleren; als deze nihil is, is met succes een Pagina geladen. Zo niet, dan zal het een fout zijn die door de aanroeper kan worden afgehandeld.

Op dit punt hebben we een eenvoudige gegevensstructuur en de mogelijkheid om op te slaan in en te laden uit een bestand. Laten we een hoofdfunctie schrijven om te testen wat we hebben geschreven:

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

Na het compileren en uitvoeren van deze code is een bestand met de naam TestPage.txt aangemaakt, dat de inhoud van p1 bevat. Het bestand wordt vervolgens ingelezen in de struct p2, en het element Body wordt afgedrukt op het scherm.

TestPage-text.png

net/http package

Laten we beginnen met een eenvoudige webserver, een soortgelijke als die we eerder hebben gedaan (Web):

Simple_Web_Code.png

De hoofdfunctie begint met een oproep aan http.HandleFunc, dat het http-pakket vertelt om alle verzoeken aan de webroot (“/”) af te handelen met handler.

Hij roept dan http.ListenAndServe aan, waarbij hij specificeert dat hij moet luisteren op poort 8080 op een willekeurige interface (“:8080”). (Maak je voorlopig geen zorgen over de tweede parameter, nihil.) Deze functie zal blokkeren totdat het programma wordt beëindigd.

ListenAndServe() retourneert altijd een fout, omdat het alleen retourneert wanneer een onverwachte fout optreedt. Om die fout te loggen omwikkelen we de functie-aanroep met log.Fatal. De Fatal functie roept os.Exit(1) op na het schrijven van het log bericht.

De functie handler is van het type http.HandlerFunc. Het neemt een http.ResponseWriter en een http.Request als argumenten.

Een http.ResponseWriter waarde assembleert het HTTP server antwoord; door er naar te schrijven, sturen we data naar de HTTP client.

Een http.Request is een data structuur die het client HTTP verzoek representeert. r.URL.Path is de path component van de request URL. De trailing betekent “maak een deel van Path vanaf het 1e teken tot het einde.” Dit laat de leidende “/” uit de padnaam weg.

Uitvoeren van dit programma en toegang krijgen tot de URL:

HiThereIlove.png

Doorgaan naar Web Applicatie Deel 2 (Gebruik van net/http).

  1. GoLang tutorial – HelloWorld
  2. Workspaces
  3. Visual Studio Code
  4. Data Types and Variables
  5. byte and rune
  6. Packages
  7. Functions
  8. Arrays en Slices
  9. Een functie die een slice neemt en retourneert
  10. Conditionals
  11. Lussen
  12. Maps
  13. Range
  14. Pointers
  15. Closures and Anonymous Functions
  16. Structs and receiver methods
  17. Value or Pointer Receivers
  18. Interfaces
  19. Web Application Part 0 (Introduction)
  20. Web Applicatie Deel 1 (Basis)
  21. Web Applicatie Deel 2 (Gebruik van net/http)
  22. Web Applicatie Deel 3 (Toevoegen van “edit” mogelijkheid)
  23. Web Applicatie Deel 4 (Behandeling van nietbestaande pagina’s en opslaan van pagina’s)
  24. Web Applicatie Deel 5 (Foutafhandeling en template caching)
  25. Web Applicatie Deel 6 (Valideren van de titel met een reguliere expressie)
  26. Web Applicatie Deel 7 (Function Literals en Closures)
  27. Bouwen van Docker image en uitrollen van Go applicatie naar een Kubernetes cluster (minikube)
  28. Serverless Framework (Serverless Application Model-SAM)
  29. Serverloze Web API met AWS Lambda
  30. Arrays vs Slices met een array links rotatie sample
  31. Variadic Functions
  32. Goroutines
  33. Channels (”
  34. Channels (”
  35. Channels (”
  36. Defer
  37. GoLang Paniek en Herstel
  38. String Opmaak
  39. JSON
  40. SQLite
  41. Modules 1 (Een nieuwe module maken)
  42. Modules 2 (Afhankelijkheden toevoegen)
  43. AWS SDK for Go (S3 listing)
  44. Linked List
  45. Binary Search Tree (BST) Part 1 (Boom/Node structs met insert en print functies)

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd.