swift 微信支付接口实现

最新推荐文章于 2019-10-27 17:19:30 发布

落宇 luoyu

最新推荐文章于 2019-10-27 17:19:30 发布

阅读量2.6k

点赞数

CC 4.0 BY-SA版权

分类专栏： IOS 第三方接口(微信、支付宝)

本文链接：https://blog.youkuaiyun.com/hanjiyu/article/details/51087621

IOS 同时被 2 个专栏收录

10 篇文章

订阅专栏

第三方接口(微信、支付宝)

5 篇文章

订阅专栏

本文详细介绍了如何在iOS应用中集成微信支付功能，包括获取预支付信息、使用Alamofire库进行网络请求、定义支付相关的数据模型及解析JSON数据等关键步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

微信支付涉及到导入sdk，配置桥接文件等，已经在 “微信分享接口实现”文章中说明了，这里就不再重新叙述了。直接进入微信支付开发

同时针对服务端的微信支付接口调用同android端一致，这里也不在叙述

直接进入正题，微信支付

微信支付步骤

编写访问服务器相关获取PrePay信息

使用网络基础库Alamofire访问服务器
- 下载Alamofire库，导入到项目中

编写相关程序实现访问服务器

Model 编写WXPrePay.swift

import Foundation

struct WXPrePay {
    let appID: String
    let noncestr: String
    let package: String
    let partnerID: String
    let prepayID: String
    let sign: String
    let timestamp: Int

    init(appID: String,
        noncestr: String,
        package: String,
        partnerID: String,
        prepayID: String,
        sign: String,
        timestamp: Int) {
            self.appID = appID
            self.noncestr = noncestr
            self.package = package
            self.partnerID = partnerID
            self.prepayID = prepayID
            self.sign = sign
            self.timestamp = timestamp
    }
}

Model 编写MyOrder.swift

import Foundation

struct MyOrder {
    let id : Int
    let title : String
    let content: String
    let url: String
    let createdAt : String
    let price : Double
    let paid : Bool
    let productID : Int

    init(id : Int,
        title : String,
        content: String,
        url: String,
        createdAt : String,
        price : Double,
        paid : Bool,
        productID : Int) {
            self.id = id
            self.title = title
            self.content = content
            self.url = url
            self.createdAt = createdAt
            self.price = price
            self.paid = paid
            self.productID = productID
    }
}

Services 编写JSON.swift 处理类

import Foundation

enum JSON {
    case JSONDictionary([String : JSON])
    case JSONArray([JSON])
    case JSONString(String)
    case JSONNumber(NSNumber)
    case JSONBool(Bool)
    case JSONNull

    subscript(key:String) -> JSON? {
        switch self {
        case .JSONDictionary(let value) :
            return value[key]
        default:
            return nil
        }
    }

    subscript(index:Int) -> JSON? {
        switch self {
        case .JSONArray(let value):
            return value[index]
        default:
            return nil
        }
    }

    var dictionary : [String:JSON]? {
        switch self {
        case .JSONDictionary(let value):
            return value
        default:
            return nil
        }
    }

    var array : [JSON]? {
        switch self {
        case .JSONArray(let value):
            return value
        default:
            return nil
        }
    }

    var string : String? {
        get {
            switch self {
            case .JSONString(let value):
                return value
            default:
                return nil
            }
        }
    }

    var number : NSNumber? {
        get {
            switch self {
            case .JSONNumber(let value):
                return value
            default:
                return nil
            }
        }
    }

    var integer: Int? {
        get {
            switch self {
            case .JSONNumber(let value):
                return value.integerValue
            case .JSONString(let value):
                let value = value as NSString
                return value.integerValue
            default:
                return nil
            }
        }
    }

    var double: Double? {
        get {
            switch self {
            case .JSONNumber(let value):
                return value.doubleValue
            case .JSONString(let value):
                let value = value as NSString
                return value.doubleValue
            default:
                return nil
            }
        }
    }


    var bool : Bool? {
        get{
            switch self {
            case .JSONBool(let value):
                return value
            case .JSONNumber(let value):
                return value.boolValue
            case .JSONString(let value):
                let value = value as NSString
                return value.boolValue
            default:
                return nil
            }
        }
    }

    static func fromString(str:String) -> JSON? {
        if let jsonData = str.dataUsingEncoding(NSUTF8StringEncoding) {
            return JSON.fromData(jsonData)
        }
        return nil
    }

    static func fromData(jsonData:NSData) -> JSON? {
        if let parsed: AnyObject = try? NSJSONSerialization.JSONObjectWithData(jsonData, options: NSJSONReadingOptions(rawValue: 0)){
            return JSON.fromObject(parsed)
        }
        return nil
    }

    static func fromObject(object:AnyObject) -> JSON? {
        //println(object.dynamicType)
        //println(object)
        switch object {
        case let value as NSNull:
            return JSON.JSONNull
        case let value as Bool:
            return JSON.JSONBool(value)
        case let value as NSNumber:
            return JSON.JSONNumber(value)
        case let value as String:
            return JSON.JSONString(value)
        case let value as NSDictionary:
            var JSONDictionary: [String:JSON] = [:]
            for(k, v): (AnyObject, AnyObject) in value {
                if let k = k as? String {
                    if let v = JSON.fromObject(v) {
                        JSONDictionary[k] = v
                    }
                }
            }
            return JSON.JSONDictionary(JSONDictionary)
        case let value as NSArray:
            var jsonArray : [JSON] = []
            for v in value {
                if let v = JSON.fromObject(v) {
                    jsonArray.append(v)
                }
            }
            return JSON.JSONArray(jsonArray)
        default:
            return nil
        }
    }
}

Services 编写JSONParser.swift 解析处理预定单JSON

import Foundation

struct JSONParser {

    static func parsePrePay(json:JSON) -> WXPrePay {
        let appid:String = json["appid"]?.string ?? ""
        let noncestr:String = json["noncestr"]?.string ?? ""
        let package:String = json["package"]?.string ?? ""
        let partnerid:String = json["partnerid"]?.string ?? ""
        let prepayid:String = json["prepayid"]?.string ?? ""
        let sign:String = json["sign"]?.string ?? ""
        let timestamp:Int = json["timestamp"]?.integer ?? 0

        return WXPrePay(appID: appid, noncestr: noncestr, package: package, partnerID: partnerid, prepayID: prepayid, sign: sign, timestamp: timestamp)
    }

    static func parseOrder(json:JSON) -> MyOrder {
        let id:Int = json["id"]?.integer ?? 0
        let title:String = json["title"]?.string ?? ""
        let content:String = json["content"]?.string ?? ""
        let createdAt:String = json["createdAt"]?.string ?? ""
        let url:String = json["url"]?.string ?? ""
        let price:Double = json["price"]?.double ?? 0.0
        let paid:Bool = json["paid"]?.bool ?? false
        let pID:Int = json["refID"]?.integer ?? 0

        return MyOrder(id: id, title: title, content: content, url: url, createdAt: createdAt, price: price, paid: paid, productID: pID)
    }

}

Services 编写DataService.swift 数据访问服务结构体

import Foundation

struct DataService {

    private static let clientID = ""
    private static let clientSecret = ""

    private enum ResourcePath: CustomStringConvertible {
        case Purchase
        case WXPayPrePay(orderID:Int)

        var description: String {
            switch self {
            case .Purchase:  return "/order/purchase"
            case .WXPayPrePay(let id): return "/api/WXAppPay!app_pay.action?plat=ios&orderid=\(id)"
            default: return ""
            }
        }
    }



    static func wxPrePay(orderID:Int, response: (WXPrePay?,NSError?) -> ()) {
        let path = ResourcePath.WXPayPrePay(orderID: orderID)
        let urlString = ServerURL + path.description

        request(.GET, urlString, parameters: nil).response { (request, res, data, error) in
            print(NSString(data: data!, encoding: NSUTF8StringEncoding))
            if error == nil {
                if let json = JSON.fromData(data!) {
                    if json["success"]?.bool == true {
                        let r = JSONParser.parsePrePay(json["info"]!["payParam"]!)
                        response(r,nil)
                    } else {
                        response(nil,NSError(domain: "come.apppaydemo", code: 404, userInfo: nil))
                    }
                }
            } else {
                response(nil,error)
            }
        }
    }


}

根目录编写MyConstants.swift 常量定义类

“`
import Foundation

let WXPaySuccessNotification = “WeixinPaySuccessNotification”

let WX_APPID = “填写自己的”
let WX_APP_SECRET = “填写自己的”

let AppScheme:String = “apppaydemo”

let ServerURL = “http://youname.com”
“`

获取PrePay信息

viewController 中加入WXApiDelegate

class ViewController: UIViewController, WKScriptMessageHandler,WXApiDelegate {

－加入enum 和 class定义

enum PaymentType {
    case Weichat
}

protocol PayMethodViewControllerDelegate: class {
    func paymentSuccess(paymentType paymentType:PaymentType)
    func paymentFail(paymentType paymentType:PaymentType)
}

定义delegate

weak var delegate:PayMethodViewControllerDelegate?

编写微信支付函数

    //微信支付
    func weixinPay(orderid:Int) {
        DataService.wxPrePay(orderid) {[weak self] (prepay, error) -> () in
            if let strongSelf = self {
                if let prepay = prepay {
                    let req = PayReq()
                    req.openID = prepay.appID
                    req.partnerId = prepay.partnerID
                    req.prepayId = prepay.prepayID
                    req.nonceStr = prepay.noncestr
                    req.timeStamp = UInt32(prepay.timestamp)
                    req.package = prepay.package
                    req.sign = prepay.sign
                    WXApi.sendReq(req)
                } else {
                    strongSelf.delegate?.paymentFail(paymentType: .Weichat)
                    let alert = UIAlertView(title: nil, message: "获取支付信息失败，请重新支付！", delegate: nil, cancelButtonTitle: "好的")
                    alert.show()
                }
            }
        }
    }

编写微信支付回调

func onReq(req: BaseReq!) {
        //onReq是微信终端向第三方程序发起请求，要求第三方程序响应。第三方程序响应完后必须调用sendRsp返回。在调用sendRsp返回时，会切回到微信终端程序界面。
    }
    func onResp(resp: BaseResp!) {
        var strTitle = "支付结果"
        var strMsg = "\(resp.errCode)"

        //如果第三方程序向微信发送了sendReq的请求，那么onResp会被回调。sendReq请求调用后，会切到微信终端程序界面。

        if resp.isKindOfClass(SendMessageToWXResp){//确保是对我们分享操作的回调
            if resp.errCode == WXSuccess.rawValue{//分享成功
                NSLog("分享成功")
            }else{//分享失败
                NSLog("分享失败，错误码：%d, 错误描述：%@", resp.errCode, resp.errStr)
            }
        }

        if resp.isKindOfClass(PayResp) {
            switch resp.errCode {
            case 0 :
                NSNotificationCenter.defaultCenter().postNotificationName(WXPaySuccessNotification, object: nil)
            default:
                strMsg = "支付失败，请您重新支付!"
                print("retcode = \(resp.errCode), retstr = \(resp.errStr)")
            }
        }

        let alert = UIAlertView(title: nil, message: strMsg, delegate: nil, cancelButtonTitle: "好的")
        alert.show()


    }