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