Go Academy · Aula

Carregamento dinâmico e símbolos

Carregue plugins em tempo de execução e chame símbolos exportados

Carregamento dinâmico e símbolos é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

plugin.Open

plugin.Open(path) carrega um arquivo .so compilado. Ele inicializa as funções init() e as variáveis no nível do pacote do plug-in e, em seguida, disponibiliza os símbolos.

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

p.Lookup

p.Lookup(name) encontra um símbolo exportado pelo nome. Ele retorna um any; faça uma asserção de tipo para o 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") }

Carregando vários plug-ins

Carregue cada .so de um diretório e registre-os em um laço:

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

Padrão de função fábrica

Os plug-ins exportam uma função fábrica (NewXxx() Processor) em vez de um valor, para que o programa hospedeiro obtenha uma nova instância a cada chamada:

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

Tratamento de erros na busca

Erros de Lookup significam que o símbolo não foi exportado ou que o nome está incorreto. Trate a situação com elegância — ignore o plug-in ou registre o erro e continue carregando os outros.

plugin.Open é idempotente

Chamar plugin.Open duas vezes com o mesmo caminho retorna o mesmo plug-in. O plug-in é inicializado apenas uma vez.

Carregamento sob demanda

Carregue os plug-ins sob demanda (no primeiro uso), em vez de carregá-los na inicialização, para reduzir o tempo de inicialização. Use um sync.Once por plug-in para garantir que ele seja carregado exatamente uma 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
}

Convenções de nomenclatura de símbolos

Use nomes CamelCase com inicial maiúscula para os símbolos exportados (a regra de visibilidade do Go se aplica). Uma convenção comum é usar Plugin para o valor principal ou New para a fábrica.

Tratando pânicos dos plug-ins

Se um plug-in causar um pânico, o middleware de recuperação no programa hospedeiro poderá capturá-lo, mas as goroutines do plug-in poderão ficar em um estado indefinido. Registre o erro e ignore o plug-in; não tente novamente.

Validando metadados do plug-in

Depois de carregar, verifique um símbolo de metadados (por exemplo, PluginVersion string) para validar a compatibilidade antes de registrar:

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

Verificação rápida

O que acontece se você chamar plugin.Open duas vezes com o mesmo caminho?

Recapitulação: carregamento dinâmico e símbolos

Pontos principais:

plugin.Open carrega .so; p.Lookup retorna any → faça uma asserção de tipo
Carregue os plug-ins de um diretório em um laço para criar um sistema de plug-ins
plugin.Open é idempotente; init() é executado uma vez por caminho
Prefira funções fábrica a símbolos de valores para obter novas instâncias

Perguntas Frequentes

A aula “Carregamento dinâmico e símbolos” é grátis?

Sim — o texto completo de “Carregamento dinâmico e símbolos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Carregamento dinâmico e símbolos”?

Carregue plugins em tempo de execução e chame símbolos exportados Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Carregamento dinâmico e símbolos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy