支付API文档

import hashlib

def create_sign(params, apikey):
    # 按键名字典序排序
    sorted_params = sorted(params.items())
    # 拼接字符串
    parts = [f'{k}={v}' for k, v in sorted_params if v]
    sign_str = '&'.join(parts) + '&key=' + apikey
    # MD5 大写
    return hashlib.md5(sign_str.encode()).hexdigest().upper()

import java.security.MessageDigest;
import java.util.Map;
import java.util.TreeMap;

public static String createSign(Map params, String apikey) 
        throws Exception {
    // 使用 TreeMap 按键名字典序排序
    Map sortedParams = new TreeMap<>(params);
    
    StringBuilder sb = new StringBuilder();
    for (Map.Entry entry : sortedParams.entrySet()) {
        String val = entry.getValue();
        if (val != null && !val.isEmpty()) {
            sb.append(entry.getKey()).append("=").append(val).append("&");
        }
    }
    sb.append("key=").append(apikey);
    
    // MD5 大写
    MessageDigest md = MessageDigest.getInstance("MD5");
    byte[] digest = md.digest(sb.toString().getBytes("UTF-8"));
    StringBuilder hexString = new StringBuilder();
    for (byte b : digest) {
        hexString.append(String.format("%02X", b));
    }
    return hexString.toString();
}

import (
    "crypto/md5"
    "encoding/hex"
    "sort"
    "strings"
)

func createSign(params map[string]string, apikey string) string {
    // 按键名字典序排序
    keys := make([]string, 0, len(params))
    for k := range params {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    
    // 拼接字符串
    parts := make([]string, 0)
    for _, k := range keys {
        v := params[k]
        if v != "" {
            parts = append(parts, k+"="+v)
        }
    }
    signStr := strings.Join(parts, "&") + "&key=" + apikey
    
    // MD5 大写
    hash := md5.Sum([]byte(signStr))
    return strings.ToUpper(hex.EncodeToString(hash[:]))
}

const crypto = require('crypto');

function createSign(params, apikey) {
    // 按键名字典序排序
    const sortedKeys = Object.keys(params).sort();
    
    // 拼接字符串
    const parts = [];
    sortedKeys.forEach(key => {
        if (params[key]) {
            parts.push(`${key}=${params[key]}`);
        }
    });
    const signStr = parts.join('&') + '&key=' + apikey;
    
    // MD5 大写
    return crypto.createHash('md5')
        .update(signStr)
        .digest('hex')
        .toUpperCase();
}

import hashlib
import requests

# 商户配置
mchid = '10001'
apikey = '您的APIKEY'
gateway = 'https://您的域名/pay/trade/query'

# 查询参数
params = {
    'pay_memberid': mchid,
    'pay_orderid': '202401010001',
}

# 生成签名
def create_sign(params, apikey):
    sorted_params = sorted(params.items())
    parts = [f'{k}={v}' for k, v in sorted_params if v and k != 'pay_md5sign']
    sign_str = '&'.join(parts) + '&key=' + apikey
    return hashlib.md5(sign_str.encode()).hexdigest().upper()

params['pay_md5sign'] = create_sign(params, apikey)

# 发送请求
response = requests.post(gateway, data=params)
result = response.json()
if result.get('status') == 200:
    print('支付状态：', result['data']['trade_state'])
else:
    print('查询失败：', result.get('msg'))

import java.io.*;
import java.net.*;
import java.security.MessageDigest;
import java.util.*;

public class PayQueryDemo {
    public static void main(String[] args) throws Exception {
        String mchid = "10001";
        String apikey = "您的APIKEY";
        String gateway = "https://您的域名/pay/trade/query";

        // 查询参数
        Map params = new TreeMap<>();
        params.put("pay_memberid", mchid);
        params.put("pay_orderid", "202401010001");

        // 生成签名
        params.put("pay_md5sign", createSign(params, apikey));

        // 构建请求体
        StringBuilder postData = new StringBuilder();
        for (Map.Entry entry : params.entrySet()) {
            if (postData.length() > 0) postData.append("&");
            postData.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            postData.append("=");
            postData.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
        }

        // 发送请求
        URL url = new URL(gateway);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setDoOutput(true);
        conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

        try (OutputStream os = conn.getOutputStream()) {
            os.write(postData.toString().getBytes("UTF-8"));
        }

        // 读取响应
        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(conn.getInputStream(), "UTF-8"))) {
            StringBuilder response = new StringBuilder();
            String line;
            while ((line = br.readLine()) != null) {
                response.append(line);
            }
            System.out.println("响应：" + response);
        }
    }

    public static String createSign(Map params, String apikey)
            throws Exception {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry entry : params.entrySet()) {
            String val = entry.getValue();
            if (val != null && !val.isEmpty() && !"pay_md5sign".equals(entry.getKey())) {
                sb.append(entry.getKey()).append("=").append(val).append("&");
            }
        }
        sb.append("key=").append(apikey);
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] digest = md.digest(sb.toString().getBytes("UTF-8"));
        StringBuilder hexString = new StringBuilder();
        for (byte b : digest) {
            hexString.append(String.format("%02X", b));
        }
        return hexString.toString();
    }
}

package main

import (
    "crypto/md5"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "sort"
    "strings"
)

func main() {
    mchid := "10001"
    apikey := "您的APIKEY"
    gateway := "https://您的域名/pay/trade/query"

    // 查询参数
    params := url.Values{}
    params.Set("pay_memberid", mchid)
    params.Set("pay_orderid", "202401010001")

    // 生成签名
    sign := createSign(params, apikey)
    params.Set("pay_md5sign", sign)

    // 发送请求
    resp, err := http.PostForm(gateway, params)
    if err != nil {
        fmt.Println("请求失败:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println("响应:", string(body))
}

func createSign(params url.Values, apikey string) string {
    keys := make([]string, 0)
    for k := range params {
        keys = append(keys, k)
    }
    sort.Strings(keys)

    parts := make([]string, 0)
    for _, k := range keys {
        v := params.Get(k)
        if v != "" && k != "pay_md5sign" {
            parts = append(parts, k+"="+v)
        }
    }

    signStr := strings.Join(parts, "&") + "&key=" + apikey
    hash := md5.Sum([]byte(signStr))
    return strings.ToUpper(hex.EncodeToString(hash[:]))
}

const crypto = require('crypto');
const https = require('https');

// 商户配置
const mchid = '10001';
const apikey = '您的APIKEY';
const gateway = '您的域名';
const path = '/pay/trade/query';

// 查询参数
const params = {
    pay_memberid: mchid,
    pay_orderid: '202401010001',
};

// 生成签名
function createSign(params, apikey) {
    const sortedKeys = Object.keys(params).sort();
    const parts = [];
    sortedKeys.forEach(key => {
        if (params[key] && key !== 'pay_md5sign') {
            parts.push(`${key}=${params[key]}`);
        }
    });
    const signStr = parts.join('&') + '&key=' + apikey;
    return crypto.createHash('md5').update(signStr).digest('hex').toUpperCase();
}

params.pay_md5sign = createSign(params, apikey);

// 发送请求
const postData = new URLSearchParams(params).toString();

const options = {
    hostname: gateway,
    path: path,
    method: 'POST',
    headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Content-Length': Buffer.byteLength(postData)
    }
};

const req = https.request(options, (res) => {
    let data = '';
    res.on('data', (chunk) => {
        data += chunk;
    });
    res.on('end', () => {
        console.log('响应：', data);
    });
});

req.on('error', (e) => {
    console.error('请求失败：', e);
});

req.write(postData);
req.end();

from flask import Flask, request

app = Flask(__name__)

@app.route('/pay_notify', methods=['POST'])
def pay_notify():
    params = request.form.to_dict()
    
    # 参与签名的参数
    sign_params = {
        'memberid': params.get('memberid', ''),
        'orderid': params.get('orderid', ''),
        'transaction_id': params.get('transaction_id', ''),
        'amount': params.get('amount', ''),
        'datetime': params.get('datetime', ''),
        'returncode': params.get('returncode', ''),
        'attach': params.get('attach', ''),
    }
    
    # 验证签名
    check_sign = create_sign(sign_params, apikey)
    if check_sign != params.get('sign', ''):
        return 'fail'
    
    if params.get('returncode') == '00':
        # 支付成功，处理业务逻辑
        update_order_status(params['orderid'], 'paid', params['amount'])
        # 必须返回 success
        return 'success'
    else:
        return 'fail'

// Spring Boot 控制器示例
@RestController
public class PayNotifyController {
    
    private String apikey = "商户APIKEY";
    
    @PostMapping("/pay_notify")
    public String payNotify(@RequestBody Map params) {
        // 参与签名的参数
        Map signParams = new TreeMap<>();
        signParams.put("memberid", params.get("memberid"));
        signParams.put("orderid", params.get("orderid"));
        signParams.put("transaction_id", params.get("transaction_id"));
        signParams.put("amount", params.get("amount"));
        signParams.put("datetime", params.get("datetime"));
        signParams.put("returncode", params.get("returncode"));
        signParams.put("attach", params.get("attach"));
        
        // 验证签名
        String checkSign = createSign(signParams, apikey);
        if (!checkSign.equals(params.get("sign"))) {
            return "fail";
        }
        
        if ("00".equals(params.get("returncode"))) {
            // 支付成功，处理业务逻辑
            updateOrderStatus(params.get("orderid"), "paid", 
                params.get("amount"));
            // 必须返回 success
            return "success";
        } else {
            return "fail";
        }
    }
}

package main

import (
    "net/http"
    "net/url"
)

func payNotify(w http.ResponseWriter, r *http.Request) {
    // 解析表单
    r.ParseForm()
    params := make(map[string]string)
    for k := range r.PostForm {
        params[k] = r.PostForm.Get(k)
    }
    
    // 参与签名的参数
    signParams := map[string]string{
        "memberid":       params["memberid"],
        "orderid":        params["orderid"],
        "transaction_id": params["transaction_id"],
        "amount":         params["amount"],
        "datetime":       params["datetime"],
        "returncode":     params["returncode"],
        "attach":         params["attach"],
    }
    
    // 验证签名
    checkSign := createSign(signParams, apikey)
    if checkSign != params["sign"] {
        w.Write([]byte("fail"))
        return
    }
    
    if params["returncode"] == "00" {
        // 支付成功，处理业务逻辑
        updateOrderStatus(params["orderid"], "paid", params["amount"])
        // 必须返回 success
        w.Write([]byte("success"))
    } else {
        w.Write([]byte("fail"))
    }
}

const express = require('express');
const app = express();
const crypto = require('crypto');

const apikey = '商户APIKEY';

app.post('/pay_notify', (req, res) => {
    const params = req.body;
    
    // 参与签名的参数
    const signParams = {
        memberid: params.memberid,
        orderid: params.orderid,
        transaction_id: params.transaction_id,
        amount: params.amount,
        datetime: params.datetime,
        returncode: params.returncode,
        attach: params.attach,
    };
    
    // 验证签名
    const checkSign = createSign(signParams, apikey);
    if (checkSign !== params.sign) {
        return res.send('fail');
    }
    
    if (params.returncode === '00') {
        // 支付成功，处理业务逻辑
        updateOrderStatus(params.orderid, 'paid', params.amount);
        // 必须返回 success
        res.send('success');
    } else {
        res.send('fail');
    }
});

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
支付下单示例 - Python
"""

import hashlib
import time
import random
import requests

# 商户配置
MCHID = '10001'          # 商户号
APIKEY = '您的APIKEY'     # 商户APIKEY
GATEWAY = 'https://您的域名/pay/index/index'

# 生成MD5签名
def create_sign(params, apikey):
    sorted_params = sorted(params.items())
    sign_str = '&'.join([f'{k}={v}' for k, v in sorted_params 
                         if v and k != 'pay_md5sign'])
    sign_str += '&key=' + apikey
    return hashlib.md5(sign_str.encode()).hexdigest().upper()

# 主程序
def main():
    # 订单参数
    params = {
        'pay_memberid': MCHID,
        'pay_orderid': time.strftime('%Y%m%d%H%M%S') + str(random.randint(1000, 9999)),
        'pay_amount': '100.00',
        'pay_applydate': time.strftime('%Y-%m-%d %H:%M:%S'),
        'pay_bankcode': '903',  # 支付通道编号
        'pay_notifyurl': 'https://您的域名/notify.py',
        'pay_callbackurl': 'https://您的域名/callback.py',
        'pay_productname': '测试商品',
    }
    
    # 生成签名
    params['pay_md5sign'] = create_sign(params, APIKEY)
    
    # 发送请求
    response = requests.post(GATEWAY, data=params)
    result = response.json()
    
    if result.get('status') == '200':
        print('支付链接：', result['data']['url'])
        # 可选择跳转到支付页面
        # webbrowser.open(result['data']['url'])
    else:
        print('下单失败：', result.get('msg'))

if __name__ == '__main__':
    main()

import java.io.*;
import java.net.*;
import java.security.MessageDigest;
import java.util.*;

/**
 * 支付下单示例 - Java
 */
public class PayDemo {
    
    private static final String MCHID = "10001";           // 商户号
    private static final String APIKEY = "您的APIKEY";     // 商户APIKEY
    private static final String GATEWAY = "https://您的域名/pay/index/index";
    
    public static void main(String[] args) throws Exception {
        // 订单参数
        Map params = new HashMap<>();
        params.put("pay_memberid", MCHID);
        params.put("pay_orderid", new Timestamp(System.currentTimeMillis())
            .toString().replaceAll("[^0-9]", "") + 
            String.format("%04d", new Random().nextInt(10000)));
        params.put("pay_amount", "100.00");
        params.put("pay_applydate", new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
            .format(new java.util.Date()));
        params.put("pay_bankcode", "903");  // 支付通道编号
        params.put("pay_notifyurl", "https://您的域名/notify");
        params.put("pay_callbackurl", "https://您的域名/callback");
        params.put("pay_productname", "测试商品");
        
        // 生成签名
        params.put("pay_md5sign", createSign(params, APIKEY));
        
        // 构建请求体
        StringBuilder postData = new StringBuilder();
        for (Map.Entry entry : params.entrySet()) {
            if (postData.length() > 0) postData.append("&");
            postData.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            postData.append("=");
            postData.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
        }
        
        // 发送请求
        URL url = new URL(GATEWAY);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setDoOutput(true);
        conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        
        try (OutputStream os = conn.getOutputStream()) {
            os.write(postData.toString().getBytes("UTF-8"));
        }
        
        // 解析响应
        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(conn.getInputStream(), "UTF-8"))) {
            StringBuilder response = new StringBuilder();
            String line;
            while ((line = br.readLine()) != null) {
                response.append(line);
            }
            System.out.println("响应：" + response);
        }
    }
    
    /**
     * 生成MD5签名
     */
    public static String createSign(Map params, String apikey) 
            throws Exception {
        Map sortedParams = new TreeMap<>(params);
        
        StringBuilder sb = new StringBuilder();
        for (Map.Entry entry : sortedParams.entrySet()) {
            String key = entry.getKey();
            String val = entry.getValue();
            if (val != null && !val.isEmpty() && !key.equals("pay_md5sign")) {
                sb.append(key).append("=").append(val).append("&");
            }
        }
        sb.append("key=").append(apikey);
        
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] digest = md.digest(sb.toString().getBytes("UTF-8"));
        StringBuilder hexString = new StringBuilder();
        for (byte b : digest) {
            hexString.append(String.format("%02X", b));
        }
        return hexString.toString();
    }
}

package main

import (
    "crypto/md5"
    "encoding/hex"
    "fmt"
    "io"
    "math/rand"
    "net/http"
    "net/url"
    "sort"
    "strings"
    "time"
)

const (
    MCHID   = "10001"       // 商户号
    APIKEY  = "您的APIKEY"   // 商户APIKEY
    GATEWAY = "https://您的域名/pay/index/index"
)

func main() {
    // 订单参数
    orderID := time.Now().Format("20060102150405") + 
        fmt.Sprintf("%04d", rand.Intn(10000))
    applyDate := time.Now().Format("2006-01-02 15:04:05")
    
    params := url.Values{}
    params.Set("pay_memberid", MCHID)
    params.Set("pay_orderid", orderID)
    params.Set("pay_amount", "100.00")
    params.Set("pay_applydate", applyDate)
    params.Set("pay_bankcode", "903")  // 支付通道编号
    params.Set("pay_notifyurl", "https://您的域名/notify")
    params.Set("pay_callbackurl", "https://您的域名/callback")
    params.Set("pay_productname", "测试商品")
    
    // 生成签名
    params.Set("pay_md5sign", createSign(params, APIKEY))
    
    // 发送请求
    resp, err := http.PostForm(GATEWAY, params)
    if err != nil {
        fmt.Println("请求失败:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("响应:", string(body))
}

// createSign 生成MD5签名
func createSign(params url.Values, apikey string) string {
    keys := make([]string, 0)
    for k := range params {
        if k != "pay_md5sign" {
            keys = append(keys, k)
        }
    }
    sort.Strings(keys)
    
    parts := make([]string, 0)
    for _, k := range keys {
        v := params.Get(k)
        if v != "" {
            parts = append(parts, k+"="+v)
        }
    }
    signStr := strings.Join(parts, "&") + "&key=" + apikey
    
    hash := md5.Sum([]byte(signStr))
    return strings.ToUpper(hex.EncodeToString(hash[:]))
}

const crypto = require('crypto');
const https = require('https');

// 商户配置
const MCHID = '10001';       // 商户号
const APIKEY = '您的APIKEY'; // 商户APIKEY
const GATEWAY = '您的域名';
const PATH = '/pay/index/index';

// 生成MD5签名
function createSign(params, apikey) {
    const sortedKeys = Object.keys(params)
        .filter(k => k !== 'pay_md5sign' && params[k])
        .sort();
    
    const parts = sortedKeys.map(k => `${k}=${params[k]}`);
    const signStr = parts.join('&') + '&key=' + apikey;
    
    return crypto.createHash('md5')
        .update(signStr)
        .digest('hex')
        .toUpperCase();
}

// 主程序
function main() {
    const orderId = new Date().toISOString().replace(/[-T:.Z]/g, '') + 
        Math.floor(Math.random() * 10000).toString().padStart(4, '0');
    const applyDate = new Date().toISOString()
        .replace('T', ' ').substring(0, 19);
    
    // 订单参数
    const params = {
        pay_memberid: MCHID,
        pay_orderid: orderId,
        pay_amount: '100.00',
        pay_applydate: applyDate,
        pay_bankcode: '903',  // 支付通道编号
        pay_notifyurl: 'https://您的域名/notify',
        pay_callbackurl: 'https://您的域名/callback',
        pay_productname: '测试商品',
    };
    
    // 生成签名
    params.pay_md5sign = createSign(params, APIKEY);
    
    // 发送请求
    const postData = new URLSearchParams(params).toString();
    
    const options = {
        hostname: GATEWAY,
        path: PATH,
        method: 'POST',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            'Content-Length': Buffer.byteLength(postData)
        }
    };
    
    const req = https.request(options, (res) => {
        let data = '';
        res.on('data', (chunk) => {
            data += chunk;
        });
        res.on('end', () => {
            try {
                const result = JSON.parse(data);
                if (result.status === '200') {
                    console.log('支付链接：', result.data.url);
                } else {
                    console.log('下单失败：', result.msg);
                }
            } catch (e) {
                console.log('响应：', data);
            }
        });
    });
    
    req.on('error', (e) => {
        console.error('请求失败：', e);
    });
    
    req.write(postData);
    req.end();
}

main();