RxSwiftSwift开发进阶Alamofire

Swift - 面向协议编程(POP)

2019-09-23  本文已影响0人  Cooci_和谐学习_不急不躁

一、OOP与POP

面向对象程序设计 (Object Oriented Programming) 其本质是以建立模型体现出来的抽象思维过程和面向对象的方法。模型是用来反映现实世界中事物特征的。任何一个模型都不可能反映客观事物的一切具体特征,只能对事物特征和变化规律的一种抽象,且在它所涉及的范围内更普遍、更集中、更深刻地描述客体的特征。通过建立模型而达到的抽象是人们对客体认识的深化。来自百度百科

正是因为化零为整的功效,方便储存数据然后传输! 面向对象的设计,在众多语言里面被采用!OC - Swift 主流方式也是 OOP. 这个相比大家已经非常熟悉了,这里也不再啰嗦。今天的主角是 POP (Protocol Oriented Programming) 一 面向协议编程

面向对象的困境

王巍面向协议编程 这一篇文章里面就有详细表达!

二、POP 面向协议编程

面向协议编程的思维,在 Swift 开发中非常非常重要!可以说如果你用好了 POP 那么你的项目绝对逼格不是一个 level 下面我们通过解决 OOP 问题的思路展开分析

POP 解决横切关注点

横切关注点 (Cross-Cutting Concerns) 那就是我们很难在不同继承关系的类里共用代码! 现在我们通过面向协议的方式,任何遵循协议的,都可以默认添加 name属性以及sayHello()方法!

protocol LGProtocl {
    /// 协议属性
    var name: String {get}
    /// 协议方法
    func sayHello()
}
struct LGTeacher: LGProtocl{
    var name: String
    func sayHello() {
        print("你好")
    }
}

这样的操作有什么作用了? 一 万物皆 lg

// 声明协议
extension LGCompatible {
    /// Reactive extensions.
    public static var lg: LGRxSwift.Reactive<Self>.Type
    /// Reactive extensions.
    public var lg: LGRxSwift.Reactive<Self>
}
// NSObject 实现
extension NSObject : LGCompatible { }

POP 解决动态派发安全性

对于没有实现 LGProtocl 的类型,编译器将返回错误,因此不存在消息误发送的情况

// Compiler Error: 
// 'LGTeacher' does not conform to protocol 'LGProtocl'
// protocol requires function 'sayHello()'

POP 解决菱形缺陷

最后我们看看多继承。多继承中存在的一个重要问题是菱形缺陷,也就是子类无法确定使用哪个父类的方法。在协议的对应方面,这个问题虽然依然存在,但却是可以唯一安全地确定的。

这里很遗憾POP在 解决菱形缺陷 这一点上也存在同样的BUG , 因为多个协议存在相同的协议属性、协议方法,遵循者也是无法确定的!⚠️ 我们在平时开发中一定要尽量规避同名协议遵循问题,我们在模块划分上面一定要做做到彻底,尽管 Swift 还不能很好地处理多个协议的冲突 但是我们可以在协议层功能抽层严格机智处理上浮与下沉功能。

举个例子:🌰

extension LGReactiveCompatible {
    /// Reactive extensions.
    public static var lg: Reactive<Self>.Type {
        get { return Reactive<Self>.self }
        set {// this enables using Reactive to "mutate" base type }
    }
    /// Reactive extensions.
    public var lg: Reactive<Self> {
        get { return Reactive(self) }
        set { // this enables using Reactive to "mutate" base object }
    }
}
public struct Reactive<Base> {
    public let base: Base
    public init(_ base: Base) {
        self.base = base
    }
}

相信到这里你已经感受到了面向协议编程的方便之处,但是还有一个非常重要的特性没有展现出来就是 一 耦合度大大降低,代码分层,逻辑更清晰

三、POP 网络

我们在实际开发中,网络请求是一个非常重要的模块

Alamofire.request("http://127.0.0.1:5000/pythonJson/")
    .validate(statusCode: 200..<300)
    .validate(contentType: ["application/json"])
    .responseData { response in
        switch response.result {
        case .success:
            print(response)
            let _ = LGLoginClient.lgJson(data: response.data)
        case .failure(let error):
            print(error)
        }
}

1️⃣:网络信息能力

enum LGHTTPMethod: String {
    case GET
    case POST
}

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

2️⃣:模块信息层

struct LGLoginRequest: LGRequest {
    typealias Response = LGPerson
    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] = [:]
    
    func parse(data: Data) -> LGPerson? {
        return LGPerson(data: data)
    }
}

3️⃣:网络请求能力

extension LGRequest {
    func send(handler: @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 res = self.parse(data: data) {
                DispatchQueue.main.async { handler(res) }
            } else {
                DispatchQueue.main.async { handler(nil) }
            }
        }
        task.resume()
    }
}

4️⃣:应用层调用

override func viewDidLoad() {
    super.viewDidLoad()
    let request = LGPersonRequest(name: "Cooci")
    request.send { (person) in
        self.updataUI(person: person!)
    }
}

5️⃣:POP网络优化重构

很显然我们的 LGRequest 这个家伙的能力太强了!能提供信息,还能发起请求,连序列化的处理能力也是由LGRequest提供!优化重构迫在眉睫。。。。

1:信息提供能力者

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

struct LGPersonRequest: LGRequest {
    typealias Response = LGPerson
    
    let name: String
    var path: String {
        return "/pythonJson/getTeacherInfo/?username=\(name)"
    }
    let method: LGHTTPMethod = .GET
    let parameter: [String: Any] = [:]
}
protocol ClientProtocol {
    var host: String { get }
    func send<T: LGRequest>(_ r: T, handler: @escaping (T.Response?) -> Void)
}


class LGClient: ClientProtocol{
    static let manager = LGClient()
    let host: String = "http://127.0.0.1:5000"
    
    func send<T>(_ r: T, handler: @escaping (T.Response?) -> Void) where T : LGRequest {
        
        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 res = T.Response.parse(data: data) {
                DispatchQueue.main.async { handler(res) }
            } else {
                DispatchQueue.main.async { handler(nil) }
            }
        }
        task.resume()
    }
}

2:网络能力提供者

class LGLoginClient: LGClient {
    
    override func send<T>(_ r: T, handler: @escaping (T.Response?) -> Void) where T : LGRequest {
        
        switch r.path {
        case let string where string.contains("/pythonJson/getTeacherInfo"):
            print("123456")
            handler(nil)
        default:
            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 res = T.Response.parse(data: data) {
                    DispatchQueue.main.async { handler(res) }
                } else {
                    DispatchQueue.main.async { handler(nil) }
                }
            }
            task.resume()
        }

    }
}

3:序列化能力提供层

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

6️⃣:小结

由于篇幅问题,这一篇面向协议编程,我们先介绍到这里!下一篇介绍 当Moya遇上RxSwift,当北京遇上西雅图,当 Moya 遇上 RxSwift,简直不要太爽!

就问此时此刻还有谁?45度仰望天空,该死!我这无处安放的魅力!

上一篇下一篇

猜你喜欢

热点阅读