Swift底层进阶--016：Moya

Moya典型的特性是面向协议编程（Protocol Oriented Programming即：POP），相比面向对象编程（Object Oriented Programming即：OOP）更加灵活

面向对象编程

class LGPerson: NSObject {
    var subject:String { return "LGPerson" }
    func study(){
        print("\(subject) 非常牛逼")
    }
    func eat(){
        print("肉")
    }
}

class LGTeacher: LGPerson {
    override var subject: String {return "LGTeacher"}
    override func eat() {
        print("🍑")
    }
}

面向对象编程中，遇到相同的功能一般采用以下这几方式实现：

• 拷贝：将相同功能的代码直接拷贝一份，这种令人发指的方式必然会增加冗余代码，使得项目难以维护
• 多继承：继承从代码复用的角度来说特别好用，但也特别容易被滥用。不恰当的使用继承导致的最大问题就是高耦合。且OC和Swift中都无法直接使用多继承
• 封装：日常开发最为常用的方式，例如将相同功能代码抽取成类库
• 动态派发：例如Runtime，这种方式安全性有缺陷，如果字符串拼写错误，编译时感觉不到，运行时造成程序崩溃

面向协议编程

protocol LGUIProtocol {
    func setUI()
}

extension LGUIProtocol{
    func setUI(){
        print("\(self) 刷新界面")
    }
}

extension LGPOPViewController: LGUIProtocol{}
extension LGStudent: LGUIProtocol{}

class LGPOPViewController: UIViewController {
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        let vc = ViewController()
        vc.setUI()
        let st = LGStudent()
        st.setUI()
    }
}

class LGStudent: LGPerson {}

• 声明LGUIProtocol协议，定义setUI方法
• 声明LGUIProtocol扩展，对setUI方法添加默认实现
• 声明LGPOPViewController和LGStudent扩展，遵循LGUIProtocol协议
• LGPOPViewController和LGStudent没有任何继承关系，也不具备任何关联性，但是它们都具备setUI的能力

架构的本质是高内聚，低耦合。
在面向对象编程中，很多模块具备相同模块区域，或者面临两个模块相互通信时，必然会导致模块间的依赖性越来越高。
使用面向对象编程时，可以将相同模块区域或模块间通信代码抽取为协议，将面向对象变成面试协议，从而让两个模块间的耦合度无限降低。

案例1：POP网络

解决ViewController对网络层的依赖，抽取网络请求协议Rquest层

LGPerson.swift

定义LGPerson结构体，通过init?(data: Data)方法进行数据解析

import Foundation

struct LGPerson {
    let name: String
    let iconName: String
    let age: String
    let hobby: String
    let petPhrase: String
    
    init?(data: Data) {
        guard let obj = try? JSONSerialization.jsonObject(with: data, options: .allowFragments) as? [String: Any] else {
            return nil
        }
        guard let name = obj["name"] as? String else {
            return nil
        }
        guard let iconName = obj["iconName"] as? String else {
            return nil
        }
        guard let age = obj["age"] as? String else {
            return nil
        }
        guard let hobby = obj["hobby"] as? String else {
            return nil
        }
        guard let petPhrase = obj["petPhrase"] as? String else {
            return nil
        }
        self.name = name
        self.iconName = iconName
        self.age = age
        self.hobby = hobby
        self.petPhrase = petPhrase
    }
}

LGRequest.swift

抽取网络请求协议

定义LGHTTPMethod枚举类型

enum LGHTTPMethod: String {
    case GET
    case POST
}

定义LGRquestProtocol协议，有一个parse(data:Data)方法，具备模型解析能力

protocol LGRquestProtocol {
    var host: String { get }
    var path: String { get }
    var method: LGHTTPMethod { get }
    var parameter: [String : Any] { get }
    
    associatedtype Response
    func parse(data:Data) -> Response?
}

定义LGRquestProtocol扩展，实现网络请求send方法

extension LGRquestProtocol{
    func send(handle: @escaping (Response?) -> Void) {
        let url = URL(string: host.appending(path))!
        var request = URLRequest(url: url)
        request.httpMethod = method.rawValue
        let task = URLSession.shared.dataTask(with: request){
            (data,response,error) in
            if let data = data, let resp = self.parse(data: data) {
                DispatchQueue.main.async {
                    handle(resp)
                }
            }else{
                DispatchQueue.main.async {
                    handle(nil)
                }
            }
        }
        task.resume()
    }
}

定义LGLoginRequest结构体，遵循LGRquestProtocol协议，并实现协议的parse(data: Data)方法

struct LGLoginRequest: LGRquestProtocol {
    let name: String
    
    let host = "http://127.0.0.1:5000"
    var path: String {
        return "/pythonJson/getTeacherInfo/?username=\(name)"
    }
    let method: LGHTTPMethod = .GET
    let parameter: [String : Any] = [:]
    
    typealias Response = LGPerson
    
    func parse(data: Data) -> LGPerson? {
        return LGPerson(data: data)
    }
}

ViewController.swift

VC中使用LGLoginRequest进行网络请求，并更新UI

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var imageView: UIImageView!
    @IBOutlet weak var nickName: UILabel!
    @IBOutlet weak var ageLabel: UILabel!
    @IBOutlet weak var hobbyLabel: UILabel!
    @IBOutlet weak var petPhraseLabel: UILabel!
    
    override func viewDidLoad() {
        super.viewDidLoad()

        LGLoginRequest(name: "Zang").send { (person) in
            self.updataUI(person: person!)
        }
    }

    func updataUI(person: LGPerson){
        imageView.image = UIImage(named: person.iconName)
        nickName.text   = person.name
        ageLabel.text   = person.age
        hobbyLabel.text = person.hobby
        petPhraseLabel.text = person.petPhrase
    }
}

上述案例，将网络请求代码下沉，交给LGRquest负责，解决VC对网络层的依赖，使得VC层轻量化、明确化。

此时又引发另一个问题，ViewController内的网络请求代码虽然被下沉，导致Rquest层越来越臃肿，难以维护。

案例2：POP网络重构

案例1中Rquest层包含接口参数的提供、请求接口的能力、模型解析的能力，导致Rquest层过于臃肿。

想要解决问题，我们必须将代码层次划分的更加清晰。将不同能力交给各自的代码层负责，让每一层只具备单一职责。

LGPerson.swift

让模型具备模型解析能力

定义LGDecodable协议，有一个parse(data:Data)方法，具备模型解析能力

protocol LGDecodable {
    static func parse(data: Data) -> Self?
}

定义LGDecodable扩展，实现模型解析parse方法

extension LGPerson: LGDecodable{
    static func parse(data: Data) -> LGPerson? {
        return LGPerson(data: data)
    }
}

LGRequest.swift

让LGRequest只负责接口参数的提供

修改LGRquestProtocol协议，只保留接口相关参数，由于host属性基本不会修改，从提供层去除，放到网络请求层

protocol LGRquestProtocol {
    var path: String { get }
    var method: LGHTTPMethod { get }
    var parameter: [String : Any] { get }
    
    associatedtype Response: LGDecodable
}

修改LGLoginRequest结构体，依然遵循LGRquestProtocol协议，但它仅负责接口参数的提供

struct LGLoginRequest: LGRquestProtocol {
    let name: String
    
    var path: String {
        return "/pythonJson/getTeacherInfo/?username=\(name)"
    }
    let method: LGHTTPMethod = .GET
    let parameter: [String : Any] = [:]
    
    typealias Response = LGPerson
}

LGClient.swift

让LGClient负责网络请求

定义LGClientProtocol协议，有一个send<T: LGRquestProtocol>(_ r: T, handler: @escaping (T.Response?) -> Void)方法，具备网络请求能力

protocol LGClientProtocol {
    func send<T: LGRquestProtocol>(_ r: T, handler: @escaping(T.Response?) -> Void)
}

定义LGClient类，遵循LGClientProtocol协议，采用单例模式，内置host属性并实现网络请求send方法

class LGClient: LGClientProtocol {
    let host: String = "http://127.0.0.1:5000"
    
    private init(){}
    static let manager = LGClient()
    
    func send<T: LGRquestProtocol>(_ r: T, handler: @escaping(T.Response?) -> Void) {
        let url = URL(string: host.appending(r.path))!
        var request = URLRequest(url: url)
        request.httpMethod = r.method.rawValue
        let task = URLSession.shared.dataTask(with: request){
            (data,response,error) in
            if let data = data, let resp = T.Response.parse(data: data) {
                DispatchQueue.main.async { handler(resp) }
            }else{
                DispatchQueue.main.async { handler(nil) }
            }
        }
        task.resume()
    }
}

• 入参r定义为泛型，让其更具有通用性
• r即是Rquest接口参数提供层
• 逃逸闭包内的T.Response即是Model模型层
• 接口路径path，请求方式method都来自于r
• 模型解析parse方法来自于T.Response

ViewController.swift

修改VC中网络层的使用方式

override func viewDidLoad() {
    super.viewDidLoad()

    let provide = LGLoginRequest(name: "Zang")

    LGClient.manager.send(provide) { (person) in
        self.updataUI(person: person!)
    }
}

• 业务数据处理到请求的提供层provide
• 通过LGClient请求网络，返回模型对象

经过案例2的重构，各模块之间分工明确，职责单一，易于维护
调用逻辑：VC层 -> Request信息提供层 -> Client网络请求层 -> Model模型层

案例3：Moya

Moya基于Alamofire的更高层网络请求封装抽象层。它可以对项目中的所有请求进行集中管理，方便开发与维护

常规网络层在iOS应用中很常见。它们之所以不好，有几个原因：

• 编写新应用程序变得困难（“我从哪里开始？”）
• 难以维护现有的应用程序（“哦，天哪，这个烂摊子……”）
• 编写单元测试变得很困难（“我该怎么做？”）

而Moya的思想是，将网络抽象层进行封装直接调用Alamofire层。它应该足够简单，让普通的事物变得简单。同时它应该足够全面，让复杂的事物也变得简单

Moya一些令人敬畏的功能：

• 编译时检查API端点访问是否正确
• 允许定义不同端点与关联枚举值的明确用法
• 将测试存根视为一等公民，因此单元测试非常容易

通过下面的案例了解一下Moya

LGLoginAPI.swift

信息提供层

定义LGLoginAPI枚举类型

public enum LGLoginAPI {
    case login(String, String, String)  // 登录接口
    case smscode(String)                // 登录，发送验证码
    case otherRequest                   // 其他接口,没有参数
}

定义LGLoginAPI扩展，遵循TargetType协议
TargetType协议由Moya提供，用于定义MoyaProvider所需规范的协议

extension LGLoginAPI: TargetType{
    //服务器地址
    public var baseURL: URL {
        return URL(string:"http://127.0.0.1:5000/")!
    }
    
    // 各个请求的具体路径
    public var path: String {
        switch self {
            case .login:
                return "login/"
            case .smscode:
                return "login/smscode/"
            case .otherRequest:
                return "login/otherRequest/"
        }
    }
    
    // 请求方式
    public var method: Moya.Method {
        switch self {
            case .login:
                return .post
            case .smscode:
                return .post
            default:
                return .get
        }
    }
    
    //这个就是做单元测试模拟的数据，只会在单元测试文件中有作用
    public var sampleData: Data {
        return "{}".data(using: String.Encoding.utf8)!
    }
    
    //请求任务事件（附带上参数）
    public var task: Task {
        var param:[String:Any] = [:]

        switch self {
            case .login(let username,let password,let smscode):
                param["username"] = username
                param["password"] = password
                param["smscode"] = smscode
            case .smscode(let username):
                param["username"] = username
            default:
                return .requestPlain
        }
        
        return .requestParameters(parameters: param, encoding: URLEncoding.default)
    }
    
    //设置请求头
    public var headers: [String: String]? {
        return nil
    }
}

上述代码，提供了各自接口所需路径、请求方式、接口参数等信息

LGLoginClient.swift

网络请求层

定义login登录方法和smscode发送验证码方法

private override init() {}
static let manager = LGLoginClient()

func login(username: String, password: String, smscode: String) {
    let provide = MoyaProvider<LGLoginAPI>()
    provide.request(.login(username, password, smscode)) { (result) in
        switch result{
        case let .success(response):
            let _ = LGLoginClient.lgJson(data: response.data)
        case let .failure(error):
            print(error)
        }
    }
}

func smscode(username: String, complete: @escaping((String) -> Void)) {
    let provide = MoyaProvider<LGLoginAPI>()
    provide.request(.smscode(username)) { (result) in
        switch result{
        case let .success(response):
            let dict = LGLoginClient.lgJson(data: response.data)
            complete(dict["smscode"] as! String)
        case let .failure(error):
            print(error)
            complete("")
        }
    }
}

ViewController.swift

VC层

在VC层只使用LGLoginClient指定方法即可，连信息提供层也不用对VC暴露了

override func viewDidLoad() {
    super.viewDidLoad()
}

@IBAction func didClickLoginBtn(_ sender: Any) {
    
    guard let username = usernameTF.text else {
        print("账户不可为空")
        return
    }
    guard let password = passwordTF.text else {
        print("账户不可为空")
        return
    }
    guard let smscode = smscodeTF.text else {
        print("账户不可为空")
        return
    }

    LGLoginClient.manager.login(username:username, password: password, smscode: smscode)
}

@IBAction func didClickCodeBtn(_ sender: Any) {
    guard let username = usernameTF.text else {
        print("账户不可为空")
        return
    }

    LGLoginClient.manager.smscode(username: username) { [weak self](smscode) in
        self?.smscodeTF.text = smscode
    }
}

案例5：Moya+RxSwift

Rx是ReactiveX的缩写，是一个用观察者模式开发异步和基于事件编程的库。用于简化异步编程方法，并提供更优雅更安全的数据绑定

Rx的特性：

• 响应及时：对UI界面事件操作及获取数据、属性改变，能够立即作出响应
• 编码简洁：对于传统事件传递和代理方法做了统一处理，例如KVO、Notification、Dlelgate
• 操作安全：不用担心内存问题，Rx统一进行DisposeBag()的销毁处理
• 优雅绑定：Rx实现数据的优雅绑定，结合Moya使用让代码层次更鲜明

在案例4中，其实还缺少严重的一步，那就是模型化。当结合RxSwift才使得整个架构层次更加完善

通过下面的案例，了解RxSwift和Moya的结合

LGModel.swift

模型层

定义LGUserModel模型，遵循HandyJSON协议

class LGUserModel: HandyJSON {
    var username: String = ""
    var password: String = ""
    required init() {}
}

LGLoginClient.swift

网络请求层

定义Response扩展，将data转为模型

extension Response {
    func mapModel<T: HandyJSON>(_ type: T.Type) -> T {
        // 容错,没有数据返回!
        if data.count < 1 {
            print("序列化-模型化不了")
            if let emptyValue = JSONDeserializer<T>.deserializeFrom(json: "{}"){
                return emptyValue
            } else if let emptyValue = JSONDeserializer<T>.deserializeFrom(json: "[{}]"){
                return emptyValue
            }
        }
        // 获取请求response的data转成json
        let jsonString = String.init(data: data, encoding: .utf8)
        if let model = JSONDeserializer<T>.deserializeFrom(json: jsonString) {
            return model
        }
        return JSONDeserializer<T>.deserializeFrom(json: "{\"status\":\"请求有误\"}")!
    }
}

定义ObservableType扩展，限定条件E必须为Response类型，将模型转为单个模型信号

extension ObservableType where E == Response {
     public func mapModel<T: HandyJSON>(_ type: T.Type) -> Observable<T> {
        return flatMap({ (response) -> Observable<T> in
            return Observable.just(response.mapModel(T.self))
        })
    }
}

定义otherRequest方法，通过rx.request进行网络请求，返回Single<Response>单个信号。使用mapModel方法转为LGUserModel模型，通过逃逸闭包返回

func otherRequest(complete: @escaping ((LGUserModel) -> Void)) {    
        let provide = MoyaProvider<LGLoginAPI>()
        _ = provide.rx.request(.otherRequest).asObservable()
            .mapModel(LGUserModel.self)
            .subscribe(onNext: { (userModel) in
                complete(userModel)
            })
    }

总结

• pop解决VC层的臃肿，将网络请求从VC层下沉到Rquest层
• 避免Rquest层的臃肿，将其拆分，增加Client网络请求层，Rquest层作为数据提供层，面向VC层
• 使用Moya让网络请求层、数据提供层、业务层变得更加清晰
• 使用Moya+RxSwift函数响应式编程，可以直接绑定响应UI，更便于开发