Go Language

Golang Web App: Hello World Example

Lets create a simple "Hello World" web application using Go.

Social Media Digital Marketing & Communication Advisor. Community Manager

Published · Nov 17 2019

  
In this chapter  we will still learn about fundamental or basic topics but are more specific towards web development.We begin with a discussion of how to create a simple "Hello World" web application using Go.
Application Making
Let's learn by practice firsthand. First create a new project folder with contents main.go, specify the package as main, then import the package fmtand net/http.
package main

import "fmt"
import "net/http"


After that, prepare two functions, each function has the same parameter scheme as follows.
The 1st parameter is type http.ResponseWrite
The second parameter is of type *http.Request
Functions with the above structure are needed http.HandleFuncfor the purpose of handling requests to the specified route. The following are the two functions in question.
func handlerIndex(w http.ResponseWriter, r *http.Request) {
    var message = "Welcome"
    w.Write([]byte(message))
}

func handlerHello(w http.ResponseWriter, r *http.Request) {
    var message = "Hello world!"
    w.Write([]byte(message))
}

The method Write()belonging to the first parameter (of type http.ResponseWrite), is used to output the data return value. Method arguments are data that you want to be output, written in the form []byte.

In this example, the data we will display is of type string, so casting needs to be done from stringto []byte. Examples can be seen like in the code above, in the section w.Write([]byte(message)).

Next, prepare a function main()with the contents in it are several routes, with actions being the two functions that have been prepared above. Do not forget to also prepare the code to start the server.
package main

import "fmt"
import "net/http"

func handlerIndex(w http.ResponseWriter, r *http.Request) {
	var message = "Welcome"
	w.Write([]byte(message))
}

func handlerHello(w http.ResponseWriter, r *http.Request) {
	var message = "Hello world!"
	w.Write([]byte(message))
}

func main() {
	http.HandleFunc("/", handlerIndex)
	http.HandleFunc("/index", handlerIndex)
	http.HandleFunc("/hello", handlerHello)

	var address = "localhost:9000"
	fmt.Printf("server started at %s\n", address)
	err := http.ListenAndServe(address, nil)
	if err != nil {
		fmt.Println(err.Error())
	}
}

The function is http.HandleFunc()used for routing. The first parameter is the route and the second parameter is the handler.

The function is http.ListenAndServe()used to create a new server at the same time, with the first parameter being the desired web server address (can be filled in host, host & port, or port only). The second parameter is the mux or multiplexer object.
In this chapter we use the default mux that has been provided by Go, so for the 2nd parameter just fill with nil.

Ok, now the program is ready, run it using go run.

  
Check the browser route that has been made, the output will appear.

  
The following is a detailed explanation per part of the program that we have created from the example above.
. . .
Use http.HandleFunc()
This function is used for routing , determines the action of a particular url when accessed (here we call it the route). The route is written in stringas the first parameter, and the action itself is wrapped in a function (can be a closure) which is placed in the second parameter (we call it a handler).

In the code above, three routes are listed:
The route /with action is a functionhandlerIndex()
The route /indexwith action is the same as /, that is, functionhandlerIndex()
Route /hellowith function actionshandlerHello()

When these routes are accessed through a browser, the output is the content handler of the route. Incidentally in this chapter, the three routes are the same output, which is a string.
In the example above, when an unregistered route is accessed, the route handler /will automatically be called.
. . .
Explanation About Handlers
Route handler or handler or parameter of both functions http.HandleFunc(), is a function with a schema func (ResponseWriter, *Request).
The 1st parameter is an object for the purpose of http response.
While the second parameter of *requestthis type , contains information relating to the http request for the relevant route.

An example of writing a handler can be seen in the handlerIndex()following function .
func handlerIndex(w http.ResponseWriter, r *http.Request) {
    var message = "Welcome"
    w.Write([]byte(message))
}

The output of the route, written in the handler uses the method Write()of the object ResponseWriter(the first parameter). The output can be anything, for just output text casting from type stringto []byte, this rule also applies to several other types of output such as html and json, but the response header Content-Typeneeds to be adjusted.

In the example program that we have created, the handler Index()raises text "Welcome", and the handler Hello()raises text "Hello world!".
A handler can be used on many routes, can be seen above the handler is Index()used on the route /and /index.
. . .
Use http.ListenAndServe()
This function is used to create a new web server. In the example that has been made, the web server is started on the port 9000(it can be written in a form localhost:9000 or :900 0just enough ).
var address = ":9000"
fmt.Printf("server started at %s\n", address)
err := http.ListenAndServe(address, nil)

The function http.ListenAndServe()is blocking, making all statements after that will not be executed, before being stopped.

This function returns a return value of type error. If the process of making a new web server fails, then we can find out what the root cause is.
. . .
Web Server Usinghttp.Server
Besides using http.ListenAndServe(), there are other ways that can be applied to start a web server, namely by utilizing structs http.Server.

The code at the start server that we have created, if changed to this way, is more or less like this.
package main

import "fmt"
import "net/http"
import "time"

func handlerIndex(w http.ResponseWriter, r *http.Request) {
	var message = "Welcome"
	w.Write([]byte(message))
}

func handlerHello(w http.ResponseWriter, r *http.Request) {
	var message = "Hello world!"
	w.Write([]byte(message))
}

func main() {
	http.HandleFunc("/", handlerIndex)
	http.HandleFunc("/index", handlerIndex)
	http.HandleFunc("/hello", handlerHello)

	var address = "localhost:9000"
	fmt.Printf("server started at %s\n", address)

	server := new(http.Server)
	server.Addr = address
	server.ReadTimeout = time.Second * 10
	server.WriteTimeout = time.Second * 10

	err := server.ListenAndServe()
	if err != nil {
		fmt.Println(err.Error())
	}
}

Host / port information needs to be entered in the property .Addrof the server object. Then from that object, call the method .ListenAndServe()to start the web server.

The advantage of using http.Server one of them is the ability to change some of the default Go web server configurations.

For example, in the following code, the timeout for read requests and write requests is changed to 10 seconds.
server.ReadTimeout = time.Second * 10
server.WriteTimeout = time.Second * 10

There are many more properties of http.Serverthis struct , which will certainly be discussed in later chapters.