So implementieren Sie Golang zur Implementierung der Alipay-Schnittstelle einer Webanwendung

Mit der Popularisierung des mobilen Internets, der Popularität von Online-Shopping und mobilem Bezahlen ist Alipay immer mehr zu einem unverzichtbaren Bestandteil des Lebens der Menschen geworden, und die Benutzeroberfläche von Alipay ist zu einer der Fähigkeiten geworden, die Entwickler beherrschen müssen. In diesem Artikel wird erläutert, wie Sie mit Golang die Alipay-Schnittstelle von Webanwendungen implementieren.

Zuerst müssen wir ein Konto auf der Entwicklerplattform von Alipay registrieren und eine Anwendung erstellen. Beim Erstellen einer Anwendung müssen Sie den Anwendungsnamen, den Anwendungstyp, die Rückrufadresse der Anwendung und andere Informationen eingeben und die Anwendungs-ID und den privaten Schlüssel generieren. Diese Informationen werden in nachfolgenden Schnittstellenaufrufen verwendet.

Als nächstes müssen wir Golang verwenden, um Code zum Aufrufen der Alipay-Schnittstelle zu schreiben. Zuerst müssen wir die notwendigen Pakete einführen:

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

Als nächstes müssen wir einige Variablen definieren. Darunter müssen die Werte von Variablen wie appId, privateKey, publicKey, GatewayUrl, charset, signType und Format entsprechend Ihren Anwendungsinformationen geändert werden.

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

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

Unter diesen müssen private Key und publicKey durch den privaten Schlüssel der Anwendung und den öffentlichen Schlüssel von Alipay ersetzt werden, die aus Sicherheitsgründen in Konstanten gespeichert werden. Tatsächlich sollten sie in Dateien oder Datenbanken gespeichert werden . .

Als nächstes müssen wir einige Strukturen zum Parsen der von der Alipay-Schnittstelle zurückgegebenen JSON-Daten definieren:

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"`
}

Hier ist nur eine TradePrecreateResponse-Struktur definiert, die zum Parsen der von der Alipay-Erstellungsauftragsschnittstelle zurückgegebenen JSON-Daten verwendet wird.

Als nächstes müssen wir einige Funktionen definieren. Zuerst müssen wir eine Funktion zum Generieren von Signaturen definieren.

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)
}

Diese Funktion sortiert zunächst die Parameter in lexikografischer Reihenfolge, berechnet dann mit dem SHA256-Algorithmus den Digest der Parameter, signiert dann den Digest mit dem privaten Schlüssel der Anwendung und codiert schließlich die Signatur mit Base64.

Als nächstes müssen wir eine Funktion definieren, um eine Anfrage an die Alipay-Schnittstelle zu senden:

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
    }
}

Diese Funktion organisiert zunächst die Parameter in einer URL-Zeichenfolge und verwendet die Funktion „generateSign“, um eine Signatur zu generieren. Senden Sie anschließend diese URL-Zeichenfolge an die Schnittstelle von Alipay und warten Sie auf das Rückgabeergebnis von Alipay. Abschließend wird das zurückgegebene Ergebnis in einen String umgewandelt und zurückgegeben.

Zu diesem Zeitpunkt haben wir die Anfrage für die Alipay-Schnittstelle abgeschlossen. Der nächste Schritt besteht darin, diese Funktion aufzurufen, um die Funktion zum Erstellen einer Vorbestellungsschnittstelle zu implementieren. Das Folgende ist eine Beispielfunktion:

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
}

Diese Funktion organisiert zunächst einige Parameter wie die Bestellnummer des Händlers, den Bestellbetrag, den Bestelltitel usw., ruft dann die Funktion doRequest auf, um die Anfrage zu senden, und analysiert das zurückgegebene Ergebnis. Wenn der Code im zurückgegebenen Ergebnis 10000 ist, bedeutet dies, dass die Anforderung erfolgreich war. Andernfalls bedeutet dies, dass die Anforderung fehlgeschlagen ist. In diesem Fall muss die Fehlermeldung zurückgegeben werden.

Schließlich können wir diese Funktion in der Webanwendung verwenden, um die Alipay-Schnittstelle zu implementieren. Im Go-Sprach-Webframework Gin können Sie beispielsweise die obige Funktion wie folgt aufrufen:

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})
}

Diese Funktion generiert eine Händlerbestellung, ruft dann die Funktion „tradePrecreate“ auf, um eine Vorbestellung zu generieren, und gibt eine JSON-Antwort mit a zurück QR-Code.

Lassen Sie uns abschließend die oben genannten Schritte zusammenfassen: Zuerst müssen Sie ein Konto auf der Alipay-Entwicklerplattform registrieren und eine Anwendung erstellen sowie eine Anwendungs-ID und einen privaten Schlüssel generieren. Anschließend verwenden Sie Golang, um Code zum Aufrufen und Definieren der Alipay-Schnittstelle zu schreiben Einige Funktionen und Variablen werden letztendlich in der Webanwendung verwendet, um die Alipay-Schnittstelle zu implementieren.

Die oben genannten Schritte und Methoden zur Verwendung von Golang zur Implementierung der Alipay-Schnittstelle von Webanwendungen werden Ihnen hoffentlich weiterhelfen.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie Golang zur Implementierung der Alipay-Schnittstelle einer Webanwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!