Comment demander du savon à Golang

Le langage Go est un langage de programmation open source, rapide et léger. Il prend en charge des fonctionnalités à haute concurrence, multithread, multiplateforme et autres, il est donc largement utilisé dans le développement de réseaux. Dans la plupart des cas, nous devons interagir avec d'autres systèmes via des requêtes HTTP. Cependant, certains systèmes ne prennent pas en charge le protocole HTTP, mais utilisent le protocole SOAP (Simple Object Access Protocol). Alors, comment envoyer une requête SOAP en langage Go ? Cet article présentera ce problème.

Connaissances préalables

Avant de commencer à parler de la façon d'envoyer des requêtes SOAP, vous devez comprendre plusieurs points de connaissances nécessaires.

SOAP Protocol

SOAP est un protocole basé sur le langage XML utilisé pour échanger des données dans un environnement distribué. Il définit les formats de message et les règles de description et de communication, permettant aux applications d'envoyer et de recevoir des messages via des protocoles tels que HTTP et SMTP. Les messages SOAP se composent principalement de trois parties : l'enveloppe, l'en-tête et le corps.

• enveloppe : L'élément racine du message SOAP, qui contient tous les éléments du message.
• En-tête : facultatif, utilisé pour transmettre des informations sans rapport avec les données réelles, telles que des informations de sécurité.
• body : contient les données réellement transmises.

Le format d'un message SOAP est le suivant :

bibliothèque

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
    <soap:Header>
        <!-- 可选的头部信息 -->
    </soap:Header>
    <soap:Body>
        <!-- 实际数据 -->
    </soap:Body>
</soap:Envelope>

net/http en langage Go

net/http est l'une des bibliothèques standards fournies par le langage Go pour gérer les requêtes et réponses HTTP. Grâce à cette bibliothèque, nous pouvons facilement implémenter les opérations réseau du serveur HTTP et du client HTTP. Pour les requêtes HTTP, vous devez faire attention aux paramètres clés suivants :

• URL : l'adresse cible de la requête.
• Méthode : méthode de requête, notamment GET, POST, PUT, DELETE, etc.
• En-têtes : demandez des informations d'en-tête, telles que le type de contenu, l'agent utilisateur, etc.
• Corps : les données réelles demandées.

Étapes pour envoyer une requête SOAP

Avec la base de connaissances précédente, nous pouvons désormais apprendre étape par étape comment envoyer des requêtes SOAP en langage Go. Les étapes spécifiques sont les suivantes :

• Confirmer l'adresse cible

Tout d'abord, nous devons confirmer l'adresse et le numéro de port du serveur cible. Après avoir déterminé ces informations, nous pouvons créer l'URL de la demande.

• Confirmez la méthode de requête et les en-têtes de requête

Ensuite, nous devons confirmer la méthode de requête SOAP et les informations d'en-tête de requête. Les requêtes SOAP doivent encapsuler les données de type de document XML dans des requêtes HTTP, nous devons donc définir des paramètres tels que Content-Type et SOAPAction dans l'en-tête de la requête. Les informations d'en-tête de demande spécifiques doivent être déterminées en fonction du document d'interface.

• Création du message de demande

Après avoir confirmé la méthode de demande et les informations d'en-tête de la demande, nous devons créer le message de demande. Le message de requête contient tous les éléments du message SOAP : Enveloppe, En-tête, Corps, etc. Parmi eux, le contenu de l’élément Body correspond aux données réelles. Vous pouvez utiliser encoding/xml ou string pour construire le message de demande. Ici, nous utilisons la méthode encoding/xml.

• Envoyer une demande

Après avoir créé le message de demande, nous pouvons utiliser le client de la bibliothèque net/http pour envoyer la demande. La méthode spécifique est la suivante :

resp, err := client.Do(req)

Parmi eux, client est le client HTTP et req est la requête HTTP. La méthode Do est utilisée pour envoyer des requêtes HTTP et renvoyer des réponses HTTP. Il est à noter que le client doit fermer la connexion après utilisation.

• Gestion de la réponse

Enfin, nous devons gérer la réponse HTTP. Extrayez les données réelles de la réponse et analysez-les. Ici, nous devons déterminer le contenu et le format des données qui doivent être extraites et analysées en fonction du document d'interface.

Exemple de code

Ci-dessous, nous prenons une requête SOAP réelle comme exemple pour montrer l'exemple de code expliquant comment utiliser le langage Go pour envoyer une requête SOAP. Nous utilisons ici l'interface d'une plateforme de commerce électronique, avec de légères modifications adaptées à la situation spécifique.

package main

import (
    "bytes"
    "encoding/xml"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
)

type Envelope struct {
    XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Envelope"`
    Header  *Header  `xml:",omitempty"`
    Body    *Body
}

type Header struct {
    // 这里可以定义需要的头部信息
}

type Body struct {
    XMLName xml.Name `xml:"Body"`
    Req     *Req
}

type Req struct {
    XMLName xml.Name `xml:"http://www.example.com/ OrderRequest"`
    Order   *Order
}

type Order struct {
    XMLName xml.Name `xml:"Order"`
    // 这里定义Order元素的子元素
}

func main() {
    // 确认目标地址
    url := "http://example.com/path/to/server"
    
    // 确认请求方法和请求头部信息
    soapAction := "http://www.example.com/OrderRequest"
    contentType := "text/xml;charset=utf-8"
    
    // 构建请求消息
    order := &Order{
        // 这里为Order元素的子元素赋值
    }
    req := &Req{
        Order: order,
    }
    body := &Body{
        Req: req,
    }
    envelope := &Envelope{
        Body: body,
    }
    data, err := xml.Marshal(envelope)
    if err != nil {
        fmt.Println("marshal error:", err)
        os.Exit(1)
    }
    
    // 发送请求
    client := &http.Client{}
    reqBody := bytes.NewBuffer(data)
    req, err := http.NewRequest("POST", url, reqBody)
    if err != nil {
        fmt.Println("create request error:", err)
        os.Exit(1)
    }
    req.Header.Set("Content-Type", contentType)
    req.Header.Set("SOAPAction", soapAction)
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("send request error:", err)
        os.Exit(1)
    }
    defer resp.Body.Close()
    
    // 处理响应
    respBody, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("read response body error:", err)
        os.Exit(1)
    }
    
    // 这里对respBody进行解析，提取需要的数据
}

Résumé

Envoyer des requêtes SOAP en langage Go peut être un peu fastidieux, mais tant que nous comprenons certaines connaissances et précautions de base, nous pouvons terminer la demande en douceur. Ces points de connaissances sont particulièrement importants lorsque vous devez accéder à une interface qui ne prend en charge que le protocole SOAP. J'espère que cet article pourra être utile aux lecteurs.

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!