สร้าง Go API โดยใช้ GIN, GORM และ MySql
Go เป็นภาษาโปรแกรมที่ร้อนแรงที่สุดในยุคที่เราอาศัยอยู่ Go นั้นง่ายมาก แต่มีประสิทธิภาพที่ใกล้เคียงกับภาษาระดับต่ำเช่น C ++ Go ถูกเรียกว่าภาษาการเขียนโปรแกรมที่เร็วที่สุดซึ่งให้ประสิทธิภาพสูงมาก Gin เป็นหนึ่งในเฟรมเวิร์กที่น่าทึ่งของ Go ซึ่งมีน้ำหนักเบาและรวดเร็วมาก คุณลักษณะที่น่าสนใจของ Gin คือมี HttpRouter เวอร์ชันที่กำหนดเอง ซึ่งทำให้เส้นทาง API นั้นเร็วมาก กว่ากรอบงาน Go อื่น ๆ อ้างว่าเร็วกว่ากรอบงาน Go อื่นที่เรียกว่า Martini ถึง 40 เท่า และแน่นอนว่ามันให้ประโยชน์มากกว่าเฟรมเวิร์กอื่นๆ และภาษาโปรแกรมอื่นๆ
Gin เป็นเพียงไมโครเฟรมเวิร์กที่ไม่ได้ให้ฟีเจอร์มากมายเหมือนเฟรมเวิร์กอื่นๆ มีเพียงเครื่องมือที่จำเป็นในการสร้าง api เช่น การกำหนดเส้นทาง การตรวจสอบความถูกต้อง ฯลฯ ผู้เชี่ยวชาญเชื่อว่า Gin ดีที่สุดสำหรับการลงทุนระยะยาว เพื่อคว้าข้อได้เปรียบที่เหมาะสมจากประสิทธิภาพและความยืดหยุ่นสูง
วันนี้เราจะสร้าง API ที่ง่ายมากโดยใช้ Go, Gin, Gorm และ Mysql เป็นฐานข้อมูล เราจะดำเนินการ CRUD สำหรับผู้ใช้ที่มีฟิลด์ไม่กี่ฟิลด์ คุณต้องมีความรู้ที่ชัดเจนเกี่ยวกับ Go เพื่อเริ่มต้นกับโครงการที่เราจะทำ
ข้อกำหนดเบื้องต้น
ข้อกำหนดสำหรับบทความนี้คือ คุณควรได้ทำตามบทความ ติดตั้ง Go บน Mac และ ติดตั้ง MySQL บน Mac มาก่อน
สร้างโปรเจค first-api
สร้างโปรเจคใหม่ ในตัวอย่างชื่อ first-api สร้างไฟล์ main.go เปิดเทอร์มินัลแล้วใช้คำสั่ง
go mod init first-apiคำสั่งนี้จะสร้างไฟล์ go.mod
ติดตั้งแพ็คเกจ
นี่คือแพ็คเกจภายนอกสำหรับโครงการ: ไดรเวอร์ sql สำหรับ mysql, gin และ gorm ป้อนคำสั่งต่อไปนี้เพื่อติดตั้งในโครงการ
go get github.com/go-sql-driver/mysql
go get github.com/gin-gonic/gin
go get github.com/jinzhu/gormโครงสร้างโครงการ
แน่นอน เราปฏิบัติตามรูปแบบ MVC สำหรับการสร้าง API ที่เป็น Model, View และ Controller แต่ ‘V’ ยังคงเงียบอยู่ที่นี่เพราะเรากำลังสร้าง API อยู่ในขณะนี้ เรามีการกำหนดค่าฐานข้อมูล โมเดล เส้นทาง ตัวควบคุม และแน่นอนว่าไฟล์หลักที่เราชื่นชอบตลอดกาลซึ่งเป็นจุดเริ่มต้นของโครงการของเรา เรามีสแน็ปช็อตสำหรับสร้างโครงสร้างของโครงการ
ตั้งค่าฐานข้อมูล
ก่อนอื่น ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง mysql ลงในเครื่องและเครื่องมือบางอย่าง เช่น phpmyadmin, mysql workbench หรือเครื่องมืออื่นๆ เพื่อใช้ฐานข้อมูลของคุณอย่างมีประสิทธิภาพ สร้างฐานข้อมูลใหม่ใน mysql ชื่อ first_go จากนั้นเราเพิ่มการกำหนดค่าฐานข้อมูลในไฟล์ Database.go ภายในไดเรกทอรี Config ฉันได้เพิ่มรายละเอียดการกำหนดค่าของฉันแล้ว และคุณต้องเพิ่มการกำหนดค่าของคุณเอง
package Config
import (
"fmt"
"github.com/jinzhu/gorm"
)
var DB *gorm.DB
// DBConfig represents db configuration
type DBConfig struct {
Host string
Port int
User string
DBName string
Password string
}
func BuildDBConfig() *DBConfig {
dbConfig := DBConfig{
Host: "localhost",
Port: 3306,
User: "root",
Password: "1234",
DBName: "first_go",
}
return &dbConfig
}
func DbURL(dbConfig *DBConfig) string {
return fmt.Sprintf(
"%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local",
dbConfig.User,
dbConfig.Password,
dbConfig.Host,
dbConfig.Port,
dbConfig.DBName,
)
}
สร้างแบบจำลอง Model
ตอนนี้ มาสร้างแบบจำลองสำหรับผู้ใช้ที่ประกอบด้วยฟิลด์ต่อไปนี้:
ชื่อ , อีเมล , โทรศัพท์ , ที่อยู่
- name
- phone
- address
เราสร้างไฟล์ UserModel.go ภายในไดเร็กทอรี Models ของเรา
package Models
type User struct {
Id uint `json:"id"`
Name string `json:"name"`
Email string `json:"email"`
Phone string `json:"phone"`
Address string `json:"address"`
}
func (b *User) TableName() string {
return "user"
}
กำหนดค่าการกำหนดเส้นทาง
ในทำนองเดียวกัน เราสร้างการกำหนดเส้นทางสำหรับโครงการของเรา เราสร้างกลุ่มเพื่อปรับการกำหนดเส้นทางของเราที่เกี่ยวข้องกับผู้ใช้ และเราต้องดูแลกลุ่มในขณะที่ใช้งาน API มาสร้างไฟล์ Routes.go ในโฟลเดอร์ Routes กัน เราจะเห็นการใช้งานฟังก์ชั่นคอนโทรลเลอร์ด้านล่าง
package Routes
import (
"first-api/Controllers"
"github.com/gin-gonic/gin"
)
//SetupRouter ... Configure routes
func SetupRouter() *gin.Engine {
r := gin.Default()
grp1 := r.Group("/user-api")
{
grp1.GET("user", Controllers.GetUsers)
grp1.POST("user", Controllers.CreateUser)
grp1.GET("user/:id", Controllers.GetUserByID)
grp1.PUT("user/:id", Controllers.UpdateUser)
grp1.DELETE("user/:id", Controllers.DeleteUser)
}
return r
}
สร้างตัวควบคุม
เราจัดการคำขอ http ที่มาจากส่วนหน้าในตัวควบคุม เราสร้างฟังก์ชันต่างๆ ที่จัดการคำขอเฉพาะของเราที่เราเตอร์ของเราส่งไปยังตัวควบคุม เรามี User.go ภายใน Models เพื่อโต้ตอบกับฐานข้อมูล เราตอบสนองต่อผู้ใช้ตามข้อมูลที่เราได้รับจากฐานข้อมูลของเรา หากเราไม่ได้รับข้อผิดพลาด เราจะตอบกลับเป็นสถานะตกลง และหากเราได้รับข้อผิดพลาด เราจะระบุสถานะข้อผิดพลาด เราสร้างไฟล์ User.go ภายในโฟลเดอร์ Controllers
package Controllers
import (
"first-api/Models"
"fmt"
"github.com/gin-gonic/gin"
"net/http"
)
//GetUsers ... Get all users
func GetUsers(c *gin.Context) {
var user []Models.User
err := Models.GetAllUsers(&user)
if err != nil {
c.AbortWithStatus(http.StatusNotFound)
} else {
c.JSON(http.StatusOK, user)
}
}
//CreateUser ... Create User
func CreateUser(c *gin.Context) {
var user Models.User
c.BindJSON(&user)
err := Models.CreateUser(&user)
if err != nil {
fmt.Println(err.Error())
c.AbortWithStatus(http.StatusNotFound)
} else {
c.JSON(http.StatusOK, user)
}
}
//GetUserByID ... Get the user by id
func GetUserByID(c *gin.Context) {
id := c.Params.ByName("id")
var user Models.User
err := Models.GetUserByID(&user, id)
if err != nil {
c.AbortWithStatus(http.StatusNotFound)
} else {
c.JSON(http.StatusOK, user)
}
}
//UpdateUser ... Update the user information
func UpdateUser(c *gin.Context) {
var user Models.User
id := c.Params.ByName("id")
err := Models.GetUserByID(&user, id)
if err != nil {
c.JSON(http.StatusNotFound, user)
}
c.BindJSON(&user)
err = Models.UpdateUser(&user, id)
if err != nil {
c.AbortWithStatus(http.StatusNotFound)
} else {
c.JSON(http.StatusOK, user)
}
}
//DeleteUser ... Delete the user
func DeleteUser(c *gin.Context) {
var user Models.User
id := c.Params.ByName("id")
err := Models.DeleteUser(&user, id)
if err != nil {
c.AbortWithStatus(http.StatusNotFound)
} else {
c.JSON(http.StatusOK, gin.H{"id" + id: "is deleted"})
}
}
จัดการคำขอ
นี่เป็นไฟล์สำคัญที่ดึงข้อมูลและโต้ตอบกับฐานข้อมูลของเราโดยตรง เราสร้างไฟล์ User.go ภายในโฟลเดอร์ Models เพื่อจัดการกับคำขอฐานข้อมูล
package Models
import (
"first-api/Config"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
//GetAllUsers Fetch all user data
func GetAllUsers(user *[]User) (err error) {
if err = Config.DB.Find(user).Error; err != nil {
return err
}
return nil
}
//CreateUser ... Insert New data
func CreateUser(user *User) (err error) {
if err = Config.DB.Create(user).Error; err != nil {
return err
}
return nil
}
//GetUserByID ... Fetch only one user by Id
func GetUserByID(user *User, id string) (err error) {
if err = Config.DB.Where("id = ?", id).First(user).Error; err != nil {
return err
}
return nil
}
//UpdateUser ... Update user
func UpdateUser(user *User, id string) (err error) {
fmt.Println(user)
Config.DB.Save(user)
return nil
}
//DeleteUser ... Delete user
func DeleteUser(user *User, id string) (err error) {
Config.DB.Where("id = ?", id).Delete(user)
return nil
}
การตั้งค่าเซิร์ฟเวอร์
นี่คือฟังก์ชันเริ่มต้นของโครงการของเรา เราเชื่อมต่อ mysql โอนย้าย modal และแบบฟอร์มเราเตอร์การตั้งค่าที่นี่โดยอัตโนมัติ เราต้องสร้าง main.go ในรูทของโปรเจ็กต์
package main
import (
"first-api/Config"
"first-api/Models"
"first-api/Routes"
"fmt"
"github.com/jinzhu/gorm"
)
var err error
func main() {
Config.DB, err = gorm.Open("mysql", Config.DbURL(Config.BuildDBConfig()))
if err != nil {
fmt.Println("Status:", err)
}
defer Config.DB.Close()
Config.DB.AutoMigrate(&Models.User{})
r := Routes.SetupRouter()
//running
r.Run()
}
ตอนนี้เราพร้อมแล้วที่จะทดสอบ API แรกของเราโดยใช้ Go และ Gin!
การสาธิต
เรียกใช้คำสั่งต่อไปนี้เพื่อเริ่มต้นเซิร์ฟเวอร์ของคุณ
go run main.go
หากคุณพบปัญหาใดๆ ระหว่างการให้บริการ ให้แก้ไขปัญหาก่อนเนื่องจากคุณอาจพลาดบางอย่างในระหว่างนั้น
ปลายทาง
นี่คือปลายทางที่เราจะใช้เพื่อสร้าง อัปเดต อ่าน และลบข้อมูลผู้ใช้
- GET user-api/user → ดึงข้อมูลผู้ใช้ทั้งหมด
- POST user-api/user → เพิ่มข้อมูลผู้ใช้ใหม่
- GET user-api/user/{id} → ดึงข้อมูลผู้ใช้คนเดียว
- PUT user-api/user/{id} → อัปเดตข้อมูลผู้ใช้
- DELETE user-api/user → ลบข้อมูลผู้ใช้
ตอนนี้ เปิดเครื่องมือทดสอบปลายทางที่คุณมี เราจะใช้ Postman ซึ่งยอดเยี่ยมมาก โปรดตรวจสอบให้แน่ใจว่าข้อมูลถูกแทรกในรูปแบบ JSON ผ่าน Postman เนื่องจากเราไม่ได้ทำงานกับข้อมูลแบบฟอร์มในโมดูลนี้
สร้างผู้ใช้ใหม่
ที่นี่ เราจะสร้างผู้ใช้สองคนพร้อมกัน
ที่ Postman เลือกเป็น POST ใส่ url http://localhost:8080/user-api/user เลือกเป็น Body -> Raw -> JSON
สร้างผู้ใช้ 1
{
"name": "Sudeep Timalsina",
"email": "sudeep @gmail.com",
"phone": "6453738212",
"address": "New Rord."
}
คลิก Send
ที่ web browser จะแสดงข้อมูล ผู้ใช้ 1 ที่เพิ่มเข้าไป
สร้างผู้ใช้ 2
{
"name": "Aashish Dahal",
"email": "aashish@gmail.com",
"phone": "9845363737",
"address": "New York"
}
ที่ web browser จะแสดงข้อมูล ผู้ใช้ 1 และ 2 ที่มีอยู่ในฐานข้อมูลของเรา
รับผู้ใช้โดย id
รับข้อมูลผู้ใช้สำหรับผู้ใช้ที่มี id=1 โดยการป้อน http://localhost:8080/user-api/user/1
อัพเดทผู้ใช้
อัปเดตข้อมูลผู้ใช้สำหรับผู้ใช้ที่มี Id=1
{
"name": "Sudeep Timalsina",
"email": "sudeep@gmail.com",
"phone": "6453738212",
"address": "New Baneshwor"
}
ที่ Postman เลือกเป็น PUT ใส่ url http://localhost:8080/user-api/user/1 เลือกเป็น Body -> Raw -> JSON
ที่ web browser จะแสดงข้อมูล ผู้ใช้ 1 ที่ แก้ไขแล้ว
ลบผู้ใช้
ลบผู้ใช้ที่มี Id=2
ที่ Postman เลือกเป็น DELETE ใส่ url http://localhost:8080/user-api/user/2
ที่ web browser ใส่ url http://localhost:8080/user-api/user/ จะแสดงข้อมูล ผู้ใช้ 2 ที่ถูกลบออกไปแล้ว
และนี่คือ API ส่วนที่เหลือที่เรียบง่ายมากที่เราสร้างขึ้นโดยใช้ Go, Gin, Gorm และ Mysql มีอะไรอีกมากมายที่คุณทำได้ด้วย Go
Github Repository: https://github.com/SudeepTimalsina/first-go
credit : https://medium.com/wesionary-team/create-your-first-rest-api-with-golang-using-gin-gorm-and-mysql-d439bcc6f987
