0Pricing
Go Academy · บทเรียน

การโหลดแบบไดนามิกและสัญลักษณ์

โหลดปลั๊กอินขณะทำงานและเรียกใช้สัญลักษณ์ที่ส่งออก

การโหลดแบบไดนามิกและสัญลักษณ์ เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

plugin.Open

plugin.Open(path) โหลดไฟล์ .so ที่คอมไพล์แล้ว ฟังก์ชัน init() และตัวแปรระดับแพ็กเกจของปลั๊กอินจะถูกเริ่มต้น จากนั้นจึงทำให้สัญลักษณ์พร้อมใช้งาน

p, err := plugin.Open("./plugins/mymodule.so")
if err != nil { log.Fatalf("load: %v", err) }

p.Lookup

p.Lookup(name) ค้นหาสัญลักษณ์ที่ส่งออกตามชื่อ โดยคืนค่าเป็น any ให้ยืนยันชนิดเป็นชนิดที่คาดไว้

sym, err := p.Lookup("NewProcessor")
if err != nil { log.Fatalf("lookup: %v", err) }
fn, ok := sym.(func() Processor)
if !ok { log.Fatal("wrong type") }

การโหลดปลั๊กอินหลายตัว

โหลดไฟล์ .so แต่ละไฟล์จากไดเรกทอรีและลงทะเบียนในลูป:

entries, _ := os.ReadDir("./plugins")
for _, e := range entries {
    if !strings.HasSuffix(e.Name(), ".so") { continue }
    p, err := plugin.Open("./plugins/" + e.Name())
    if err != nil { log.Printf("skip %s: %v", e.Name(), err); continue }
    loadPlugin(p)
}

รูปแบบฟังก์ชันโรงงาน

ปลั๊กอินส่งออกฟังก์ชันโรงงาน (NewXxx() Processor) แทนค่า เพื่อให้โฮสต์ได้รับอินสแตนซ์ใหม่ในแต่ละครั้งที่เรียกใช้:

sym, _ := p.Lookup("NewProcessor")
factory := sym.(func() Processor)
proc := factory() // new instance

การจัดการข้อผิดพลาดขณะค้นหา

ข้อผิดพลาดจาก Lookup หมายความว่าสัญลักษณ์ไม่ได้ถูกส่งออกหรือชื่อไม่ถูกต้อง ให้จัดการอย่างเหมาะสม โดยข้ามปลั๊กอินนั้น หรือบันทึกข้อผิดพลาดแล้วโหลดรายการอื่นต่อ

plugin.Open ให้ผลเหมือนเดิมเมื่อเรียกซ้ำ

การเรียก plugin.Open ด้วยพาธเดิมสองครั้งจะคืนค่าปลั๊กอินตัวเดียวกัน ปลั๊กอินจะถูกเริ่มต้นเพียงครั้งเดียว

การโหลดแบบเลื่อนเวลา

โหลดปลั๊กอินเมื่อจำเป็นต้องใช้ครั้งแรก แทนการโหลดเมื่อเริ่มต้นโปรแกรม เพื่อลดเวลาเริ่มต้น ใช้ sync.Once แยกสำหรับปลั๊กอินแต่ละตัว เพื่อให้แน่ใจว่าจะโหลดเพียงครั้งเดียว

var mu sync.Mutex
var loaded = map[string]*plugin.Plugin{}

func getPlugin(path string) (*plugin.Plugin, error) {
    mu.Lock(); defer mu.Unlock()
    if p, ok := loaded[path]; ok { return p, nil }
    p, err := plugin.Open(path)
    if err != nil { return nil, err }
    loaded[path] = p
    return p, nil
}

แนวทางการตั้งชื่อสัญลักษณ์

ใช้ชื่อแบบ CamelCase ที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่สำหรับสัญลักษณ์ที่ส่งออก (ใช้กฎการมองเห็นของ Go) แนวทางที่พบบ่อยคือใช้ Plugin สำหรับค่าหลัก หรือ New สำหรับโรงงาน

การจัดการแพนิกของปลั๊กอิน

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

การตรวจสอบเมทาดาทาของปลั๊กอิน

หลังจากโหลดแล้ว ให้ตรวจสอบสัญลักษณ์เมทาดาทา (เช่น PluginVersion string) เพื่อยืนยันความเข้ากันได้ก่อนลงทะเบียน:

ver, _ := p.Lookup("PluginVersion")
if *ver.(*string) != expectedVersion { log.Fatal("incompatible") }

ตรวจสอบอย่างรวดเร็ว

จะเกิดอะไรขึ้นหากเรียก plugin.Open สองครั้งด้วยพาธเดียวกัน

สรุป: การโหลดแบบไดนามิกและสัญลักษณ์

ประเด็นสำคัญ:

  • plugin.Open โหลด .so ส่วน p.Lookup คืนค่าเป็น any → ให้ยืนยันชนิด
  • โหลดปลั๊กอินจากไดเรกทอรีในลูปเพื่อสร้างระบบปลั๊กอิน
  • plugin.Open ให้ผลเหมือนเดิมเมื่อเรียกซ้ำ และ init() ทำงานครั้งเดียวต่อพาธ
  • ควรใช้ฟังก์ชันโรงงานแทนสัญลักษณ์ค่าคงที่เพื่อให้ได้อินสแตนซ์ใหม่

คำถามที่พบบ่อย

บทเรียน “การโหลดแบบไดนามิกและสัญลักษณ์” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การโหลดแบบไดนามิกและสัญลักษณ์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การโหลดแบบไดนามิกและสัญลักษณ์”

โหลดปลั๊กอินขณะทำงานและเรียกใช้สัญลักษณ์ที่ส่งออก คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การโหลดแบบไดนามิกและสัญลักษณ์” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม

ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. พื้นฐานแพ็กเกจ plugin ของ Go
  2. การออกแบบ interface ของปลั๊กอิน
  3. การโหลดแบบไดนามิกและสัญลักษณ์
  4. ทางเลือกอื่น: HashiCorp go-plugin
← กลับไปที่ Go Academy