其实写这个网络框架的时候我也只是才学习了RxSwift一周左右的时间，尝试一下自己搭建的网络请求的框架。抱着学习的态度，若果有什么不对的地方，请各位指正。
首先先用CocoaPods导入第三方库，这是写在Podfile中的：
Podfile
这四个三方库我就不一一说明了，不清楚的小伙伴可以自行查阅。下面来看看整个框架结构：
NetworkTool
APIUtil 这里放的是网络协议，通过面向协议编程对网络请求进行封装。
APIError 一个枚举类型，专门用来处理网络错误(可以自定义添加)。
Router 所有的接口地址在这里进行拼接。
接下来一起看看它是怎么实现的。
APIUtil
我在这里定义了一个网络协议:
import Foundation
import Alamofire
import HandyJSON
import RxSwift
struct APIUtil {
static var httpsHeaders: HTTPHeaders = ["Content-Type": "application/json"]
}
接下来我对网络进行第一层封装：
// MARK: - 对Alamofire的第一层封装
extension APIUtil {
/// 网络请求方法
///
/// - Parameters:
/// - observer: Rx 观察者
/// - url: 路由地址
/// - method: 请求方式
/// - parameters: 参数
/// - returnType: 返回类型
fileprivate static func request<T: HandyJSON>(observer: AnyObserver<T>, url: Router, method: HTTPMethod, parameters: Parameters?, encoding: ParameterEncoding, returnType: T.Type) {
AF.request(url, method: method, parameters: parameters, encoding: encoding, headers: httpsHeaders).responseJSON { response in
switch response.result {
case .success:
successHandle(observer: observer, result: response.value, retrunType: returnType)
case .failure(let error):
failHandle(observer: observer, error: APIError.apiError(with: error as NSError))
}
}
}
/// 上传方法
///
/// - Parameters:
/// - observer: Rx 观察者
/// - url: 路由地址
/// - method: 请求方式
/// - uploadDatas: 上传的数据数组
/// - parameters: 参数
/// - returnType: 返回类型
fileprivate static func uploadRequest<T: HandyJSON>(observer: AnyObserver<T>, url: Router, method: HTTPMethod, uploadDatas: [UploadData]?, parameters: Parameters?, returnType: T.Type) {
AF.upload(multipartFormData: { data in
// Parameters
if let parameters = parameters {
for param in parameters {
let value = (param.value as! String).data(using: .utf8)
data.append(value!, withName: param.key)
}
}
// uploadData
if let toUploadDatas = uploadDatas {
for toUploadData in toUploadDatas {
if let uploadData = toUploadData.data {
data.append(uploadData, withName: toUploadData.name!, fileName: toUploadData.fileName!, mimeType: toUploadData.mimeType!)
}
}
}
}, to: url, method: method, headers: httpsHeaders).responseJSON { response in
switch response.result {
case .success:
successHandle(observer: observer, result: response.value, retrunType: returnType)
case .failure(let error):
failHandle(observer: observer, error: APIError.apiError(with: error as NSError))
}
}
}
- 这一层封装主要利用RxSwift对Alamofire的网络请求的结果包装成一个AnyObserver，对不同的结果进行不同的处理。
接下来是对请求结果的处理：
// MARK: - 对网络成功与否的处理
extension APIUtil {
/// 网络请求成功之后的回调
///
/// - Parameters:
/// - observer: Rx 的观察者(传递数据)
/// - result: 请求结果
/// - retrunType: 返回值类型
fileprivate static func successHandle<T: HandyJSON>(observer: AnyObserver<T>, result: Any?, retrunType: T.Type) {
// 如果解析出来的不是json
guard let JSON = result, let jsonDic = JSON as? [String: Any] else {
failHandle(observer: observer, error: APIError.dataJSON(errorMessage: "非JSON格式的数据"))
return
}
// jsonDic是原始数据，将其转成HandyJSON
guard let responseModel = retrunType.deserialize(from: NSDictionary(dictionary: jsonDic)) else {
failHandle(observer: observer, error: APIError.dataMatch(errorMessage: "无法解析"))
return
}
observer.onNext(responseModel)
observer.onCompleted()
}
/// 网络请求失败的回调
///
/// - Parameters:
/// - observer: Rx 的观察者
/// - error: 错误信息
fileprivate static func failHandle<T: HandyJSON>(observer: AnyObserver<T>, error: Error) {
observer.onError(NetError.networkError(with: error as NSError))
observer.onCompleted()
}
}
- 如果请求成功的话会返回一个遵循HandyJSON协议的数据模型，失败的话返回网络错误的信息。
接下来创建Rx序列：
// MARK: - 利用Rx传递数据
extension APIUtil {
/// 获取数据
///
/// - Parameters:
/// - url: 路由地址
/// - method: 请求方式
/// - parameters: 参数
/// - returnType: 返回类型
/// - Returns: 返回一个Rx序列
static func fetchData<T: HandyJSON>(with url: Router, method: HTTPMethod = .get, parameters: Parameters? = nil, encoding: ParameterEncoding = URLEncoding.queryString, returnType: T.Type) -> Observable<T> {
return Observable<T>.create({ (observer: AnyObserver<T>) -> Disposable in
self.request(observer: observer, url: url, method: method, parameters: parameters, returnType: returnType)
return Disposables.create()
})
}
/// 上传数据
///
/// - Parameters:
/// - url: 路由地址
/// - method: 请求方式
/// - uploadDatas: 上传数据的数组
/// - parameters: 参数(可以不填)
/// - returnType: 返回类型
/// - Returns: 返回一个Rx序列
static func uploadData<T: HandyJSON>(with url: Router, method: HTTPMethod, uploadDatas: [UploadData]?, parameters: Parameters? = nil, returnType: T.Type) -> Observable<T> {
return Observable<T>.create({ (observer: AnyObserver<T>) -> Disposable in
self.uploadRequest(observer: observer, url: url, method: method, uploadDatas: uploadDatas, parameters: parameters, returnType: returnType)
return Disposables.create()
})
}
- 调用方法会创建一个Rx的序列，在闭包中直接调用第一层封装的方法。
APIError
在这里我们为网络错误的处理进行了简单的分类：
import Foundation
enum NetError: Error {
/// 普通的错误信息
case error(errorMessage: String)
/// 数据不是json格式
case dataJSON(errorMessage: String)
/// 数据不匹配
case dataMatch(errorMessage: String)
/// 数据为空
case dataEmpty(errorMessage: String)
/// 网络错误
case network(errorMessage: String)
/// 网络错误的信息打印
///
/// - Parameter error: 错误信息
/// - Returns: 网络错误处理
static func networkError(with error: NSError) -> NetError {
print("This error message is \(error)")
if error.domain == "Alamofire.AFError" {
//处理自带的错误
if error.code == 4 {
return NetError.dataEmpty(errorMessage: "数据为空")
}
}
return NetError.network(errorMessage: "未知的网络错误")
}
}
Router
import UIKit
import Alamofire
enum Router: String, URLConvertible {
case tianqi = "data/sk/101010100.html"
/// 实现协议方法
func asURL() throws -> URL {
return try URL(string: urlString)!.asURL()
}
/// 主机地址
static var baseUrl: String = "http://mobile.weather.com.cn/"
/// 拼接过的地址链接
private var urlString: String {
return Router.baseUrl.appending(rawValue)
}
}
在这里要说明一下URLConvertible这个协议，实现这个协议可以将Router中的地址自动拼接并转成URL类型。
接下来就可以使用它来进行简单的网络请求：
import Foundation
import HandyJSON
import RxSwift
struct DataModel: HandyJSON {
var skinfo: SkyInfo?
mutating func mapping(mapper: HelpingMapper) {
mapper <<<
self.skinfo <-- "sk_info"
}
}
struct SkyInfo: HandyJSON {
var areaID: Int = 0
var cityName: String?
var date: String?
var sd: String?
var sm: String?
var temp: String?
var tempF: String?
var time: String?
var wd: String?
var ws: String?
mutating func mapping(mapper: HelpingMapper) {
mapper.specify(property: &date) { (dateInt) -> String in
return "\(dateInt)"
}
}
}
extension DataModel {
func fetchSkyData() -> Observable<DataModel> {
return APIUtil.fetchData(with: .tianqi, method: .get, parameters: ["_" : "1381891661455"], returnType: DataModel.self).map({ (response: DataModel) -> DataModel in
return response
})
}
}
- 在这里调用网络请求的方法，返回一个Rx序列携带请求结果。
最后在需要对数据处理的地方返回模型：
let dataModel = DataModel()
let disposeBag = DisposeBag()
dataModel.fetchSkyData().subscribe(onNext: { (model) in
print(model.skinfo!.date!)
}, onError: { (error) in
print(error)
}).disposed(by: disposeBag)
到这里，就完成了一个简单的网络请求框架，最后放上demo的地址，感兴趣的小伙伴可以下载看看：demo地址
