iOS => Architettura MVP

introduzione

MVP è un modello architettonico, una derivazione del Model-View-Controller. È rappresentato da tre componenti distinti: Modello, Visualizza e Presentatore. È stato progettato per facilitare i test unitari automatizzati e migliorare la separazione delle preoccupazioni nella logica di presentazione.

Negli esempi troverai un semplice progetto costruito pensando al pattern MVP.

Osservazioni

componenti:

Il modello è un'interfaccia responsabile per i dati del dominio (da visualizzare o altrimenti applicata nella GUI)
La vista è responsabile del livello di presentazione (GUI)
Presenter è "l'uomo medio" tra Modello e Vista. Reagisce alle azioni dell'utente eseguite sulla vista, recupera i dati dal modello e li formatta per la visualizzazione nella vista

Funzioni del componente:

Modello	vista	Presentatore
Comunica con il livello DB	Rende i dati	Esegue query sul modello
Alzare gli eventi appropriati	Riceve gli eventi	Formatta i dati dal modello
	Logica di validazione molto semplice	Invia dati formattati alla vista
		Logica di convalida complessa

Differenze tra MVC e MVP :

La vista in MVC è strettamente accoppiata al controller, la parte View dell'MVP è composta da UIViews e UIViewController
MVP View è il più stupido possibile e non contiene quasi nessuna logica (come in MVVM), MVC View ha alcune logiche di business e può interrogare il Modello
MVP View gestisce i gesti dell'utente e delega l'interazione al Presenter, in MVC il Gestore gestisce gesti e comandi Modello
Il modello MVP supporta molto il test delle unità, MVC ha un supporto limitato
MVC Controller ha molte dipendenze UIKit, MVP Presenter non ne ha

Professionisti:

MVP rende UIViewController una parte del componente View è stupido, passivo e ... meno massiccio;]
La maggior parte della logica aziendale è incapsulata a causa delle viste stupide, questo offre un'eccellente testabilità. È possibile introdurre oggetti fittizi per testare la parte del dominio.
Le entità separate sono più facili da tenere a mente, le responsabilità sono chiaramente divise.

Contro

Scriverò più codice.
Barriera per sviluppatori inesperti o per coloro che non lavorano ancora con il modello.

Dog.swift

import Foundation

enum Breed: String {
    case bulldog  = "Bulldog"
    case doberman = "Doberman"
    case labrador = "Labrador"
}

struct Dog {
    let name:  String
    let breed: String
    let age:   Int
}

DoggyView.swift

import Foundation

protocol DoggyView: NSObjectProtocol {
    func startLoading()
    func finishLoading()
    func setDoggies(_ doggies: [DoggyViewData])
    func setEmpty()
}

DoggyService.swift

import Foundation

typealias Result = ([Dog]) -> Void

class DoggyService {

    func deliverDoggies(_ result: @escaping Result) {
        
        let firstDoggy  = Dog(name: "Alfred", breed: Breed.labrador.rawValue, age: 1)
        let secondDoggy = Dog(name: "Vinny",  breed: Breed.doberman.rawValue, age: 5)
        let thirdDoggy  = Dog(name: "Lucky",  breed: Breed.labrador.rawValue, age: 3)

        let delay = DispatchTime.now() + Double(Int64(Double(NSEC_PER_SEC)*2)) / Double(NSEC_PER_SEC)
        
        DispatchQueue.main.asyncAfter(deadline: delay) {
            result([firstDoggy,
                    secondDoggy,
                    thirdDoggy])
        }
    }
}

DoggyPresenter.swift

import Foundation

class DoggyPresenter {

    // MARK: - Private
    fileprivate let dogService: DoggyService
    weak fileprivate var dogView: DoggyView?

    init(dogService: DoggyService){
        self.dogService = dogService
    }

    func attachView(_ attach: Bool, view: DoggyView?) {
        if attach {
            dogView = nil
        } else {
            if let view = view { dogView = view }
        }
    }

    func getDogs(){
        self.dogView?.startLoading()
    
        dogService.deliverDoggies { [weak self] doggies in
            self?.dogView?.finishLoading()
        
        if doggies.count == 0 {
            self?.dogView?.setEmpty()
        } else {
            self?.dogView?.setDoggies(doggies.map {
                return DoggyViewData(name: "\($0.name) \($0.breed)",
                                      age: "\($0.age)")
                })
            }
        }
    }
}

struct DoggyViewData {
    let name: String
    let age:  String
}

DoggyListViewController.swift

import UIKit

class DoggyListViewController: UIViewController, UITableViewDataSource {

    @IBOutlet weak var emptyView: UIView?
    @IBOutlet weak var tableView: UITableView?
    @IBOutlet weak var spinner:   UIActivityIndicatorView?

    fileprivate let dogPresenter = DoggyPresenter(dogService: DoggyService())
    fileprivate var dogsToDisplay = [DoggyViewData]()

    override func viewDidLoad() {
        super.viewDidLoad()
    
        tableView?.dataSource = self
        spinner?.hidesWhenStopped = true
        dogPresenter.attachView(true, view: self)
        dogPresenter.getDogs()
    }

    // MARK: DataSource
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return dogsToDisplay.count
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = UITableViewCell(style: .subtitle, reuseIdentifier: "Cell")
        let userViewData = dogsToDisplay[indexPath.row]
        cell.textLabel?.text = userViewData.name
        cell.detailTextLabel?.text = userViewData.age
        return cell
    }
}

extension DoggyListViewController: DoggyView {

    func startLoading() {
        spinner?.startAnimating()
    }

    func finishLoading() {
        spinner?.stopAnimating()
    }

    func setDoggies(_ doggies: [DoggyViewData]) {
        dogsToDisplay = doggies
        tableView?.isHidden = false
        emptyView?.isHidden = true;
        tableView?.reloadData()
    }

    func setEmpty() {
        tableView?.isHidden = true
        emptyView?.isHidden = false;
    }
}

Modified text is an extract of the original Stack Overflow Documentation

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

iOS
Architettura MVP

Ricerca…