其实写这个网络框架的时候我也只是才学习了RxSwift一周左右的时间，尝试一下自己搭建的网络请求的框架。抱着学习的态度，若果有什么不对的地方，请各位指正。
首先先用CocoaPods导入第三方库，这是写在Podfile中的：
Podfile.png
这四个三方库我就不一一说明了，不清楚的小伙伴可以自行查阅。下面来看看整个框架结构：
image
NetworkTool 这里放的是网络协议，通过面向协议编程对网络请求进行封装。
NetError 一个枚举类型，专门用来处理网络错误(可以自定义添加)。
Router 所有的接口地址在这里进行拼接。
接下来一起看看它是怎么实现的。
NetworkTool
我在这里定义了一个网络协议:
import Foundation
import Alamofire
import HandyJSON
import RxSwift
protocol NetworkProtocol { }
接下来我对网络进行第一层封装：
// MARK: - 对Alamofire的第一层封装
extension NetworkProtocol {
/// 网络请求方法
///
/// - Parameters:
/// - observer: Rx 观察者
/// - url: 路由地址
/// - method: 请求方式
/// - parameters: 参数
/// - returnType: 返回类型
fileprivate static func request<T: HandyJSON>(observer: AnyObserver<T>, url: Router, method: HTTPMethod, parameters: Parameters?, returnType: T.Type) {
Alamofire.request(url, method: method, parameters: parameters, encoding: JSONEncoding.default, headers: httpheaders).responseJSON { (response) in
switch response.result {
case .success:
self.successHandle(observer: observer, result: response.result, retrunType: returnType)
break
case .failure(let error):
observer.onError(NetError.networkError(with: error as NSError))
observer.onCompleted()
break
}
}
}
/// 上传方法
///
/// - 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) {
Alamofire.upload(multipartFormData: { (data: MultipartFormData) 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: httpheaders) { (result: SessionManager.MultipartFormDataEncodingResult) in
switch result {
case .success(let upload, _, _):
upload.responseJSON(completionHandler: { (response: DataResponse<Any>) in
self.successHandle(observer: observer, result: response.result, retrunType: returnType)
})
break
case .failure(let encodingError):
self.failHandle(observer: observer, error: encodingError)
break
}
}
}
}
- 这一层封装主要利用RxSwift对Alamofire的网络请求的结果包装成一个AnyObserver，对不同的结果进行不同的处理。
接下来是对请求结果的处理：
// MARK: - 对网络成功与否的处理
extension NetworkProtocol {
/// 网络请求成功之后的回调
///
/// - Parameters:
/// - observer: Rx 的观察者(传递数据)
/// - result: 请求结果
/// - retrunType: 返回值类型
fileprivate static func successHandle<T: HandyJSON>(observer: AnyObserver<T>, result: Result<Any>, retrunType: T.Type) {
//如果解析出来的不是json
guard let JSON = result.value, let jsonDic = JSON as? Dictionary<String, AnyObject> else {
observer.onError(NetError.dataJSON(errorMessage: "服务器返回的数据格式不是JSON"))
observer.onCompleted()
return
}
//jsonDic是原始数据，将其转成HandyJSON
guard let responseModel = retrunType.deserialize(from: NSDictionary(dictionary: jsonDic)) else {
observer.onError(NetError.dataMatch(errorMessage: "返回的数据不能解析"))
observer.onCompleted()
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 NetworkProtocol {
/// 获取数据
///
/// - Parameters:
/// - url: 路由地址
/// - method: 请求方式
/// - parameters: 参数
/// - returnType: 返回类型
/// - Returns: 返回一个Rx序列
func fetchData<T: HandyJSON>(with url: Router, method: HTTPMethod = .post, parameters: Parameters?, 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序列
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的序列，在闭包中直接调用第一层封装的方法。
NetError
在这里我们为网络错误的处理进行了简单的分类：
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 URL(string: urlString())!
}
/// 主机地址
static var baseUrl: String = "http://mobile.weather.com.cn/"
/// 接口拼接
///
/// - Returns: 返回拼接好的接口地址字符
private func urlString() -> String {
return Router.baseUrl.appending(rawValue)
}
}
在这里要说明一下URLConvertible这个协议，实现这个协议可以将Router中的地址自动拼接并转成URL类型。
接下来就可以使用它来进行简单的网络请求：
import Foundation
import HandyJSON
import RxSwift
class DataModel: HandyJSON, NetworkProtocol {
var skinfo: SkyInfo?
required init() {}
func mapping(mapper: HelpingMapper) {
mapper <<<
self.skinfo <-- "sk_info"
}
}
class 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?
required init() {}
func mapping(mapper: HelpingMapper) {
mapper.specify(property: &date) { (dateInt) -> String in
return "\(dateInt)"
}
}
}
extension DataModel {
func fetchSkyData() -> Observable<DataModel> {
return 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地址
网友评论