Yes, using Go's standard library makes it easy to build REST APIs without relying on third-party frameworks. 1. Create the project structure and initialize the module: create main.go, handlers.go, models.go and go.mod files, and run go mod init myapi. 2. Define the data model: Define the User structure in models.go, including ID, Name, Email fields and corresponding json tags. 3. Write HTTP processor functions: implement getUsers, getUser and createUser functions in handlers.go, respectively, process the acquisition of all users, obtaining a single user according to the ID, and creating a new user request, set the correct content type and perform JSON encoding. 4. Configure the route and start the server: Use http.NewServeMux to register GET /users, POST /users and GET /users/{id} routes in main.go. Go 1.22 supports path parameters {id}, and finally start the service through http.ListenAndServe. 5. Test API: Use the curl command to send POST and GET requests to verify the interface function. In addition, third-party frameworks such as Gin are optional for more powerful routing, middleware and error handling capabilities. In actual projects, you also need to connect to the database, use context, add input verification and write tests, but the standard library is fast enough to build a lightweight REST API, which is simple and efficient in design, small code volume and superior performance.

Building a REST API in Go is straightforward thanks to Go's built-in net/http package and its clean, minimal design. You don't need a heavy framework — though popular ones like Gin or Echo exist — to get a production-ready API up and running.

Here's how to build a basic REST API in Go using only the standard library, step by step.

1. Set Up Your Project Structure

Start with a simple project layout:

 myapi/
├── main.go
├── handlers.go
├── models.go
└── go.mod

Initialize your module:

 go mod init myapi

2. Define Your Data Model

In models.go , define a struct to represent your data (eg, a User ):

 // models.go
package main

type User struct {
    ID int `json:"id"`
    Name string `json:"name"`
    Email string `json:"email"`
}

3. Create HTTP Handlers

In handlers.go , write functions to handle HTTP requests. These functions must match the http.HandlerFunc signature.

 // handlers.go
package main

import (
    "encoding/json"
    "net/http"
)

var users []User
var nextID = 1

// GET /users - Return all users
func getUsers(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}

// GET /users/{id} - Return a single user
func getUser(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id") // Go 1.22 supports named path parameters
    // For older versions, parse from r.URL.Path manually
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"message": "Get user " id})
}

// POST /users - Create a new user
func createUser(w http.ResponseWriter, r *http.Request) {
    var user User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        Return
    }
    user.ID = nextID
    nextID  
    users = append(users, user)

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

?? Note: r.PathValue() requires Go 1.22 . For earlier versions, extract the ID from r.URL.Path manually using strings.Split .

4. Set Up Routes in main.go

 // main.go
package main

import (
    "net/http"
    "log"
)

func main() {
    mux := http.NewServeMux()

    // Register routes
    mux.HandleFunc("GET /users", getUsers)
    mux.HandleFunc("POST /users", createUser)
    mux.HandleFunc("GET /users/{id}", getUser)

    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", mux))
}

Go 1.22 supports pattern matching in ServeMux , so you can use {id} as a placeholder.

5. Test Your API

Run the server:

 go run main.go

Now test with curl :

 # Create a user
curl -X POST http://localhost:8080/users \
  -H "Content-Type: application/json" \
  -d '{"name":"Alice","email":"alice@example.com"}'

# Get all users
curl http://localhost:8080/users

Optional: Use a Router (Like Gorilla Mux or Gin)

For more complex routing, use a third-party router.

Example with Gin :

 go get github.com/gin-gonic/gin

 package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    r.GET("/users", getUsers)
    r.POST("/users", createUser)
    r.Run(":8080")
}

Gin provides better error handling, middleware, and performance.

Key Points to Remember

• Use json tags in structs for proper serialization.
• Always set Content-Type: application/json .
• Validate input and handle errors gracefully.
• Avoid global variables in production — use dependency injection.
• Add middleware for logging, auth, CORS, etc.

For a real-world API, you'd also:

• Connect to a database (eg, PostgreSQL with pgx or gorm )
• Use context for timeouts and cancellation
• Implement proper error responses
• Add input validation
• Write tests using net/http/httptest

But for a simple REST API, Go's standard library is more than enough to get started.

Basically, it's clean, fast, and doesn't require much code.

The above is the detailed content of How do you build a REST API in Go?. For more information, please follow other related articles on the PHP Chinese website!