Swift:封装网络框架

2017-08-02 本文已影响0人 sinalma

笔者在用swift做练手项目时，发现用大牛的框架很蛋疼，什么swfit2转3，要么是要少这个文件，要其他一些配置，总之很糟糕，那既然是练手项目，自己封装一些框架，何乐而不为。
今天，谈谈网络框架的封装，实现用到URLSession类，做完整项目，那可以再封装参数类和错误类。

下面开始逐步封装:

1. 核心类(因是个简单的框架，核心不过是一个类):NetWorking,继承自NSObject，给外界的接口，仿照Alamofire,类方法

// @escaping:逃逸闭包，当需要传给外界，当此处需要回调是要加上@escaping
class func request(method:String = "GET",url:String,parameters:Dictionary<String,AnyObject> = [:],successed:@escaping (_ data:Dictionary<String, AnyObject>?) ->Void,failed: @escaping (_ error:Error?) -> Void)

2.核心方法的实现如下:

       // 在子线程中执行网络请求
        DispatchQueue.global().async { 
        var innerUrl = url
         // 处理GET请求
        if method == "GET" {
            innerUrl += "?" + SINNetworking().getParamStr(parameters: parameters) // 拼接参数到url后面
        }
       // 创建请求
        let request = NSMutableURLRequest.init(url: NSURL.init(string: innerUrl)!  as URL)
        // 设置请求用get还是post
        request.httpMethod = method
        // 当请求是post，将参数放入请求体中
        if method == "POST" {
            request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
// 这里需要将参数字典拆开拼接成字符串，实现请看第3步
            request.httpBody = SINNetworking().getParamStr(parameters: parameters).data(using: String.Encoding.utf8)
        }
        // 创建网络对象
        let session = URLSession.shared
        // 开始工作
        let task = session.dataTask(with: request as URLRequest) { (data, response, error) -> Void in
            if error != nil{
                failed(error)
                if let tempRes = response {
                    print(tempRes)
                }
            }else{
                if (response as! HTTPURLResponse).statusCode == 200{
                   // 这里需要用到解析类，具体实现看第4步
                    let reData = SINEncoding.dictionaryObjcet(data: data!)
                    DispatchQueue.main.async(execute: { 
                        // 请求成功，回调闭包，将数据传出
                        successed(reData)
                    })
                }else{
                    failed(error)
                }
            }
        }
        task.resume()
        }//子线程结束

3.辅助方法的实现:
- 将参数字典转换为拼接成的一段字符串

func getParamStr(parameters:[String:AnyObject]) -> String {
       
       var components:[(String,String)] = []
       for key in (parameters.keys).sorted(){
           let value :AnyObject! = parameters[key]
           components +=  self.queryComponents(key: key, value)
       }
       
       return (components.map{"\($0)=\($1)"} as [String]).joined(separator: "&")
   }
   
   func queryComponents(key:String,_ value:AnyObject) -> [(String,String)] {
       
       var components:[(String,String)] = []
       
       if let dictionary = value as? [String:AnyObject]{
           for (nestedKey,value) in dictionary{
               components += queryComponents(key: "\(key)[\(nestedKey)]", value)
           }
       }else if let array = value as? [AnyObject] {
           for value in array{
               components += queryComponents(key: "\(key)", value)
           }
       }else
       {
           components.append(contentsOf: [(key,"\(value)")])
       }
       return components   
   }

4.最简单的解析类实现,创建Encoding类，实现是用JSONSerialization类，作用是将data数据转换成字典，并且可以用plist格式写入到本地

class func dictionaryObjcet(data:Data) -> Dictionary<String, AnyObject> {
        // 这个方法需要抛出异常
        do{
            let json = try JSONSerialization.jsonObject(with: data, options: JSONSerialization.ReadingOptions.mutableContainers)
            
            if json is Dictionary<String,AnyObject>{
                return json as! Dictionary
            }
            
        }catch
        {
            print(error)
        }
        return ["":"" as AnyObject]
  
        }

5.现在外界就可以用这个框架来发送请求来获取网络数据，当然如果需要请求很多次，每次的参数不尽相同，那可以封装一个参数类，来简化代码
实现如下:
- 5.1 创建参数类，Paramers
- 5.2 创建枚举，枚举的值根据请求的不同数据来定义

enum RequestType {
    case homeNormal // 大众数据
    case homeAddress // 城市
    case homeLikefeed // 猜你喜欢
    case homeHotStore // 热门商铺
}

5.3 定义一个公开的参数字典属性，将大部分请求中相同的参数写入
5.4 在参数类中定义一个构造方法，参数将传入一个枚举值,然后用switch来判别不同请求，改边不同的参数的值，或删除增加某些参数

switch type {
         case RequestType.homeNormal:
            // 做更改参数取值的操作
                                                     break
        case RequestType.homeLikefeed:
                                                     break
        case RequestType.homeLikefeed:
                                                     break
       default: break
}

整个网络框架的实现流程就是这样，轻松简单
6.具体的使用可以创建一个网络服务类DataService，一个模块的所有请求都用服务类的接口

// 定义属性，保存需要回调的闭包
static var addressCompletiones:[(_ cityName:String) -> Void] = []
    static var addressErrors:[(_ errorMessage:String)->Void] = []

// 发送网络请求，类方法
class func getAddress(completion:@escaping (_ curAddress:String)->Void,error:@escaping (_ errorMessage:String)->Void) {
        // 保存闭包
        addressCompletiones.append(completion)
        addressErrors.append(error)
        // 子线程执行
        DispatchQueue.global().async {
SINNetworking.request(method: "POST", url: "https://app.nuomi.com/naserver/common/gpstogeo", parameters: SINParameters.init(type: RequestType.homeAddress).params as Dictionary<String, AnyObject>, successed: { (resopnse) in
            
            let isSusscess = resopnse?["errmsg"] as! String
            if isSusscess != "success"{
                if addressErrors.first != nil {
                    addressErrors.first!("SIN_ $_ 首页_ 地址_ 数据请求失败")
                }
                return
            }
            let dict = resopnse?["data"] as! Dictionary<String, AnyObject>
            let address = dict["short_name"] as! String 
            // 如果需要讲字典转为模型，可以在这里操作
            if addressCompletiones.first != nil{
                
                DispatchQueue.main.async(execute: {
                addressCompletiones.first!(address)
                })
            }
            
        }) { (error) in
            print(error!)
        }
    }// sub thread
    }

7.现在外界的想要获取数据就非常的舒服

DataService.getAddress(completion: { (address) in
                self.topAddressLab.text = address
            }) { (errorMsg) in
                print(errorMsg)
            }

Swift:封装网络框架

下面开始逐步封装:

猜你喜欢

热点阅读