基于Alamofire+RxSwift+HandyJSON的网络请求框架

其实写这个网络框架的时候我也只是才学习了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(observer: AnyObserver, 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(observer: AnyObserver, 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(observer: AnyObserver, 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(observer: AnyObserver, 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(with url: Router, method: HTTPMethod = .get, parameters: Parameters? = nil, encoding: ParameterEncoding = URLEncoding.queryString, returnType: T.Type) -> Observable {
        return Observable.create({ (observer: AnyObserver) -> 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(with url: Router, method: HTTPMethod, uploadDatas: [UploadData]?, parameters: Parameters? = nil, returnType: T.Type) -> Observable {
        return Observable.create({ (observer: AnyObserver) -> 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 {
        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地址