Go Academy · Aula

Projetando uma interface de plugin

Defina contratos de interface compartilhados entre o host e o plugin

Projetando uma interface de plugin é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 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.

Plug-ins baseados em interface

Defina uma interface Go estável que os plug-ins devem implementar. O programa hospedeiro carrega o plug-in, obtém a implementação e a chama por meio da interface — sem fazer asserções de tipo em cada método.

type Processor interface {
    Name() string
    Process(ctx context.Context, data []byte) ([]byte, error)
}

Ponto de entrada do plug-in

Cada plug-in exporta um símbolo conhecido (por exemplo, Plugin) que retorna a implementação da interface:

// In the plugin:
var Plugin processor // exported symbol

type processor struct{}
func (p processor) Name() string { return "my-processor" }
func (p processor) Process(ctx context.Context, data []byte) ([]byte, error) {
    return bytes.ToUpper(data), nil
}

Carregando por meio de uma interface

No programa hospedeiro, carregue o símbolo e faça uma asserção para a interface:

sym, _ := p.Lookup("Plugin")
proc, ok := sym.(Processor)
if !ok { log.Fatal("plugin does not implement Processor") }

Padrão de registro

Mantenha um registro dos plug-ins carregados, organizados por nome:

var registry = map[string]Processor{}

func register(p Processor) { registry[p.Name()] = p }
func get(name string) (Processor, bool) {
    p, ok := registry[name]
    return p, ok
}

Versionamento da interface

Adicione um método Version() à interface para que o programa hospedeiro possa verificar a compatibilidade antes de registrar o plug-in.

type Versioned interface {
    APIVersion() string
}
if v, ok := proc.(Versioned); ok && v.APIVersion() != "1.0" {
    log.Fatalf("incompatible plugin version: %s", v.APIVersion())
}

Contexto e cancelamento

Propague o contexto pelas chamadas de métodos do plug-in para que o programa hospedeiro possa cancelar operações longas do plug-in durante o encerramento ou quando a solicitação atingir o tempo limite.

Contrato de tratamento de erros

Defina se os plug-ins devem causar pânico ou retornar erros em caso de falha. Retornar erros é mais seguro — os pânicos nos plug-ins podem não ser capturáveis pelo middleware de recuperação do programa hospedeiro.

Configuração

Passe a configuração aos plug-ins no momento do carregamento por meio de um método Init(config map[string]string) error. Isso separa a criação do plug-in da configuração.

Gerenciamento do ciclo de vida

Adicione Close() error à interface para plug-ins que mantêm recursos (conexões com bancos de dados, goroutines) que precisam ser liberados durante o encerramento.

Testando plug-ins de forma independente

Teste diretamente a implementação do plug-in (como um pacote Go), sem carregar o binário .so. A interface torna simples realizar testes com simulações.

Contrato de documentação

Documente claramente o contrato da interface: quais métodos são chamados e quando, as garantias de execução concorrente e o que constitui um erro em vez de uma condição fatal.

Verificação rápida

Por que definir uma interface Go estável para os plug-ins em vez de procurar símbolos de funções individuais?

Recapitulação: design da interface de plug-ins

Pontos principais:

Defina uma interface estável que o plug-in deve implementar
Exporte um símbolo conhecido (var Plugin InterfaceType) a partir do plug-in
Faça uma única asserção de tipo no carregamento; todas as chamadas são seguras quanto ao tipo por meio da interface
Adicione Version(), Init() e Close() para gerenciar o ciclo de vida

Perguntas Frequentes

A aula “Projetando uma interface de plugin” é grátis?

Sim — o texto completo de “Projetando uma interface de plugin” é 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 “Projetando uma interface de plugin”?

Defina contratos de interface compartilhados entre o host e o plugin 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 2 de 4.

Quanto tempo leva a aula “Projetando uma interface de plugin”?

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