golang implémente la couche d'accès

Avec le développement continu de la technologie Internet, de plus en plus de systèmes doivent désormais accéder à plusieurs interfaces de services externes pour mettre en œuvre diverses fonctions. Afin d'unifier la gestion et de simplifier les appels aux interfaces externes, une couche d'accès doit être introduite pour protéger l'architecture sous-jacente des modifications apportées aux API externes. Cet article explique comment utiliser Golang pour implémenter une couche d'accès afin d'accéder facilement aux interfaces de services externes.

1. Qu'est-ce que la couche d'accès ?

La couche d'accès fait référence à un niveau d'abstraction entre l'intérieur et l'extérieur du système. Elle est principalement responsable des appels d'interface internes et externes. La couche d'accès peut gérer et contrôler uniformément les appels d'API de plusieurs systèmes externes, masquer les détails de l'interface sous-jacente et fournir des méthodes d'appel d'interface simplifiées aux utilisateurs externes.

2. Avantages de golang

Golang est un langage de programmation efficace avec les avantages suivants :

1. Syntaxe concise et claire, facile à lire et à maintenir
2. Fortes capacités de programmation simultanée, adaptées au développement d'applications distribuées ; mécanisme de collecte des ordures, pas besoin de gestion manuelle de la mémoire ;
3. Système de type fiable, capable de détecter les erreurs potentielles à l'avance.
4. Pour résumer, golang est très approprié pour implémenter la couche d'accès. Ce qui suit explique comment utiliser Golang pour implémenter une couche d'accès de base.

3. Implémentation de la couche d'accès

Structure de la couche d'accès

1. Avant de commencer à écrire du code, vous devez d'abord créer une architecture de base de la couche d'accès. La structure de la couche d'accès se compose de trois parties :

Handlers : gère diverses requêtes d'interface.

1. Gestionnaire d'interface : gère toutes les interfaces et est responsable du routage des demandes du centre de couche d'accès et du routage des demandes vers le gestionnaire approprié.
2. Centre : accepte les demandes des services externes et envoie les demandes au gestionnaire d'interface afin que le bon gestionnaire soit sélectionné pour traiter la demande au bon moment.
3. Gestionnaires d'implémentation
4. Les gestionnaires sont la partie la plus importante de la couche d'accès. Ils sont responsables du traitement des demandes des systèmes externes vers la couche d'accès. Selon les différents types de requêtes, nous pouvons écrire différents gestionnaires.

Voici un exemple de gestionnaire qui gère les requêtes HTTP GET :

package handlers

import (
    "fmt"
    "net/http"
)

func GetHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "This is a GET request, URL: %s", r.URL.Path[1:])
}

Implémentation du gestionnaire d'interface

3. Le gestionnaire d'interface fait partie du centre de couches d'accès et peut être utilisé pour gérer toutes les interfaces disponibles et acheminer les requêtes vers le gestionnaire approprié. supérieur. Ce qui suit est une implémentation simple du gestionnaire d'interface :

package manager

import (
    "fmt"
    "net/http"
)

var (
    handlers = make(map[string]func(http.ResponseWriter, *http.Request))
)

func AddHandler(name string, handler func(http.ResponseWriter, *http.Request)) {
    handlers[name] = handler
}

func GetHandlerByName(name string) (func(http.ResponseWriter, *http.Request), bool) {
    val, ok := handlers[name]
    return val, ok
}

func Router(w http.ResponseWriter, r *http.Request) {
    handler, ok := GetHandlerByName(r.URL.Path[1:])
    if ok {
        handler(w, r)
    } else {
        fmt.Fprintf(w, "Unknown request URL: %s", r.URL.Path[1:])
    }
}

Le package du gestionnaire d'interface implémente la méthode AddHandler(), qui est utilisée pour ajouter les interfaces disponibles. Dans le même temps, il implémente également la méthode GetHandlerByName(), qui est utilisée pour rechercher le gestionnaire portant le nom spécifié. Lorsque la méthode Router() est appelée, elle utilisera GetHandlerByName() pour trouver le bon gestionnaire et acheminer la requête vers ce gestionnaire.

Centre de mise en œuvre

4. Le centre est le cœur de la couche d'accès. Il reçoit toutes les demandes des services externes et les achemine vers le bon gestionnaire d'interface. Ce qui suit est une implémentation centrale simple :

package center

import (
    "log"
    "net/http"

    "manager"
)

func StartServer(port string) {
    http.HandleFunc("/", manager.Router)
    log.Fatal(http.ListenAndServe(":"+port, nil))
}

La méthode centrale StartServer() utilise la méthode http.HandleFunc() pour définir les règles de routage, en utilisant "/" comme préfixe de routage et la méthode Router() comme gestionnaire. Appelez la méthode log.Fatal() pour arrêter immédiatement l'exécution du programme et obtenir une erreur. Si la surveillance du réseau échoue, le programme ne démarrera pas.

4. Utilisation de la couche d'accès

Après avoir terminé l'écriture de la couche d'accès, nous pouvons l'utiliser dans l'application en suivant les étapes suivantes :

Ajouter l'interface à exposer au gestionnaire d'interface via la méthode AddHandler() . Par exemple, pour ajouter une interface nommée "/hello" :

1. manager.AddHandler("hello", handlers.HelloHandler)

Démarrez le centre via le gestionnaire d'interface, en acheminant la requête vers le bon gestionnaire.

2. center.StartServer("8080")

Après avoir démarré le centre, vous pouvez facilement tester l'interface à l'aide de la commande curl. Par exemple, pour tester l'interface nommée "/hello" :

curl -X GET http://localhost:8080/hello

5. Résumé

Dans cet article, nous avons présenté les concepts de base de la couche d'accès et la méthode d'utilisation de golang pour implémenter la couche d'accès. L'utilisation de Golang peut facilement mettre en œuvre une couche d'accès efficace et facile à maintenir afin que nous puissions mieux gérer et traiter les services externes. De plus, nous avons expliqué comment utiliser la couche d'accès côté client afin de pouvoir facilement tester l'interface et comprendre ses fonctionnalités.

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!