เว็บเฟรมเวิร์ก 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 ของเราได้ดังนี้

  1. /api/bookmark – รับจุดสิ้นสุดสำหรับรายการบุ๊กมาร์ก
  2. /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 เพื่อรับรายการ คุณเพียงแค่ต้องผ่านตัวแปรเพื่อเก็บข้อมูล

Leave a Reply

Your email address will not be published. Required fields are marked *