เว็บเฟรมเวิร์ก Go Fiber
Go เป็นภาษาเอนกประสงค์ คุณสามารถใช้ Go เพื่อสร้างเว็บแอป ไมโครเซอร์วิส บริการคลาวด์ API เครื่องมือ DevOps และแอปพลิเคชันใดก็ได้
Go Fiber เป็นเฟรมเวิร์กที่ได้รับแรงบันดาลใจจาก Express สำหรับ Golang Go Fiber เป็นเว็บเฟรมเวิร์กที่สร้างขึ้นบน HTTP ที่รวดเร็ว สามารถใช้ในการจัดการการดำเนินการต่างๆ เช่น การกำหนดเส้นทาง/ปลายทาง มิดเดิลแวร์ คำขอของเซิร์ฟเวอร์ ฯลฯ
ข้อกำหนดเบื้องต้น
ในการปฏิบัติตามบทช่วยสอนนี้ คุณต้องมีความรู้พื้นฐานเกี่ยวกับ Golang
ซึ่งรวมถึง:
- ติดตั้ง Go บนคอมพิวเตอร์ของคุณแล้ว เรียกใช้
go version
คำสั่งเพื่อตรวจสอบการติดตั้ง Go - สามารถตั้งค่าโปรแกรม Golang พื้นฐานได้
- เรียกใช้และสร้างแอปพลิเคชัน Golang รวมทั้งทำความเข้าใจวิธีเขียนโค้ด Golang
ตั้งค่าโครงการ Go
เช่นเดียวกับแอปพลิเคชันพื้นฐานทั่วไป ให้สร้างโฟลเดอร์โปรเจ็กต์และเปิดด้วยโปรแกรมแก้ไขข้อความที่คุณชื่นชอบ ฉันจะใช้ Visual Studio ในบทช่วยสอนนี้
Go ใช้ไลบรารีและกรอบงานที่แตกต่างกัน ดังนั้น เมื่อสร้างแอปพลิเคชัน คุณต้องบันทึกไบนารีของแพ็คเกจเหล่านั้นภายในโครงการของคุณ เพื่อให้แอปของคุณสามารถเข้าถึงได้
Go ยังใช้ระบบไฟล์เพื่อบันทึกการพึ่งพาโมดูล สิ่งนี้จะบันทึกโมดูล Go ด้วยพาธของโมดูลและเวอร์ชัน sematic ที่เชื่อมโยงกับโมดูลที่ติดตั้งอยู่ในปัจจุบัน จากนั้นเรานำเข้าโมดูลเหล่านี้ไปยังแอปพลิเคชันของเราภายในไดเรกทอรีรากของโครงการ
ไปใช้งาน go.mod และ go.sum จัดการการขึ้นต่อกันเหล่านี้ go.mod มีการพึ่งพาทางอ้อมทั้งหมดที่คุณติดตั้งด้วยเวอร์ชันที่คุณต้องการใช้ การพึ่งพาทางอ้อมจะไม่ถูกใช้ภายในโปรเจ็กต์ แต่จะถือว่าเป็นการพึ่งพาทางอ้อม
นอกจากนี้ การพึ่งพาใด ๆ ที่กล่าวถึงใน go.mod แพ็คเกจแต่ไม่พบในไฟล์ต้นทางใด ๆ จะถือว่าเป็นการพึ่งพาทางอ้อมด้วย go.sum รักษา checksum ของแพ็คเกจที่ติดตั้งสำเร็จ
หากคุณเรียกใช้โปรเจ็กต์อีกครั้ง โปรเจ็กต์จะไม่ติดตั้งแพ็กเกจทั้งหมด ทำได้โดยเก็บแคชของแพ็คเกจไว้ในไดเร็กทอรี $GOPATH/pkg/mod ตัวอย่างเปรียบเทียบคือเมื่อใช้ Node.js และ NPM ในกรณีนี้ package.json และ package-lock.json ไฟล์ต่างๆ จะถูกใช้เพื่อจัดการการพึ่งพา Node.js
ในการเริ่มต้นไฟล์เหล่านี้ ให้รันคำสั่งต่อไปนี้ที่รูทของไดเร็กทอรีโครงการของคุณ
go mod init go-fiber-app

ในกรณีนี้ go-fiber-app จะเป็นโมดูลโดยตรงของเราและการประกาศโมดูลสำหรับการรักษาการควบคุมเวอร์ชัน go-fiber-app ทำหน้าที่เป็น URL สำหรับการนำเข้าโมดูลท้องถิ่นภายในแอปพลิเคชันของเรา go 1.17 เป็นเวอร์ชัน go ที่ทำงานอยู่ในคอมพิวเตอร์ของคุณ go.sum จะถูกสร้างขึ้นในภายหลังเมื่อเราเริ่มติดตั้งแพ็คเกจของเรา
การตั้งค่าเซิร์ฟเวอร์ Go Fiber พื้นฐาน
มาเริ่มสร้างเซิร์ฟเวอร์ HTTP แรกของเราใน Go และรับแนวคิดพื้นฐานที่สุดของ Go Fiber เช่นเดียวกับ Express การเริ่มต้นเซิร์ฟเวอร์ Go แรกของคุณนั้นตรงไปตรงมาโดยใช้เฟรมเวิร์กไฟเบอร์
Go Fiber เป็นเฟรมเวิร์กที่ได้รับแรงบันดาลใจจาก Express ลองย้อนกลับไปดูว่าเราสร้างเซิร์ฟเวอร์ Node.js อย่างง่ายด้วย Express ได้อย่างไร ด้านล่างนี้เป็นเซิร์ฟเวอร์พื้นฐานที่ใช้กรอบงาน Express
// add Express library
const express = require("express");
// create a new Express instance
const app = express();
// Create a new endpoint
app.get("/", (req, res) => {
// send text
res.send("Hello World!");
});
// Start server on port 3000
app.listen(3000);
ขณะนี้ด้วย Golang และการใช้เฟรมเวิร์กไฟเบอร์ ตัวอย่าง Node.js ด้านบนใช้งานได้เหมือนกัน มันเป็นเพียงบางไวยากรณ์ที่เปลี่ยนแปลง กำลังใช้งานเซิร์ฟเวอร์ HTTP เดียวกัน แต่มีภาษาต่างกันโดยใช้เฟรมเวิร์กต่างกัน
มาดูกันว่าเราจะสร้างเซิร์ฟเวอร์ที่เหมือนกันด้วย Go และ Fiber ได้อย่างไร
ขั้นแรก เราต้องทำให้ Fiber พร้อมใช้งานสำหรับแอปของเราโดยใช้คำสั่ง go get
มาติดตั้งโดยใช้คำสั่งต่อไปนี้:
go get -u github.com/gofiber/fiber/v2

ตอนนี้เราสามารถเริ่มใช้งานเซิร์ฟเวอร์ HTTP ที่ได้รับแรงบันดาลใจจาก Go Fiber ตัวแรกของเราได้แล้ว ไปข้างหน้าและสร้างไฟล์ main.go ภายในโฟลเดอร์โครงการของคุณ จากนั้นทำตามขั้นตอนด้านล่าง:
- เพิ่มโมดูลหลัก
โมดูลหลักรวมอยู่ในไฟล์ Go ทุกไฟล์ มันนำเข้าโมดูลไปยังโมดูลอื่น ๆ ภายในไฟล์ใน Go
package main
- เนื่องจากเราใช้ Fiber เราจึงต้องนำเข้าแพ็คเกจเพื่อเข้าถึงฟังก์ชันและวิธีการ Go Fiber
// add Fiber package
import "github.com/gofiber/fiber/v2"
- เพิ่มฟังก์ชั่นหลัก
ฟังก์ชันหลักคือวิธี Go พิเศษที่กำหนดจุดเริ่มต้นของแอปพลิเคชัน Golang มันถูกใช้เพื่อดำเนินการฟังก์ชั่นที่ชัดเจนอื่น ๆ หรือบล็อกของโค้ด Golang
func main() {
// create a new Fiber instance
app := fiber.New()
ภายในฟังก์ชัน main
เรากำลังสร้างอินสแตนซ์ Fiber ใหม่ การดำเนินการนี้จะยกตัวอย่างแอป Fiber
- สร้างจุดสิ้นสุด
app.get
จะตั้งค่าฟังก์ชันเส้นทางเริ่มต้นของเรา จะใช้ context
บริบทของ Fiber และคาดว่าจะมีข้อผิดพลาด context
โครงสร้างนี้มีสิ่งที่น่าสนใจมากมาย ในกรณีของเรา เรากำลังส่งข้อความธรรมดา
// Create a new endpoint
app.Get("/", func(c *fiber.Ctx) error {
// send text
return c.SendString("Hello, World!")
})
- กำหนดพอร์ตเซิร์ฟเวอร์
จากนั้นตั้งค่าหมายเลขพอร์ตที่เซิร์ฟเวอร์ของเราจะรับฟังและเรียกใช้ในเครื่อง
// Start server on port 3000
app.Listen(":3000")
}
แอปพร้อมแล้ว และตอนนี้เราสามารถทดสอบได้โดยใช้คำสั่งต่อไปนี้:
go run main.go

เอาท์พุท:

ที่นั่นคุณมีมัน เซิร์ฟเวอร์ Go Fiber HTTP ที่ง่ายที่สุดของคุณเปิดใช้งานแล้ว ไปที่ http://127.0.0.1:3000/
และข้อความ ‘Hello, World!’ ธรรมดาจะปรากฏขึ้นบนเบราว์เซอร์

เรากำลังสร้างอะไร
เรากำลังค้นหาส่วนลึกของอินเทอร์เน็ตตลอดทั้งวันและบ่อยครั้งกว่านั้นเราจะสร้างลิงก์ที่น่าสนใจ คุณอาจคุ้นเคยกับคุณลักษณะบุ๊กมาร์กของเบราว์เซอร์ ซึ่งจะเพิ่มลิงก์ไปยังเบราว์เซอร์ และเราจะจำลองคุณลักษณะดังกล่าวในแอปพลิเคชันของเรา

เราจะมีโมเดลข้อมูลอย่างง่ายสำหรับแอพนี้
ชื่อ – ชื่อที่ผู้ใช้กำหนดสำหรับบุ๊กมาร์ก
URL – ลิงค์ HTTP ของเว็บไซต์
การสร้างแพ็คเกจใหม่สำหรับ bookmark logic
สร้างโฟลเดอร์ใหม่ชื่อว่า bookmark และ เพิ่มไฟล์ bookmark.go ภายในโฟลเดอร์ เพิ่มตรรกะทั้งหมดของบุ๊กมาร์กภายในไฟล์นั้น ซึ่งจะช่วยในการแยกตรรกะการกำหนดเส้นทาง API และตรรกะทางธุรกิจ และทำให้แอปดูเป็นระเบียบเรียบร้อย

อัปเดตไฟล์ main.go เพื่อนำเข้าแพ็คเกจบุ๊กมาร์ก
package main
import (
"go-fiber-app/bookmark"
"github.com/gofiber/fiber/v2"
)
func status(c *fiber.Ctx) error {
return c.SendString("Server is running! Send your request")
}
func setupRoutes(app *fiber.App) {
app.Get("/", status)
app.Get("/api/bookmark", bookmark.GetAllBookmarks)
app.Post("/api/bookmark", bookmark.SaveBookmark)
}
func main() {
app := fiber.New()
setupRoutes(app)
app.Listen(":3000")
}

หน้าที่หลักจะแบ่งออกเป็นหลายวิธีเช่นกัน ลอจิกการกำหนดเส้นทางถูกสร้างเป็นฟังก์ชันแยกต่างหากที่เรียกว่า setupRoutes
ซึ่งจะนำตัวชี้ไปยังแอป Fiber
/
เส้นทางเริ่มต้นถูกตั้งค่าให้ส่งคืนสถานะสตริง ซึ่งจะช่วยตรวจสอบว่าแอปของคุณทำงานอย่างถูกต้องหรือไม่
คำอธิบายเส้นทางอื่นๆ
เป็นแบบแผนในการสร้าง API เพื่อนำหน้าเส้นทางทั้งหมด/api
ที่จะทำเครื่องหมายเป็น API อย่างชัดเจน คุณสามารถกำหนดปลายทาง REST ทั้งหมดสำหรับทรัพยากรเฉพาะโดยใช้ชื่อทรัพยากรหลังจากนั้น
ชื่อทรัพยากรของเราคือ bookmark
เราสามารถกำหนดกริยา REST ของเราได้ดังนี้
- /api/bookmark – รับจุดสิ้นสุดสำหรับรายการบุ๊กมาร์ก
- /api/bookmark – POST endpoint เพื่อบันทึกบุ๊กมาร์กใหม่
การตั้งค่าฐานข้อมูล
เราจะใช้ sqlite3 สำหรับฐานข้อมูล มีอินเทอร์เฟซที่เรียบง่ายสำหรับการบันทึกและโหลดข้อมูล และได้รับการจัดเก็บไว้ในไฟล์ .db ในโครงการ นี่ไม่ใช่ทางออกที่ดีที่สุดสำหรับแอปที่พร้อมสำหรับการผลิต แต่วิธีนี้จะทำให้การสาธิตของเราจัดเก็บและดึงข้อมูล
เรากำลังใช้ Gorm เพื่อตั้งค่าไดรเวอร์ฐานข้อมูล SQLite ของเรา Gorm ยังใช้แพ็คเกจ go-sqlite3 เพื่อตั้งค่าฐานข้อมูล SQLite
คอมไพเลอร์ GCC เป็นเวอร์ชันที่ปรับให้เหมาะสมของโปรเจ็กต์ GNU ที่คอมไพล์ภาษาการเขียนโปรแกรมต่างๆ เช่น โค้ด C
go-sqlite3 เอกสารระบุว่าหลังจากที่คุณสร้างและติดตั้ง go-sqlite3 ด้วยgo install github.com/mattn/go-sqlite3 (ซึ่งต้องใช้ GCC) คุณสามารถสร้างแอปของคุณได้โดยไม่ต้องพึ่งพา GCC ในอนาคต
อย่างไรก็ตาม ในกรณีของเราg o-sqlite3 ติดตั้งผ่านไดรเวอร์ Gorm SQLite ดังนั้นเราจำเป็นต้องตั้งค่าสภาพแวดล้อม GCC มาดาวน์โหลด download GCC MinGW-w64 สำหรับระบบปฏิบัติการ Windows รุ่น 64 บิต จากนั้น ติดตั้ง MinGW-w64 ลงในแล็ปท็อปของคุณ
ขณะติดตั้งสิ่งนี้ ตรวจสอบให้แน่ใจว่าคุณได้เลือกสถาปัตยกรรมต่อไปนี้

เมื่อการติดตั้งเสร็จสิ้น ให้เพิ่มตัวแปรสภาพแวดล้อม GCC ค้นหาตัวแปรสภาพแวดล้อม PATH ในส่วนตัวแปรระบบ และเพิ่ม GCC bin เช่นC:\Program Files\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin

ตรวจสอบให้แน่ใจว่าเส้นทางตรงกับเส้นทางถังขยะของ GCC ที่ติดตั้ง หากต้องการใช้การเปลี่ยนแปลงเหล่านี้ คุณต้องรีบูตเครื่องคอมพิวเตอร์ เมื่อเสร็จแล้ว ให้รันคำสั่งนี้ในเทอร์มินัลของคุณเพื่อตรวจสอบว่ามีการเปลี่ยนแปลงเกิดขึ้นหรือไม่
gcc

GORM – ORM สำหรับ Go
เราจะใช้ ORM ( Object-Relational-Mapping ) เพื่อทำให้การโต้ตอบกับฐานข้อมูลง่ายขึ้น หากคุณเลือกที่จะทำงานกับฐานข้อมูลโดยตรง คุณจะต้องเขียนแบบสอบถามฐานข้อมูลเพื่อดำเนินการกับฐานข้อมูล ORM ทำให้ง่ายขึ้นโดยดูแลการแปลงคำขอของเราเป็นการสืบค้นและให้ API อย่างง่ายสำหรับเราในการอ่าน เขียนข้อมูลไปยังฐานข้อมูล
การติดตั้ง sqlite3 และ Gorm
go get -u github.com/mattn/go-sqlite3
go get -u gorm.io/gorm
go get -u gorm.io/driver/sqlite

เริ่มต้นฐานข้อมูลด้วย model
ทำตามรูปแบบที่คล้ายกันเช่นแพ็คเกจบุ๊กมาร์กและสร้างโฟลเดอร์ใหม่ที่เรียกว่า database และสร้างไฟล์ชื่อ database.go
เราจะใช้ตารางเพื่อเก็บข้อมูลของเรา ใน Sqlite3 เราจะต้องกำหนดคอลัมน์ที่มีประเภทในฐานข้อมูล สิ่งนี้สามารถทำได้ง่ายโดยใช้ ORM เมื่อเรากำหนดแบบจำลองที่เราต้องการจัดเก็บ Gorm ดูแลการสร้างตารางที่มีคอลัมน์ที่ถูกต้อง
เรายังได้รับคอลัมน์การทำบัญชีเพิ่มเติมอีกสองสามคอลัมน์เมื่อสร้างแบบจำลองด้วย Gorm เช่น “ID, CreatedAt, UpdatedAt, DeletedAt”
type Bookmark struct {
gorm.Model
Name string `json:"name"`
Url string `json:"url"`
}
โมเดลถูกกำหนดให้เป็น struct ชื่อ JSON ที่จะใช้เมื่อแปลงโมเดลเป็น JSON และส่งกลับไปยังไคลเอนต์
func InitDatabase() error {
db, err := gorm.Open(sqlite.Open("bookmark.db"), &gorm.Config{})
if err != nil {
return err
}
db.AutoMigrate(&Bookmark{})
return nil
}
InitDatabaseมีการกำหนดฟังก์ชันซึ่งจะพยายามสร้างการเชื่อมต่อกับฐานข้อมูล หากไม่มีไฟล์อยู่ ระบบจะสร้างไฟล์ใหม่ชื่อ “bookmark.db”
AutoMigrate call ช่วยในการสร้างตารางหากยังไม่มีอยู่ การโยกย้ายฐานข้อมูลมักจะเป็นสิ่งที่เปลี่ยนโครงสร้างของฐานข้อมูลเมื่อเวลาผ่านไป และสิ่งนี้ช่วยในการทำให้แน่ใจว่าโครงสร้างฐานข้อมูลถูกย้ายไปยังเวอร์ชันล่าสุดอย่างเหมาะสม
โค้ดทั้งหมด
package database
import (
"gorm.io/driver/sqlite"
"gorm.io/gorm"
)
type Bookmark struct {
gorm.Model
Name string `json:"name"`
Url string `json:"url"`
}
func InitDatabase() error {
db, err := gorm.Open(sqlite.Open("bookmark.db"), &gorm.Config{})
if err != nil {
return err
}
db.AutoMigrate(&Bookmark{})
return nil
}
func GetAllBookmarks() ([]Bookmark, error) {
var bookmarks []Bookmark
db, err := gorm.Open(sqlite.Open("bookmark.db"), &gorm.Config{})
if err != nil {
return bookmarks, err
}
db.Find(&bookmarks)
return bookmarks, nil
}
func CreateBookmark(name string, url string) (Bookmark, error) {
var newBookmark = Bookmark{Name: name, Url: url}
db, err := gorm.Open(sqlite.Open("bookmark.db"), &gorm.Config{})
if err != nil {
return newBookmark, err
}
db.Create(&Bookmark{Name: name, Url: url})
return newBookmark, nil
}

อัปเดตไฟล์ main.go เพื่อเริ่มต้นฐานข้อมูล
โพสต์คำขอเพื่อเพิ่มบุ๊คมาร์ค
เริ่มต้นด้วยการส่งคำขอ POST ไปยังเซิร์ฟเวอร์เพื่อสร้างบุ๊กมาร์กใหม่เพื่อจัดเก็บไว้ในฐานข้อมูล การใช้ Gorm ทำให้กระบวนการง่ายขึ้นโดยเรียกใช้เมธอด Create บนฐานข้อมูลและส่งข้อมูลที่จำเป็นที่จำเป็น
func main() {
app := fiber.New()
dbErr := database.InitDatabase()
if dbErr != nil {
panic(dbErr)
}
setupRoutes(app)
app.Listen(":3000")
}
โค้ดทั้งหมด
package main
import (
"go-fiber-app/bookmark"
"go-fiber-app/database"
"github.com/gofiber/fiber/v2"
)
func status(c *fiber.Ctx) error {
return c.SendString("Server is running! Send your request")
}
func setupRoutes(app *fiber.App) {
app.Get("/", status)
app.Get("/api/bookmark", bookmark.GetAllBookmarks)
app.Post("/api/bookmark", bookmark.SaveBookmark)
}
func main() {
app := fiber.New()
dbErr := database.InitDatabase()
if dbErr != nil {
panic(dbErr)
}
setupRoutes(app)
app.Listen(":3000")
}

โพสต์คำขอเพื่อเพิ่มบุ๊คมาร์ค
เริ่มต้นด้วยการส่งคำขอ POST ไปยังเซิร์ฟเวอร์เพื่อสร้างบุ๊กมาร์กใหม่เพื่อจัดเก็บไว้ในฐานข้อมูล การใช้ Gorm ทำให้กระบวนการง่ายขึ้นโดยเรียกใช้เมธอด Create บนฐานข้อมูลและส่งข้อมูลที่จำเป็นที่จำเป็น
อัปเดตโค้ดในไฟล์ bookmark.go เพื่อส่งคำขอไปยังฐานข้อมูล
package bookmark
import (
"go-fiber-app/database"
"github.com/gofiber/fiber/v2"
)
func GetAllBookmarks(c *fiber.Ctx) error {
result, err := database.GetAllBookmarks()
if err != nil {
return c.Status(500).JSON(&fiber.Map{
"success": false,
"message": err,
"data": nil,
})
}
return c.Status(200).JSON(&fiber.Map{
"success": true,
"message": "",
"data": result,
})
}
func SaveBookmark(c *fiber.Ctx) error {
newBookmark := new(database.Bookmark)
err := c.BodyParser(newBookmark)
if err != nil {
c.Status(400).JSON(&fiber.Map{
"success": false,
"message": err,
"data": nil,
})
return err
}
result, err := database.CreateBookmark(newBookmark.Name, newBookmark.Url)
if err != nil {
c.Status(400).JSON(&fiber.Map{
"success": false,
"message": err,
"data": nil,
})
return err
}
c.Status(200).JSON(&fiber.Map{
"success": true,
"message": "",
"data": result,
})
return nil
}

อัปเดตไฟล์ฐานข้อมูลเพื่อส่งคืนรายการบุ๊กมาร์กจากฐานข้อมูล สามารถใช้ฟังก์ชัน Find เพื่อรับรายการ คุณเพียงแค่ต้องผ่านตัวแปรเพื่อเก็บข้อมูล
