By ยินดีต้อนรับเข้าสู่ Go Tutorial Series ของเรากันนะครับ ซึ่งใน Series นี้เราจะมาใช้ภาษา Go ในการทำ Web Service ซึ่งเริ่มตั้งแต่การทำ REST API เบื้องต้น, การเชื่อมต่อกับ Database และการทำ Authorization
สำหรับใน EP นี้ เราจะมาเน้นเรื่องการสร้าง API ด้วย Gin Framework กันครับ
ในบทความนี้จะเหมาะสำหรับคนที่มีพื้นฐานการเขียนโปรแกรมด้วยภาษาเบื้องต้นมาแล้วนะครับ ซึ่งสำหรับคนที่ยังไม่รู้จักภาษา Go หรือยังไม่เคยเขียนภาษา Go มาก่อนเลย ผมแนะนำให้ลองฝึกภาษา Go แบบเบื้องต้นดูก่อนครับผ่าน Go Tour Official
และถ้าอยากเรียนภาษา Go แบบแน่นๆ เลย ทาง Skooldio ก็มีคอร์สสอน Go ตั้งแต่พื้นฐานจน Advanced เลยครับ สามารถดูรายละเอียดเพิ่มเติมได้ที่นี่เลยครับ
และสำหรับคนที่เขียนภาษา Go เบื้องต้นเป็นอยู่แล้ว เราก็มาลุยกันเลยดีกว่าครับ!
Prerequisites — ก่อนเริ่ม
0. เริ่มต้นจากติดตั้ง Go (ดูวิธีเพิ่มเติมได้ที่ https://go.dev/doc/install)
Project Setup — ขึ้นโปรเจกต์ใหม่
1.สร้าง Directory หรือ Folder ใหม่ขึ้นมาด้วการรันคำสั่งใน Command Line
mkdir go-rest-api
2. รันคำสั่ง go mod init เพื่อสร้างไฟล์ go.mod ในโปรเจกต์ของเรา
go mod init example/go-rest-api
3. สร้างไฟล์ชื่อ main.go และเขียนโค้ด Hello World ง่ายๆ กันก่อน
4. ลองรันโค้ดด้วยคำสั่งใน Command Line
go run main.go
5. ซึ่งเราก็จะเห็นผลลัพธ์แบบนี้ใน Command Line ของเรา
Hello World!
สร้าง API แบบง่ายๆ ด้วย Gin Framework
1. เรามาเริ่มจากการเขียน API คืน Response เป็น JSON แบบง่ายๆ
ในโค้ดนี้เราเริ่มจากการสร้าง router ขึ้นมาด้วยคำสั่ง gin.New() และเราก็ทำการลงทะเบียน Route / ด้วยคำสั่ง r.GET พร้อมใส่ Handler Function และปิดท้ายด้วยการรัน Router ด้วยคำสั่ง r.Run()
ซึ่งใน Handler Function เราก็จะทำการส่ง Response กลับไปในรูปแบบของ JSON ด้วยคำสั่ง c.JSON เพื่อทำการส่งข้อมูลที่มีหน้าตาแบบนี้กลับไป
{
"message": "Hello World!"
}
2. เมื่อเขียนโค้ดเสร็จแล้วก็ทำการรันคำสั่งใน Command Line เพื่อติดตั้ง dependencies ต่างๆ ของโปรแกรมนี้
go get
go mod tidy
3. และรันคำสั่งนี้เพื่อทำการเริ่ม API Server ของเราขึ้นมา
go run main.go
4. เราสามารถทดสอบ API ของเราได้โดยการไปที่ URL http://localhost:8080 เพื่อดูผลลัพธ์ ใน Web Browser ที่เราใช้กันเช่น Chrome, Firefox, และอื่นๆ
มาเริ่มสร้าง REST API กันจริงๆ เลยดีกว่า
1. เริ่มจากการสร้าง Struct และ Mock Data ลงใน Slice
สร้าง Struct ที่ชื่อ Book และตัวแปร Slice ที่เก็บข้อมูล API ของเรากัน
สังเกตว่าในแต่ละ Field ใน Book Struct จะมี Tag `json:"xxx"` ต่อท้ายอยู่ ซึ่ง tag เหล่านี้มีไว้สำหรับให้ Go สามารถรู้ว่าควรจะเชื่อมเอา Field อันไหนใน JSON มาเชื่อมกับ Field ไหนใน Struct ของเรานั่นเอง
2. สร้าง GET Endpoint สำหรับข้อมูล Book List
เขียนโค้ดสร้าง GET /books Endpoint แบบนี้ได้เลย
สังเกตว่าเราสามารถใส่ Slice ไปตรงๆ ได้เลย แล้วเราก็จะสามารถคืนค่า Book List ตามที่เราต้องการใน Response ได้เลย
ซึ่งตอนนี้หน้าตาของ main.go ทั้งไฟล์เลยจะเป็นแบบนี้
รันโค้ดเพื่อเริ่ม API Server เหมือนเดิม
go run main.go
ทดสอบ API โดยการใส่ URL http://localhost:8080/books ใน Browser และเราก็จะเห็น Book List ที่เราสร้างไว้แบบนี้
3. สร้าง POST Endpoint สำหรับการสร้าง Book
มาต่อกันที่ Endpoint POST /albums ตามโค้ดด้านล่างนี้เลย
สำหรับ Handler นี้ จะมีเพิ่มเติมในส่วนของการนำ Body ของ Request มาใช้ ผ่านคำสั่ง c.ShouldBindJSON และทำการ Bind ตัวข้อมูลใน Body เข้ากับตัวแปร Struct ที่เราสร้างขึ้นที่ชื่อว่า book
ซึ่งถ้าหากมี Validation Error ในตอนที่ Bind เราก็ต้องทำจัดการ Error นั้นและส่ง 400 Bad Request พร้อมกับ Error Message กลับไปให้กับผู้ที่ใช้งาน API ของเรา
พอเสร็จเรียบร้อยเราก็ทำการเพิ่ม Struct Book อันใหม่ของเราเพิ่มเข้าไปใน Slice และคืนค่า Struct Book อันใหม่ของเราให้กับ Client
ซึ่งตอนนี้หน้าตาของ main.go ทั้งไฟล์เลยจะเป็นแบบนี้
มาถึงขั้นตอนการทดสอบ API เราเหมือนเดิม แต่ว่าคราวนี้เราไม่สามารถที่จะทดสอบผ่านการเข้า Browser แบบตรงๆ เหมือนก่อนหน้านี้ได้แล้ว เพราะว่าถ้าใส่ URL เข้าไปใน Browser ตรงๆ นั้น มันจะเป็นยิง Request แบบ GET แต่เราต้องการจะทดสอบ แบบ POST
ซึ่งทำให้เราต้องใช้เครื่องมือเสริมในการทดสอบ POST Request ซึ่งในบทความนี้ ผมเลือกใช้ Tools ที่ชื่อว่า REST Client ซึ่งเป็น Extension ตัวหนึ่งของ VSCode
วิธีการใช้ก็คือทำการสร้างไฟล์ test.http แบบนี้เลย
และก็สามารถกดปุ่ม Send Request ที่ด้านบนเพื่อทำการทดสอบ API ของเราได้เลย โดยเราจะเริ่มทดสอบจากการ POST และส่ง Body ที่เป็น JSON เพื่อสร้าง Book อันใหม่เข้าไปก่อน ที่ Endpoint POST http://localhost:8080/books
ต่อจากนั้นเราก็ทดสอบยิง Request ไปที่ GET http://localhost:8080/books อีกครั้งเพื่อให้มั่นใจว่า Book อันใหม่ของเรานั้นได้ถูกสร้างขึ้นมาเรียบร้อยแล้ว
**ตรงนี้อยากให้โน้ตไว้ครับว่าข้อมูล Book ต่างๆ ของเรานั้น จะเก็บอยู่ใน Memory ซึ่งถ้าหากว่าเราทำการปิด Server ตัวนี้แล้วเปิดใหม่ ข้อมูลทั้งหมดก็จะหายไป เพราะว่าเรายังไม่ได้ทำการบันทึกข้อมูลต่างๆ เหล่านี้ลง Database ที่เป็น Persistence (ซึ่งเราก็จะมาดูวิธีการต่อกับ Database แบบนี้ใน EP ถัดไปของ Tutorial นี้ครับ)
4. สร้าง DELETE Endpoint เพื่อทำการลบ Book
มาถึง Endpoint สุดท้ายของเรา DELETE /albums/:id
ในครั้งนี้เราจำเป็นต้องใช้ข้อมูลเสริมอีกตัวหนึ่ง นั่นก็คือ Book ID ที่ Client ต้องการจะลบนั่นเอง ซึ่งเราสามารถใช้ Feature ของ Gin ที่เป็น Path Parameters โดยการใช้ :id เข้าไปใน Route ของเรา และก็ทำการเรียกใช้ผ่านคำสั่ง c.Param("id") เพื่อดึง Param เข้ามาใช้ในตัวแปรของเรา
หลังจากที่ได้ ID มาจาก Param มาแล้ว เราก็ทำการเขียน Logic ในการลบ Book ที่มี ID ตรงกับที่ได้รับมาออกจาก Slice ของเรา และพอเสร็จเรียบร้อยก็คืน Status 204 No Content กลับไปก็เป็นอันเสร็จ
ซึ่งตอนนี้หน้าตาของ main.go ทั้งไฟล์เลยจะเป็นแบบนี้
และเช่นเดิม เราก็จะมาทดสอบ API ของเรากันโดยเพิ่ม Request DELETE เข้าไปในไฟล์ test.http แบบนี้
แต่ก่อนที่เราจะยิง DELETE Request เรามาเริ่มจากการยิง GET Request กันก่อนเพื่อดูว่าข้อมูลก่อนหน้าที่เราจะลบนั้น เป็นอย่างไรบ้าง
ต่อมาเราก็ทำการยิง DELETE Request ไป จะได้ผลลัพธ์แบบนี้
และสุดท้ายกลับมายิง GET Request เพื่อดูว่าข้อมูล Book ของเราที่ต้องการจะลบ ได้ถูกลบไปเรียบร้อยแล้วรึเปล่า
มา Refactor โค้ดเรากันเถอะ!
เพื่อความง่ายในการอ่านและการ Maintain ของ Code นี้ เราจะทำการแยก Handler ออกมาเป็น Function แยกด้วยตัวมันเองแบบนี้
ปิดท้ายด้วยการย้าย Book Struct และ Slice ลงมาอยู่ด้านล่าง Main Function
เสร็จเรียบร้อยแล้ว! กับ API Service แบบง่ายๆ ของเราที่สร้างด้วย Gin Framework.
The Final Code
สุดท้ายหน้าตาของไฟล์ main.go ของเราก็จะเป็นแบบนี้
ตอนต่อไปใน Series นี้
ใน EP ถัดไป เราจะมาเรียนรู้การใช้ Database เพื่อทำการเก็บข้อมูลต่างๆ เหล่านี้เพื่อไม่ให้สูญหาย แม้ว่าเราจะปิด Server ไปแล้วก็ตาม โดยการใช้ GORM Library
