module wechatpay-jsapi-demo

go 1.21

require (
	github.com/gin-gonic/gin v1.9.1
	github.com/joho/godotenv v1.5.1
	github.com/wechatpay-apiv3/wechatpay-go v0.2.21
)

# 服务器配置
SERVER_PORT=8080
BASE_URL=https://your-domain.com

# 微信支付配置
MCH_ID=1900000000
MCH_API_V3_KEY=YourAPIv3KeyHere
MCH_CERT_SERIAL_NO=YourCertSerialNo
MCH_PRIVATE_KEY_PATH=./certs/apiclient_key.pem

# 微信支付公钥配置（新商户必填）
WECHAT_PAY_PUBLIC_KEY_ID=PUB_KEY_ID_xxxxxxxx
WECHAT_PAY_PUBLIC_KEY_PATH=./certs/wechatpay_pub_key.pem

# 公众号配置
APP_ID=wx0000000000000000
APP_SECRET=YourAppSecret

# 支付配置
NOTIFY_URL=https://your-domain.com/api/pay/notify
ORDER_EXPIRE_MINUTES=30

package config

import (
	"fmt"
	"log"
	"os"
	"path/filepath"

	"github.com/joho/godotenv"
)

type Config struct {
	ServerPort             string
	BaseURL                string
	MchID                  string
	MchAPIv3Key            string
	MchCertSerialNo        string
	MchPrivateKeyPath      string
	WechatPayPublicKeyID   string
	WechatPayPublicKeyPath string
	AppID                  string
	AppSecret              string
	NotifyURL              string
	OrderExpireMinutes     int
}

var GlobalConfig *Config

func Load() *Config {
	if err := godotenv.Load(); err != nil {
		log.Println("Warning: .env file not found")
	}

	config := &Config{
		ServerPort:             getEnv("SERVER_PORT", "8080"),
		BaseURL:                getEnv("BASE_URL", ""),
		MchID:                  getEnv("MCH_ID", ""),
		MchAPIv3Key:            getEnv("MCH_API_V3_KEY", ""),
		MchCertSerialNo:        getEnv("MCH_CERT_SERIAL_NO", ""),
		MchPrivateKeyPath:      getEnv("MCH_PRIVATE_KEY_PATH", "./certs/apiclient_key.pem"),
		WechatPayPublicKeyID:   getEnv("WECHAT_PAY_PUBLIC_KEY_ID", ""),
		WechatPayPublicKeyPath: getEnv("WECHAT_PAY_PUBLIC_KEY_PATH", "./certs/wechatpay_pub_key.pem"),
		AppID:                  getEnv("APP_ID", ""),
		AppSecret:              getEnv("APP_SECRET", ""),
		NotifyURL:              getEnv("NOTIFY_URL", ""),
		OrderExpireMinutes:     getEnvAsInt("ORDER_EXPIRE_MINUTES", 30),
	}

	if err := config.validate(); err != nil {
		log.Fatalf("Config validation failed: %v", err)
	}

	config.MchPrivateKeyPath = toAbsPath(config.MchPrivateKeyPath)
	config.WechatPayPublicKeyPath = toAbsPath(config.WechatPayPublicKeyPath)

	GlobalConfig = config
	return config
}

func (c *Config) validate() error {
	required := []string{"MCH_ID", "MCH_API_V3_KEY", "MCH_CERT_SERIAL_NO",
		"WECHAT_PAY_PUBLIC_KEY_ID", "WECHAT_PAY_PUBLIC_KEY_PATH",
		"APP_ID", "APP_SECRET", "NOTIFY_URL", "BASE_URL"}

	for _, field := range required {
		if getEnv(field, "") == "" {
			return fmt.Errorf("%s is required", field)
		}
	}
	return nil
}

func toAbsPath(path string) string {
	if !filepath.IsAbs(path) {
		if abs, err := filepath.Abs(path); err == nil {
			return abs
		}
	}
	return path
}

func getEnv(key, defaultVal string) string {
	if v := os.Getenv(key); v != "" {
		return v
	}
	return defaultVal
}

func getEnvAsInt(key string, defaultVal int) int {
	if v := os.Getenv(key); v != "" {
		var i int
		if _, err := fmt.Sscanf(v, "%d", &i); err == nil {
			return i
		}
	}
	return defaultVal
}

package handlers

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"

	"wechatpay-jsapi-demo/config"

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

type AuthHandler struct {
	cfg *config.Config
}

func NewAuthHandler() *AuthHandler {
	return &AuthHandler{cfg: config.GlobalConfig}
}

// Auth 发起微信授权
func (h *AuthHandler) Auth(c *gin.Context) {
	redirectURI := url.QueryEscape(h.cfg.BaseURL + "/auth/callback")
	state := "STATE123" // 生产环境应使用随机数并验证

	authURL := fmt.Sprintf(
		"https://open.weixin.qq.com/connect/oauth2/authorize?appid=%s&redirect_uri=%s&response_type=code&scope=snsapi_base&state=%s#wechat_redirect",
		h.cfg.AppID, redirectURI, state,
	)

    /*
    目前网页授权有两个 scope，分别是：snsapi_base 和 snsapi_userinfo，解释如下：

    - snsapi_base：用来获取进入页面的用户的openid的，并且是静默授权并自动跳转到回调页的。（不会弹出信息确认框,仅能获取用户 openid 等信息，无法获取昵称头像）
    - snsapi_userinfo：用来获取用户的基本信息的。但这种授权需要用户手动同意。（由于用户同意过，所以无须依赖用户关注服务号，就可在授权后获取该用户的基本信息）
    */

	c.Redirect(http.StatusFound, authURL)
}

// Callback 授权回调
func (h *AuthHandler) Callback(c *gin.Context) {
	code := c.Query("code")
	if code == "" {
		c.String(http.StatusBadRequest, "Authorization failed")
		return
	}

	openID, err := h.getOpenID(code)
	if err != nil {
		c.String(http.StatusInternalServerError, "Failed to get openid")
		return
	}

	// 存储到 cookie
	c.SetCookie("openid", openID, 3600, "/", "", false, true)

	redirect := c.DefaultQuery("redirect", "/pay")
	c.Redirect(http.StatusFound, redirect)
}

func (h *AuthHandler) getOpenID(code string) (string, error) {
	tokenURL := fmt.Sprintf(
		"https://api.weixin.qq.com/sns/oauth2/access_token?appid=%s&secret=%s&code=%s&grant_type=authorization_code",
		h.cfg.AppID, h.cfg.AppSecret, code,
	)

	resp, err := http.Get(tokenURL)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)

	var result struct {
		OpenID  string `json:"openid"`
		ErrCode int    `json:"errcode"`
		ErrMsg  string `json:"errmsg"`
	}

	if err := json.Unmarshal(body, &result); err != nil {
		return "", err
	}

	if result.ErrCode != 0 {
		return "", fmt.Errorf("wechat error: %s", result.ErrMsg)
	}

	return result.OpenID, nil
}

// GetOpenID 从 cookie 获取
func GetOpenID(c *gin.Context) (string, error) {
	openid, err := c.Cookie("openid")
	if err != nil {
		return "", fmt.Errorf("not authorized")
	}
	return openid, nil
}

package handlers

import (
	"context"
	"crypto/rsa"
	"fmt"
	"log"
	"net/http"
	"time"

	"wechatpay-jsapi-demo/config"

	"github.com/gin-gonic/gin"
	"github.com/wechatpay-apiv3/wechatpay-go/core"
	"github.com/wechatpay-apiv3/wechatpay-go/core/auth/verifiers"
	"github.com/wechatpay-apiv3/wechatpay-go/core/notify"
	"github.com/wechatpay-apiv3/wechatpay-go/services/payments"
	"github.com/wechatpay-apiv3/wechatpay-go/services/payments/jsapi"
)

type PaymentHandler struct {
	client             *core.Client
	cfg                *config.Config
	svc                jsapi.JsapiApiService
	wechatPayPublicKey *rsa.PublicKey
}

func NewPaymentHandler(client *core.Client, pubKey *rsa.PublicKey) *PaymentHandler {
	return &PaymentHandler{
		client:             client,
		cfg:                config.GlobalConfig,
		svc:                jsapi.JsapiApiService{Client: client},
		wechatPayPublicKey: pubKey,
	}
}

// Index 商品页
func (h *PaymentHandler) Index(c *gin.Context) {
	c.HTML(http.StatusOK, "index.html", nil)
}

// PayPage 支付页
func (h *PaymentHandler) PayPage(c *gin.Context) {
	openid, err := GetOpenID(c)
	if err != nil {
		redirect := url.QueryEscape("/pay")
		c.Redirect(http.StatusFound, "/auth?redirect="+redirect)
		return
	}
	c.HTML(http.StatusOK, "pay.html", gin.H{"openid": openid})
}

// CreateOrder 创建订单
func (h *PaymentHandler) CreateOrder(c *gin.Context) {
	var req struct {
		ProductID   string  `json:"product_id"`
		ProductName string  `json:"product_name"`
		Price       float64 `json:"price"` // 单位：元（实际业务中最好不要使用浮点数避免精度问题，这里只是方便演示）
		OpenID      string  `json:"openid"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// 金额转换：元 → 分
	amount := int64(req.Price * 100)

	outTradeNo := generateOrderNo()
	expireTime := time.Now().Add(time.Duration(h.cfg.OrderExpireMinutes) * time.Minute)

	resp, _, err := h.svc.PrepayWithRequestPayment(context.Background(),
		jsapi.PrepayRequest{
			Appid:       core.String(h.cfg.AppID),
			Mchid:       core.String(h.cfg.MchID),
			Description: core.String(req.ProductName),
			OutTradeNo:  core.String(outTradeNo),
			Attach:      core.String(req.ProductID),
			NotifyUrl:   core.String(h.cfg.NotifyURL),
			Amount: &jsapi.Amount{
				Total: core.Int64(amount),
			},
			Payer: &jsapi.Payer{
				Openid: core.String(req.OpenID),
			},
			TimeExpire: core.Time(expireTime),
		},
	)

	if err != nil {
		log.Printf("Create order failed: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "create order failed"})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success":      true,
		"out_trade_no": outTradeNo,
		"appId":        resp.Appid,
		"timeStamp":    resp.TimeStamp,
		"nonceStr":     resp.NonceStr,
		"package":      resp.Package,
		"signType":     resp.SignType,
		"paySign":      resp.PaySign,
	})
}

// Notify 支付回调
func (h *PaymentHandler) Notify(c *gin.Context) {
	handler, err := notify.NewRSANotifyHandler(
		h.cfg.MchAPIv3Key,
		verifiers.NewSHA256WithRSAPubkeyVerifier(h.cfg.WechatPayPublicKeyID, *h.wechatPayPublicKey),
	)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"code": "FAIL"})
		return
	}

	transaction := new(payments.Transaction)
	if _, err := handler.ParseNotifyRequest(context.Background(), c.Request, transaction); err != nil {
		c.JSON(http.StatusUnauthorized, gin.H{"code": "FAIL"})
		return
	}

	// 处理业务逻辑
	if transaction.TradeState != nil && *transaction.TradeState == "SUCCESS" {
		log.Printf("Payment success: %s, amount: %d",
			*transaction.OutTradeNo, *transaction.Amount.Total)
		// TODO: 更新订单状态（注意幂等性）
	}

	c.JSON(http.StatusOK, gin.H{"code": "SUCCESS"})
}

func generateOrderNo() string {
	return fmt.Sprintf("D%s%06d",
		time.Now().Format("20060102150405"),
		time.Now().Nanosecond()%1000000)
}

package main

import (
	"context"
	"fmt"
	"log"

	"wechatpay-jsapi-demo/config"
	"wechatpay-jsapi-demo/handlers"

	"github.com/gin-gonic/gin"
	"github.com/wechatpay-apiv3/wechatpay-go/core"
	"github.com/wechatpay-apiv3/wechatpay-go/core/option"
	"github.com/wechatpay-apiv3/wechatpay-go/utils"
)

func main() {
	cfg := config.Load()

	// 加载证书
	mchPrivateKey, err := utils.LoadPrivateKeyWithPath(cfg.MchPrivateKeyPath)
	if err != nil {
		log.Fatalf("load private key failed: %v", err)
	}

	wechatPayPublicKey, err := utils.LoadPublicKeyWithPath(cfg.WechatPayPublicKeyPath)
	if err != nil {
		log.Fatalf("load public key failed: %v", err)
	}

	// 使用公钥模式初始化客户端
	opts := []core.ClientOption{
		option.WithWechatPayPublicKeyAuthCipher(
			cfg.MchID,
			cfg.MchCertSerialNo,
			mchPrivateKey,
			cfg.WechatPayPublicKeyID,
			wechatPayPublicKey,
		),
	}

	client, err := core.NewClient(context.Background(), opts...)
	if err != nil {
		log.Fatalf("init client failed: %v", err)
	}

	// 设置路由
	r := gin.Default()
	r.LoadHTMLGlob("templates/*")

	paymentHandler := handlers.NewPaymentHandler(client, wechatPayPublicKey)
	authHandler := handlers.NewAuthHandler()

	r.GET("/", paymentHandler.Index)
	r.GET("/pay", paymentHandler.PayPage)
	r.GET("/auth", authHandler.Auth)
	r.GET("/auth/callback", authHandler.Callback)
	r.POST("/api/pay/create", paymentHandler.CreateOrder)
	r.POST("/api/pay/notify", paymentHandler.Notify)

	r.Run(":" + cfg.ServerPort)
}

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>商品列表</title>
    <style>
      body {
        font-family: -apple-system, sans-serif;
        max-width: 600px;
        margin: 0 auto;
        padding: 20px;
      }
      .product {
        border: 1px solid #ddd;
        padding: 15px;
        margin: 10px 0;
        border-radius: 8px;
        cursor: pointer;
      }
      .product:hover {
        border-color: #07c160;
      }
      .price {
        color: #ff6b6b;
        font-size: 20px;
        font-weight: bold;
      }
    </style>
  </head>
  <body>
    <h2>选择商品</h2>
    <div class="product" onclick="buy('P001', '测试商品-可乐', 0.01)">
      <h3>测试商品-可乐</h3>
      <p class="price">¥0.01</p>
    </div>
    <div class="product" onclick="buy('P002', '测试商品-雪碧', 0.01)">
      <h3>测试商品-雪碧</h3>
      <p class="price">¥0.01</p>
    </div>

    <script>
      function buy(id, name, price) {
        // price 单位：元
        sessionStorage.setItem("product", JSON.stringify({ id, name, price }));
        location.href = "/pay";
      }
    </script>
  </body>
</html>

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>确认支付</title>
    <style>
      body {
        font-family: -apple-system, sans-serif;
        max-width: 600px;
        margin: 0 auto;
        padding: 20px;
        text-align: center;
      }
      .amount {
        font-size: 48px;
        color: #333;
        margin: 30px 0;
      }
      .btn {
        background: #07c160;
        color: white;
        padding: 15px 40px;
        border: none;
        border-radius: 5px;
        font-size: 18px;
      }
    </style>
  </head>
  <body>
    <h2>确认支付</h2>
    <div id="productName"></div>
    <div class="amount">¥<span id="price">0.00</span></div>
    <button class="btn" onclick="pay()">立即支付</button>

    <script>
      const product = JSON.parse(sessionStorage.getItem("product"));
      document.getElementById("productName").textContent = product.name;
      document.getElementById("price").textContent = product.price.toFixed(2);

      async function pay() {
        const openid = "{{.openid}}";

        // 金额转换：元 → 分
        const amountInCent = Math.round(product.price * 100);

        const res = await fetch("/api/pay/create", {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            product_id: product.id,
            product_name: product.name,
            price: product.price, // 实际业务中应该后端根据商品id查询价格，而不是前端指定价格，这里只是为了方便演示
            openid: openid,
          }),
        });

        const data = await res.json();
        if (!data.success) {
          alert("创建订单失败");
          return;
        }

        // 调起微信支付
        WeixinJSBridge.invoke(
          "getBrandWCPayRequest",
          {
            appId: data.appId,
            timeStamp: data.timeStamp,
            nonceStr: data.nonceStr,
            package: data.package,
            signType: data.signType,
            paySign: data.paySign,
          },
          function (res) {
            if (res.err_msg === "get_brand_wcpay_request:ok") {
              alert("支付成功");
              location.href = "/";
            } else if (res.err_msg === "get_brand_wcpay_request:cancel") {
              alert("已取消");
            } else {
              alert("支付失败: " + res.err_msg);
            }
          },
        );
      }
    </script>
  </body>
</html>