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，更便于开发
网友评论