Go Lang - Developing a REST API

Building a RESTful API with Go

Developing a REST API with Go involves creating endpoints that respond to HTTP requests, handling data persistence, and implementing CRUD operations. Here’s a step-by-step guide to building a RESTful API using Go:

Key Steps:

Setup: Initialize a new Go module and install necessary dependencies (e.g., gorilla/mux for routing, gorm for ORM).
Define Models: Create Go structs to represent data models.
Implement Handlers: Write handler functions for each API endpoint (e.g., GET, POST, PUT, DELETE).
Routing: Use a router (e.g., gorilla/mux) to define API routes and map them to corresponding handler functions.
Data Persistence: Use an ORM (e.g., gorm) or direct SQL queries to interact with a database.
Validation: Validate incoming requests and handle errors gracefully.
Testing: Write unit tests to ensure API endpoints behave as expected.
Documentation: Document API endpoints using tools like Swagger or godoc.
Deployment: Deploy the API on a cloud platform or using Docker for containerization.

Example Code Snippet: Basic REST API in Go

Below is a simplified example of a basic REST API implementation in Go using the gorilla/mux router and gorm ORM:


package main

import (
	"log"
	"net/http"

	"github.com/gorilla/mux"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

type Todo struct {
	gorm.Model
	Title     string `json:"title"`
	Completed bool   `json:"completed"`
}

var db *gorm.DB
var err error

func main() {
	// Connect to SQLite database
	db, err = gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
	if err != nil {
		log.Fatal("Failed to connect to database:", err)
	}
	
	// Auto-migrate table
	db.AutoMigrate(&Todo{})

	// Initialize router
	r := mux.NewRouter()

	// Define API routes
	r.HandleFunc("/todos", getTodos).Methods("GET")
	r.HandleFunc("/todos/{id}", getTodo).Methods("GET")
	r.HandleFunc("/todos", createTodo).Methods("POST")
	r.HandleFunc("/todos/{id}", updateTodo).Methods("PUT")
	r.HandleFunc("/todos/{id}", deleteTodo).Methods("DELETE")

	// Start server
	log.Println("Server started on port 8080")
	log.Fatal(http.ListenAndServe(":8080", r))
}

func getTodos(w http.ResponseWriter, r *http.Request) {
	var todos []Todo
	db.Find(&todos)
	json.NewEncoder(w).Encode(todos)
}

func getTodo(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	var todo Todo
	db.First(&todo, params["id"])
	json.NewEncoder(w).Encode(todo)
}

func createTodo(w http.ResponseWriter, r *http.Request) {
	var todo Todo
	json.NewDecoder(r.Body).Decode(&todo)
	db.Create(&todo)
	json.NewEncoder(w).Encode(todo)
}

func updateTodo(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	var todo Todo
	db.First(&todo, params["id"])
	json.NewDecoder(r.Body).Decode(&todo)
	db.Save(&todo)
	json.NewEncoder(w).Encode(todo)
}

func deleteTodo(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	var todo Todo
	db.Delete(&todo, params["id"])
}

Summary

This guide provided a step-by-step approach to developing a RESTful API with Go, including setting up routes, defining models, implementing CRUD operations, and handling data persistence using an ORM. By following these steps, developers can create robust and scalable REST APIs using the Go programming language.