Golang implémente le plug-in

Avec le développement continu des activités, nos applications ont tendance à devenir plus volumineuses et plus complexes. À l'heure actuelle, de nombreux modèles de développement de logiciels traditionnels peuvent devenir insuffisants. Le modèle de couplage de code traditionnel est difficile à répondre à nos divers besoins de développement, tandis que la méthode de développement de plug-ins fournit un concept de conception plus flexible et évolutif, qui peut réaliser efficacement le découplage de code et permettre aux applications de fonctionner sans modification. De nouvelles fonctions peuvent être ajoutées à tout moment. temps tout en conservant la logique du code d’origine.

Dans le processus de mise en œuvre du développement de plug-ins, Golang, en tant que langage de programmation efficace, fiable et hautement développé, est naturellement un très bon choix. Aujourd'hui, nous allons découvrir comment implémenter une application plug-in dans Golang.

Introduction au développement de plug-ins

Avant l'opération proprement dite, présentons brièvement ce qu'est le développement de plug-ins. Le développement de plug-ins est une méthode de développement qui divise une application en plusieurs composants indépendants. Chaque composant peut être développé, testé, déployé et maintenu indépendamment, et ces composants peuvent être ajoutés ou supprimés à tout moment pendant l'exécution de l'application. Cela présente plusieurs avantages :

1. Amélioration de la réutilisabilité du code : Chaque composant est un module indépendant, ce qui les rend réutilisables dans différentes applications.
2. Réalisez le découplage du code : seules les interfaces doivent être définies entre les composants, sans connaître les détails d'implémentation internes des autres composants. De cette manière, différents composants peuvent être développés, testés et déployés indépendamment.
3. Amélioration de l'évolutivité du code : lorsque l'application nécessite de nouvelles fonctions, seuls de nouveaux composants doivent être ajoutés, évitant ainsi la modification du code d'origine et permettant à l'application d'être étendue plus efficacement.

Utiliser Go pour implémenter la plug-inisation

Ensuite, nous utiliserons le langage Go pour implémenter une application plug-in. Nous utiliserons le package plugin de Go pour charger et exécuter un plug-in. Chaque plug-in doit implémenter une interface spécifique pour être appelé dans l'application. Ici, nous allons développer une application de calcul simple, principalement pour démontrer comment utiliser Go pour réaliser le développement de plug-ins.

L'application calculatrice peut prendre en charge les fonctions d'addition, de soustraction, de multiplication, de division et autres, et chaque fonction correspond à un plug-in. Nous allons écrire un programme principal et quatre plug-ins pour implémenter quatre logiques de calcul différentes d'addition, de soustraction, de multiplication et de division.

Tout d'abord, jetons un coup d'œil au code du programme principal :

package main

import (
    "fmt"
    "os"
    "plugin"
)

type Operation interface {
    Calculate(a, b int) int
}

type Plugin struct {
    Name      string
    Operation Operation
}

func main() {

    if len(os.Args) < 3 {
        fmt.Println("Usage: pluginCalculator OPERATION VALUE")
        os.Exit(-1)
    }

    op := os.Args[1]
    value := os.Args[2]

    plugins := []Plugin{
        Plugin{"Add", nil},
        Plugin{"Subtract", nil},
        Plugin{"Multiply", nil},
        Plugin{"Divide", nil},
    }

    for i, plugin := range plugins {
        p, err := pluginOpen("./plugins/" + plugin.Name + ".so")
        if err != nil {
            fmt.Println("Error opening plugin:", plugin.Name)
            continue
        }
        var op Operation
        op, err = p.Lookup("Operation")
        if err != nil {
            fmt.Println("Error looking up operation:", plugin.Name)
            continue
        }
        plugins[i].Operation = op
    }

    for _, plugin := range plugins {
        if plugin.Operation == nil {
            continue
        }
        if plugin.Name == op {
            valueInt := 0
            fmt.Sscanf(value, "%d", &valueInt)
            result := plugin.Operation.Calculate(100, valueInt)
            fmt.Printf("Result of %s(%d, %d): %d
", op, 100, valueInt, result)
            return
        }
    }

    fmt.Println("Unsupported operation:", op)
}

func pluginOpen(path string) (*plugin.Plugin, error) {
    p, err := plugin.Open(path)
    return p, err
}

Dans ce programme, nous utilisons le package plugin de Go pour charger le plugin et effectuer ses opérations. Tout d'abord, nous définissons un fonctionnement de l'interface de la calculatrice. Chaque plug-in doit implémenter cette interface pour être appelé dans l'application. Ensuite, nous avons défini une structure Plugin pour représenter les informations d'un plug-in, y compris le nom du plug-in et l'instance d'opération.

Ensuite, nous définissons un tableau de plugins pour stocker toutes les informations sur les plugins. Nous utilisons une boucle for pour parcourir tous les plugins et charger les fichiers du plugin via la fonction plugin.Open. Si le chargement échoue, enregistrez une erreur et continuez à parcourir le plugin suivant. Si le chargement réussit, utilisez la fonction p.Lookup pour rechercher l'interface d'opération implémentée dans le plug-in et attribuez-la au tableau des plugins. Enfin, nous interrogeons l'opération saisie par l'utilisateur, et si le plug-in correspondant est trouvé, nous utilisons la fonction Calculer du plug-in pour calculer le résultat et afficher les informations du résultat sur la console.

Ensuite, jetons un coup d'œil à l'implémentation du code du plug-in. Ici, nous allons écrire quatre plug-ins pour implémenter quatre logiques de calcul différentes d'addition, de soustraction, de multiplication et de division. Ces plug-ins implémenteront tous l’interface Operation que nous avons définie précédemment.

Tout d'abord, jetons un coup d'œil au code du plug-in Add qui implémente l'addition :

package main

type Add struct{}

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

var Operation = Add{}

Dans ce programme, nous définissons une structure Add qui implémente la méthode Calculate de l'interface Operation que nous avons définie, qui implémente l'opération d'addition , et exportez-le en tant que variable d'opération pour un chargement facile par le programme principal.

De même, voici l'implémentation du code des quatre plug-ins :

Plug-in de soustraction :

package main

type Subtract struct{}

func (*Subtract) Calculate(a, b int) int {
    return a - b
}

var Operation = Subtract{}

Plug-in de multiplication :

package main

type Multiply struct{}

func (*Multiply) Calculate(a, b int) int {
    return a * b
}

var Operation = Multiply{}

Plug-in de division :

package main

type Divide struct{}

func (*Divide) Calculate(a, b int) int {
    return a / b
}

var Operation = Divide{}

L'implémentation du plug-in est très simple et clair, ce ne sont que des implémentations de la méthode Calculate dans l'interface Operation, mais vous devez utiliser l'indicateur -buildmode=plugin pour générer un fichier .so lors de la construction, par exemple :

go build -buildmode=plugin Add.go

Résumé

Dans cet article, nous avons présenté les concepts de base du développement de plug-ins et utilisé une application Golang implémentant une calculatrice de plug-ins pour démontrer comment développer et utiliser des plug-ins. Cette méthode de développement de plug-ins peut améliorer considérablement l'efficacité et la qualité de notre développement logiciel, tout en réalisant efficacement un découplage du code et une expansion flexible des applications. Il convient de noter que dans le développement réel, il est nécessaire d'évaluer soigneusement les besoins de l'application et de sélectionner une solution de développement de plug-ins appropriée en fonction de la situation réelle pour obtenir un effet de développement optimal.

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!