【XE2V项目收获系列】五、面向协议编程与操作自动化──以实现刷新自动化为例

微信扫一扫,分享到朋友圈

【XE2V项目收获系列】五、面向协议编程与操作自动化──以实现刷新自动化为例

前言

Swift 语言的一大亮点就是支持面向协议编程(POP),相比于传统的面向对象编程(OOP),POP 有诸多优点,比如,喵神在其文章 《面向协议编程与 Cocoa 的邂逅 (上)》
中提到,POP 解决了 OOP 的动态派发安全性与横切关注点的问题,并在一定程度上避免了 OOP 中的菱形缺陷。POP 的优势不止于此,它还有着天生的自动化基因。思考一下,协议的作用是什么? 协议规范了组件的行为与特征
;自动化又是什么呢? 自动化就是将有着特定行为与特征的组件以恰当的方式组合起来
。所以, 我们可以以恰当的方式组合协议化的组件以实现自动化
。接下来,我会以刷新为例,介绍如何通过使用协议最终实现刷新操作的自动化。

一、简化 UITableView 的创建及配置过程

当一个页面有多种 cell 时,注册及配置 cell 需要写很多重复的代码,有没有方法简化这一过程?让我们先来观察一下注册方法:

tableView.register(ACell.self, forCellReuseIdentifier: "ACell")
tableView.register(BCell.self, forCellReuseIdentifier: "BCell")
tableView.register(CCell.self, forCellReuseIdentifier: "CCell")
tableView.register(DCell.self, forCellReuseIdentifier: "DCell")
复制代码

register(_:forCellReuseIdentifier:)
方法需要提供两个参数── cell 的类型和与 cell 对应的重用标识符。既然重用标识符与 cell 类型是一一对应的,直接给 cell 添加一个类型属性当作它的重用标识符好了。基于此,我们定义 ReusableView
协议。

  • ReusableView

public protocol ReusableView { }
extension ReusableView {
public static var reuseIdentifier: String {
return String(describing: self)
}
}
extension UITableViewCell: ReusableView { }
复制代码
  • NibView

当 cell 以 nib 方式创建时,注册方式有所不同,为此,我们定义 NibView
协议:

public protocol NibView { }
extension NibView where Self: UIView {
public static var nib: UINib {
return UINib(nibName: String(describing: self), bundle: nil)
}
}
extension UITableViewCell: NibView { }
复制代码

于是,注册 cell 时可以这么写:

tableView.register(ACell.self, forCellReuseIdentifier: ACell.reuseIdentifier)
复制代码

注册 cell 时只需提供它的类型即可。

  • 扩展 UITableView

接下来,为了解决注册方法需要重复书写的问题,我们给 UITableView 添加扩展方法:

extension UITableView {
public func registerCells(with cells: [UITableViewCell.Type]) {
for cell in cells {
register(cell, forCellReuseIdentifier: cell.reuseIdentifier)
}
}
public func registerNibs(with cells: [UITableViewCell.Type]) {
for cell in cells {
register(cell.nib, forCellReuseIdentifier: cell.reuseIdentifier)
}
}
}
复制代码

从而,注册多个类型的 cell 变得相当简洁:

tableView.registerCells(with: [ACell.self, BCell.self])
tableView.registerNibs(with: [CCell.self, DCell.self])
复制代码

另一个出现重复代码的地方在 tableView(_:cellForRowAt:)
方法中。当页面有多类 cell 时,我们可能这么写:

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
switch indexPath.section {
case 0:
let cell = tableView.dequeueReusableCell(withIdentifier: "ACell", for: indexPath) as! ACell
cell.configure(model[indexPath.section][indexPath.row])
return cell
case 1:
let cell = tableView.dequeueReusableCell(withIdentifier: "BCell", for: indexPath) as! BCell
cell.configure(model[indexPath.section][indexPath.row])
return cell
case 2:
let cell = tableView.dequeueReusableCell(withIdentifier: "CCell", for: indexPath) as! CCell
cell.configure(model[indexPath.section][indexPath.row])
return cell
case 3:
let cell = tableView.dequeueReusableCell(withIdentifier: "DCell", for: indexPath) as! DCell
cell.configure(model[indexPath.section][indexPath.row])
return cell
}
}
复制代码

能否改进这段代码?这里的关键在于, dequeueReusableCell(…)
方法要能够在不同的 identifier 下返回不同的 cell。你想到了什么?对了,Swift 5.1 推出的不透明类型正是解决这个问题的钥匙。我们只需给 UITableView 添加一个扩展:

extension UITableView {
public func dequeueReusableCell(
for indexPath: IndexPath,
with cells: [UITableViewCell.Type]
) -> some UITableViewCell {
for (index, cell) in cells.enumerated() where index == indexPath.section {
let cell = dequeueReusableCell(withIdentifier: cell.reuseIdentifier, for: indexPath)
return cell
}
fatalError()
}
}
复制代码

然后 tableView(_:cellForRowAt:)
方法中就可以这样写:

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(for: indexPath, with: [ACell.self, BCell.self, CCell.self, DCell.self])
cell.configure(model[indexPath.section][indexPath.row])
return cell
}
复制代码
  • Configurable

为了让 cell 有一个 configure(_:)
方法,需要定义一个 Configurable
协议:

@objc public protocol Configurable {
func configure(_ model: Any?)
}
extension UITableViewCell: Configurable {
open func configure(_ model: Any?) {  }
}
复制代码
  • ModelType

注册及配置过程中手写 cell 类型显得不那么优雅,因为 Model 是与页面对应的,我们可以把页面的 cell 类型当作 Model 的类型属性存储,需要时调用 Model 就可以了。为此我们定义 ModelType

public protocol ModelType {
static var tCells: [UITableViewCell.Type]? { get }
static var tNibs: [UITableViewCell.Type]? { get }
// All cell types to be registered, sort by display order
static var tAll: [UITableViewCell.Type]? { get }
// 存储所有 cell 的 model
var data: [[Any]]? { get set }
}
extension ModelType {
public static var tCells: [UITableViewCell.Type]? { nil }
public static var tNibs: [UITableViewCell.Type]? { nil }
public static var tAll: [UITableViewCell.Type]? { nil }
}
复制代码

于是,当一个 model 遵循并实现了 ModelType
,我们可以这样注册及配置 cell:

// 注册 cell
tableView.registerCells(with: SomeModel.tCells!)
tableView.registerNibs(with: SomeModel.tNibs!)
// 创建及配置 cell
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(for: indexPath, with: SomeModel.tAll!)
cell.configure(someModel.data![indexPath.section][indexPath.row])
return cell
}
复制代码

二、将各个页面的刷新操作聚合到一起

通常我们会为每个页面编写非常相似的刷新代码,这个过程中包含大量的重复,所以,一个自然的问题就是,有没有可能将刷新操作都聚合到一起呢?

什么是刷新?刷新就是,当用户发起一个动作,下拉刷新或加载更多,页面状态发生变化,伴随着网络请求等操作,最终完成刷新,页面状态稳定下来。动作、状态、操作,啊,这正是使用状态机的绝佳时机。

什么是状态机?根据维基百科的定义,它是“表示有限个状态以及在这些状态之间的转移和动作等行为的数学计算模型”。为了实现聚合刷新操作的目的,我创建了一个状态机 YLStateMachine
,它包含四个部分: StateType
ActionType
StateMachine
OperatorType
。这里我们只需关注 OperatorType

  • OperatorType

当状态发生变化时,状态机会调用 OperatorType
协议定义的方法进行一些操作。它的定义如下:

public protocol OperatorType {
associatedtype Action: ActionType
/// 开始过渡前调用
func startTransition(_ state: Action.State)
/// 过渡时调用
func transition(with action: Action, completion: @escaping (Action.State) -> Void)
/// 结束过渡后调用
func endTransition(_ state: Action.State)
}
extension OperatorType {
public func startTransition(_ state: Action.State) { }
public func endTransition(_ state: Action.State) { }
}
复制代码
  • RefreshOperator 与 DataSourceType

对于刷新来说,它的普通状态无非就是五种:初始状态、刷新中、还有更多数据未加载的稳定状态、加载更多中和数据已全部加载的稳定状态,当然还包含一个错误状态;而动作只有两种:下拉刷新与加载更多。要创建刷新状态机,关键在于实现遵循 OperatorType
协议的 RefreshOperator

RefreshOperator
的功能是进行一些刷新过程中的操作。刷新过程中要进行那些操作?嗯,它需要将请求来的数据模型赋予一个 model 拥有者,为此,我们定义一个 DataSourceType

public protocol DataSourceType {
associatedtype Model: ModelType
var model: Model? { get set }
// 用来存储更新 target 时可能需要的信息
var targetInfo: Any? { get set }
}
复制代码

接下来, RefreshOperator
可以这样定义:

open class RefreshOperator<DataSource: DataSourceType>: OperatorType {
typealias Action = RefreshAction
public var dataSource: DataSource
public init(dataSource: DataSource) {
self.dataSource = dataSource
}
open func startTransition(_ state: RefreshState) { }
open func endTransition(_ state: RefreshState) { }
/// 子类必须重写此方法
open func transition(with action: RefreshAction, completion: @escaping (RefreshState) -> Void) {
fatalError()
}
}
复制代码

要使用刷新状态机,我们需要创建一个继承自 RefreshOperator
的子类,在其中进行网络请求并处理返回的数据,所谓聚合刷新操作,就是在这里实现的,它大概是这样的:

class SomeRefreshOperator<DS: DataSourceType>: RefreshOperator<DS> {
let networkManager = NetworkManager()
var target: Target = .first(page: 1)
override func transition(with action: RefreshAction, completion: @escaping (RefreshState) -> Void) {
updateTarget(when: action)
networkManager.request(target: target) {
[unowned self] (result: Result<DS.Model, Error>) in
switch result {
case .success(let model):
switch action {
case .pullToRefresh:
self.dataSource.model = model
case .loadingMore:
// 加载更多发生在最后一个 section 中
let last = model.data!.count - 1
self.dataSource.model!.data![last] += model.data!.last!
}
// 传递刷新状态
let state: RefreshState = (model.nextPage == nil) ? .populated : .paginated
completion(state)
case .failure(let error):
completion(self.errorHandling(error))
}
}
}
func updateTarget(when: RefreshAction) {
...
}
func errorHandling(_ error: Error) -> RefreshState {
// 错误处理
...
return .error(error)
}
}
复制代码

三、实现刷新操作的自动化

  • 重新审视 RefreshOperator

观察上面的 SomeRefreshOperator
,在 transition(with:completion:)
方法中,得到数据后的处理过程是模式化的,需要自主实现的有更新 target 和错误处理。错误处理是可选的,所以需要自主实现的只剩下更新 target 一项,如果我们让 target 自己提供更新的接口, RefreshOperator
就变得完全模式化,我们不必再进行自定义。为此,我们需要定义 Target
NetworkManager

  • TargetType

有些页面并没有刷新的需求,所以 target 要有一个 isRefreshable
的只读属性,用来判断页面是否可刷新;此外, RefreshOperator
要求 target 要有一个更新自身的方法。综上, TargetType
的定义如下:

public protocol TargetType: Hashable {
/// 是否能进行下拉刷新。
var isRefreshable: Bool { get }
/// 更新 target
mutating func update(with action: RefreshAction, targetInfo: Any?)
}
extension TargetType {
public var isRefreshable: Bool { true }
public mutating func update(with action: RefreshAction, targetInfo: Any?) { }
}
复制代码
  • 更新 ModelType

说到 target,数据可能是分页的,所以我们需要更新 ModelType
,给它添加一个 nextPage
属性:

public protocol Pageable {
var nextPage: Int? { get }
}
extension Pageable {
public var nextPage: Int? { nil }
}
extension ModelType: Pageable { }
复制代码
  • NetworkManagerType

RefreshOperator
中已经给出了 networkManager 需要实现的方法,我们这里将其协议化:

public protocol NetworkManagerType {
associatedtype Target: TargetType
associatedtype Model: ModelType
associatedtype E: Error
associatedtype R
@discardableResult
func request(target: Target, completion: @escaping (Result<Model, E>) -> Void) -> R
}
复制代码
  • 重写 RefreshOperator

有了上面的基础,我们就可以对 RefreshOperator
进行重写,它的实现时这样的:

open class RefreshOperator<
DS: DataSourceType, NM: NetworkManagerType
>: OperatorType where DS.Model == NM.Model
{
public private(set) var dataSource: DS
public private(set) var networkManager: NM
public private(set) var target: NM.Target
public init(dataSource: DS, networkManager: NM, target: NM.Target) {
self.dataSource = dataSource
self.networkManager = networkManager
self.target = target
}
open func startTransition(_ state: RefreshState) { }
open func endTransition(_ state: RefreshState) { }
open func transition(with action: RefreshAction, completion: @escaping (RefreshState) -> Void) {
target.update(with: action, targetInfo: dataSource.targetInfo)
networkManager.request(target: target) {
[unowned self] (result: Result<DS.Model, NM.E>) in
switch result {
case .success(let model):
switch action {
case .pullToRefresh:
self.dataSource.model = model
case .loadingMore:
// 加载更多发生在最后一个 section 中
let last = model.data!.count - 1
self.dataSource.model!.data![last] += model.data!.last!
}
// 传递刷新状态
let state: RefreshState = (model.nextPage == nil) ? .populated : .paginated
completion(state)
case .failure(let error):
completion(self.errorHandling(error))
}
}
}
open func errorHandling(_ error: Error) -> RefreshState {
// 错误处理
// ...
return .error(error)
}
}
复制代码
  • AutoRefreshable

为了实现自动刷新,我们给 UIScrollView 添加一个自动刷新方法。有了刷新状态机,它很容易实现:

public protocol AutoRefreshable {
func setAutoRefresh<DS: DataSourceType, NM: NetworkManagerType>(
refreshStateMachine: StateMachine<RefreshOperator<DS, NM>>
) where DS.Model == NM.Model
}
extension UIScrollView: AutoRefreshable {
public func setAutoRefresh<DS: DataSourceType, NM: NetworkManagerType>(
refreshStateMachine: StateMachine<RefreshOperator<DS, NM>>
) where DS.Model == NM.Model {
if refreshStateMachine.operator.target.isRefreshable {
configRefreshHeader { [unowned self] in
refreshStateMachine.trigger(.pullToRefresh) {
// 根据刷新状态选择展示或移除 footer
switch refreshStateMachine.currentState {
case .error:
// 出错了
...
case .paginated:
// 有下一页
...
default:
// 没有下一页了
...
}
}
}
configRefreshFooter { [unowned self] in
refreshStateMachine.trigger(.loadingMore) {
// 根据刷新状态选择展示或移除 footer
switch refreshStateMachine.currentState {
case .populated:
// 没有下一页了
...
default:
...
}
}
}
} else {
// 不能进行刷新就没必要配置 header 与 footer 了
refreshStateMachine.trigger(.pullToRefresh)
}
}
}
复制代码
  • Refreshable

一个能够刷新的页面需要有些什么?首先,它需要一个可刷新的 view;其次,既然我们是以刷新状态机来进行刷新操作,它应该还需要一个刷新状态机作为属性;最后,它还需要绑定刷新状态机,以进行刷新后的数据重载操作。它长这样:

public protocol Refreshable {
associatedtype DS: DataSourceType
associatedtype NM: NetworkManagerType where DS.Model == NM.Model
var refreshStateMachine: StateMachine<RefreshOperator<DS, NM>>! { get set }
var refreshableView: UIScrollView? { get set }
func bindRefreshStateMachine()
func bindRefreshStateMachine(_ completion: @escaping () -> Void)
}
extension Refreshable where Self: UIViewController {
public func bindRefreshStateMachine() {
refreshStateMachine.completionHandler = { [weak self] in
guard
let self = self,
!self.refreshStateMachine.currentState.isError
else { return }
if let tableView = self.refreshableView as? UITableView {
tableView.separatorStyle = .singleLine
tableView.reloadData()
} else if let collectionView = self.refreshableView as? UICollectionView {
collectionView.reloadData()
}
}
}
public func bindRefreshStateMachine(_ completion: @escaping () -> Void) {
refreshStateMachine.completionHandler = { [weak self] in
guard
let self = self,
!self.refreshStateMachine.currentState.isError
else { return }
if let tableView = self.refreshableView as? UITableView {
tableView.separatorStyle = .singleLine
tableView.reloadData()
} else if let collectionView = self.refreshableView as? UICollectionView {
collectionView.reloadData()
}
completion()
}
}
}
复制代码
  • ViewModel

刷新操作涉及到 UITableViewDataSource
,由于第一步的努力,我们已经可以使这个过程模式化。我们定义 ViewModel
类做为所有页面的 viewModel 的基类:

open class ViewModel<Model: ModelType>:
NSObject,
DataSourceType,
UITableViewDataSource
{
// DataSourceType 的要求
public var model: Model?
public var targetInfo: Any?
// MARK: - UITableViewDataSource
open func numberOfSections(in tableView: UITableView) -> Int {
model == nil ? 0 : model!.data!.count
}
open func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
model == nil ? 0 : model!.data![section].count
}
open func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(for: indexPath, with: Model.tAll!)
cell.configure(model!.data![indexPath.section][indexPath.row])
return cell
}
open func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
nil
}
open func tableView(_ tableView: UITableView, titleForFooterInSection section: Int) -> String? {
nil
}
open func tableView(_ tableView: UITableView, canEditRowAt indexPath: IndexPath) -> Bool {
false
}
open func tableView(_ tableView: UITableView, canMoveRowAt indexPath: IndexPath) -> Bool {
false
}
open func tableView(_ tableView: UITableView, moveRowAt sourceIndexPath: IndexPath, to destinationIndexPath: IndexPath) {
}
open func tableView(_ tableView: UITableView, sectionForSectionIndexTitle title: String, at index: Int) -> Int {
}
open func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath) {
}
}
复制代码

然后,创建页面的 ViewModel 时我们可以这样做:

class SomeViewModel: ViewModel<SomeModel> { }
复制代码

完全不需要在里面写任何刷新的代码 。

  • TViewController

最后,由于 ViewController 中的操作大多也是模式化的,我们可以创建一个遵循 Refreshable
协议的 TViewController
为我们提供便利:

open class TViewController<DS: DataSourceType, NM: NetworkManagerType, RO: RefreshOperator<DS, NM>>: UIViewController, Refreshable where DS.Model == NM.Model {
public var refreshableView: UIScrollView? = UITableView()
public var refreshStateMachine: StateMachine<RefreshOperator<DS, NM>>!
public convenience init(refreshOperator: RO) {
self.init()
refreshStateMachine = StateMachine(operator: refreshOperator)
bindRefreshStateMachine()
}
public convenience init(refreshOperator: RO, afterRefreshed: @escaping () -> Void) {
self.init()
refreshStateMachine = StateMachine(operator: refreshOperator)
bindRefreshStateMachine(afterRefreshed)
}
open override func viewDidLoad() {
super.viewDidLoad()
guard let tableView = refreshableView as? UITableView else { return }
tableView.frame = view.bounds
tableView.separatorStyle = .none
// 防止出现多余的分割线
tableView.tableFooterView = UIView()
tableView.dataSource = refreshStateMachine.operator.dataSource as? UITableViewDataSource
if DS.Model.tCells != nil {
tableView.registerCells(with: DS.Model.tCells!)
}
if DS.Model.tNibs != nil {
tableView.registerNibs(with: DS.Model.tNibs!)
}
view.addSubview(tableView)
}
}
复制代码

你只需简单地继承它并在 viewDidLoad()
方法中调用 refreshableView
setAutoRefresh(refreshStateMachine:)
方法即可:

class SomeViewController: TViewController<SomeViewModel, NetworkManager<SomeModel>, RefreshOperator<SomeViewModel, NetworkManager<SomeModel>>> {
override func viewDidLoad() {
super.viewDidLoad()
// 一些自定义操作
...
// 开始刷新
refreshableView?.setAutoRefresh(refreshStateMachine: refreshStateMachine)
}
}
复制代码

写在最后

如果你想了解刷新自动化的更多细节,请查看 YLExtensions
YLStateMachine
YLRefreshKit
的源码。由于 ViewModel
的场景路由功能,它的实现放在了另一个库 Descomposer
中。

最后,欢迎大家拥抱面向协议编程,发掘出它的更多潜力。

微信扫一扫,分享到朋友圈

【XE2V项目收获系列】五、面向协议编程与操作自动化──以实现刷新自动化为例

好莱坞科幻电影《2067》曝预告 回到未来拯救人类

上一篇

极光财报:2020年Q2极光营收1.308亿元 同比下降55%

下一篇

你也可能喜欢

【XE2V项目收获系列】五、面向协议编程与操作自动化──以实现刷新自动化为例

长按储存图像,分享给朋友