This content originally appeared on DEV Community and was authored by Neel Patel
Building Your First REST API with Go – Let’s Get Started!
So, you’ve heard the buzz about Go, right? It’s fast, it’s simple, and it’s basically the rockstar of backend development these days. If you’re new to Go or just looking to build something cool with it, you’ve come to the right place. This week, we’re going to take a dive into building your very own REST API with Go, so buckle up—it’s gonna be a fun ride!
Why Go?
Now, why exactly are so many devs swooning over Go? Well, imagine this: Google engineers, tired of waiting around for their programs to compile, decided to create something that wouldn't make them want to tear their hair out. Enter Go—a language that doesn’t just get the job done but does it fast and effortlessly.
Go is built for today’s hardware, taking full advantage of multi-core systems. Its secret weapon? Goroutines—these magical little concurrent workers that can handle tons of tasks simultaneously without breaking a sweat. Whether you’re building web apps, APIs, or microservices, Go keeps things running smoothly, like that well-oiled machine you always dream of.
And here’s the kicker: Go is stupidly easy to learn. Whether you’re switching over from Python, Java, or even something as “classic” as PHP, you’ll be up and coding in Go before you can say "Hello, World!" And it runs fast—like, really fast. Need I say more?
Setting Up Your Go Project
Alright, enough chit-chat, let’s get our hands dirty. First, we need to set up a simple Go project. Don’t worry, I’ve got you covered:
Make sure Go is installed. If not, grab it here.
Now, let’s create a project directory and initialize the project:
mkdir go-rest-api
cd go-rest-api
go mod init github.com/yourusername/go-rest-api
- Inside this directory, create a new file called
main.go, and get ready for some coding magic.
Writing the API
Here’s where things get exciting! We’re going to build a super simple API to manage a list of books (because who doesn’t love books?). Our API will have the following endpoints:
-
GET /books– Fetch all the books (yay, books!) -
POST /books– Add a new book -
GET /books/:id– Fetch a specific book by its ID (because not all books are created equal)
Ready? Let’s dive into the code:
package main
import (
"encoding/json"
"fmt"
"log"
"net/http"
"strconv"
"github.com/gorilla/mux"
)
type Book struct {
ID int `json:"id"`
Title string `json:"title"`
Author string `json:"author"`
}
var books []Book
// Get all books
func getBooks(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(books)
}
// Get a single book by ID
func getBook(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
id, err := strconv.Atoi(params["id"])
if err != nil {
http.Error(w, "Invalid book ID", http.StatusBadRequest)
return
}
for _, book := range books {
if book.ID == id {
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(book)
return
}
}
http.Error(w, "Book not found", http.StatusNotFound)
}
// Add a new book
func createBook(w http.ResponseWriter, r *http.Request) {
var book Book
_ = json.NewDecoder(r.Body).Decode(&book)
book.ID = len(books) + 1 // Assign an ID (we’re just winging it here)
books = append(books, book)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(book)
}
func main() {
// Add some dummy data to start with
books = append(books, Book{ID: 1, Title: "The Go Programming Language", Author: "Alan A. A. Donovan"})
books = append(books, Book{ID: 2, Title: "Learning Go", Author: "Jon Bodner"})
// Initialize the router
r := mux.NewRouter()
// Define the endpoints
r.HandleFunc("/books", getBooks).Methods("GET")
r.HandleFunc("/books/{id}", getBook).Methods("GET")
r.HandleFunc("/books", createBook).Methods("POST")
// Start the server
fmt.Println("Server is running on port 8000...")
log.Fatal(http.ListenAndServe(":8000", r))
}
Breaking It Down
-
Mux Router: We’re using
gorilla/muxto handle routing in our API. It makes it easy to define routes and is a go-to for building web services in Go. You can install it with:
go get -u github.com/gorilla/mux
Handlers: We’ve set up
getBooks,getBook, andcreateBookfunctions to handle HTTP requests. They use Go’snet/httppackage to handle responses and data encoding/decoding. Easy-peasy!JSON Encoding: Go’s built-in
jsonpackage is doing the heavy lifting here, converting our data into JSON format for easy communication between the client and the API.
Running the API
Now for the fun part—let’s run this thing! In your terminal, simply execute:
go run main.go
Boom! Your API is up and running. You can now use tools like Postman or curl to test it:
- Get all books:
curl http://localhost:8000/books
- Get a specific book:
curl http://localhost:8000/books/1
- Add a new book:
curl -X POST http://localhost:8000/books -d '{"title":"New Book","author":"New Author"}' -H "Content-Type: application/json"
What’s Next?
This little API is just the tip of the iceberg when it comes to what Go can do in backend development. Next week, we’ll level up by adding authentication (yep, we’re going full JWT) and protecting these endpoints from unwanted visitors.
Stay tuned for part 2 -- Setting up middleware for authentication in a REST API using JWT (JSON Web Tokens) in Go
This content originally appeared on DEV Community and was authored by Neel Patel
Neel Patel | Sciencx (2024-10-02T05:16:19+00:00) Building Your First REST API with Go. Retrieved from https://www.scien.cx/2024/10/02/building-your-first-rest-api-with-go-2/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.