How to build a RESTful API using Golang and use an ORM?

Building a RESTful API using Golang and using an ORM involves the following steps: Create the API using Gin. Install and use GORM as your ORM. Define data models and apply database migrations. Create a CRUD API route. Use GORM for database operations. Deploy API and front-end applications.

How to use Golang to build a RESTful API and use ORM

Introduction

RESTful API uses web standards such as HTTP, URL and JSON to A standard for modern application programming interfaces for interacting with servers and getting data. In this article, we will learn how to build a RESTful API using Golang and leverage an ORM (Object Relational Mapper) to simplify interaction with the database.

Prerequisites

• Install Golang 1.16+
• Install a database (such as MySQL or PostgreSQL)

Build API using Gin

Gin is an open source web framework for building Go applications. First, install Gin using the following command:

go get github.com/gin-gonic/gin

Then, let us create a new file named main.go and write the following code:

package main

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

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

    router.GET("/hello", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello, World!",
        })
    })

    router.Run()
}

In the terminal Run go run main.go and navigate to localhost:8080/hello in your browser. You should see a JSON response containing Hello, World!.

Using GORM as an ORM

GORM is an open source ORM in Go language that simplifies interaction with databases. First, install GORM:

go get -u gorm.io/gorm

In main.go, add the following code:

import (
    "gorm.io/gorm"
    "gorm.io/driver/mysql"
)

var DB *gorm.DB

func connectDB() {
    // 替换 "user", "password", "dbname" 为实际值
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        // 处理连接错误
    }
    DB = db
}

Define the data model

Let us define a file named Data model of Todo:

type Todo struct {
    gorm.Model
    Task string
    Done bool
}

Create tables and migrate

Before running the API, we need to create tables and migrate the database schema. Run the following command in the terminal:

go run main.go migrate

This will print the migration script. Run the following command to apply the migration:

go run main.go migrate --migration-dir=./migrations up

CRUDAPI

Now, we can define our CRUD API routes:

// 创建 Todo
router.POST("/todos", createTodo)

// 获取所有 Todo
router.GET("/todos", getTodos)

// 获取指定 Todo
router.GET("/todos/:id", getTodoByID)

// 更新 Todo
router.PUT("/todos/:id", updateTodo)

// 删除 Todo
router.DELETE("/todos/:id", deleteTodo)

In each function, Use GORM for database operations, for example:

func getTodos(c *gin.Context) {
    var todos []Todo
    if err := DB.Find(&todos).Error; err != nil {
        // 处理错误
    }
    c.JSON(200, todos)
}

Practical case

The following is a practical case using the API we built:

• Front end:Create the front end using JavaScript frameworks such as React or Angular.
• Backend: Get and update data from the database using our Golang RESTful API.
• Deployment: Deploy the API and frontend to a cloud platform such as AWS or Heroku.

In this way, you have a fully functional application that can manage tasks in the database.

The above is the detailed content of How to build a RESTful API using Golang and use an ORM?. For more information, please follow other related articles on the PHP Chinese website!