Согласно последнему опросу российских команд iOS разработки made by iOS Good Reads, архитектура MVVM занимает лидирующую строчку в хит-параде, этого подхода придерживаются 59% опрошенных. А как известно, наиболее частый спутник MVVM - реактивный подход. Наша команда Upstarts - не исключение, мы используем MVVM + RxSwift последние 5 лет на большинстве проектов, и за это время столкнулись с множеством проблем и челленджей, написали десятки расширений, оберток и сформировали свой собственный пул инструментов для максимального удобства работы с RxSwift.
В этом материале я раскрою и предложу решение для одной из самых распространенных проблем при работе с Rx свойствами - инкапсуляцией прав на чтение / запись, а также предложу удобную запись для инкапсулированных Rx свойств.
Для желающих скипнуть лирику и сразу смотреть финальный код
Добро пожаловать на github: Rx+Output.swift, Rx+Input.swift.
Суть проблемы
Рассмотрим кейс на примере ViewModel.
В классическом представлении ViewModel использует Rx свойства для того, чтобы с их помощью получать какие-то данные на вход от сервисов, баз данных или других модулей (Input), обрабатывать эти данные, а затем на выход (Output) отдавать контент для презентационного слоя, контекст для роутинга или какие-то данные/команды для других дочерних или зависимых модулей.
Для примера, условная ViewModel с одним Rx свойством может выглядеть так:
protocol ViewModelProtocol {
var text: BehaviorRelay<String> { get }
}
class ViewModel: ViewModelProtocol {
let text = BehaviorRelay<String>(value: "initial text")
}View хранит ее инстанс и должна иметь доступ к чтению свойства:
var viewModel: ViewModelProtocol!
/// Читать и подписываться - ок
viewModel.text.bind(to: label.rx.text)Проблема в том, что при такой записи View получает доступ и к записи в text, что нам совсем не нужно, это чревато багами и является нарушением инкапсуляции:
/// Одновременно с правом на чтение, View сможет записывать значения
/// в Relay / Subject. Это нарушение инкапсуляции
viewModel.text.accept("some new text")Такая же проблема актуальна и для случаев записи - иногда нужно раскрыть свойство только на запись, без возможности подписаться или получить другие детали реализации извне.
Существующие решения
Способов спрятать реактивное проперти существует как минимум несколько, а пытливый ум вполне может придумать и свой собственный, изощеренность которого зависит только от фантазии и ограничений языка.
Самый банальный способ привнести инкапсуляцию в код выглядит так:
/// Приватная реализация конкретного BehaviorRelay
private let _text = BehaviorRelay(value: "initial text")
/// Ну а в протокол можно добавить этот Observable,
/// чтобы разрешить только подписку.
var text: Observable<String> { _text.asObservable() }Очевидный минус такого подхода - каждое свойство превращается в два, а если их у вас 10 или 20? Решение массивное и требует много boilerplate.
Одним энтузиастом предлагался RxProperty, который под капотом держит BehaviorRelay. По задумке автора, использование RxProperty выглядит так:
class ViewModel<T> {
// Hide variable.
private let _state = BehaviorRelay<T>(...)
// `Property` is a better type than `Observable`.
let state: Property<T>
init() {
self.state = Property(_state)
}
}Можно согласиться с тем, что "Property is a better type than Observable". Лучше он только тем, что помимо .asObservable() предоставляет еще и текущий value. В остальном - точно так же дублируется объявление переменной, а код выглядит не менее сложно, чем в предыдущем варианте.
В статье на Medium раскрывается решение этой задачи через propertyWrapper @ReadWrite. Это уже смотрится гораздо лучше:
@propertyWrapper
final class ReadWrite<Element> {
var wrappedValue: RxProperty<Element>
init(wrappedValue: RxProperty<Element>) {
self.wrappedValue = wrappedValue
}
var projectedValue: BehaviorRelay<Element> {
return wrappedValue._behaviorRelay
}
}
// Usage:
@ReadWrite let state = RxProperty(initialValue)Плюсы: свойство state можно объявить одной строкой. Минусы: использование ограничено RxProperty, и соответственно, BehaviorRelay, а остальные типы реактивных свойств нам как будто и не нужны.
Output: желаемый результат
Как бы выглядела декларация реактивных свойств без проблем с инкапсуляцией? Удобная и минималистичная? Такая, чтобы можно было использовать любой тип, а не только BehavorRelay?
Время пофантазировать. Корневую обертку назовем Output, а основных юз-кейсов выделим 7 штук:
/// `BehaviorRelay`
@Output.Relay(value: "initial value")
var output_1: Observable<String>
/// `PublishRelay`
@Output.Relay()
var output_2: Observable<String>
/// `BehaviorSubject`
@Output.Subject(value: "initial value")
var output_3: Observable<String>
/// `PublishSubject`
@Output.Subject()
var output_4: Observable<String>
/// `ReplaySubject`
@Output.Subject(replay: .once)
var output_5: Observable<String>
/// `Completable`
@Output.Completable
var output_6: Completable
/// `Single`
@Output.Single()
var output_7: Single<String>Базовая реализация Output.Stream
Приступаем к воплощению задуманных деклараций. Для начала опишем сущность Output.Stream, которая сможет оборачивать любое ObservableConvertibleType свойство:
/// Output - название корневой обертки
struct Output {
/// Stream - базовый класс для будущих конкретных реализаций
@propertyWrapper
class Stream<Element, RxPropertyType: ObservableConvertibleType> where Element == RxPropertyType.Element {
/// Rx Свойство будем хранить открыто.
/// Доступ к нему пригодится
let rx: RxPropertyType
/// Обязательная реализация для любого @propertyWrapper
var wrappedValue: Observable<Element> {
rx.asObservable()
}
}
}Что с инициализацией? Тут посложнее. Для BehaviorRelay и BehaviorSubject нужно сразу задать начальное значение, тогда как для Publish- и ReplaySubject свойств оно не нужно. Придется написать отдельный init для Behavior-based свойств. А чтобы не плодить совсем уже одинаковых init-ов, для начала объединим Behavior-based свойства под один протокол:
protocol RxBehaviorPropertyInitializable: ObservableType {
init(value: Element)
}
extension BehaviorSubject: RxBehaviorPropertyInitializable {}
extension BehaviorRelay: RxBehaviorPropertyInitializable {}Теперь напишем первый init:
class Stream<...> where ... {
let rx: RxPropertyType
// MARK: - Init with `RxBehaviorPropertyInitializable`
init(value: RxPropertyType.Element,
_ rxPropertyType: RxPropertyType.Type) where RxPropertyType: RxBehaviorPropertyInitializable {
rx = rxPropertyType.init(value: value)
}
}Аналогичным образом добавим поддержку PublishSubject и PublishRelay:
protocol RxPublishPropertyInitializable: ObservableType {
init()
}
extension PublishSubject: RxPublishPropertyInitializable {}
extension PublishRelay: RxPublishPropertyInitializable {}Инициализатор для Publish- свойств выглядит так:
class Stream<...> where ... {
let rx: RxPropertyType
// MARK: - Init with `RxPublishPropertyInitializable`
init(_ rxPropertyType: RxPropertyType.Type) where RxPropertyType: RxPublishPropertyInitializable {
rx = rxPropertyType.init()
}
}Теперь мы можем создавать Observable, под капотом которого может быть любой из четырех типов. Пока что выглядит не идеально, но первый кирпич заложен:
// 1. BehaviorRelay
@Output.Stream(value: .zero, BehaviorRelay.self)
var someOutput: Observable<Int>
// 2. BehaviorSubject
@Output.Stream(value: .zero, BehaviorSubject.self)
var someOutput: Observable<Int>
// 3. PublishSubject
@Output.Stream(PublishSubject.self)
var someOutput: Observable<Int>
// 4. PublishRelay
@Output.Stream(PublishRelay.self)
var someOutput: Observable<Int>Синтаксис для Relay
Чтобы сделать запись более приятной, расширим Output.Stream, добавив синтаксис для Relay:
extension Output {
@propertyWrapper
class Relay<Element, RxPropertyType: ObservableConvertibleType>: Stream<Element, RxPropertyType> where Element == RxPropertyType.Element {
init(value: Element) where RxPropertyType == BehaviorRelay<Element> {
super.init(value: value, BehaviorRelay.self)
}
init<Element>() where RxPropertyType == PublishRelay<Element> {
super.init(PublishRelay.self)
}
override var wrappedValue: Observable<Element> {
rx.asObservable()
}
}
}По итогу мы имеем вот такие записи, что уже соответствует изначальной идее:
/// `BehaviorRelay`
@Output.Relay(value: "initial value")
var output_1: Observable<String>
/// `PublishRelay`
@Output.Relay()
var output_2: Observable<String>Синтаксис для Subject + Replay
Основа кода для Behavior- PublishSubject почти не отличается от аналогичной для Relay. Но помимо них в RxSwift есть еще другие штуки вроде ReplaySubject и AsyncSubject. Первый - довольно частый гость в наших проектах, поэтому я бы добавил удобный код и для него.
При инициализации ReplaySubjectпринимает размер буфера, то есть количество элементов, повторяемых для каждого нового подписчика. Для начала обернем размер буфера в синтаксически более приятный enum:
enum RxReplayStrategy {
case once, all, custom(Int), none
var count: Int? {
switch self {
case .none: return 0
case .once: return 1
case .custom(let count): return count
default: return nil
}
}
}И добавим к нам в Output.Stream новый инициализатор:
class Stream<...> where ... {
let rx: RxPropertyType
// MARK: - Init with `ReplaySubject`
fileprivate init(replay: RxReplayStrategy) where RxPropertyType == ReplaySubject<Element> {
let replaySubject: ReplaySubject<RxPropertyType.Element>
if let bufferSize = replay.count {
replaySubject = ReplaySubject.create(bufferSize: bufferSize)
} else {
replaySubject = ReplaySubject.createUnbounded()
}
rx = replaySubject
}
}Обертка для Subject будет выглядеть так:
extension Output {
@propertyWrapper
class Subject<Element, RxPropertyType: ObservableConvertibleType>: Stream<Element, RxPropertyType> where Element == RxPropertyType.Element {
init(value: Element) where RxPropertyType == BehaviorSubject<Element> {
super.init(value: value, BehaviorSubject.self)
}
init() where RxPropertyType == PublishSubject<Element> {
super.init(PublishSubject.self)
}
override init(replay: RxReplayStrategy) where RxPropertyType == ReplaySubject<Element> {
super.init(replay: replay)
}
override var wrappedValue: Observable<Element> {
rx.asObservable()
}
}
}Получилось довольно вкусно:
/// `BehaviorSubject`
@Output.Subject(value: "initial value")
var output_3: Observable<String>
/// `PublishSubject`
@Output.Subject()
var output_4: Observable<String>
/// `ReplaySubject`
@Output.Subject(replay: .once)
var output_5: Observable<String>Completable
Иногда раскрыть соседям нужно лишь одну простую команду. Например, в случае с прогресс-баром это может быть сигнал о том, что он заполнился на 100% и завершил свою анимацию. В RxSwift для таких случаев есть Completable. На существующий каркас его реализация ложится очень просто:
extension Output {
@propertyWrapper
class Completable: Stream<Never, PublishSubject<Never>> {
init() {
// `PublishSubject` хорошо подходит для основы `Completable`.
super.init(PublishSubject.self)
}
var wrappedValue: RxSwift.Completable {
rx.asCompletable()
}
/**
Функция для удобный байндингов любых событий
к событию `completed` нашего `Completable`
*/
func complete<Element>() -> AnyObserver<Element> {
AnyObserver { [weak rx] observer in
rx?.onCompleted()
}
}
}
}Использование выглядит так:
@Output.Completable
var output: CompletableА что насчет Input?
В случае c Output, все реактивные свойства можно привести к ObservableConvertibleType, то есть, на выходе получить Observable<Element>.
С Input ситуация сложнее. Приемник событий в RxSwift, как правило, ObserverType. Но Relay-свойства под него не подписаны, поскольку в ObserverType можно передать любой Event, включая события error и completed.
Так что теперь поколдуем немного над Relay свойствами:
/// Под одним протоколом объединим Relay-based свойства
protocol RxRelayPropertyAcceptable: AnyObject {
associatedtype Element
func accept(_ event: Element)
}
extension BehaviorRelay: RxRelayPropertyAcceptable {}
extension PublishRelay: RxRelayPropertyAcceptable {}Затем, нам нужен некий объект, который будет являться ObserverType и сможет принимать на вход события, независимо от того, что у него под капотом - Relay или Subject. Назовем его AnyRxInput:
class AnyRxInput<Value>: ObserverType {
typealias Element = Value
/// Свойства - приемники событий
private let acceptValue: (Value) -> Void
private var acceptError: ((Error) -> Void)?
private var complete: (() -> Void)?
/**
Инициализатор для Relay-based свойств
*/
init<RxRelayProperty: RxRelayPropertyAcceptable>(_ relay: RxRelayProperty) where RxRelayProperty.Element == Value {
acceptValue = { [weak relay] value in
relay?.accept(value)
}
}
/**
Инициализатор для Subject-based свойств,
которые сами по себе являются `ObserverType`
*/
init(_ observer: AnyObserver<Value>) {
acceptValue = { value in
observer.onNext(value)
}
acceptError = { error in
observer.onError(error)
}
complete = {
observer.onCompleted()
}
}
/**
Единственная необходимая реализация для `ObserverType`
*/
func on(_ event: Event<Element>) {
switch event {
case .next(let element):
acceptValue(element)
case .error(let error):
acceptError?(error)
case .completed:
complete?()
}
}
}Дальнейшая реализация Input.Stream мало чем отличается от Output.Stream, за исключением использования AnyRxInput вместо Observable. Приведу пример только для Relay:
struct Input {
@propertyWrapper
class Stream<Value, RxPropertyType: ObservableConvertibleType> where Value == RxPropertyType.Element {
/// Rx свойство под капотом остается доступным
let rx: RxPropertyType
/// Обернутое свойство для записи извне
fileprivate let input: AnyRxInput<Value>
/**
Инициализатор для BehaviorRelay, который конформит
`RxBehaviorPropertyInitializable` & `RxRelayPropertyAcceptable`
*/
init(value: Value,
_ rxPropertyType: RxPropertyType.Type) where RxPropertyType: RxBehaviorPropertyInitializable & RxRelayPropertyAcceptable {
let rxProperty = rxPropertyType.init(value: value)
rx = rxProperty
input = .init(rxProperty)
}
var wrappedValue: AnyRxInput<Value> {
input
}
}
}Обертка для Relay:
extension Input {
@propertyWrapper
class Relay<Value, RxPropertyType: ObservableConvertibleType>: Stream<Value, RxPropertyType> where Value == RxPropertyType.Element {
init(value: Value) where RxPropertyType == BehaviorRelay<Value> {
super.init(value: value, BehaviorRelay.self)
}
init() where RxPropertyType == PublishRelay<Value> {
super.init(PublishRelay<Value>.self)
}
override var wrappedValue: AnyRxInput<Value> {
input
}
}
}Использование выглядит аналогично Output:
/// `BehaviorRelay`
@Input.Relay(value: "initial value")
var input_1: AnyRxInput<String>
/// `PublishRelay`
@Input.Relay()
var input_2: AnyRxInput<String>Результаты
Итак, инкапсулированные Rx свойства теперь можно записывать следующим образом:
// MARK: - Output
/// `BehaviorRelay`
@Output.Relay(value: "????")
var output_1: Observable<String>
/// `PublishRelay`
@Output.Relay()
var output_2: Observable<String>
/// `BehaviorSubject`
@Output.Subject(value: "????")
var output_3: Observable<String>
/// `PublishSubject`
@Output.Subject()
var output_4: Observable<String>
/// `ReplaySubject`
@Output.Subject(replay: .once)
var output_5: Observable<String>
/// `Completable`
@Output.Completable
var output_6: Completable
// MARK: - Input
/// `BehaviorRelay`
@Input.Relay(value: "????")
var input_1: AnyRxInput<String>
/// `PublishRelay`
@Input.Relay()
var inputB_2: AnyRxInput<String>
/// `BehaviorSubject`
@Input.Subject(value: "????")
var input_3: AnyRxInput<String>
/// `PublishSubject`
@Input.Subject()
var input_4: AnyRxInput<String>
/// `ReplaySubject`
@Input.Subject(replay: .once)
var input_5: AnyRxInput<String>Что дальше?
В этом материале я привел упрощенную реализацию Input / Output. У себя в проектах мы используем более полную версию, в которой есть пара дополнительных фич.
Во-первых, mutators для модификации Observable, на практике может выглядеть так:
/// Под капотом лежит BehaviorRelay<String>
/// Но с помощью mutator мы раскрываем Observable<Int>
/// Который считает количество символов в строке
@Output.Relay(value: "some_text", mutator: { $0.map(\.count) })
var charCount: Observable<Int>Также, по аналогии с остальными типами, добавили поддержку Single:
@Output.Single()
var output: Single<String>Выводы
Достаточно интересных результатов можно добиться, если поставить целью лаконизацию привычного кода. В творческом процессе проникаешься особенностями языка, узнаешь несколько новых фишек и вдохновляешься на новые решения на основе полученного опыта.
Данное решение не претендует на роль идеального. Но некоторые идеи могут быть развиты и дальше, а с приходом новых версий Swift (как там комбайн, эппл?) и вовсе преображаться до неузнаваемости.
Обертывание Rx свойств обернулось (извините за тавтологию) относительно большим количеством кода. Но такой trade-off есть всегда при написании фреймворка: либо core будет супер простой, но массивный usage, либо наоборот - под капотом будет спрятана массивная реализация, а ее использование станет лаконичным. Я являюсь сторонником второго подхода, поэтому доволен реализацией и у себя в команде мы повсеместно ее используем.
Периодически мы улучшаем и расширяем код, а полную его версию можно посмотреть и взять на вооружение у нас на github: Rx+Output.swift, Rx+Input.swift.
adsa1
Круто!