Golang: Migration to Go language Book (HTML Version)

fmt.Println("Display Time Go Routine")

2. JavaTimer with threads: (32 lines)

package javatimer;

import java.util.Date;

class JavaTimerThread extends Thread{

System.out.println(ID + ":" + new Date().toString());

try {

Thread.sleep(1000);

} catch (InterruptedException ex) {

System.err.println("Error: " + ex.toString());

public static void main(String[] args) throws InterruptedException {

public class JavaTimer {

JavaTimerThread timer = new JavaTimerThread();

timer.ID = 1;

timer.start();

JavaTimerThread timer2 = new JavaTimerThread();

timer2.ID = 2;

timer2.start();

When we run command to check process internal threads we will notice that GoTimer remains with 5 threads while Java process threads has increased to 17:

Executable size

Another important difference, but this time is on Java side: Java produces small size byte code executable (in kilobytes), while Go compiler produces self-contained large size binary executable, which contains run-time libraries and used packages, all of them will be inside executable that starts with about 2 megabytes in size.

Java is heavily rely on Java virtual machine or Java runtime (JRE), so that byte-code executable are very small and relies on shared JRE between all java applications on that machine Here are our previous comparison projects sizes:

That was the minimum compiler output size, so that we need to check real projects for multi thousands lines:

17K a.out

C binary has less statically-linked run-time size compared to Go, also C has no garbage collector.

Here is Go 6k lines that uses few packages:

12M CodeAccountingWS

Compared to Java 7k lines that uses few Java class libraries:

5.5M SMSPanel.war

This is not big issue for disk space on which we deploy executable, but it might be an issue when transferring binary files via network/Internet, it could take a time to in case of low speed network connections, so that it is better to compress binaries while copying.

Installing Go

For Linux, Go could be installed from repositories, but it is better to be downloaded directly from official Go site to get the latest versions:

https://go.dev/

After downloading suitable OS version we can follow the “installation instructions” depending on platform we are using.

This package contains Go compiler, debugger, run-time libraries, Go packages, and command line tools that used by developer and used by IDE that we will install later

This is an example of deploying Go package in Linux:

rm -rf /usr/local/go && tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz

or as multiple commands and using sudo:

sudo rm -rf /usr/local/go

sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz

After that we need to check Go compiler has been deployed, and in case of installing new version we need to make sure new version is working now:

go version

Result could be something like this depending on version and target OS:

go version go1.20 linux/amd64

First Go application

After installing Go compiler, we could use any simple text editor to write first Go sample command line project:

First we should create folder by the same project name, for example “first”, then create main.go file inside “first” folder and write below code.

Then we can use gofmt tool to reformat text alignment to Go standards for more readability:

fmt.Println("Hello Go")

Then run first application:

go run main.go

This produces executable binary in a temporary directory and run that binary

Output:

Hello Go

To build go binary output, we can use go build command:

go build main.go

or just go build in case of multiple project files:

go build

After running go build command we will find executable in the same directory of source project code:

-rw-rw-r-- 1 motaz motaz 105 Feb 11 08:31 main.go

-rwxrwxr-x 1 motaz motaz 1.9M Feb 11 08:34 main

Previous sample files represents Linux environment, in Windows we will find main.exe file

We can run executable and distribute it to other machines

As in native compiled languages, we will get a binary executable depending on OS and Platform, and that executable runs only on the same targeted Platform, to check executable in Linux we could use file command tool to check the file compiled target:

file main

The result will be something like this depending on OS:

main: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, Go BuildID=T1xYAYiZPSUBtfa28x_N/Kko4il7vBW6OyEirX06W/9vAOZhoNUt7A7DP7tVTG/Y_meKiaUFP4PphxQag_Q, with debug_info, not stripped

The advantage of Java here -compared to native compiled language- is that Java produced byte code will run on every machine that has compatible version of Java virtual machine, so that only one byte code is required to be produced, and could be run in different platforms in which JVM exists there.

Cross compilation

As Go available on all major platforms, we could compile that source in every platform the same like C and C++, but the advantage here in Go is that there is an easy cross-compilation, which means you can produce compiled binary for any supported platform from your development platform, for example if you are using Linux, you can produce Linux, Windows 64/32, Mac, ARM binaries from your Linux PC.

Here is an example of how to produce Windows 64 bit binary from Linux or any other platform:

GOOS=windows GOARCH=amd64 go build main.go

and now we will find main.exe file and if we checked it with file main.exe we will get:

file main.exe

main.exe: PE32+ executable (console) x86-64 (stripped to external PDB),

for MS Windows

Here another example to build ARM executable that could run on RaspberyPI:

env GOOS=linux GOARCH=arm GOARM=5 go build main.go

produced executable name will be main, so that your previous Linux binary will be overwritten, and you need to use file command to differentiate between different binaries of Linux, and Unix. Mac binary also has no extension the same like Linux:

file main

main: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, Go BuildID=Fk6aTEOgy7bWmOgkdLVd/KKZ5f1Qe8FS4O-NQHfYY/ce9Vr7NIvgeZAQWdT0HI/FLMnwvzqn4tiG38gW_wB, with debug_info, not stripped

IDE

Go compiler and it’s tools are independent of any development IDEs, it could be used with many IDEs, such as Visual Studio Code, and LiteIDE. These IDEs are using Go compiler and tools to provide syntax check, format, compilation, run, testing, building and debugging.

1. Visual Studio Code

It is one of famous development IDE, and it uses extensions in order to provide support for variety of programming languages.

After installing Visual Code, we can install Go extensions, or start writing Go project, then IDE will suggest extensions to be installed.

First extension will be: Go for Visual Studio Code, then Go runner extension to manage running and stopping Go programs.

2. LiteIDE

LiteIDE is a specific Go IDE, so that it will be ready for Go projects, no extensions or special configuration is required, it will be ready out of the box for Go programs. It is ideal for starting with Go. It provides compilation, building, modules initialization, testing, and cross-compilation.

Also we can easily work in multiple projects in LiteIDE, but it lacks integration with source control, you need to use external tools or command line to import and commit projects in source control.

In our illustration we will use LiteIDE because of previously mentioned reasons, but we will mention command line method for running and building which is used by Visual Code.

First Go sample with LiteIDE

To create new Go project you will find multiple choices, we will choose: Go new command project option.

This creates project in default go/src directory, if you want to create project in another directory you could select Go new command project (Anywhere) option

We named it first-sample, then we will find below ready written source template:

// first-sample project main.go

fmt.Println("Hello World!")

If we try to run it using build and run button (BR) or Control+R, we will get below message:

go: go.mod file not found in current directory or any parent directory; see 'go help modules'

Error: process exited with code 1.

LiteIDE enforces to use Go module in spite of that this simple project does not require external package, but we could initialize module for future use of external packages.

Module could be initialized using (M) button menu, then select Go module Init.

For Visual code we don’t have to initialize module unless we need an external package, and in this case we could initialize module using below command line in project directory:

go mod init

go.mod file will be created containing below text:

module first-sample

go 1.20

Then we can run again the project and see the result, also an executable will be produced after building project, either first-sample filename in Linux, Unix, and Mac environment or first-sample.exe in Windows environment

We can add another line to main.go source file to display current date and time by typing:

fmt.Println(time.

Then LiteIDE will suggests to add time package automatically, and code will be:

// first-sample project main.go

fmt.Println("Hello World!")

fmt.Println(time.Now().String())

this requires build and run again to get below result:

Hello World!

2023-02-28 08:41:40.236956669 +0200 CAT m=+0.000123066

Success: process exited with code 0.

In below command, we can do temporary build for this program and run it:

go run .

This command will not provide executable in current directory, and if we need to produce executable without running the application we can use below command:

go build

then we can run produced binary using:

./first-sample

in Linux, Unix, and Mac

or first.sample in Windows

first-sample

We can right-click project in LiteIDE then select Open terminal here

We can assign current time to a variable then use that variable for different purposes such as to display time or to store date and time in a log file, using one of below variable declarations:

1. Using explicit declaration using var keyword:

var atime time.Time

atime = time.Now()

fmt.Println(atime.String())

2. Second method is to declare variable by direct assign of value using (:=) operator:

atime := time.Now()

fmt.Println(atime.String())

In this example we will use explicit declaration of atime type, then assign value in the same line:

var atime time.Time = time.Now()

fmt.Println(atime.String())

This could also be for any other types, such as integers and strings:

var area int = 1200

diameter := 1.2

unit := "Kilometers"

fmt.Printf("Area is %d %s\n", area, unit)

fmt.Printf("Diameter is %f %s\n", diameter, unit)

Note that explicit declaration of variable type makes it more readable to define to readers the type of variable instead of searching function returned value type or guessing assigned value type. IDE also could help showing function returned value by moving mouse pointer to function name as in Visual Code, or pressing Control key and pointing by mouse as in LiteIDE, but sometimes we need to review code using browser when accessing source control, so that explicit delegation will help in this case.

Note that there is no semicolon (;) at the end of lines or statements, which eliminates ; expected compiler errors, such as in other programming languages, but it could be used for multi-statement lines such as:

diameter := 1.2; unit := "Kilometers"

If we click save on LiteIDE or used gofmt, they will convert it to two lines and removes ;

Arrays and Slices:

Arrays in Go has fixed length of specific type, here is example of array of string:

It could be iterated using for .. range statement:

for i, item := range list {

First variable of for .. range (i) will hold index of current iterated item of array while second variable (item) will hold current iterated array element. We can omit index if we need only item by using underscore:

for _, item := range list {

Slices are dynamic, it requires initialization either with zero-length then append it later with items, or initialized with initial size and also it could be appended later:

var list []string

list = make([]string, 3)

list[0] = "First"

list[1] = "Second"

list[2] = "Third"

list = append(list, "Fourth")

fmt.Println(list)

output:

[First Second Third Fourth]

Maps

Maps in Go is an implementation of hash table, which stores data in a key-value pair, as in below example:

personMap := make(map[string]string)

personMap["name"] = "Motaz"

personMap["address"] = "Khartoum,Sudan"

personMap["title"] = "Developer"

personMap["dob"] = "1975-11-16"

fmt.Println("Name = ", personMap["name"])

fmt.Println(personMap)

delete(personMap, "dob")

fmt.Println(personMap)

map[address:Khartoum,Sudan dob:1975-11-16 name:Motaz title:Developer]

output:

Name = Motaz

map[address:Khartoum,Sudan name:Motaz title:Developer]

Here we have initialized map of string that their keys are string also, and we could use other types such as map[string]int, that their values are integer and keys as string, or map[int]string: values are string and keys as integer.

We can iterate through map using for .. range statement as in below sample:

for key, value := range personMap {

fmt.Println(key, "=", value)

When calling a function we could call it using constant parameters such as:

output:

name = Motaz

address = Khartoum,Sudan

title = Developer

dob = 1975-11-16

Passing variables by reference

displaySum(2, 5)

or passing parameters using variable by copy:

a:= 5

b:= 6

displaySum(a, b)

Third option is to pass parameter by reference, in which we need to let function to be able to change variable value, for example swap function:

In this case we have to define parameters as pointers:

func swapNumbers(a *int, b *int) {

*a, *b = *b, *a

When calling that function we have to pass address instead of values (&a, &b):

swapNumbers(&a, &b)

Here is another example using string type: a function to change spaces to underscore in names:

func toUnderscore(name *string) {

*name = strings.ReplaceAll(*name, " ", "_")

*name = means the contents of pointer (name)

We can call it by passing variable address (&x):

name := "go language"

toUnderscore(&name)

fmt.Println(name)

We can make a general swap function using interface{} type or it’s new alias type (any) :

func swap(a, b *any) {

Generics

Generics has been added to Go in version 1.18, instead of using dynamic empty interface{} or it’s any alias type that is checking type at run-time and could generate panic error which could close application, a new method has been introduced, in this method compiler could check types at compile time and prevents errors. Here is an example of add function that could be used to add integers, float or concatenate strings:

func add[T int | float64 | string](a T, b T) (result T) {

return a + b

This generic add function could be called as in below example:

fmt.Println(add(2, 3))

fmt.Println(add(1.2, 2.1))

fmt.Println(add("Hello", " World"))

Using this generic method is more safer and faster than interface{}, the compiler will generate multiple instances of add function for each type. This represents static and strong typing discipline in Go language

Writing to text file

Here is an example of how to write string in text file, if file does not exist; writeToFile function will create it, and if file already exists it will append to it:

fmt.Println("Writing to text file")

writeToFile("text.txt", "Time in server is: "+time.Now().String())

func writeToFile(filename string, text string) (err error) {

var file *os.File

file, err = os.OpenFile(filename,

os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)

file.WriteString(text + "\n")

We have used point to type os.File in “os” package, so that we have added it to import section.

In writeToFile function we have called os.OpenFile with create and append options, if opening/creating file has succeeded and err is nil, it will write text to file, but note that we have used defer keyword statement in front of closing file (f.Close()). Defer do two things: 1: delays execution of given statement to end of current block or function, and 2: ensures execution of that statement in all cases, such as error or panic, except if explicit Exit command is called.

File mode parameter that contains 0644 is a Unix permission type giving full read-write permission to owner, and read-only for groups and others.

Reading text file

In this example we have written two ways to read from text file: first method (readLinesFromFile) is to read line by line, and second method (readEntireFile) that reads all contents at once :

filename := "main.go"

fmt.Println("Reading from text file: ", filename)

//readLinesFromFile(filename)

readEntireFile(filename)

func readLinesFromFile(filename string) (err error) {

var file *os.File

file, err = os.OpenFile(filename, os.O_RDONLY, 0644)

scanner := bufio.NewScanner(file)

for scanner.Scan() {

line := scanner.Text()

fmt.Println(line)

fmt.Println("Error: ", err.Error())

} else {

func readEntireFile(filename string) (err error) {

var file *os.File

file, err = os.OpenFile(filename, os.O_RDONLY, 0644)

contents, err = ioutil.ReadAll(file)

var contents []byte

fmt.Println("Error reding file : ", err.Error())

fmt.Print(string(contents))

} else {

fmt.Println("Error: ", err.Error())

I think the code is clear and needs no more clarifications, it reads all file contents in an array of byte, then we could typecast if to string to show it in console.

We can read filename from command line arguments by modifying main function to:

fmt.Println("readtextfile <filename>")

if len(os.Args) != 2 {

fmt.Println("Usage:")

} else {

filename := os.Args[1]

fmt.Println("Reading from text file: ", filename)

//readLinesFromFile(filename)

readEntireFile(filename)

Note that first argument (os.Args[0]) is program executable name itself with it’s path

We could call it from command line in Linux and Max as:

./readtextfile main.go

And in Windows:

readtextfile main.go

Go routines

Go routines is a way of implementing parallel running for code and using multi-core CPU. Go routine is lighter than Java thread, here is sample using of Go routines:

func displayTime(id string) {

for i := 0; i < 3; i++ {

fmt.Printf("Routine : %s time in server is: %s\n", id,

time.Now().String()[:19])

Routine : 1 time in server is: 2023-04-11 08:27:34

Output:

Routine : 2 time in server is: 2023-04-11 08:27:34

Routine : 3 time in server is: 2023-04-11 08:27:34

Routine : 1 time in server is: 2023-04-11 08:27:35

Routine : 2 time in server is: 2023-04-11 08:27:35

Routine : 3 time in server is: 2023-04-11 08:27:35

Routine : 3 time in server is: 2023-04-11 08:27:36

Routine : 1 time in server is: 2023-04-11 08:27:36

Routine : 2 time in server is: 2023-04-11 08:27:36

We have only added go keyword to run displayTime function in background as that simple.

Three routines will run simultaneously

Infinite for loop is important to keep main program wait that execution, otherwise application will exit before executing any routine. We could also add timer instead of infinite loop, because using infinite loop will not exist unless it has been closed using Ctrl-C or ending it from tasks or processes manager

go displayTime("1")

go displayTime("2")

go displayTime("3")

time.Sleep(time.Second * 3)

Wait Group

If we have Go routines or multiple Go routines that we want to run in parallel and waiting their results before proceed to next statements, we can use WaitGroup in sync package.

We have modified previous go routine sample that has three times for loop to use WaitGroup instead of infinite for loop at end of program:

var wg sync.WaitGroup

wg.Add(3)

go displayTime(&wg, "1")

go displayTime(&wg, "2")

go displayTime(&wg, "3")

wg.Wait()

fmt.Println("All routines has finished")

func displayTime(wg *sync.WaitGroup, id string) {

for i := 0; i < 3; i++ {

fmt.Printf("Routine : %s time in server is: %s\n", id,

time.Now().String()[:19])

wg.Done()

In this sample program we have declared wg variable as sync.WaitGroup type, and have initialized it for three routines using Add method ( wg.Add(3) ) and we will wait until all these three routines to finish. We have passed wg variable by reference ( &wg ) to displayTime function to call Done() method of wait group.

At main function after calling go routines we have called wg.Wait() to wait all routines to finish before proceed with next statements of program, and we could get result back for another process, such as fetching data from web in parallel then do process for that data

Output:

Routine : 3 time in server is: 2023-04-11 09:13:20

Routine : 1 time in server is: 2023-04-11 09:13:20

Routine : 2 time in server is: 2023-04-11 09:13:20

Routine : 2 time in server is: 2023-04-11 09:13:21

Routine : 1 time in server is: 2023-04-11 09:13:21

Routine : 3 time in server is: 2023-04-11 09:13:21

Routine : 2 time in server is: 2023-04-11 09:13:22

Routine : 3 time in server is: 2023-04-11 09:13:22

Routine : 1 time in server is: 2023-04-11 09:13:22

All routines has finished

Note that it is better to call Done() at the top of function with defer keyword to ensure calling it at any cases, and not let Wait() wait forever in case of crash inside function before reaching Done() method:

func displayTime(wg *sync.WaitGroup, id string) {

defer wg.Done()

for i := 0; i < 3; i++ {

fmt.Printf("Routine : %s time in server is: %s\n", id,

time.Now().String()[:19])

One of important thing in Go routines and threads is shared resources access, for example if we look back to our write to text file sample and tried to write on that file using multiple go routines, a race condition will occur, which means trying to access resource exclusively, in this case to write on file, such race condition could corrupt file or crashes the program. To prevent race condition, we have to synchronize writing to that file, by enabling only one thread/go routine to write to that file and lock the resource while writing, then release that lock after finish writing, while enforce other routines to wait first routine until finish.

Mutex

Mutex (Mutual Exclusion) in Go enables lock and unlock for any resource, here write to file sample program rewritten using go routines and mutex :

var mutex *sync.Mutex

var counter int = 0

fmt.Println("Writing to text file")

mutex = &sync.Mutex{}

for i := 0; i < 10; i++ {

go writeToFile("text.txt",

fmt.Sprintf("routine # %d: Time in server is: %s",

i+1, time.Now().String()))

time.Sleep(time.Second * 5)

mutex.Lock()

defer mutex.Unlock()

fmt.Println("Written counter: ", counter)

func writeToFile(filename string, text string) (err error) {

file, err = os.OpenFile(filename, os.O_APPEND|os.O_CREATE|

os.O_WRONLY, 0644)

file.WriteString(text + "\n")

Now we have two shared resources: external text file, and counter global variable, which they should be accessed in synchronized method for go routines.

We have defined mutex as pointer of type sync.Mutex globally in program and initialized it at main function

We used Lock() method of mutex before access shared resource, and release lock using Unlock() method after writing/reading from that resource:

mutex.Lock()

fmt.Println("Written counter: ", counter)

mutex.Unlock()

We can test our programs against race condition using below command line:

go run -race main.go

go build --race main.go

then run it as main executable normally

In our case we will get normal execution and result:

Writing to text file

Written counter: 10

If we commented out mutex.Lock() and mutext.Unlock() in writeToFile method

//mutex.Lock()

//defer mutex.Unlock()

and build the application then run go run -race main.go again, we will get race condition:

==================

WARNING: DATA RACE

Read at 0x0000005f8780 by main goroutine:

main.main()

/home/motaz/………/samples/textfiles/main.go:24 +0x266

Previous write at 0x0000005f8780 by goroutine 15:

main.writeToFile()

/home/motaz/………/samples/textfiles/main.go:31 +0x84

main.main.func1()

/home/motaz/………/samples/textfiles/main.go:19 +0x53

Goroutine 15 (finished) created at:

main.main()

/home/motaz/……/samples/textfiles/main.go:19 +0xe4

Race condition happens on below lines:

counter++

and

fmt.Println("Written counter: ", counter)

Note that race condition isn’t detected in writing to text file, only on global variable (counter) writing and reading while others are writing. This might mean that writing to a file in Go is thread-safe, but it is not guaranteed in all cases and all platforms, we are here to demonstrate the need and mechanism of using Mutex

HTTP Web Sample

Go supports HTTP web applications (backend) easily in standard networking packages. HTTP application could be either web application or web service, here is our sample application for web app:

We have created a new project as command line project with name first-web, then we have initialized module in LiteIDE.

When using Visual Code or other editor we will not need to initialize module, because we are using only standard packages in this sample:

// first-web project main.go

http.HandleFunc("/", index)

fmt.Println("Listening on \nhttp://localhost:9090")

err := http.ListenAndServe(":9090", nil)

fmt.Println("Error while listening to port 9090: " + err.Error())

func index(w http.ResponseWriter, r *http.Request) {

w.Header().Set("content-type", "text/html")

fmt.Fprintf(w, "<h2>Go Web Page</h2>")

fmt.Fprintf(w, "<font color=blue>Main index page</font>")

fmt.Fprintf(w, "<br/>Today is %s", time.Now().String())

Main important function here is http.ListenAndServe(":9090", nil), which will work as an embedded HTTP web server, listening on port (9090 in this example), and this lets program holds and keep working, and makes it a multi-threaded application server listening and serving all requests on that port.

If port is used by other process, or no permission to use (ports under 1024 requires admin permission), ListenAndServe will exit and returns error in err object and our command application will closes in this case.

Second important method is the handler: index() method that we have written to receive HTTP client requests (such as browser request through URL, curl or any HTTP client)

We have linked HTTP path request of (/) to index() handler using HandleFunc method:

http.HandleFunc("/", index)

We could add another path handler such as /hello after writing hello() method handler and link it using HandleFunc:

http.HandleFunc("/hello", hello)

func hello(w http.ResponseWriter, r *http.Request) {

w.Header().Set("content-type", "text/html")

fmt.Fprintf(w, "<h2>Hello Go</h2>")

This is a simple method for writing web pages in Go, but in real development we use templates that we will talk about it later.

Web services

Web service is using the same HTTP package and similar to web page in Go, except it has no user interface and is not targeting browsers, so that there is no HTML here, instead; it targets calling from other applications, but it is still can be called for - testing purposes - from browsers, command line tools, and browser web services plugins.

Here is a simple web service that returns server’s date and time in JSON format:

// first-service project main.go

http.HandleFunc("/time", gettime)

fmt.Println("Listening on \nhttp://localhost:9090")

err := http.ListenAndServe(":9090", nil)

fmt.Println("Error while listening to port 9090: " + err.Error())

type TimeResponseType struct {

Time string

func gettime(w http.ResponseWriter, r *http.Request) {

w.Header().Set("content-type", "application/json")

var atime TimeResponseType

atime.Time = time.Now().String()

res, _ := json.Marshal(atime)

w.Write(res)

Note that the first difference here is content-type type, which is application/json in web services instead of text/html in web pages. Also we have used struct type to return JSON response object:

type TimeResponseType struct {

Time string

We call the web service using below request URL:

http://localhost:9090/time

We will get below JSON response:

{"Time":"2023-03-10 09:32:39.072559162 +0200 CAT m=+4.697942371"}

We can add any other type as fields on this struct object (TimeResponseType), but we have to capitalize first letter of field names to make it public, if we write first letter of struct field name in small letter it will be private and will not be displayed in JSON response.

If we want to display it in JSON format as lower-case or in another name we can add JSON formatted as below:

type TimeResponseType struct {

Time string `json:"time"`

}

Another example :

Time string `json:"server-time"`

This will make field naming in JSON independent of Go field naming

Simple API sample

We have write another API sample that has three methods:

1.addorder: to send order information
2.removeorder: to remove already sent order
3.getorders: to list current exist orders

In this sample we use text file to store orders to make it simple and to focus for web services in Go without database connection complications.

Sample has been uploaded into Github repository:

https://github.com/motaz/go-api-sample

Here is main file of go-api-sample project:

package main

import (

"fmt"

"net/http"

)

func main() {

http.HandleFunc("/addorder", AddOrder)

http.HandleFunc("/removeorder", RemoveOrder)

http.HandleFunc("/getorders", GetOrders)

http.HandleFunc("/", About)

port := "10022"

fmt.Println("http://localhost:" + port)

err := http.ListenAndServe(":"+port, nil)

if err != nil {

fmt.Println("Error while listening: ", err.Error())

}

Here is request sample for /addorder method:

{"Phone":"123456789","Name":"Motaz","Address":"Khartoum"}

Here is parsing part of order:

type ordertype struct {

Phone string

Name string

Address string

}

func AddOrder(w http.ResponseWriter, r *http.Request) {

w.Header().Add("content-type", "application/json")

requestBytes, err := io.ReadAll(r.Body)

if err != nil {

fmt.Fprintf(w, err.Error())

} else {

var request ordertype

err := json.Unmarshal(requestBytes, &request)

…

You can see or download complete project from Github:

https://github.com/motaz/go-api-sample/

Go HTML templates

Go has templates processors, which enables web developers to isolate HTML design from Go code to achieve single responsibility principle and MVC in web development.

Not like PHP and JSP which allows developers to write code inside presentation (HTML) files, Go language has a simple HTML tags notation that could be used inside HTML to do presentation functions, such as displaying variables, iterating through slice to fill a table, and limited if conditions. This notation is a bridge between Go code which represents controller and presentation HTML pages. This notation is called Go template language.

We have created for templates sample a new project called (webpage) and created new sub-folder inside project folder called (templates) in which we can put HTML pages, and we have created new file called index.html with below contents:

<html>

<head>

<title>Go Template</title>

<body>

<h3>Go HTML Template web application</h3>

<p>

Time in server is: <b> {{.Time}} </b>

<br/>

Your IP address is: <b> {{.IP}} </b>

</p>

</body>

</html>

Note that {{.Time}} and {{.IP}} tags will be replaced later by values passed from Go code.

var mytemplate *template.Template

mytemplate = template.Must(template.ParseGlob("templates/*"))

fmt.Println("http://localhost:9090")

http.HandleFunc("/", index)

err := http.ListenAndServe(":9090", nil)

fmt.Println("Error while listening to port 9090")

type TemplateData struct {

IP string

Time string

func index(w http.ResponseWriter, r *http.Request) {

var data TemplateData

data.IP = r.RemoteAddr

if strings.Contains(data.IP, ":") {

data.IP = data.IP[:strings.Index(data.IP, ":")]

data.Time = time.Now().String()[:19]

mytemplate.Execute(w, data)

We have defined mytemplate global variable as point to template.Template type, then initialized it to load all HTML files in (templates) directory:

mytemplate = template.Must(template.ParseGlob("templates/*"))

We have used our own struct type (TemplateData) to encapsulate all our required variables and data to be displayed in HTML page

Then we called it inside index handler to display HTML contents and passing required variables/tags to it:

mytemplate.Execute(w, data)

r.RemoteAddr returns client IP address with port number such as: 27.0.0.1:43060 and we want to remove the port using strings package:

data.IP = r.RemoteAddr

if strings.Contains(data.IP, ":") {

data.IP = data.IP[:strings.Index(data.IP, ":")]

We can copy part of string using [:] for instance: copy first two characters:

name := "Ahmed"

name = name[:2]

and last two characters as:

name = name[len(name)-2:]

and two letters from the middle as:

name = name[2:4]

here is the output page in browser:

http://localhost:9090/

Go HTML Template web application

Time in server is: 2023-04-10 07:26:24
Your IP address is: 127.0.0.1

Static contents in Web applications

We can add front-end static contents to Go web application such as: images, css, and java script in directories and make that directory accessible to clients, from our HTTP web server using below as in our below sample.

Below sample is part of GoCat project (which is similar to Tomcat), this web application is used for Go web applications and Web services to deploy and mange that applications, complete source exist in this repository:

https://github.com/motaz/gocat

In main.go file before calling http.Listen..

fs := SetCacheHeader(http.FileServer(http.Dir("static")))

http.Handle("/gocat/static/", http.StripPrefix("/gocat/static/", fs))

We have a directory called static contains css sub-folder and images sub-folder:

We can access static contents from HTML template as in below HTML header tags:

Deploying Web apps and Web services

In production it is not practical to have many Go web applications and web services with different ports and enable/open that ports in Firewall. Support that we have 3 apps in the same server listening on ports 9090, 9091, and 9092, and more apps could be added later that requires opening new ports if deployment server is behind a firewall, instead we could use web server such as Apache or Nginx to host our applications. Nginx is more easy and ready to work as reverse proxy, here is sample of entry in sites-enabled/default file for one of our Go web apps or web services listening on port 9090:

location /timer/ {

proxy_pass http://localhost:9090/;