{"id":183,"date":"2026-07-07T20:35:18","date_gmt":"2026-07-07T20:35:18","guid":{"rendered":"https:\/\/kindsonthegenius.com\/go\/2026\/07\/07\/12-go-http-rest-api\/"},"modified":"2026-07-07T20:38:40","modified_gmt":"2026-07-07T20:38:40","slug":"12-go-http-rest-api","status":"publish","type":"post","link":"https:\/\/kindsonthegenius.com\/go\/2026\/07\/07\/12-go-http-rest-api\/","title":{"rendered":"Go HTTP REST API \u2013 Build a Complete Books Service (Capstone)"},"content":{"rendered":"

<\/p>\n

\n

Updated July 2, 2026.<\/strong> Refreshed for Go 1.22+ and current SEO best practices.<\/p>\n<\/div>\n

Welcome to the Go REST API tutorial<\/strong> capstone \u2014 Lesson 12 of this series. You will build a complete HTTP service with net\/http<\/code> that exposes JSON CRUD endpoints for a books<\/code> resource. This lesson ties together everything you learned: structs, pointers, error handling, JSON encoding, and concurrent request handling with goroutines. By the end you will have a runnable API you can test with curl<\/code> or Postman.<\/p>\n

Prerequisites:<\/strong> Lessons 1\u201311 completed, Go 1.22 or newer installed. Estimated time:<\/strong> 75\u201390 minutes.<\/p>\n

1. Complete Go Tutorial Series Overview<\/h4>\n

You have reached the final lesson. Here is the full twelve-lesson path \u2014 start from Lesson 1 if you are new, or use this table to revisit any topic:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Lesson<\/th>\nTopic<\/th>\nLink<\/th>\n<\/tr>\n<\/thead>\n
1<\/td>\nGo Programming Introduction<\/td>\nLesson 1<\/a><\/td>\n<\/tr>\n
2<\/td>\nGo Programming Setup<\/td>\nLesson 2<\/a><\/td>\n<\/tr>\n
3<\/td>\nGo Basic Syntax<\/td>\nLesson 3<\/a><\/td>\n<\/tr>\n
4<\/td>\nGo Variables and Types<\/td>\nLesson 4<\/a><\/td>\n<\/tr>\n
5<\/td>\nGo Control Flow<\/td>\nLesson 5<\/a><\/td>\n<\/tr>\n
6<\/td>\nGo Functions<\/td>\nLesson 6<\/a><\/td>\n<\/tr>\n
7<\/td>\nGo Arrays, Slices, and Maps<\/td>\nLesson 7<\/a><\/td>\n<\/tr>\n
8<\/td>\nGo Structs and Methods<\/td>\nLesson 8<\/a><\/td>\n<\/tr>\n
9<\/td>\nGo Pointers<\/td>\nLesson 9<\/a><\/td>\n<\/tr>\n
10<\/td>\nGo Interfaces and Errors<\/td>\nLesson 10<\/a><\/td>\n<\/tr>\n
11<\/td>\nGo Goroutines and Channels<\/td>\nLesson 11<\/a><\/td>\n<\/tr>\n
12<\/td>\nGo HTTP REST API (this lesson)<\/td>\nYou are here<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

If you come from Java or enterprise backends, compare this Go service with the Spring Boot tutorials on munonye.com<\/a> \u2014 especially the Angular + Spring Boot CRUD series<\/a> and the complete REST API guide<\/a>. The HTTP verbs and JSON payloads are the same; Go’s net\/http<\/code> is lighter than a full Spring stack but follows identical REST principles.<\/p>\n

2. API Architecture<\/h4>\n

Our books service follows a layered design: the HTTP server receives requests, route handlers parse input and call the store, and the store manages an in-memory map protected by a mutex. Each incoming request runs in its own goroutine \u2014 Go’s default concurrency model for HTTP.<\/p>\n

\n\"Go
Go REST API architecture \u2014 client requests flow through net\/http handlers to an in-memory BookStore with JSON encoding.<\/figcaption><\/figure>\n

The API exposes these endpoints:<\/p>\n\n\n\n\n\n\n\n\n\n
Method<\/th>\nPath<\/th>\nAction<\/th>\n<\/tr>\n<\/thead>\n
GET<\/code><\/td>\n\/api\/books<\/code><\/td>\nList all books<\/td>\n<\/tr>\n
GET<\/code><\/td>\n\/api\/books\/{id}<\/code><\/td>\nGet one book by ID<\/td>\n<\/tr>\n
POST<\/code><\/td>\n\/api\/books<\/code><\/td>\nCreate a new book<\/td>\n<\/tr>\n
PUT<\/code><\/td>\n\/api\/books\/{id}<\/code><\/td>\nUpdate an existing book<\/td>\n<\/tr>\n
DELETE<\/code><\/td>\n\/api\/books\/{id}<\/code><\/td>\nDelete a book<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

3. Project Setup<\/h4>\n

Create a new module and project folder. From your terminal:<\/p>\n

mkdir books-api && cd books-api\ngo mod init github.com\/kindsonthegenius\/books-api\n<\/code><\/pre>\n
We will use a single main.go<\/code> file for clarity. In production you would split handlers, models, and store into separate packages \u2014 but one file keeps the capstone easy to follow and run.<\/p>\n
4. Book Model and Thread-Safe Store<\/h4>\n
Define the Book<\/code> struct with JSON tags so field names serialize correctly. The BookStore<\/code> wraps a map with a sync.RWMutex<\/code> \u2014 multiple goroutines (one per HTTP request) can read and write safely:<\/p>\n
package main\n\nimport (\n\t\"encoding\/json\"\n\t\"errors\"\n\t\"fmt\"\n\t\"log\"\n\t\"net\/http\"\n\t\"strconv\"\n\t\"strings\"\n\t\"sync\"\n)\n\ntype Book struct {\n\tID     int     `json:\"id\"`\n\tTitle  string  `json:\"title\"`\n\tAuthor string  `json:\"author\"`\n\tPrice  float64 `json:\"price\"`\n}\n\ntype BookStore struct {\n\tmu    sync.RWMutex\n\tbooks map[int]Book\n\tnext  int\n}\n\nfunc NewBookStore() *BookStore {\n\treturn &BookStore{\n\t\tbooks: map[int]Book{\n\t\t\t1: {ID: 1, Title: \"The Go Programming Language\", Author: \"Donovan & Kernighan\", Price: 39.99},\n\t\t\t2: {ID: 2, Title: \"Concurrency in Go\", Author: \"Katherine Cox-Buday\", Price: 34.99},\n\t\t},\n\t\tnext: 3,\n\t}\n}\n\nvar ErrNotFound = errors.New(\"book not found\")\n\nfunc (s *BookStore) List() []Book {\n\ts.mu.RLock()\n\tdefer s.mu.RUnlock()\n\tlist := make([]Book, 0, len(s.books))\n\tfor _, b := range s.books {\n\t\tlist = append(list, b)\n\t}\n\treturn list\n}\n\nfunc (s *BookStore) Get(id int) (Book, error) {\n\ts.mu.RLock()\n\tdefer s.mu.RUnlock()\n\tb, ok := s.books[id]\n\tif !ok {\n\t\treturn Book{}, ErrNotFound\n\t}\n\treturn b, nil\n}\n\nfunc (s *BookStore) Create(b Book) Book {\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\tb.ID = s.next\n\ts.next++\n\ts.books[b.ID] = b\n\treturn b\n}\n\nfunc (s *BookStore) Update(id int, b Book) (Book, error) {\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\tif _, ok := s.books[id]; !ok {\n\t\treturn Book{}, ErrNotFound\n\t}\n\tb.ID = id\n\ts.books[id] = b\n\treturn b, nil\n}\n\nfunc (s *BookStore) Delete(id int) error {\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\tif _, ok := s.books[id]; !ok {\n\t\treturn ErrNotFound\n\t}\n\tdelete(s.books, id)\n\treturn nil\n}\n<\/code><\/pre>\n
Notice how each store method returns error<\/code> for not-found cases \u2014 the same pattern from Lesson 10. The mutex ensures that a concurrent POST<\/code> and DELETE<\/code> on the same book cannot corrupt the map.<\/p>\n
5. HTTP Handlers and JSON Responses<\/h4>\n
Handlers parse the request, call the store, and write JSON responses with appropriate status codes. A helper function keeps error responses consistent:<\/p>\n
func writeJSON(w http.ResponseWriter, status int, data any) {\n\tw.Header().Set(\"Content-Type\", \"application\/json\")\n\tw.WriteHeader(status)\n\tif err := json.NewEncoder(w).Encode(data); err != nil {\n\t\tlog.Printf(\"writeJSON: %v\", err)\n\t}\n}\n\nfunc writeError(w http.ResponseWriter, status int, message string) {\n\twriteJSON(w, status, map[string]string{\"error\": message})\n}\n\ntype BookHandler struct {\n\tstore *BookStore\n}\n\nfunc (h *BookHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n\tpath := strings.TrimPrefix(r.URL.Path, \"\/api\/books\")\n\tpath = strings.Trim(path, \"\/\")\n\n\tswitch {\n\tcase path == \"\" && r.Method == http.MethodGet:\n\t\twriteJSON(w, http.StatusOK, h.store.List())\n\n\tcase path == \"\" && r.Method == http.MethodPost:\n\t\tvar b Book\n\t\tif err := json.NewDecoder(r.Body).Decode(&b); err != nil {\n\t\t\twriteError(w, http.StatusBadRequest, \"invalid JSON body\")\n\t\t\treturn\n\t\t}\n\t\tif b.Title == \"\" || b.Author == \"\" {\n\t\t\twriteError(w, http.StatusBadRequest, \"title and author are required\")\n\t\t\treturn\n\t\t}\n\t\tcreated := h.store.Create(b)\n\t\twriteJSON(w, http.StatusCreated, created)\n\n\tcase path != \"\":\n\t\tid, err := strconv.Atoi(path)\n\t\tif err != nil {\n\t\t\twriteError(w, http.StatusBadRequest, \"invalid book id\")\n\t\t\treturn\n\t\t}\n\t\th.handleByID(w, r, id)\n\n\tdefault:\n\t\twriteError(w, http.StatusMethodNotAllowed, \"method not allowed\")\n\t}\n}\n\nfunc (h *BookHandler) handleByID(w http.ResponseWriter, r *http.Request, id int) {\n\tswitch r.Method {\n\tcase http.MethodGet:\n\t\tb, err := h.store.Get(id)\n\t\tif errors.Is(err, ErrNotFound) {\n\t\t\twriteError(w, http.StatusNotFound, err.Error())\n\t\t\treturn\n\t\t}\n\t\twriteJSON(w, http.StatusOK, b)\n\n\tcase http.MethodPut:\n\t\tvar b Book\n\t\tif err := json.NewDecoder(r.Body).Decode(&b); err != nil {\n\t\t\twriteError(w, http.StatusBadRequest, \"invalid JSON body\")\n\t\t\treturn\n\t\t}\n\t\tupdated, err := h.store.Update(id, b)\n\t\tif errors.Is(err, ErrNotFound) {\n\t\t\twriteError(w, http.StatusNotFound, err.Error())\n\t\t\treturn\n\t\t}\n\t\twriteJSON(w, http.StatusOK, updated)\n\n\tcase http.MethodDelete:\n\t\tif err := h.store.Delete(id); errors.Is(err, ErrNotFound) {\n\t\t\twriteError(w, http.StatusNotFound, err.Error())\n\t\t\treturn\n\t\t}\n\t\tw.WriteHeader(http.StatusNoContent)\n\n\tdefault:\n\t\twriteError(w, http.StatusMethodNotAllowed, \"method not allowed\")\n\t}\n}\n<\/code><\/pre>\n
BookHandler<\/code> implements http.Handler<\/code> by defining a ServeHTTP<\/code> method \u2014 the interface from Lesson 10 in action. Go 1.22+ also supports method-based routing with patterns like GET \/api\/books\/{id}<\/code>, but manual path parsing keeps this example compatible and easy to understand.<\/p>\n
6. Starting the Server<\/h4>\n
Wire everything together in main<\/code>. Register the handler and listen on port 8080:<\/p>\n
func main() {\n\tstore := NewBookStore()\n\thandler := &BookHandler{store: store}\n\n\tmux := http.NewServeMux()\n\tmux.Handle(\"\/api\/books\", handler)\n\tmux.Handle(\"\/api\/books\/\", handler)\n\n\taddr := \":8080\"\n\tfmt.Printf(\"Books API listening on http:\/\/localhost%s\\n\", addr)\n\tfmt.Println(\"Try: curl http:\/\/localhost:8080\/api\/books\")\n\tif err := http.ListenAndServe(addr, mux); err != nil {\n\t\tlog.Fatal(err)\n\t}\n}\n<\/code><\/pre>\n
Run the server:<\/p>\n
go run .\n<\/code><\/pre>\n
Test the full CRUD lifecycle with curl<\/code>:<\/p>\n
# List all books\ncurl http:\/\/localhost:8080\/api\/books\n\n# Get one book\ncurl http:\/\/localhost:8080\/api\/books\/1\n\n# Create a book\ncurl -X POST http:\/\/localhost:8080\/api\/books \\\n  -H \"Content-Type: application\/json\" \\\n  -d '{\"title\":\"Learning Go\",\"author\":\"Me\",\"price\":29.99}'\n\n# Update a book\ncurl -X PUT http:\/\/localhost:8080\/api\/books\/3 \\\n  -H \"Content-Type: application\/json\" \\\n  -d '{\"title\":\"Learning Go (2nd ed)\",\"author\":\"Me\",\"price\":34.99}'\n\n# Delete a book\ncurl -X DELETE http:\/\/localhost:8080\/api\/books\/3\n<\/code><\/pre>\n
Each curl<\/code> request is handled in a separate goroutine. The RWMutex<\/code> allows concurrent reads (GET<\/code>) while writes (POST<\/code>, PUT<\/code>, DELETE<\/code>) hold an exclusive lock \u2014 a pattern you will recognize from the Goroutines lesson.<\/p>\n
7. Next Steps Beyond the Capstone<\/h4>\n
Congratulations \u2014 you have completed the twelve-lesson Go programming tutorial. Your books API is a solid foundation. To move toward production, consider these enhancements:<\/p>\n