Go Academy · Lección

Carga dinámica y símbolos

Carga de plugins en tiempo de ejecución y llamada a símbolos exportados

Carga dinámica y símbolos es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

plugin.Open

plugin.Open(path) carga un archivo .so compilado. Inicializa las funciones init() y las variables a nivel de paquete del plugin y, a continuación, hace que los símbolos estén disponibles.

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

p.Lookup

p.Lookup(name) busca un símbolo exportado por nombre. Devuelve un valor any; haga una aserción de tipo al tipo esperado.

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

Cargar varios plugins

Cargue cada archivo .so de un directorio y regístrelo en un bucle:

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

Patrón de función de fábrica

Los plugins exportan una función de fábrica (NewXxx() Processor) en lugar de un valor, de modo que el host obtiene una instancia nueva en cada llamada:

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

Gestión de errores durante la búsqueda

Los errores de Lookup indican que el símbolo no está exportado o que el nombre es incorrecto. Gestiónelos correctamente: omita el plugin o registre el error y continúe cargando los demás.

plugin.Open es idempotente

Al llamar dos veces a plugin.Open con la misma ruta se devuelve el mismo plugin. El plugin solo se inicializa una vez.

Carga diferida

Cargue los plugins bajo demanda (la primera vez que se utilicen) en lugar de hacerlo al iniciar la aplicación para reducir el tiempo de inicio. Utilice un sync.Once por plugin para garantizar que se cargue exactamente una vez.

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
}

Convenciones para nombrar símbolos

Utilice nombres CamelCase con mayúscula inicial para los símbolos exportados (se aplica la regla de visibilidad de Go). La convención habitual es Plugin para el valor principal o New para la fábrica.

Gestión de pánicos de plugins

Si un plugin provoca un pánico, el middleware recover del host puede interceptarlo, pero las goroutines del plugin podrían quedar en un estado no definido. Registre el error y omita el plugin; no lo reintente.

Validar los metadatos del plugin

Después de cargarlo, compruebe un símbolo de metadatos (por ejemplo, PluginVersion string) para validar la compatibilidad antes de registrarlo:

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

Comprobación rápida

¿Qué sucede si llama dos veces a plugin.Open con la misma ruta?

Repaso: carga dinámica y símbolos

Puntos clave:

plugin.Open carga .so; p.Lookup devuelve any → haga una aserción de tipo
Cargue los plugins de un directorio en un bucle para crear un sistema de plugins
plugin.Open es idempotente; init() se ejecuta una vez por ruta
Prefiera funciones de fábrica a símbolos de valores para obtener instancias nuevas

Preguntas frecuentes

¿La lección «Carga dinámica y símbolos» es gratis?

Sí — el texto completo de «Carga dinámica y símbolos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Carga dinámica y símbolos»?

Carga de plugins en tiempo de ejecución y llamada a símbolos exportados Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Carga dinámica y símbolos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy