Creating a CRUD App With Go

Introduction

Hello! 😎

In this tutorial I will show you how to build a CRUD app using the Go programming language. By the end, you'll have a fully functioning CRUD (Create, Read, Update, Delete) app running locally. Let's get started.

---

Requirements

• Go installed
• Basic understanding of Go

---

Setting up the project

Create a new directory for the project and navigate into it:

mkdir crud-app && cd crud-app

Next we will initialize the go module and install the dependencies:

go mod init go-crud-app
go get -u github.com/gorilla/mux

Now that the project and required packages are installed we can start working on the application. 😸

---

Coding the Application

Create a new file called "main.go" and import the following:

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "strconv"
    "github.com/gorilla/mux"
)

• encoding/json: For encoding and decoding JSON data
• log: For logging errors
• net/http: For building the HTTP server
• strconv: For converting strings to integers
• github.com/gorilla/mux: A popular package for routing HTTP requests

Next we define our global variables like so:

var memos []Memo
var idCounter int

• memos: A slice that will store all our memos
• idCounter: A counter to keep track of memo IDs

Now we need to create a struct to define a memo:

type Memo struct {
    ID      int    `json:"id"`
    Title   string `json:"title"`
    Content string `json:"content"`
}

Next we will create handlers for each of the CRUD operations, the first one will handle create a new memo:

func createMemo(w http.ResponseWriter, r *http.Request) {
    var memo Memo
    json.NewDecoder(r.Body).Decode(&memo)
    idCounter++
    memo.ID = idCounter
    memos = append(memos, memo)
    json.NewEncoder(w).Encode(memo)
}

• Decode the JSON request body into a memo struct
• Increment the idCounter and assign a new memo
• Append the new memo to the memos slice
• Encode and return the created memo as a JSON response

The next function will handle getting all the memos:

func getMemos(w http.ResponseWriter, r *http.Request) {
    json.NewEncoder(w).Encode(memos)
}

• Encode and return the memos slice as a JSON response

Below is the handler to handle getting a single memo:

func getMemo(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])

    for _, memo := range memos {
        if memo.ID == id {
            json.NewEncoder(w).Encode(memo)
            return
        }
    }

    http.Error(w, "Memo not found", http.StatusNotFound)
}

• Retrieve the id from the URL parameters
• Search for the memo with the matching ID in the memos slice
• Return the memo if found, otherwise returns a 404 error

The next function handles updating a memo:

func updateMemo(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])

    for i, memo := range memos {
        if memo.ID == id {
            json.NewDecoder(r.Body).Decode(&memo)
            memo.ID = id
            memos[i] = memo
            json.NewEncoder(w).Encode(memo)
            return
        }
    }

    http.Error(w, "Memo not found", http.StatusNotFound)
}

• Retrieve the id from the URL parameters
• Search for the memo with the matching ID in the memos slice
• Decode the JSON request body into the found memo and update it
• Return the updated memo as a JSON response or return a 404 error if not found

Lastly we need a function to handle the delete operation:

func deleteMemo(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])

    for i, memo := range memos {
        if memo.ID == id {
            memos = append(memos[:i], memos[i+1:]...)
            json.NewEncoder(w).Encode("The memo was deleted successfully")
            return
        }
    }

    http.Error(w, "Memo not found", http.StatusNotFound)
}

• Retrieve the id from the URL parameters
• Search for the memo with the matching ID in the memos slice
• Delete the memo by removing it from the slice
• Return a success message or a 404 error if the memo is not found

Next we need to set up the routes to handle each of the CRUD requests:

func initializeRouter() {
    router := mux.NewRouter()

    router.HandleFunc("/memos", createMemo).Methods("POST")
    router.HandleFunc("/memos", getMemos).Methods("GET")
    router.HandleFunc("/memos/{id}", getMemo).Methods("GET")
    router.HandleFunc("/memos/{id}", updateMemo).Methods("PUT")
    router.HandleFunc("/memos/{id}", deleteMemo).Methods("DELETE")

    log.Fatal(http.ListenAndServe(":8000", router))
}

• Initialize a new router using mux.NewRouter
• Define routes for each CRUD operation and map them to the respective handlers
• Start the HTTP server on port 8000

Finally we need to implement the main function, as so:

func main() {
    memos = append(memos, Memo{ID: 1, Title: "First memo", Content: "Hello World"})
    idCounter = 1
    initializeRouter()
}

• Initialize the memos slice with a sample memo
• Set the idCounter to 1
• Call the previous initializeRouter function to start the server

Done! Now we can move onto testing the application. 😆

---

Testing the Application

First we need to start the server before we can make requests to it, this is done via the following command:

go run main.go

Now we can use the following CURL commands to test each of the endpoints.

Create a memo:

curl -X POST -d '{"title":"New Memo","content":"This is a new memo."}' -H "Content-Type: application/json" http://localhost:8000/memos

Get all memos:

curl http://localhost:8000/memos

Get a memo by it's ID:

curl http://localhost:8000/memos/1

Update a memo:

curl -X PUT -d '{"title":"Updated Memo","content":"This is an updated memo."}' -H "Content-Type: application/json" http://localhost:8000/memos/1

Delete a memo:

curl -X DELETE http://localhost:8000/memos/1

Feel free to change the contents and have a play around with it. 👀

---

Conclusion

In this tutorial I have shown how to implement a CRUD application using the Go programming language, I'm having a lot of fun learning Go and I hope this tutorial has helped you.

As always you can find the sample code on my Github:
https://github.com/ethand91/go-crud

Happy Coding! 😎

---

Like my work? I post about a variety of topics, if you would like to see more please like and follow me.
Also I love coffee.

If you are looking to learn Algorithm Patterns to ace the coding interview I recommend the [following course](https://algolab.so/p/algorithms-and-data-structure-video-course?affcode=1413380_bzrepgch

Comments

[Matin Mollapur]

this is an awesome tutorial for creating a CRUD app with go! the step-by-step approach makes it easy to follow, even for beginners. i appreciate how you covered everything from setting up the project to writing and testing each endpoint. the explanations are clear and the code examples are practical. great job making go accessible and fun to learn! looking forward to more tutorials from you.

[Ethan]

Thanks for the lovely comment <3 I'll do my best! :)

[Antonio | CEO at Litlyx.com]

Great! Im Listening a lot of positive things on Golang in this period. Definitely to be learned! There is some power in this lang, i really want to learn the tips and tricks.

Thanks a lot for sharing this Entry level CRUD app for us all.

Antonio, CEO at Litlyx

[Ethan]

Your welcome :)
I'm glad you like it

[developedbyjk]

Interesting 🧠 Never Tried Go Though 🤔💭

[Ethan]

I'm also new to it, it's different from the other languages but it is fun to learn

[Amit Kumar Rout]

I am studying GOLANG currently. This will help in building projects.

[Ethan]

Good luck in your studies :)

[Sysmat]

• gorilla/mux is not even techempower.com/benchmarks
• use interface for CRUD then you can swap implementation if something change

[Douglas Taylor]

pizdez