Alamofire的二次封装
最近开始在学习Swift，在网络工具的选择中，我选择了AFNetworking的Swift版本--->Alamofire，为了更加方便的项目的开发，我对Alamofire做了一些封装， 话不多说 直接上码
工具类属性定义
//网络请求方式的Key
let BWRequestMethodKey = "BWRequestMethodKey"
//网络请求成功的回调
typealias BWNetworkSuccess = (_ isSuccess: Bool, _ code: String, _ hint: String, _ list: AnyObject, _ responseData: AnyObject) -> Void
//网络请求失败的回调
typealias BWNetworkFail = (_ error: AnyObject) -> Void
//网络状态
typealias BWNetworkStatusBlock = (_ networkStatus: UInt32) -> Void
enum BWNetworkStatus: Int32 {
case unkonw = -1 //未知网络
case notReachable = 0 //网络无连接
case wwan = 1 //2，3，4G网络
case wifi = 2 //wifi网络
}
class BWNetworkingService: NSObject {
//MARK: var & let
static let shareService = BWNetworkingService()
//记录当前请求路由
private var currentRequestUrl: String = ""
//记录当前请求方式
private var currentRequestMethod: HTTPMethod = .get
//记录当前请求接口参数
private var currentParams: Dictionary<String,Any>?
//记录当前接口是否需要缓存到本地
private var shouldCache: Bool = false
//超时时间
private let requestTimeout: TimeInterval = 20
//获取资源超时时间
private let resourceTimeout: TimeInterval = 20
//header
private lazy var httpHeader: [String: Any] = {
let header : HTTPHeaders = SessionManager.defaultHTTPHeaders
// header["Authorization"] = ""
// header.updateValue("application/json", forKey: "Accept")
return header
}()
//数据缓存路径
private let cachePath = NSHomeDirectory() + "/Documents/NetworkingCaches/"
//当前网络状态
private var networkStatus: BWNetworkStatus = .wifi
//sessionManager
private lazy var sessionManager: SessionManager = {
#warning("此处换成其他的SessionManager在任务组中处理时第一次请求会报cancel错误，暂时换成default，以后再处理此处")
return SessionManager.default
// let configuration = URLSessionConfiguration.default
// configuration.httpAdditionalHeaders = SessionManager.defaultHTTPHeaders
// configuration.timeoutIntervalForRequest = self.requestTimeout
// configuration.timeoutIntervalForResource = self.resourceTimeout
// return SessionManager(configuration: configuration)
}()
基础请求
//MARK: 基础网络请求
/// 基础网络请求
///
/// - Parameters:
/// - url: 请求链接
/// - method: 请求方式
/// - shouldCache: 是否需要缓存此处数据
/// - success: 请求成功回调
/// - fail: 请求失败回调
public func baseRequestWith(url: String,
method: HTTPMethod,
shouldCache: Bool,
params: [String : Any]?,
success: @escaping BWNetworkSuccess,
fail: @escaping BWNetworkFail) {
var urlPath: String = url
//拼接域名
urlPath = CWAppConfig.shared.routerUrl + urlPath
if networkStatus.rawValue == BWNetworkStatus.unkonw.rawValue || networkStatus.rawValue == BWNetworkStatus.notReachable.rawValue {
if shouldCache == true {
//从缓存中取出此处的数据
let cacheData = self.cacheDataFrom(urlPath: urlPath)
if cacheData != nil {
//数据处理
self.fetchData(cacheData as AnyObject, success)
}
if self.networkStatus == .notReachable || self.networkStatus == .unkonw {
return;
}
}
}
//清除空格
if urlPath.contains(" ") {
urlPath = urlPath.replacingOccurrences(of: " ", with: "")
}
var tempParams = params
if tempParams == nil {
tempParams = [String: Any]()
}
//设置token
tempParams?["token"] = USERINFO.token ?? ""
self.currentRequestUrl = urlPath
self.currentRequestMethod = method
self.currentParams = tempParams
self.shouldCache = shouldCache
BWLog("当前请求接口:\(self.currentRequestUrl) 请求参数:\(String(describing: self.currentParams))")
//从服务器获取数据
self.sessionManager.request(self.currentRequestUrl, method: self.currentRequestMethod, parameters: self.currentParams, encoding: URLEncoding.default, headers: nil).responseJSON { (responseData) in
switch responseData.result {
case .success:
if let value = responseData.result.value as? [String : Any] {
//是一个字典 此处可自定义一些处理 (判断接口是否返回了正确数据 接口是否报错 接口报错类型 是否需要重新登录。。。)
self.fetchData(value as AnyObject, success)
let resultDic: [String: AnyObject] = value as [String: AnyObject]
let code: String = resultDic["code"] as! String
let isSuccess = code == "40000"
if code == "40004" {
//删除用户信息 重新登录
USERINFO.removeLocalUserInfo()
CWLoginHandle.showLoginVC()
}
//判断是否需要缓存数据
if shouldCache == true && isSuccess == true {
//缓存当前接口返回的数据
self.cacheResponseDataWith(responseData: value as AnyObject, urlPath: urlPath)
}
}
case .failure(let error):
fail(error as AnyObject)
debugPrint("接口请求失败--\(error)")
}
}
}
//数据第一次处理
func fetchData(_ responseData: AnyObject, _ success: BWNetworkSuccess) {
let resultDic: [String: AnyObject] = responseData as! [String: AnyObject]
let code: String = resultDic["code"] as! String
let hint: String = resultDic["hint"] as! String
let list: AnyObject = resultDic["list"] as AnyObject
let isSuccess: Bool = code == "40000"
success(isSuccess,code,hint,list,responseData as AnyObject)
}
GET & POST
//MARK: GET请求--不带接口缓存
/// GET请求
///
/// - Parameters:
/// - url: 请求链接
/// - params: 请求参数
/// - success: 成功的回调
/// - fail: 失败的回调
public func requestGetWith(url: String,
params: [String: Any]?,
success: @escaping BWNetworkSuccess,
fail: @escaping BWNetworkFail) {
self.requestGetWith(url: url, params: params, shouldCache: false, success: success, fail: fail)
}
//MARK: POST请求--不带接口缓存
/// POST请求
///
/// - Parameters:
/// - url: 请求链接
/// - params: 请求参数
/// - success: 成功的回调
/// - fail: 失败的回调
public func requestPostWith(url: String,
params: [String: Any]?,
success: @escaping BWNetworkSuccess,
fail: @escaping BWNetworkFail) {
self.requestPostWith(url: url, params: params, shouldCache: false, success: success, fail: fail)
}
//MARK: GET请求--携带是否缓存参数
/// GET请求---携带是否缓存参数
///
/// - Parameters:
/// - url: 请求路由
/// - params: 请求参数
/// - shouldCache: 是否需要缓存数据
/// - success: 成功的回调
/// - fail: 失败的回调
public func requestGetWith(url: String,
params: [String: Any]?,
shouldCache: Bool,
success: @escaping BWNetworkSuccess,
fail: @escaping BWNetworkFail) {
self.baseRequestWith(url: url, method: .get, shouldCache: shouldCache, params: params, success: success, fail: fail)
}
//MARK: POST请求---携带是否缓存参数
/// POST请求---携带是否缓存参数
///
/// - Parameters:
/// - url: 请求路由
/// - params: 请求参数
/// - shouldCache: 是否需要缓存数据
/// - success: 成功的回调
/// - fail: 失败的回调
public func requestPostWith(url: String,
params: [String: Any]?,
shouldCache: Bool,
success: @escaping BWNetworkSuccess,
fail: @escaping BWNetworkFail) {
self.baseRequestWith(url: url, method: .post, shouldCache: shouldCache, params: params, success: success, fail: fail)
}
并发请求多接口---返回接口以已传入的urlPath作为key存在字典中
/// 异步多接口请求--返回的数据由[urlPath: responseData]的字典数组形式按传入mutableUrls中的顺序返回
///
/// - Parameters:
/// - mutableUrls: 多个请求接口
/// - params: 各接口请求参数 如果是POST请求 一定要传BWRequestMethodKey=.posto 否则将当做get请求处理
/// - completionHandle: 回调
public func asyncMutablRequestWith(mutableUrls: [String],
shouldCache: Bool,
params:[Dictionary<String, Any>]?,
completionHandle: @escaping ([String: Any]) -> Void) {
if params != nil && params?.count ?? 0 > 0 {
//抛出异常 参数字典数组(params)与请求路由数组(mutableUrls)数量需一致
if params?.count != mutableUrls.count {
assert(false, "参数字典数组(params)与请求路由数组(mutableUrls)数量需一致")
}
}
//创建字典于接收服务器返回的数据
var resultDictionary: Dictionary = [String: AnyObject].init()
//创建调度组
let dispatchGroup = DispatchGroup.init()
//创建并发队列
let concurrentQueue = DispatchQueue.init(label: "com.mutableNetwork.xiongbenwan", qos: .default, attributes: .concurrent, autoreleaseFrequency: .inherit, target: nil)
for (index, url) in mutableUrls.enumerated() {
var urlPath = url
if urlPath.contains(" ") {
//清除urlPath中的空格
urlPath = urlPath.replacingOccurrences(of: " ", with: "")
}
if urlPath.count <= 0 {
//抛出异常 传入的url不能为空字符串
assert(false, "下标为\(index)的url不能为空字符串")
}
var paramDic: Dictionary<String, Any>?
var httpMethod: HTTPMethod = .get
if params != nil && params?.count ?? 0 > 0 {
paramDic = params?[index]
if paramDic != nil {
//取出字典中的请求方式的value 如果没有 则默认为GET请求
let requestMethod: HTTPMethod? = paramDic![BWRequestMethodKey] as? HTTPMethod
if requestMethod == HTTPMethod.post {
httpMethod = .post
}
}
}
dispatchGroup.enter()
concurrentQueue.async {
self.baseRequestWith(url: urlPath, method: httpMethod, shouldCache: shouldCache, params: paramDic, success: { (isSuccess, code, hint, list, responseData) in
//将服务器返回的数据按照url:data的形式放在字典中
resultDictionary[urlPath] = responseData
dispatchGroup.leave()
}, fail: { (error) in
resultDictionary[urlPath] = error
dispatchGroup.leave()
})
}
}
//线程通知的方式等待任务组完成---回到主线程中处理数据
dispatchGroup.notify(queue: DispatchQueue.main) {
completionHandle(resultDictionary)
}
}
数据缓存相关
extension BWNetworkingService {
/// 从缓存中获取数据
///
/// - Parameter urlPath: 请求路由
/// - Returns: 缓存数据
public func cacheDataFrom(urlPath: String) -> Any? {
//对请求路由base64编码
let base64Path = urlPath.md5String()()
//拼接缓存路径
var directorPath: String = cachePath
directorPath.append(base64Path)
let data: Data? = FileManager.default.contents(atPath: directorPath)
let jsonData: Any?
if data != nil {
print("从缓存中获取数据:\(directorPath)")
do {
jsonData = try JSONSerialization.jsonObject(with: data!, options: .mutableContainers)
return jsonData
} catch {
return data
}
}
return nil
}
/// 将接口请求成功的数据缓存到本地
///
/// - Parameters:
/// - responseData: 服务器返回的数据
/// - urlPath: 请求路由
/// - params: 请求参数
public func cacheResponseDataWith(responseData: AnyObject,
urlPath: String) {
var directorPath: String = cachePath
//创建目录
createRootCachePath(path: directorPath)
//对请求的路由进行base64编码
let base64Path = urlPath.md5String()
//拼接路径
directorPath.append(base64Path)
//将返回的数据转换成Data
var data: Data?
do {
try data = JSONSerialization.data(withJSONObject: responseData, options: .prettyPrinted)
} catch {
}
//将data存储到指定的路径
if data != nil {
let cacheSuccess = FileManager.default.createFile(atPath: directorPath, contents: data, attributes: nil)
if cacheSuccess == true {
debugPrint("当前接口缓存成功:\(directorPath)")
} else {
debugPrint("当前接口缓存失败:\(directorPath)")
}
}
}
//新建数据缓存路径
func createRootCachePath(path: String) {
if !FileManager.default.fileExists(atPath: path, isDirectory: nil) {
do {
try FileManager.default.createDirectory(atPath: path, withIntermediateDirectories: true, attributes: nil)
} catch let error {
debugPrint("create cache dir error:" + error.localizedDescription + "\n")
return
}
}
}
}
网络状态监听
extension BWNetworkingService {
/// 网络状态监听
public func monitorNetworkingStatus() {
let reachability = NetworkReachabilityManager()
reachability?.startListening()
reachability?.listener = { [weak self] status in
guard let weakSelf = self else { return }
if reachability?.isReachable ?? false {
switch status {
case .notReachable:
weakSelf.networkStatus = BWNetworkStatus.notReachable
case .unknown:
weakSelf.networkStatus = BWNetworkStatus.unkonw
case .reachable(.wwan):
weakSelf.networkStatus = BWNetworkStatus.wwan
case .reachable(.ethernetOrWiFi):
weakSelf.networkStatus = BWNetworkStatus.wifi
}
} else {
weakSelf.networkStatus = BWNetworkStatus.notReachable
}
}
}
}
收工！！！
