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.
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.
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 :
Nous mettrons en œuvre les étapes ci-dessus étape par étape ci-dessous.
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 }
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.
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
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 }
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)) }
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!