Comment implémenter des plug-ins dans Golang

Avec l'expansion continue de l'échelle des systèmes logiciels informatiques, l'évolutivité des programmes est devenue la priorité de la plupart des entreprises et des équipes. Un moyen courant d’atteindre l’évolutivité consiste à utiliser une architecture enfichable. Le mécanisme de plug-in permet d'étendre les fonctions du programme à tout moment sans modifier directement le code du programme. Par rapport à l'architecture modulaire traditionnelle, l'architecture plug-in est plus flexible, hautement cohérente et gérable. Cet article explique comment concevoir et implémenter un mécanisme de plug-in en langage Golang.

1. Le concept de plug-in

Un plug-in fait référence à un composant qui peut être chargé dynamiquement et étendre les fonctionnalités d'un programme. Les plug-ins sont généralement indépendants du programme principal et peuvent être chargés ou déchargés pendant l'exécution du programme principal. Les plug-ins contiennent généralement une ou plusieurs interfaces via lesquelles ils communiquent avec le programme principal.

Dans l'architecture des plug-ins, le programme principal est responsable du chargement ou du déchargement des plug-ins, de la communication avec les plug-ins et de la coordination de la collaboration entre les plug-ins. Les plug-ins sont chargés d'implémenter les fonctions qu'ils fournissent et de les exposer au programme principal pour les appels via des interfaces prédéfinies.

2. plug-in golang

Dans golang, vous pouvez utiliser des bibliothèques de liaison dynamique (Dynamic Linking Libraries) pour implémenter le plug-in. Les étapes spécifiques sont les suivantes :

• Définir l'interface ou le type de structure du plug-in. selon les besoins
• Écrivez le code du plug-in et compilez-le en tant que bibliothèque de liens dynamiques
• Fournissez des interfaces de fonction ou des appels de fonction de bibliothèque dynamique dans le programme principal, chargez la bibliothèque de liens dynamiques et appelez le code du plug-in au moment de l'exécution

Nous mettrons en œuvre les étapes ci-dessus étape par étape ci-dessous.

3. Définir l'interface du plug-in

Nous devons déterminer ce que le plug-in que nous voulons implémenter doit faire et quelles interfaces il fournit. En prenant un simple programme de calculatrice comme exemple, nous définissons l'interface du plug-in comme suit :

package plugin

type CalculatorPlugin interface {
    GetName() string
    Add(int, int) int
    Sub(int, int) int
}

4. Écrivez le code du plug-in

Nous supposons qu'il existe deux plug-ins : AddPlugin et SubPlugin. Ils implémentent tous l’interface CalculatorPlugin.

AddPlugin implémente deux méthodes : GetName() et Add().

package main

import (
    "github.com/bwmarrin/discordgo"
    "github.com/derry6/DSGO_BOT/plugin"
)

type AddPlugin struct {
}

func (ap *AddPlugin) GetName() string {
    return "加法插件"
}

func (ap *AddPlugin) Add(a, b int) int {
    return a + b
}

func New() plugin.CalculatorPlugin {
    return &AddPlugin{}
}

func main() {}

SubPlugin implémente deux méthodes : GetName() et Sub().

package main

import (
    "github.com/bwmarrin/discordgo"
    "github.com/derry6/DSGO_BOT/plugin"
)

type SubPlugin struct {
}

func (sp *SubPlugin) GetName() string {
    return "减法插件"
}

func (sp *SubPlugin) Sub(a, b int) int {
    return a - b
}

func New() plugin.CalculatorPlugin {
    return &SubPlugin{}
}

func main() {}

Ce qu'il faut noter dans le code, c'est la fonction New(), qui renvoie une valeur de type d'interface CalculatorPlugin. Le programme principal utilisera cette fonction pour charger dynamiquement le plug-in.

5. Compilez le plug-in

Utilisez la commande go build pour compiler le plug-in et générer une bibliothèque de liens dynamiques.

go build -buildmode=plugin -o add.so add.go
go build -buildmode=plugin -o sub.so sub.go

6. Chargement des plug-ins dans le programme principal

Le programme principal est responsable du chargement des plug-ins Nous devons définir une fonction pour charger le plug-in en fonction du chemin où il se trouve.

func LoadPlugin(path string) (p plugin.CalculatorPlugin, err error) {
    plugin, err := plugin.Open(path)
    if err != nil {
        return nil, err
    }
    symbol, err := plugin.Lookup("New")
    if err != nil {
        return nil, err
    }
    return symbol.(func() plugin.CalculatorPlugin)(), nil
}

7. Utilisez la fonction plug-in

Une fois que le programme principal a chargé le plug-in, nous pouvons obtenir le nom du plug-in et effectuer des opérations d'addition et de soustraction grâce aux méthodes fournies par le plug-in. Voici un exemple de code :

package main

import (
    "fmt"
    "github.com/derry6/DSGO_BOT/plugin"
)

func main() {
    addPlugin, _ := LoadPlugin("./add.so")
    subPlugin, _ := LoadPlugin("./sub.so")

    fmt.Println("插件名称: ", addPlugin.GetName())
    fmt.Println("3 + 2 = ", addPlugin.Add(3, 2))

    fmt.Println("插件名称: ", subPlugin.GetName())
    fmt.Println("3 - 2 = ", subPlugin.Sub(3, 2))
}

8. Résumé

La plug-inisation dans Golang est réalisée grâce à des bibliothèques de liens dynamiques. Avec le mécanisme de plug-in, l'évolutivité et la maintenabilité du code peuvent être considérablement améliorées. Lorsque nous devons ajouter de nouvelles fonctions, il suffit d'écrire les plug-ins correspondants au lieu de modifier le code original du programme. L'idée de conception de l'architecture des plug-ins et la mise en œuvre de plug-ins compilés Golang peuvent nous permettre de mieux concevoir et développer l'ingénierie logicielle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!