Swift5.0 Alamofire网络请求的二次封装

最新推荐文章于 2023-04-21 17:00:09 发布
最新推荐文章于 2023-04-21 17:00:09 发布
阅读量1.2w 收藏 7
点赞数 8
分类专栏： Swift SwiftJson Alamofire ObjectMapper Swift 5.0
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38735568/article/details/89670325
版权
Swift 同时被 3 个专栏收录
30 篇文章 2 订阅
订阅专栏
Swift 5.0
18 篇文章 3 订阅
订阅专栏
Alamofire
2 篇文章 0 订阅
订阅专栏

Alamofire结合SwiftyJSON、ObjectMapper二次封装网络请求

Alamofire

AFNetworking的作者Matt Thompson 提出了一个新的类似AFNetworking的网络基础库，并且专门使用最新的Swift语言写的，名为 Alamofire.
支持多种网络请求方式：

public enum Method: String {
case OPTIONS, GET, HEAD, POST, PUT, PATCH, DELETE, TRACE, CONNECT
}

本文基于Alamofire结合ObjectMapper、SwiftyJSON封装出来的一套网络请求体系，告别繁琐的书写格式。

直接上代码吧

1.请求方法代码
需要的头文件和block

import UIKit
import Alamofire
import SwiftyJSON
import ObjectMapper
import MBProgressHUD

//成功
typealias NetSuccessBlock<T: Mappable> = (_ value: YBaseModel<T>, JSON) -> Void
//失败
typealias NetFailedBlock = (AFSErrorInfo) -> Void
typealias AFSProgressBlock = (Double) -> Void//进度

单例方法：请求类：

class YRequestManager: NSObject {
    private var sessionManager: SessionManager?
    static let share = YRequestManager()
    override init() {
        super.init()
        let configuration = URLSessionConfiguration.default
        configuration.timeoutIntervalForRequest = 20
        sessionManager = SessionManager.init(configuration: configuration, delegate: SessionDelegate.init(), serverTrustPolicyManager: nil)
//        let delegate =
    }
}

YRequestManager扩展请求方法：post、get、upload

暴露给外面调用两个方法

  1. 普通请求
  2. 上传文件
extension YRequestManager {
 func requestByTargetType<T: Mappable>(targetType: YAPITargetType, model: T.Type, success: @escaping NetSuccessBlock<T>, failed: @escaping NetFailedBlock) -> Void {
        let url = targetType.baseUrl + targetType.path
        switch targetType.method {
        case .get:
            self.GET(url: url, param: targetType.pararms, headers: targetType.headers, isShowHUD: targetType.isShowHUD, success: success, failed: failed)
            break
        case .post:
            self.POST(url: url, param: targetType.pararms, headers: targetType.headers, isShowHUD: targetType.isShowHUD, success: success, failed: failed)
            break
        case .bodyPost:
            self.POST(url: url, paramBody: targetType.pararms, headers: targetType.headers, isShowHUD: targetType.isShowHUD, success: success, failed: failed)
            break
        default:
            break
        }
    }
    
    func uploadByTargetType<T: Mappable>(targetType: YAPITargetType, model: T.Type,progess:@escaping AFSProgressBlock , success: @escaping NetSuccessBlock<T>, failed: @escaping NetFailedBlock) -> Void {
        let url = targetType.baseUrl + targetType.path
        switch targetType.method {
        case .uploadImage:
            self.postImage(image: targetType.pararms["image"] as! UIImage, url: url, param: nil, headers: targetType.headers, isShowHUD: targetType.isShowHUD, progressBlock: progess, successBlock: success, faliedBlock: failed)
            break
        case .uploadMp4:
            self.postVideo(video: targetType.pararms["video"] as! Data, url: url, param: nil, headers: targetType.headers, isShow: targetType.isShowHUD, progressBlock: progess, successBlock: success, faliedBlock: failed)
            break
        default:
            break
        }
    }
}

扩展私有方法，封装请求



extension YRequestManager {
    
    fileprivate func GET<T: Mappable>(url: String, param: Parameters?, headers: HTTPHeaders, isShowHUD: Bool, success: @escaping NetSuccessBlock<T>, failed: @escaping NetFailedBlock) -> Void {
//        let encodStr = url.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)
        if isShowHUD {
            let keyViewController = UIApplication.shared.keyWindow?.rootViewController
            if (keyViewController != nil) {
                MBProgressHUD.showAdded(to: keyViewController!.view, animated: true)
            }
        }
        self.sessionManager?.request(url, method: .get, parameters: param, encoding: URLEncoding.httpBody , headers: headers).validate().responseJSON(completionHandler: { (response) in
            let keyViewController = UIApplication.shared.keyWindow?.rootViewController
            if (keyViewController != nil) {
                MBProgressHUD.hide(for: keyViewController!.view, animated: true)
                //            MBProgressHUD.
            }
            self.handleResponse(response: response, successBlock: success, faliedBlock: failed)
        })
    }
    
    fileprivate func POST<T: Mappable>(url: String, param: Parameters?, headers: HTTPHeaders, isShowHUD: Bool, success: @escaping NetSuccessBlock<T>, failed: @escaping NetFailedBlock) -> Void {
        //let encodStr = url.addingPercentEncoding(withAllowedCharacters: NSCharacterSet.urlQueryAllowed);
        
//        let headers: HTTPHeaders = ["Content-Type":"application/json;charset=utf-8"];
        // http
        if isShowHUD {
            let keyViewController = UIApplication.shared.keyWindow?.rootViewController
            if (keyViewController != nil) {
                MBProgressHUD.showAdded(to: keyViewController!.view, animated: true)
            }
        }
        self.sessionManager!.request(url, method: HTTPMethod.post, parameters: param, encoding: URLEncoding.httpBody, headers: headers)
            .validate()
            .responseJSON(completionHandler: { (response) in
                let keyViewController = UIApplication.shared.keyWindow?.rootViewController
                if (keyViewController != nil) {
                    MBProgressHUD.hide(for: keyViewController!.view, animated: true)
                    //            MBProgressHUD.
                }
                self.handleResponse(response: response, successBlock: success, faliedBlock: failed)
            })
    }
//    内容放在body里面
    func POST<T: Mappable>(url: String, paramBody: Dictionary<String, Any>?, headers: HTTPHeaders, isShowHUD: Bool, success: @escaping NetSuccessBlock<T>, failed: @escaping NetFailedBlock) -> Void {
        //let encodStr = url.addingPercentEncoding(withAllowedCharacters: NSCharacterSet.urlQueryAllowed);
        if isShowHUD {
            let keyViewController = UIApplication.shared.keyWindow?.rootViewController
            if (keyViewController != nil) {
                MBProgressHUD.showAdded(to: keyViewController!.view, animated: true)
            }
        }
        let json = JSON.init(paramBody as Any)
        let urlReqest = URL.init(string: url)
        var request = URLRequest.init(url: urlReqest!)
        request.httpMethod = HTTPMethod.post.rawValue
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = json.description.data(using: .utf8)
        // http
        self.sessionManager!.request(request)
            .validate()
            .responseJSON(completionHandler: { (response) in
                self.handleResponse(response: response, successBlock: success, faliedBlock: failed)
                let keyViewController = UIApplication.shared.keyWindow?.rootViewController
                if (keyViewController != nil) {
                    MBProgressHUD.hide(for: keyViewController!.view, animated: true)
                    //            MBProgressHUD.
                }
            })
    }
    
//    上传图片
    func postImage<T: Mappable>(image: UIImage, url: String, param: Parameters?, headers: HTTPHeaders, isShowHUD: Bool, progressBlock: @escaping AFSProgressBlock, successBlock:@escaping NetSuccessBlock<T>,faliedBlock:@escaping NetFailedBlock) {
        if isShowHUD {
            let keyViewController = UIApplication.shared.keyWindow?.rootViewController
            if (keyViewController != nil) {
                MBProgressHUD.showAdded(to: keyViewController!.view, animated: true)
            }
        }
        
        let imageData = image.jpegData(compressionQuality: 0.0001)
        let headers = ["content-type":"multipart/form-data"];
        self.sessionManager?.upload(multipartFormData: { (multipartFormData) in
            //采用post表单上传
            // 参数解释
            let dataStr = DateFormatter.init()
            dataStr.dateFormat = "yyyyMMddHHmmss"
            let fileName = "\(dataStr.string(from: Date.init())).png"
            multipartFormData.append(imageData!, withName: "file", fileName: fileName, mimeType: "image/jpg/png/jpeg")
        }, to: url, headers: headers, encodingCompletion: { (encodingResult) in
            let keyViewController = UIApplication.shared.keyWindow?.rootViewController
            if (keyViewController != nil) {
                MBProgressHUD.hide(for: keyViewController!.view, animated: true)
                //            MBProgressHUD.
            }
            switch encodingResult {
            case .success(let upload, _, _):
                //连接服务器成功后，对json的处理
                upload.responseJSON { response in
                    //解包
                    self.handleResponse(response: response, successBlock: successBlock, faliedBlock: faliedBlock)
//                    print("json:\(result)")
                }
                //获取上传进度
                upload.uploadProgress(queue: DispatchQueue.global(qos: .utility)) { progress in
                    progressBlock(progress.fractionCompleted);
                    print("图片上传进度: \(progress.fractionCompleted)")
                }
                break
            case .failure(let encodingError):
                self.handleRequestError(error: encodingError as NSError, faliedBlock: faliedBlock);
                break
            }
        })
    }
    
    func postVideo<T: Mappable>(video: Data, url: String, param: Parameters?,headers: HTTPHeaders,isShow: Bool, progressBlock: @escaping AFSProgressBlock, successBlock:@escaping NetSuccessBlock<T>,faliedBlock:@escaping NetFailedBlock) {
//        let headers = ["content-type":"multipart/form-data"];
        if isShow {
            let keyViewController = UIApplication.shared.keyWindow?.rootViewController
            if (keyViewController != nil) {
                MBProgressHUD.showAdded(to: keyViewController!.view, animated: true)
            }
        }
        self.sessionManager?.upload(multipartFormData: { (multipartFormData) in
            //采用post表单上传
            // 参数解释
            let dataStr = DateFormatter.init()
            dataStr.dateFormat = "yyyyMMddHHmmss"
            let fileName = "\(dataStr.string(from: Date.init())).mp4"
            multipartFormData.append(video, withName: "file", fileName: fileName, mimeType: "video/mp4");
        }, to: url, headers: headers, encodingCompletion: { (encodingResult) in
            
            let keyViewController = UIApplication.shared.keyWindow?.rootViewController
            if (keyViewController != nil) {
                MBProgressHUD.hide(for: keyViewController!.view, animated: true)
                //            MBProgressHUD.
            }
            switch encodingResult {
            case .success(let upload, _, _):
                //连接服务器成功后，对json的处理
                upload.responseJSON { response in
                    //解包
                    self.handleResponse(response: response, successBlock: successBlock, faliedBlock: faliedBlock)
                    //                    print("json:\(result)")
                }
                //获取上传进度
                upload.uploadProgress(queue: DispatchQueue.global(qos: .utility)) { progress in
                    progressBlock(progress.fractionCompleted);
                    print("图片上传进度: \(progress.fractionCompleted)")
                }
                break
            case .failure(let encodingError):
                self.handleRequestError(error: encodingError as NSError, faliedBlock: faliedBlock);
                break
            }
        })
    }
}

请求数据返回响应方法

extension YRequestManager {
    /** 处理服务器响应数据*/
    private func handleResponse<T: Mappable>(response:DataResponse<Any>, successBlock: NetSuccessBlock<T> ,faliedBlock: NetFailedBlock){
        if let error = response.result.error {
            // 服务器未返回数据
            self.handleRequestError(error: error as NSError , faliedBlock: faliedBlock)
            
        }else if let value = response.result.value {
            // 服务器又返回数h数据
            if (value as? NSDictionary) == nil {
                // 返回格式不对
                self.handleRequestSuccessWithFaliedBlcok(faliedBlock: faliedBlock)
            }else{
                self.handleRequestSuccess(value: value, successBlock: successBlock, faliedBlock: faliedBlock);
            }
        }
    }
    
    /** 处理请求失败数据*/
    private func handleRequestError(error: NSError, faliedBlock: NetFailedBlock){
        var errorInfo = AFSErrorInfo();
        errorInfo.code = error.code;
        errorInfo.error = error;
        if ( errorInfo.code == -1009 ) {
            errorInfo.message = "无网络连接";
        }else if ( errorInfo.code == -1001 ){
            errorInfo.message = "请求超时";
        }else if ( errorInfo.code == -1005 ){
            errorInfo.message = "网络连接丢失(服务器忙)";
        }else if ( errorInfo.code == -1004 ){
            errorInfo.message = "服务器没有启动";
        }else if ( errorInfo.code == 404 || errorInfo.code == 3) {
        }
        faliedBlock(errorInfo)
    }
    
     /** 处理请求成功数据*/
    private func handleRequestSuccess<T: Mappable>(value:Any, successBlock: NetSuccessBlock<T>,faliedBlock: NetFailedBlock){
        let json: JSON = JSON(value);
        let baseModel = YBaseModel<T>.init(JSONString: json.description)
        if baseModel?.status == 0 {
            successBlock(baseModel!, json)
        } else if baseModel?.status == 11 || baseModel?.status == 12 { // 获取服务器返回失败原因
            var errorInfo = AFSErrorInfo();
            errorInfo.code = baseModel!.status;
            errorInfo.message = (baseModel?.msg)!;
            faliedBlock(errorInfo);
        }
    }
    
    /** 服务器返回数据解析出错*/
    private func handleRequestSuccessWithFaliedBlcok(faliedBlock:NetFailedBlock){
        var errorInfo = AFSErrorInfo();
        errorInfo.code = -1;
        errorInfo.message = "数据解析出错";
    }
}

AFSErrorInfo结构体 和 YAPITargetType协议protocol

/** 访问出错具体原因 */
struct AFSErrorInfo {
    var code = 0
    var message = ""
    var error = NSError()
}

public protocol YAPITargetType {
    var method: RequestMed {get}
    
    var baseUrl: String { get }
    
    var path: String { get }
    
    var pararms: Dictionary<String, Any>{get}
    
    var headers: HTTPHeaders {get}
    
    var isShowHUD: Bool {get}
}

public enum RequestMed: Int {
    case post = 0
    case get = 1
    case bodyPost = 2
    case uploadImage = 3
    case uploadMp4 = 4
}

baseModel代码

YBaseModel.swift
//
//  YBaseModel.swift
//  YHuadingSwift
//
//  Created by bruce yao on 2019/1/26.
//  Copyright © 2019 bruce yao. All rights reserved.
//

import UIKit
import ObjectMapper

struct YBaseModel<T: Mappable>: Mappable {
    var status: Int = 100 //编码
    var msg: String = ""
    var data: [T]? //返回数据
    var dataAny: String?
    var dataStr: [String]? //返回数据
    var dicData: T?//返回数据
    var success: Int = 1 // 1 成功
    var pageNo: Int?
    var totalPages: Int?
    var hasNextPage: Bool = false
    var total: Int? {
        didSet {
            if self.total == nil {
                self.total = 0
            }else {
                if self.total! % 10 == 0 {
                    self.total = Int(self.total! / 10)
                }else {
                    self.total = Int(self.total! / 10) + 1
                }
            }
        }
    }
    
    init?(map: Map) {
    }
    mutating func mapping(map: Map) {
        status <- map["status"]
        status <- map["Code"]
        
        data <- map["data"]
        dataStr <- map["data"]
        data <- map["data.data"]
        data <- map["Data"]
        dataAny <- map["Data"]
        dataAny <- map["data"]
        
        dicData <- map["data"]
        dicData <- map["data.data"]
        dicData <- map["Data"]
        hasNextPage <- map["data.hasNextPage"]
        success <- map["success"]
        pageNo <- map["data.pageNo"]
        totalPages <- map["data.totalPages"]
        totalPages <- map["data.data.totalPages"]
        total <- map["total"]
        total <- map["data.totalRecord"]
        msg <- map["msg"]
    }
}

struct YNormalModel: Mappable {
    init?(map: Map) {
    }
    init() {  
    }
    mutating func mapping(map: Map) {
        
    }
}

实例1

api文件：

//
//  YSendArticelAPI.swift
//  YHmallNews
//
//  Created by bruce yao on 2019/4/28.
//  Copyright © 2019 bruce yao. All rights reserved.
//

import UIKit
import Alamofire
import ObjectMapper
enum YSendArticelAPI {
    case sendArticel(params:Dictionary<String, Any>)
    case sendArticel3(params:Dictionary<String, Any>)
}
extension YSendArticelAPI: YAPITargetType {
    var method: RequestMed {
        switch self {
        case .sendArticel(_):
            return .bodyPost
        default:
            return .get
        }
    }
    var modelType: Mappable.Type {
        return YNormalModel.self
    }
    
    var baseUrl: String {
        switch self {
        case .sendArticel(_):
            return HD_Search_Base
        default:
            return HD_Search_Base
        }
        
    }
    
    var path: String {
        switch self {
        case .sendArticel(_):
            return "manage/xtx/addXtxArticle"
        default:
            return HD_Search_Base
        }
    }
    
    var pararms: Dictionary<String, Any> {
        switch self {
        case .sendArticel(let parprms):
            return parprms
        default:
            return [:]
        }
    }
    
    var headers: HTTPHeaders {
        return ["Content-Type":"application/json;charset=utf-8"]
    }
    var isShowHUD: Bool {
        return true
    }
}

调用页面：

let dic = ["name": "xiaoLi", "age": 1]
YRequestManager.share.requestByTargetType(targetType: YSendArticelAPI.sendArticel(params: dic), model: YNormalModel.self, success: { [weak self](baseModel, json) in
            debugPrint(baseModel)
            self!.showTipsWithHUDDefaultTime(text: "发布成功")
            self?.navigationController?.popViewController(animated: true)
        }) { [weak self](error) in
            debugPrint(error)
            self!.showTipsWithHUDDefaultTime(text: "请求出错")
        }

说明

  1. API 说明：如果是postBody请求，请求的参数会直接转化为data数据，发给服务器
  2. YAPITargetType协议，目的抽象出来网络层，不用把请求方式啊以及URL、参数、统统写在Controller。也是为了给Controller瘦身，一定程度上分化啦代码结构
  3. 结合SwiftyJSON、ObjectMapper直接把数据转化为Model对象输出、简化繁琐的json转model代码逻辑
仰望星空01
关注
  • 8
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
iOS 项目中 网络请求Alamofire 的二次封装
weixin_43259805的博客
12-02 1196
iOS项目中 封装网络请求工具类
swift + Alamofire 网络请求封装
DongStone的专栏
06-23 635
用法： APISessionManager.default.request("xx/xx/", method: .get, headers: nil, parameters: nil) { [weak self ](response: [String : Any]) in } failureHandler: { (Error) in } APISession // // APISession.swift /.
Swift5 Alamofire5.0 二次封装
飞跃 Ni Wo Ta
08-29 8700
使用Objective-C开发的应该非常熟悉AFNetworking这个网络框架。在Swift诞生之后，AFNetworking的作者用Swift来编写一个类似AFNetworking的网络框架，那就是Alamofire！->github. 一直使用Objective-C开发，我来尝试下用Swift进行开发，首先从网络框架入手，对Alamofire进行二次封装。 目前Alamofire的最新...
Alamofire 二次封装
LAOning11的博客
04-21 423
var Network_DefaultErrorMessage = “操作失败，请重试！/// 调用接口后，对返回数据处理需要弹窗提示时取值用的key。/// 调用接口后，对返回数据处理时 判断是否成功用到的key。///是否需要添加HTTPHeaders。/////获取headers。/// 错误时，默认提示语。///对返回信息进行处理。
Alamofire二次封装Swift版的AF
芷江的博客
06-27 2196
import UIKitimport Alamofireimport SwiftyJSON/** 请求成功回调*/typealias NetSuccessBlock = (NSDictionary,SwiftyJSON.JSON) -&gt; Void/** 请求失败回调*/typealias NetFaliedBlock = (AFSErrorInfo) -&gt; Voidclass AFSN...
对AlamofireObjectMapper进行二次封装
Alan_xz的博客
10-28 727
Swift 使用Alamofire网络框架的封装
swift网络请求封装（Moya）
范佐佐的博客
04-13 3670
swift最新网络请求封装，使用moya进行数据请求，对返回的数据进行了模型转化，将返回的数据直接转化为model类型，方便好用，赶快试试吧！
swift-swift基于Alamofire数据请求封装
08-15
从压缩包文件名`XHNetworkSwift-master`来看，可能是一个包含示例项目的源码仓库，该项目可能展示了如何在Swift项目中使用Alamofire进行网络请求封装的具体实现。你可以下载并研究这个项目，以获取更多关于如何实际...
swift开发基础库,包含基于alamofire的网络请求框架的封装.zip
最新发布
05-05
swift开发基础库,包含基于alamofire的网络请求框架的封装.zipswift开发基础库,包含基于alamofire的网络请求框架的封装.zipswift开发基础库,包含基于alamofire的网络请求框架的封装.zipswift开发基础库,包含基于...
swift 使用 Alamofire 网络请求
CSDN博客
10-01 1229
首先这是摘抄自大神的网络请求，后台非常规范的时候建议使用,我再此基础上稍微改了下，也不知道有没有弄巧成拙 headers 里面内容可看我前面的文章 iOS 获取设备信息 (OC/Swift) import HandyJSON import Alamofire import CocoaLumberjack // MARK: 5.getter private static let msgNetError = "网络错误，请联网后点击重试" private static let msgD
swift-基于Alamofire封装的网络请求工具
08-15
基于Alamofire封装的网络请求工具
ios-swift第三方Alamofire封装.zip
07-11
swift第三方Alamofire封装
swift5.0 封装Alamofire
zhaofahseng的博客
06-17 1024
swift对Alamofire的二次封装，设置header参数等
简单封装Alamofire
kicinio的博客
09-12 1101
前言： 第三方库提供的API有时候并不能直接提供在项目里面直接调用，为了避免第三方库的不稳定性带来的影响，将其封装使用是个很好的做法。类似于JPA或MyBatis这样的“三层架构”实际上可以变换思路改成封装第三方库的做法，下面是一个利用协议和闭包简易封装的Alamofire做法，过程非常简单。 协议层： 协议层定义两个待实现的方法，一个为get请求，一个为post请求。当然，必要的数参数和闭包（数据请求完后将其回调出）也是具备的。内容如下： import Foundation import SwiftyJS
Swift + Alamofire 4.8 的网络请求简单封装 记录
sinat_18599211的博客
05-08 2061
import UIKit import Foundation import Alamofire typealias ReqRsponseSuccess = (_ response: AnyObject) -> Void typealias ReqResponseFail = (_ error: AnyObject) -> Void typealias NetworkStatus ...
Alamofire 、ObjectMapper封装
weixin_33895516的博客
01-08 226
2019独角兽企业重金招聘Python工程师标准>>> ...
Alamofire封装
QL_ProCareer的博客
06-08 1920
摘要: Alamofire封装 // //  BLHttpSessionsRequest.swift //  ALSFinancial-Swift // //  Created by 冰泪 on 16/8/23. //  Copyright © 2016年 冰泪. All rights reserved. //网络请求类封装 import UIKit import Ala
SWIFT闭包，介绍，使用（ALAMOFIRE封装 异步请求）
hatjs880328的博客
01-12 2742
闭包说明： 首先说明简明扼要的说明一下：闭包，可以看做 JAVA中匿名函数。 我们来看APPLE文档： 一个函数，可以看做一个特殊的闭包 嵌套函数，是一个捕获其所在函数中上下文的闭包 闭包表达式，是一个写法奇特，可以捕获上下文变量的【匿名闭包】 那么让我们开始：        我们有这样子的一个需求：写一个API，他需要两个参数，第一个参数是一个 字符串数组，第二个参数是一个
[Swift 开发] async/await异步编程封装Alamofire
u010130947的专栏
02-24 1502
Alamofire 是一个强大的网络请求库，可以轻松实现异步编程。本文将介绍如何使用 async/await 封装 Alamofire，以实现更加优雅的异步编程。总结一下，本文介绍了如何使用 async/await 封装 Alamofire，以实现更加优雅的异步网络请求。通过使用 async/await，可以使得网络请求变得更加简洁、优雅，让开发者更加轻松地实现异步编程。然后，我们封装一下逻辑层，模拟了3个网络请求，其中包括(无参get, 有参get，无参post )首先，我们用Alamofire的。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值