การเขียน Code Memcache CRUD โดยใช้ภาษา Golang

 

 

บทนำ

การจัดการข้อมูลในระบบที่มีความเร็วสูงและประสิทธิภาพดี เป็นสิ่งที่ทุกคนในวงการพัฒนาซอฟต์แวร์พึงปรารถนา การใช้ Memcache จึงกลายเป็นทางเลือกหนึ่งที่ถูกใช้กันอย่างแพร่หลายในวงการนี้ เพราะมันช่วยให้เราสามารถเก็บ Cache ข้อมูลที่มักถูกเรียกใช้งานบ่อย ๆ ได้อย่างรวดเร็ว ในบทความนี้ เราจะพูดถึงวิธีการสร้าง CRUD (Create, Read, Update, Delete) ด้วย Memcache ภายใต้ภาษา Golang ที่มีความเป็นมาตรฐานและมีประสิทธิภาพ ส่วนจะทำอย่างไรนั้น มาติดตามกันได้เลย!

 

Memcache คืออะไร?

Memcache เป็นระบบจัดเก็บข้อมูลที่ให้บริการเก็บ Key-Value ซึ่งสามารถทำงานในหน่วยความจำได้อย่างรวดเร็ว เหมาะสำหรับการใช้เป็น Cache เพื่อเพิ่มประสิทธิภาพการเข้าถึงข้อมูลในฐานข้อมูลหลัก (Database) แทนที่การเข้าถึงฐานข้อมูลโดยตรงที่อาจช้าเกินไป ในการพัฒนาแอปพลิเคชันที่ต้องการความเร็วและประสิทธิภาพ Memcache จะเข้ามาช่วยจัดการข้อมูลที่มีปริมาณมากและถูกเรียกใช้งานบ่อยได้ดี

 

ทำไมควรเลือกใช้ Golang?

Golang หรือที่เรียกกันว่า Go เป็นภาษาโปรแกรมที่พัฒนาโดย Google ที่มีจุดเด่นในด้านความเร็ว ความง่ายในการจัดการ Threading และการพัฒนา Web Application ด้วยการใช้ Goroutines ที่มีอยู่ภายในภาษา Go ทำให้การเขียนโปรแกรมเป็นเรื่องที่ง่ายกว่าในหลาย ๆ ภาษา เราจะใช้ Golang ในการสร้างระบบ CRUD กับ Memcache ในบทความนี้กัน

 

การติดตั้ง Memcache

ลำดับแรกที่คุณต้องทำคือการติดตั้ง Memcache ในเครื่องของคุณ คุณสามารถดาวน์โหลดได้ที่ [Memcached](https://memcached.org/) เพียงทำตามคู่มือการติดตั้งที่มีอยู่ขั้นตอนง่าย ๆ ในการเริ่มต้นใช้งาน Memcache

 

การติดตั้ง Golang

คุณสามารถโหลดภาษา Golang ได้จาก [Golang Official Website](https://golang.org/dl/) และทำการติดตั้งตามขั้นตอน หลังจากติดตั้งเรียบร้อยแล้ว คุณควรตรวจสอบว่า Go ถูกติดตั้งอย่างถูกต้องหรือไม่โดยการเปิด Terminal หรือ Command Prompt แล้วพิมพ์คำสั่งต่อไปนี้:

 go version

 

การติดตั้ง Memcache Client

เราจะใช้ library ที่มีชื่อว่า `gomemcache` ในการเชื่อมต่อกับ Memcache จาก Golang รันคำสั่งต่อไปนี้ใน Terminal:

 go get github.com/bradfitz/gomemcache/memcache

 

การสร้าง Code CRUD กับ Memcache

หลังจากจัดเตรียมทุกอย่างเสร็จแล้ว เราจะเริ่มการสร้างความสามารถ CRUD กันเลย!

1. สร้างโปรเจกต์ใหม่

สร้างโฟลเดอร์ใหม่สำหรับโปรเจกต์ Golang ของคุณ พร้อมกับสร้างไฟล์ `main.go` ขึ้นมา:

 mkdir memcache_crud
cd memcache_crud
touch main.go

2. เขียน Code CRUD

เปิดไฟล์ `main.go` และเขียน Code ดังนี้

 package main

import (
    "fmt"
    "log"
    "time"

    "github.com/bradfitz/gomemcache/memcache"
)

func main() {
    mc := memcache.New("localhost:11211")

    // Create
    err := mc.Set(&memcache.Item{
        Key:        "exampleKey",
        Value:      []byte("Hello, World!"),
        Expiration: 60, // ตั้งเวลาในการหมดอายุของ Cache
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Created key 'exampleKey' with value 'Hello, World!'")

    // Read
    item, err := mc.Get("exampleKey")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Read key 'exampleKey': %s\n", item.Value)

    // Update
    err = mc.Set(&memcache.Item{
        Key:   "exampleKey",
        Value: []byte("Hello, Golang!"),
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Updated key 'exampleKey' with value 'Hello, Golang!'")

    // Delete
    err = mc.Delete("exampleKey")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Deleted key 'exampleKey'")
}

3. คำอธิบาย Code

- Create: เราสร้าง key ใหม่โดยใช้ฟังก์ชัน `Set` และกำหนดค่าให้กับ key ที่ชื่อว่า `exampleKey` โดยมีค่าเป็น “Hello, World!” ซึ่งจะหมดอายุในเวลา 60 วินาที - Read: เราอ่านค่าของ key โดยใช้ฟังก์ชัน `Get` ซึ่งจะแสดงค่าของ key ที่เราตั้งไว้ - Update: เราทำการอัปเดตค่าของ key `exampleKey` ด้วยค่าที่ใหม่ - Delete: เราใช้ฟังก์ชัน `Delete` เพื่อลบ key ที่เราสร้างขึ้น

4. รันโปรแกรม

เพื่อรันโปรแกรมนี้ เพียงใช้คำสั่งใน Terminal:

 go run main.go

 

ใช้งาน Memcache กับฐานข้อมูล

ในชีวิตจริง เรามักจะแนะนำให้ใช้ Memcache ควบคู่กับฐานข้อมูลหลัก (ซึ่งอาจจะเป็น MySQL, PostgreSQL หรือ MongoDB) โดยการใช้ Memcache เพื่อเก็บ Cache ข้อมูลที่ถูกเรียกใช้งานบ่อย ๆ ตัวอย่างเช่น ถ้าคุณมีเนื้อหาที่ถูกเรียกใช้อยู่บ่อย ๆ แทนที่การดึงข้อมูลจากฐานข้อมูลทุกครั้ง คุณสามารถดึงข้อมูลจาก Memcache แทนได้ ทำให้ลดระยะเวลาการทำงานได้อย่างมาก

 

สรุป

การใช้งาน Memcache พร้อมกับภาษา Golang สามารถช่วยเหลือคุณในการพัฒนาระบบที่รวดเร็ว อีกทั้งลดภาระการเข้าถึงฐานข้อมูล อันจะส่งผลให้แอปพลิเคชันของคุณใช้งานได้ราบรื่นขึ้น

หากคุณสนใจศึกษาเพิ่มเติมเกี่ยวกับการเขียนโปรแกรมหรือการพัฒนาระบบที่มีประสิทธิภาพ เราขอเชิญคุณมาเรียนรู้ที่ EPT (Expert-Programming-Tutor) เรามีหลักสูตรและผู้สอนที่มีประสบการณ์ เพื่อให้คุณสามารถเรียนรู้และพัฒนาไปในเส้นทางนี้ได้อย่างมั่นใจ!

เริ่มต้นการเรียนรู้โปรแกรมมิ่งกับเรา EPT วันนี้ แล้วขับเคลื่อนความฝันของคุณให้เป็นจริง!

 

 

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