如何使用Golang实现Web应用程序的微信支付

微信支付是一种非常普遍的在线支付方式，许多网站/应用都需要集成这个功能。本文将介绍如何使用 Golang 实现微信支付功能。在本文中，我们将使用 Gin 框架来构建一个简单的 Web 应用程序，并使用 go-wechat 微信 SDK 来快速实现微信支付。

需求

在本教程中，我们将构建一个简单的电商网站。该网站需要实现以下功能：

1. 用户通过微信登录网站。
2. 用户浏览商品并将商品添加到购物车。
3. 用户可以使用微信支付购买商品。

准备工作

在开始之前，请确保您有以下要求：

• 已经注册了微信支付账号， 拥有 appid、mch_id、key 等参数。
• 安装了 Golang 和 Gin 框架。

安装 go-wechat SDK

在继续之前，请从 go-wechat 的 Github 存储库中安装微信 SDK。

go get github.com/silenceper/wechat/v2

配置环境变量

从微信支付账户中获得以下参数并将其添加到系统环境变量中：

• APP_ID : 微信 APP_ID
• MCH_ID： 商户号
• API_KEY： 商户 API 密钥

export APP_ID=your_appid
export MCH_ID=your_mchid
export API_KEY=your_api_key

构建应用程序

初始化 Gin

在文件 main.go 中，我们将使用 gin 包来初始化应用程序。

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    router := gin.Default()

    router.GET("/", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello World!")
    })

    router.Run(":8080")
}

将微信登录添加到应用程序中

在上一页中，我们设置了基本的 Gin 应用程序。我们现在将添加微信登录功能。

1. 添加配置文件

您可以选择通过 JSON 、YAML 或 TOML 格式定义配置。这里，我们将 创建一个 config.json 文件来定义配置。

{
    "wechat": {
        "appid": "your_appid",
        "secret": "your_app_secret"
    }
}

2. 初始化 WeChat

下一步是初始化 WeChatClient 并使用 oauth2 请求代码来获取访问令牌。

import (
    "encoding/json"
    "io/ioutil"
    "net/http"
    "os"

    "github.com/silenceper/wechat/v2"
)

func loadConfig() map[string]string {
    file, err := os.Open("config.json")
    if err != nil {
        panic("Failed to load config file.")
    }
    defer file.Close()

    data, err := ioutil.ReadAll(file)
    if err != nil {
        panic("Failed to read config file.")
    }

    var config map[string]map[string]string
    err = json.Unmarshal(data, &config)
    if err != nil {
        panic("Failed to parse config file.")
    }

    return config["wechat"]
}

func initializeWeChat() *wechat.WeChat {
    config := loadConfig()
    client := wechat.NewWechat(&wechat.Config{
        AppID:          config["appid"],
        AppSecret:      config["secret"],
        Token:          "",
        EncodingAESKey: "",
    })

    return client
}

func weChatLoginHandler(c *gin.Context) {
    client := initializeWeChat()

    redirectURL := "<YOUR_REDIRECT_URL>"
    url := client.Oauth2.GetRedirectURL(redirectURL, "snsapi_userinfo", "")
    c.Redirect(http.StatusTemporaryRedirect, url)
}

从本质上讲，我们定义了一个包含应用程序的身份验证的 WeChatClient。我们还定义了一个 Gin 处理程序，该处理程序设置了重定向 URL 并使用 WeChatClient 中的 oauth2 请求获取访问令牌。

3. 处理微信授权

在重定向 URL 中，用户授权我们的应用程序在其账户下运行时，将调用 /wechat/callback 处理程序。该处理程序将用户的微信 ID、昵称和其他公开数据存储在用户会话中。

func callbackHandler(c *gin.Context) {
    code := c.Request.URL.Query().Get("code")

    client := initializeWeChat()
    accessToken, err := client.Oauth2.GetUserAccessToken(code)
    if err != nil {
        panic("Failed to get access token from WeChat.")
    }

    userInfo, err := client.Oauth2.GetUserInfo(accessToken.AccessToken, accessToken.Openid)
    if err != nil {
        panic("Failed to get user info from WeChat.")
    }

    session := sessions.Default(c)
    session.Set("wechat_openid", userInfo.Openid)
    session.Set("wechat_nickname", userInfo.Nickname)
    session.Save()

    c.Redirect(http.StatusTemporaryRedirect, "/")
}

4. 集成微信登录

我们应该将微信登录集成到我们的应用程序中。这个过程相对简单。仅需将处理程序添加到 Gin 路由器即可。

func main() {
    ...
    router.GET("/wechat/login", weChatLoginHandler)
    router.GET("/wechat/callback", callbackHandler)
    ...
}

实现购物车

我们将为应用程序添加 basic 的购物车状态。只需在用户会话中添加购物车信息即可。

type CartItem struct {
    ProductID int
    Quantity  int
}

func (c *CartItem) Subtotal() float64 {
    // TODO: Implement.
}

type Cart struct {
    Contents []*CartItem
}

func (c *Cart) Add(productID, quantity int) {
    item := &CartItem{
        ProductID: productID,
        Quantity:  quantity,
    }

    found := false
    for _, existingItem := range c.Contents {
        if existingItem.ProductID == productID {
            existingItem.Quantity += quantity
            found = true
            break
        }
    }

    if !found {
        c.Contents = append(c.Contents, item)
    }
}

func (c *Cart) Remove(productID int) {
    for i, item := range c.Contents {
        if item.ProductID == productID {
            c.Contents = append(c.Contents[:i], c.Contents[i+1:]...)
            break
        }
    }
}

func (c *Cart) Total() float64 {
    total := 0.0
    for _, item := range c.Contents {
        total += item.Subtotal()
    }
    return total
}

func cartFromSession(session sessions.Session) *Cart {
    value := session.Get("cart")
    if value == nil {
        return &Cart{}
    }

    cartBytes := []byte(value.(string))
    var cart Cart
    json.Unmarshal(cartBytes, &cart)
    return &cart
}

func syncCartToSession(session sessions.Session, cart *Cart) {
    cartBytes, err := json.Marshal(cart)
    if err != nil {
        panic("Failed to sync cart with session data store.")
    }

    session.Set("cart", string(cartBytes))
    session.Save()
}

如上所示，我们实现了一个包含 Add(productID, quantity int)，Remove(productID int), Total() float64几个方法的 cart struct。我们从会话中存储和加载 cart 数据 （cartFromSession() 和 syncCartToSession()），并通过 CartItem.Subtotal() 方法计算项目的小计。

在页面底部展示购物车状态：

<footer>
    <div class="container">
        <div class="row">
            <div class="col-sm-4">
                <a href="/">Back to home</a>
            </div>
            <div class="col-sm-4">
                <p id="cart-count"></p>
            </div>
            <div class="col-sm-4">
                <p id="cart-total"></p>
            </div>
        </div>
    </div>
</footer>
<script>
    document.getElementById("cart-count").innerText = "{{.CartItemCount}} items in cart";
    document.getElementById("cart-total").innerText = "Total: ${{.CartTotal}}";
</script>

微信支付

为了实现微信支付，我们需要定义一个订单 struct、生成订单并将其发送给微信支付、处理支付通知。以下是一个简单的实现。

1. 定义订单 struct

type Order struct {
    OrderNumber string
    Amount      float64
}

2. 生成订单并向微信发送订单

在此步骤中，我们将生成订单并通过微信支付创建订单号。阅读 go-wechat 的支付文档以了解有关更多信息。

func generateOutTradeNo() string {
    // TODO: Implement.
}

func createOrder(cart *Cart) *Order {
    order := &Order{
        OrderNumber: generateOutTradeNo(),
        Amount:      cart.Total(),
    }

    client := initializeWeChat()
    payment := &wechat.Payment{
        AppID:          APP_ID,
        MchID:          MCH_ID,
        NotifyURL:      "<YOUR_NOTIFY_URL>",
        TradeType:      "JSAPI",
        Body:           "购物车结算",
        OutTradeNo:     order.OrderNumber,
        TotalFee:       int(order.Amount * 100),
        SpbillCreateIP: "127.0.0.1",
        OpenID:         "<USER_WECHAT_OPENID>",
        Key:            API_KEY,
    }
    result, err := client.Pay.SubmitPayment(payment)
    if err != nil {
        panic("Failed to submit payment.")
    }

    // Save order state and return it.
    return order
}

3. 处理微信的支付通知

在微信通知我们已经收到用户的支付后，在回调中，我们将存储订单状态，供以后查询。

func setupCheckOrderStatus() {
    go func() {
        for {
            // Wait 10 seconds before checking (or less if you want to check more frequently).
            time.Sleep(10 * time.Second)

            client := initializeWeChat()
            // TODO: Retrieve orders that need to be checked.
            for _, order := range ordersToCheck {
                queryOrderResult, err := client.Pay.QueryOrder(&wechat.QueryOrderParams{
                    OutTradeNo: order.OrderNumber,
                })
                if err != nil {
                    panic("Failed to query order.")
                }

                switch queryOrderResult.TradeState {
                case wechat.TradeStateSuccess:
                    // Handle order payment in your app.
                    order.Paid = true
                    // TODO: Update order state in database.
                case wechat.TradeStateClosed:
                    // Handle order payment in your app.
                    order.Paid = false
                    // TODO: Update order state in database.
                case wechat.TradeStateRefund:
                    // Handle order payment in your app.
                    order.Paid = false
                    // TODO: Update order state in database.
                default:
                    break
                }

                // TODO: Remove checked order from cache.
            }
        }
    }()
}

我们需要调用查询功能以检查微信强制更改订单状态的交易。微信 SDK 会返回以下状态之一。

• TradeStateSuccess：用户付款成功。
• TradeStateClosed：已关闭订单。
• TradeStateRefund：交易已退款。

总结

在这篇文章中，我们学习了如何使用 Golang 和 Gin 框架来构建一个电商网站，并使用 go-wechat SDK 快速实现了微信登录和支付功能。我们了解到如何通过 WeChatClient 处理用户的认证和授权，并如何将微信用户数据存储在用户的会话中。我们还学习了如何定义一个简单的购物车和订单，并使用 go-wechat SDK 与微信支付集成。

以上是如何使用Golang实现Web应用程序的微信支付的详细内容。更多信息请关注PHP中文网其他相关文章！