Comment utiliser Golang pour implémenter l'interface Alipay d'une application Web

Avec la popularisation de l'Internet mobile, la popularité des achats en ligne et du paiement mobile, Alipay est devenu de plus en plus un élément indispensable dans la vie des gens, et l'interface d'Alipay est devenue l'une des compétences que les développeurs doivent maîtriser. Cet article expliquera comment utiliser Golang pour implémenter l'interface Alipay des applications Web.

Tout d’abord, nous devons créer un compte sur la plateforme de développement d’Alipay et créer une application. Lors de la création d'une application, vous devez renseigner le nom de l'application, le type d'application, l'adresse de rappel de l'application et d'autres informations, et générer l'ID de l'application et la clé privée. Ces informations seront utilisées dans les appels d'interface ultérieurs.

Ensuite, nous devons utiliser Golang pour écrire du code permettant d'appeler l'interface d'Alipay. Tout d'abord, nous devons introduire les packages nécessaires :

import (
    "bytes"
    "crypto"
    "crypto/rsa"
    "crypto/x509"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
    "sort"
    "strings"
    "time"
)

Ensuite, nous devons définir quelques variables. Parmi elles, les valeurs de variables telles que appId, privateKey, publicKey, gatewayUrl, charset, signType et format doivent être modifiées en fonction des informations de votre application.

const (
    appId      = "xxx"
    privateKey = `xxx`
    publicKey  = `xxx`

    gatewayUrl = "https://openapi.alipay.com/gateway.do"
    charset    = "utf-8"
    signType   = "RSA2"
    format     = "json"
)

Parmi eux, privateKey et publicKey doivent être remplacés par la clé privée de l'application et la clé publique Alipay obtenues auprès de la plateforme de développement Alipay. Pour des raisons de sécurité, elles sont stockées dans des constantes. .

Ensuite, nous devons définir quelques structures pour analyser les données JSON renvoyées par l'interface Alipay :

type AlipayResponse struct {
    Code    string `json:"code"`
    Msg     string `json:"msg"`
    SubCode string `json:"sub_code"`
    SubMsg  string `json:"sub_msg"`
}

type TradePrecreateResponse struct {
    AlipayResponse
    OutTradeNo string `json:"out_trade_no"`
    QrCode     string `json:"qr_code"`
}

Une seule structure TradePrecreateResponse est définie ici, qui est utilisée pour analyser les données JSON renvoyées par l'interface d'ordre de création Alipay.

Ensuite, nous devons définir certaines fonctions. Tout d’abord, nous devons définir une fonction pour générer des signatures.

func generateSign(params url.Values) string {
    keys := make([]string, 0, len(params))

    for key := range params {
        keys = append(keys, key)
    }

    sort.Strings(keys)

    var sortedParams bytes.Buffer

    for _, key := range keys {
        values := params[key]
        value := ""
        if len(values) > 0 {
            value = values[0]
        }

        sortedParams.WriteString(key)
        sortedParams.WriteString("=")
        sortedParams.WriteString(value)
        sortedParams.WriteString("&")
    }

    sortedParams.Truncate(sortedParams.Len() - 1)

    h := crypto.SHA256.New()
    h.Write(sortedParams.Bytes())

    privateKeyByte := []byte(privateKey)
    block, _ := pem.Decode(privateKeyByte)
    privateKey, _ := x509.ParsePKCS8PrivateKey(block.Bytes)

    signature, err := rsa.SignPKCS1v15(nil, privateKey.(*rsa.PrivateKey), crypto.SHA256, h.Sum(nil))
    if err != nil {
        panic(err)
    }

    return base64.StdEncoding.EncodeToString(signature)
}

Cette fonction trie d'abord les paramètres par ordre lexicographique, puis utilise l'algorithme SHA256 pour calculer le résumé des paramètres, puis utilise la clé privée de l'application pour signer le résumé, et enfin base64 encode la signature.

Ensuite, nous devons définir une fonction pour envoyer une requête à l'interface Alipay :

func doRequest(apiName string, bizContent map[string]interface{}) (string, error) {
    var (
        response *http.Response
        err      error
    )

    params := url.Values{}
    params.Set("app_id", appId)
    params.Set("method", apiName)
    params.Set("version", "1.0")
    params.Set("format", format)
    params.Set("charset", charset)
    params.Set("sign_type", signType)
    params.Set("timestamp", time.Now().Format("2006-01-02 15:04:05"))
    params.Set("biz_content", toJsonString(bizContent))

    params.Set("sign", generateSign(params))

    url := gatewayUrl + "?" + params.Encode()

    if response, err = http.Get(url); err != nil {
        return "", err
    }

    defer response.Body.Close()

    if body, err := ioutil.ReadAll(response.Body); err != nil {
        return "", err
    } else {
        return string(body), nil
    }
}

Cette fonction organise d'abord les paramètres dans une chaîne d'URL et utilise la fonction generateSign pour générer une signature. Après cela, envoyez cette chaîne URL à l'interface d'Alipay et attendez le résultat de retour d'Alipay. Enfin, le résultat renvoyé est converti en chaîne et renvoyé.

À ce stade, nous avons terminé la demande pour l'interface Alipay. L'étape suivante consiste à savoir comment appeler cette fonction pour réaliser la fonction de création d'une interface de précommande. Voici un exemple de fonction :

func tradePrecreate(subject, outTradeNo string, totalAmount float32) (*TradePrecreateResponse, error) {
    bizContent := make(map[string]interface{})
    bizContent["out_trade_no"] = outTradeNo
    bizContent["total_amount"] = fmt.Sprintf("%.2f", totalAmount)
    bizContent["subject"] = subject
    bizContent["timeout_express"] = "30m"

    responseStr, err := doRequest("alipay.trade.precreate", bizContent)
    if err != nil {
        return nil, err
    }

    var response TradePrecreateResponse

    if err := json.Unmarshal([]byte(responseStr), &response); err != nil {
        return nil, err
    }

    if response.Code != "10000" {
        return nil, fmt.Errorf("%s (%s)", response.Msg, response.SubMsg)
    }

    return &response, nil
}

Cette fonction organise d'abord certains paramètres, tels que le numéro de commande du commerçant, le montant de la commande, le titre de la commande, etc., puis appelle la fonction doRequest pour envoyer la demande et analyse le résultat renvoyé. Si le code dans le résultat renvoyé est 10000, cela signifie que la requête a réussi, sinon cela signifie que la requête a échoué, et dans ce cas, le message d'erreur doit être renvoyé.

Enfin, nous pouvons utiliser cette fonction dans l'application web pour implémenter l'interface Alipay. Par exemple, dans le framework Web du langage Go gin, vous pouvez appeler la fonction ci-dessus comme ceci :

func createOrder(c *gin.Context) {
    subject := "Test Order"
    outTradeNo := "12345"
    totalAmount := 1.00

    response, err := tradePrecreate(subject, outTradeNo, totalAmount)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"qr_code": response.QrCode})
}

Cette fonction générera une commande marchand, puis appellera la fonction tradePrecreate pour générer une précommande et renverra une réponse JSON avec un Code QR.

Enfin, résumons les étapes ci-dessus : Tout d'abord, vous devez créer un compte sur la plateforme de développement Alipay et créer une application, puis générer un identifiant d'application et une clé privée, puis utiliser Golang pour écrire du code pour appeler l'interface d'Alipay et définir ; certaines structures, fonctions et variables ; finalement, ces fonctions sont utilisées dans l'application web pour implémenter l'interface Alipay.

Voici les étapes et méthodes d'utilisation de Golang pour implémenter l'interface Alipay des applications Web. J'espère que cela vous sera utile.

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!