博客> Swift MVVM 你喜欢哪种?
Swift MVVM 你喜欢哪种?
2小时前 评论:0 阅读:264 DelegateChai
ios swift MVVM

RAC or RXSwift?

   今天的主题不是这些商业级应用框架,而是小而美的MVVM实现方案:Closure AND Protocol实现MVVM

1、Closure

   运用闭包的方式,使用一个辅助工具,实现的MVVM,可以实现数据绑定,响应式编程的很大优点就是数据绑定。将主要的数据处理逻辑和请求处理都会放到viewModel里处理,辅助工具的主要任务是提供一个闭包来存储数据,在view里对闭包进行实现,viewModel里拿到数据的时候,调用闭包,实现数据的绑定。 辅助工具的实现如下:

class Observable<T>{

    typealias Observer = (T) -> ()
    var observer:Observer?

    var value:T{
        didSet{
            observer?(value)
        }
    }

    init(_ value:T) {
        self.value = value
    }

    func observer(observer:Observer?){
        self.observer = observer
        observer?(value)
    }
}

   viewModel中的数据属性,都应该是Observable类型的,T代表的是具体需要的数据的类型,在给value赋值的时候,就会对observer观察者进行调用,执行闭包,进行数据刷新。 比如Controller里有个HeadView,可以这样写HeadView的相关代码:

//View
class HeadView: UIView {

    lazy var timeLabel:UILabel = {
        let timeLabel = UILabel()
        return timeLabel
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)
        timeLabel.frame = frame
        addSubview(timeLabel)
    }

    var headViewModel:HeadViewModel?{
        didSet{
            headViewModel?.timeText.observer {
                [unowned self] in
                self.timeLabel.text = $0
            }
        }
    }
}
//Model
struct HeadModel {

    let timeText:String

}
//ViewModel
class HeadViewModel{

    var timeText:Observable<String>

    init(_ model:HeadModel) {
        self.timeText = Observable(model.timeText)
    }
}

   在Controller里,可以这样给HeadView的数据进行绑定,代码如下:

//这段代码里的viewModel是整个Controller的ViewModel,
 func addHeadView(){
        headView = HeadView(frame: CGRect(x: 0, y: 0, width: self.view.frame.width, height: headH))
       //数据绑定
        viewModel.headViewModel.observer{
            [unowned self] headViewModel in
            self.headView.headViewModel = headViewModel
        }
        view.addSubview(headView)
    }

   我这边应用的MVVM划分的比较细致,我把每个View都会给对应一个ViewModel,而且还会给ViewController对应一个ViewModel,包含所有它所拥有的View的ViewModel的数据。这样,可以让数据进行分级处理,例如:有些数据在ViewController需要稍微处理的原始数据,而在它的view的子view中需要复杂处理的数据。这个时候,就可以对不同的层次做不同的数据处理了,层次更加分明。

//比如一个Viewcontroller中有HeadView和TableView,ViewController的ViewModel会是这个样子
class ViewModel{

    let cellDatas:Observable<[CellViewModel]>
    let headViewModel:Observable<HeadViewModel xss=removed xss=removed>
    let headViewModel:Observable<HeadViewModel xss=removed xss=removed>()){
        self.getData { model in
            let cellViewModel = model.cellModels.map({ cellModel in
                return CellViewModel(cellModel)
            })
            headViewModel.value = HeadViewModel(model.headModel)
            cellDatas.value = cellViewModel
            completion()
       }
   //数据清洗
    func  dataCleaning(){

     } 
} 

   目前,在我的项目中,并没有大规模的使用的这样的方式,这个东西会大量地使用闭包,所以会有大量的闭包在堆里,造成内存增高。所以,推荐通用的View或组件会使用这种方式MVVM的方式,会很适合。

2、Protocol

   基于Protocol来实现的MVVM解耦合,这个方式是以组合协议的方式来构成ViewModel。在这之前,需要先说明下组合的优点,一些老司机会说:组合优于继承。那么,相比较于组合,继承有什么缺点呢?    (1)继承会产生god class,这是代码中的毒瘤,试图集成很多的功能,像是ViewController基类中的loadView一样,当这个类的功能越来越多的时候,这个类就会变得难以维护,很明显的违反了我们代码中单一功能的原则。组合能够帮助我们去处这些god class。    (2)破坏封装,子类与父类之间紧密耦合,子类依赖于父类的实现,子类缺乏独立性。组合,每个都是功能点都是独立的。在Swift中,我们能使用Swift的特性-协议,来更好地实现组合。    (3)不支持动态继承,在运行时,子类无法选择不同的父类。而使用组合,我们可以选择我们想要的功能点。    所以,组合比继承更具灵活性和稳定性,在程序设计的时候优先使用组合会比较好。    在组合Protocol中,我会将一个试图拆分成更小的基本单位。例如,一个cell中有tltle、subtitle和image,就可以拆分出三个个协议出来,再给这几个协议添加默认实现,例如这样子的协议。    

protocol LabelPresentable {
    var title:String{get}
    var titleColor:UIColor {get}
    func updataLabelData(_ titleLable:UILabel)
}
extension LabelPresentable  {
    var titleColor:UIColor{
        return UIColor.blue
    }
    func updataLabelData(_ titleLable:UILabel){
        titleLable.text = title
        titleLable.textColor = titleColor
    }
}
protocol ImageViewPresentable {
    var imageName:String{get}
    func updataImageViewData(_ imageView:UIImageView)
}
extension ImageViewPresentable{
    func updataImageViewData(_ imageView:UIImageView){
        imageView.image = UIImage(named:imageName)
    }
}
protocol SubLabelPresentable {
    var subTitle:String{get}
    var subTitleColor:UIColor {get}
    func updataSublabelData(_ subTitleLable:UILabel)
}
extension SubLabelPresentable{
    var subTitleColor:UIColor{
        return UIColor.red
    }
    func updataSublabelData(_ subTitleLable:UILabel){
        subTitleLable.text = subTitle
        subTitleLable.textColor = subTitleColor
    }
}

   这样,一些公共的实现就添加到了协议里面,只要某个类遵守这些协议,就能够拥有这些属性和功能了。ViewModel是这样实现的:

protocol CustomCellProtocol: LabelPresentable,ImageViewPresentable,SubLabelPresentable{}
class CellViewModel:CustomCellProtocol{

    var title: String
    var imageName: String
    var subTitle:String//比上面的多了一个属性
    init(_ model:CellModel) {
        //处理数据逻辑
        self.title = model.lableOneText
        self.imageName = model.imageAdress
        self.subTitle = model.lableTwoText
    }
}

   先将需要用到的协议可以组合起来,形成一个大的协议CustomCellProtocol,实现协议必须要实现的属性。具体到cell中的实现,就很简单了,在cell中添加一个遵守CustomCellProtocol协议的属性,数据传递过来后,更新显示就好了:

 var customCellModel:CustomCellProtocol?{
        didSet{
            customCellModel?.updataImageViewData(self.imageView!)
            customCellModel?.updataLabelData(self.textLabel!)
            customCellModel?.updataSublabelData(self.detailTextLabel!)
        }
    }

   这样的MVVM将显示层拆分成粒子化的Protocol,构成更加复用的单个Protocol或者是组合 Protocol,可以将通用的Label或者是Image组合起来,每一个View都可以作为一个插件使用,极大地增加了view的复用性。适合于一些公用组建的抽取,模块化。但是,自我感觉,要大规模的应用还是要踩不少的坑的。我在写Demo的时候就踩了不少的坑,感觉坑还不会少

收藏
0
sina weixin mail 回到顶部