DEV Community

Cover image for Go: CRUD API using Gin Framework
Ankit malik
Ankit malik

Posted on

Go: CRUD API using Gin Framework

Introduction:

Building APIs that perform CRUD (Create, Read, Update, and Delete) operations is a common requirement for many web applications. The Gin framework is a popular choice for building APIs in Go, as it provides a robust set of features and is easy to use. In this article, we'll walk through how to create a basic CRUD API using the Gin framework and the Go programming language.

Installation

To install the Gin framework. We can do this by running the following command in the terminal:

go get -u github.com/gin-gonic/gin

Enter fullscreen mode Exit fullscreen mode

Example

Let's look at an example using a User object for CRUD api with the help of Gin framework.

package main

import (
    "net/http"
    "strconv"

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

type User struct {
    ID       int    `json:"id"`
    Username string `json:"username"`
    Email    string `json:"email"`
}

var users []User

func main() {
    r := gin.Default()

    // Initialize the users variable
    users = []User{
        {ID: 1, Username: "user1", Email: "user1@example.com"},
        {ID: 2, Username: "user2", Email: "user2@example.com"},
    }

    // Define routes for user API
    r.GET("/users", GetUsers)
    r.GET("/users/:id", GetUserByID)
    r.POST("/users", CreateUser)
    r.PUT("/users/:id", UpdateUser)
    r.DELETE("/users/:id", DeleteUser)

    r.Run(":8080")
}

// Get all users
func GetUsers(c *gin.Context) {
    c.JSON(http.StatusOK, users)
}

// Get a single user by ID
func GetUserByID(c *gin.Context) {
    id := c.Param("id")

    for _, user := range users {
        if strconv.Itoa(user.ID) == id {
            c.JSON(http.StatusOK, user)
            return
        }
    }

    c.JSON(http.StatusNotFound, gin.H{"message": "User not found"})
}

// Create a new user
func CreateUser(c *gin.Context) {
    var user User

    if err := c.BindJSON(&user); err != nil {
        c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    user.ID = len(users) + 1
    users = append(users, user)

    c.JSON(http.StatusCreated, user)
}

// Update an existing user
func UpdateUser(c *gin.Context) {
    id := c.Param("id")

    for i, user := range users {
        if strconv.Itoa(user.ID) == id {
            var updatedUser User

            if err := c.BindJSON(&updatedUser); err != nil {
                c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": err.Error()})
                return
            }

            updatedUser.ID = user.ID
            users[i] = updatedUser

            c.JSON(http.StatusOK, updatedUser)
            return
        }
    }

    c.JSON(http.StatusNotFound, gin.H{"message": "User not found"})
}

// Delete a user
func DeleteUser(c *gin.Context) {
    id := c.Param("id")

    for i, user := range users {
        if strconv.Itoa(user.ID) == id {
            users = append(users[:i], users[i+1:]...)
            c.JSON(http.StatusOK, gin.H{"message": "User deleted successfully"})
            return
        }
    }

    c.JSON(http.StatusNotFound, gin.H{"message": "User not found"})
}


Enter fullscreen mode Exit fullscreen mode

In this example, the User struct has three fields: ID, Username, and Email. The HTTP handlers for the CRUD operations are very similar to the ones in the previous example, except they operate on the users slice instead of the books slice.

Benefits of Using Gin framework

There are several benefits to using the Gin framework for building web applications and APIs in Go:

  • Fast and Lightweight: Gin is designed to be lightweight and performant, making it an excellent choice for building high-performance web applications and APIs.
  • Easy to Use: Gin's simple and intuitive API makes it easy to get started with, even if you're new to Go or web development.
  • Robust Routing: Gin provides a powerful and flexible routing engine that allows you to define your routes using a variety of HTTP methods, URL patterns, and middleware functions.
  • Middleware Support: Gin comes with a built-in middleware stack that provides support for things like logging, error handling, authentication, and more.
  • Scalable: Gin is designed to be scalable and can handle large volumes of traffic with ease. It's also highly customizable, making it easy to add additional features and functionality as your application grows.

Conclusion:

The Gin framework is a powerful tool for building APIs in Go, and it makes it easy to create CRUD APIs that perform the basic operations required by most web applications. In this article, we've demonstrated how to use Gin to create a basic CRUD API for managing users. With the code examples provided, you should have a good starting point for building your own APIs using the Gin framework.

Top comments (3)

Collapse
 
dyfet profile image
David Sugar

I originally started with gin, then rapidly migrated to fiber, where I have been ever since.

Collapse
 
ankitmalikg profile image
Ankit malik • Edited

@dyfet
That is similar to express framework.
What benefits did you find in the fiber over Gin?

Collapse
 
dyfet profile image
David Sugar

Better performance and much smaller executable sizes. The latter surprised me, but it appears gin code has a lot of dependencies, including protobuf, that fiber does not have.