Go Academy · Lezione

Caricamento dinamico e simboli

Caricare plugin a runtime e chiamare simboli esportati

Caricamento dinamico e simboli è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

plugin.Open

plugin.Open(path) carica un file .so compilato. Inizializza le funzioni init() e le variabili a livello di pacchetto del plugin, quindi rende disponibili i simboli.

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

p.Lookup

p.Lookup(name) trova un simbolo esportato tramite il nome. Restituisce un any; esegua un'asserzione di tipo sul tipo previsto.

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

Caricamento di più plugin

Carichi ogni .so da una directory e lo registri in un ciclo:

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)
}

Pattern della funzione factory

I plugin esportano una funzione factory (NewXxx() Processor) invece di un valore, così l'host ottiene una nuova istanza a ogni chiamata:

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

Gestione degli errori nella ricerca

Gli errori di Lookup indicano che il simbolo non è esportato o che il nome è errato. Li gestisca correttamente: ignori il plugin oppure registri l'errore e continui a caricare gli altri.

plugin.Open è idempotente

Chiamare plugin.Open due volte sullo stesso percorso restituisce lo stesso plugin. Il plugin viene inizializzato una sola volta.

Caricamento differito

Carichi i plugin su richiesta (al primo utilizzo) anziché all'avvio, per ridurre il tempo di avvio. Utilizzi una sync.Once per ogni plugin, così da garantire che venga caricato esattamente una volta.

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
}

Convenzioni per i nomi dei simboli

Utilizzi nomi CamelCase con iniziale maiuscola per i simboli esportati (si applica la regola di visibilità di Go). Una convenzione comune prevede Plugin per il valore principale o New per la factory.

Gestione dei panic dei plugin

Se un plugin genera un panic, il middleware recover dell'host potrebbe intercettarlo, ma le goroutine del plugin potrebbero trovarsi in uno stato non definito. Registri l'errore e ignori il plugin; non riprovi.

Convalida dei metadati del plugin

Dopo il caricamento, verifichi un simbolo di metadati (ad esempio PluginVersion string) per convalidare la compatibilità prima della registrazione:

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

Verifica rapida

Che cosa accade se si chiama plugin.Open due volte con lo stesso percorso?

Riepilogo: caricamento dinamico e simboli

Punti chiave:

plugin.Open carica un .so; p.Lookup restituisce any → eseguire un'asserzione di tipo
Caricare i plugin da una directory in un ciclo per creare un sistema di plugin
plugin.Open è idempotente; init() viene eseguito una volta per percorso
Preferire le funzioni factory ai simboli valore per ottenere nuove istanze

Domande Frequenti

La lezione «Caricamento dinamico e simboli» è gratuita?

Sì — il testo completo di «Caricamento dinamico e simboli» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Caricamento dinamico e simboli»?

Caricare plugin a runtime e chiamare simboli esportati Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Caricamento dinamico e simboli»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy