Flux-подход на практике: как навести порядок в потоке данных React-приложения

•
Опубликовано
•
12 мин чтения

Текст написан с позиции февраля 2015 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

Когда разработчик только начинает работать с React, первое впечатление обычно очень приятное. Компоненты выглядят логично, интерфейс удобно раскладывается на части, идея с состоянием кажется понятной, а сама модель описания UI воспринимается как шаг вперёд по сравнению с бесконечными ручными манипуляциями над DOM. Но проходит совсем немного времени, и на сцену выходит более неприятный вопрос: что делать, когда приложение уже не ограничивается парой изолированных компонентов, а данные начинают течь через несколько уровней интерфейса сразу?

Именно в этот момент многие команды сталкиваются с характерным ощущением: React сам по себе отлично отвечает на вопрос «как рендерить интерфейс», но не всегда даёт простой и дисциплинированный ответ на вопрос «как организовать движение данных по приложению». Пока приложение маленькое, всё держится на props, локальном состоянии и нескольких обработчиках. Это удобно, быстро и в целом прекрасно работает. Но когда один компонент должен сообщить о действии другому, несколько частей экрана зависят от общих данных, а пользовательские события начинают влиять сразу на несколько областей интерфейса, код постепенно теряет прозрачность. Кто изменил состояние? Почему именно этот компонент перерисовался? Откуда пришли эти данные? Где правильное место для логики обновления? Вот здесь и возникает интерес к Flux.

Зафиксируем сразу честно: Flux не выглядит как простая и уютная штука, которую любой разработчик принимает с первого взгляда. Наоборот, у многих первая реакция на него примерно такая: зачем вообще всё это нужно? Зачем какие-то dispatcher, store, action и отдельные потоки, если можно просто передавать данные вниз, поднимать колбэки вверх и не плодить абстракции? Возражение вполне разумное. Проблема в том, что оно верно только до определённого масштаба. Как и многие архитектурные идеи, Flux начинает быть полезным не в тот момент, когда приложение только зарождается, а тогда, когда хаос ещё не победил окончательно, но уже явно стучится в дверь.

Важно не свалиться в другую крайность и не подать Flux как очередную серебряную пулю. Это не революция и не магия, а попытка вернуть приложению то, что оно теряет по мере роста, — прослеживаемость изменений. Дальше я разберу, в чём именно состоит эта потеря, что Flux предлагает взамен, чем за это приходится платить и где он скорее помешает, чем поможет.

Растущее React-приложение теряет не компоненты, а ясность потока данных

Самое неприятное в растущем React-приложении — не количество компонентов само по себе, а потеря ясности в потоке данных. В простом приложении всё выглядит предсказуемо: родитель передаёт props детям, дети вызывают обработчики, родитель обновляет состояние, интерфейс перерисовывается. Эта модель хороша своей очевидностью. Но чем больше приложение, тем чаще возникает соблазн срезать углы. Где-то состояние начинают дублировать. Где-то один компонент напрямую влияет на другой через обходной путь. Где-то логика запроса к серверу внезапно оказывается внутри view. Где-то один и тот же кусок данных живёт сразу в нескольких местах. В итоге приложение вроде бы по-прежнему написано на React, но внутренняя картина уже не выглядит чистой. Компоненты становятся не просто отображением данных, а участниками неформальных договорённостей, которые трудно удерживать в голове.

Flux интересен именно тем, что пытается вернуть эту потерянную ясность. Его главная идея звучит почти слишком просто: поток данных в приложении должен быть однонаправленным. Пользователь совершает действие, действие оформляется как action, action проходит через dispatcher, соответствующие store обновляют своё состояние, а затем компоненты получают новые данные и перерисовываются. Вся конструкция строится вокруг мысли, что изменение состояния должно происходить по понятному маршруту, а не через набор случайных вмешательств из разных точек системы.

Дисциплина Flux спасает не первые два дня, а третью неделю

На бумаге это может показаться бюрократией. И, надо признать, такое впечатление не совсем обманчиво. Flux действительно требует больше дисциплины, чем наивная сборка React-приложения из компонентов с локальным состоянием и разбросанными обработчиками. Нужно формализовать действия. Нужно выделять store. Нужно привыкать к тому, что не всякая часть системы имеет право напрямую менять всё, что ей хочется. Но именно в этой «бюрократии» и скрыта польза. Flux не пытается ускорить первые два дня разработки. Он пытается спасти третью неделю, когда приложение уже успело обрасти связями и стало чувствительным к любой правке.

Чтобы понять практическую ценность Flux, полезно посмотреть на типичную боль без него. Представим небольшое React-приложение, в котором есть список элементов, форма редактирования, уведомления и фильтры. Пользователь меняет элемент, после чего нужно обновить список, скрыть форму, показать сообщение об успехе и, возможно, заново применить фильтр. Если приложение организовано без чёткой модели потока данных, такая операция быстро расползается по нескольким компонентам. Один отвечает за форму и знает, что надо отправить запрос. Другой знает, как обновить список. Третий как-то показывает уведомления. Четвёртый хранит локальный фильтр. Всё это может работать, но обычно начинает требовать всё больше координации между частями интерфейса. Код при этом теряет свою локальность: чтобы понять, что произойдёт после одного действия пользователя, приходится мысленно обходить полприложения.

Flux предлагает другой сценарий. Пользователь нажал сохранить — создаётся action. Store, который отвечает за соответствующие данные, получает сигнал и после результата обновляет своё состояние. Компоненты, подписанные на store, получают новое состояние и обновляются соответственно. Уведомление тоже может реагировать на изменение состояния через свой источник данных, а не через прямую команду из формы. Это очень важный сдвиг: части приложения перестают командовать друг другом напрямую и начинают реагировать на изменения общей модели данных в предсказуемом порядке.

Главная ценность Flux — не схема, а предсказуемость происходящего

Именно эта предсказуемость — самое ценное, что даёт Flux на практике. Когда приложение растёт, разработчику критически важно понимать не только что происходит, но и где именно это происходит. Flux дисциплинирует такие вопросы. Если состояние изменилось, значит, был action. Если store обновился, можно проследить, почему он это сделал. Если интерфейс поменялся, это следствие изменения store, а не спонтанной DOM-магии и не скрытого побочного эффекта из соседнего компонента. Для команды это часто означает одно важное улучшение: о приложении становится легче разговаривать.

Вообще, Flux особенно хорош не только как архитектурная схема, но и как общий язык для обсуждения проблем. Пока команда работает без внятной модели данных, обсуждения быстро скатываются в расплывчатые формулировки: «вот тут что-то обновить», «надо пробросить это вниз», «давай отсюда дёрнем тот компонент», «можно ещё сохранить это в state вот здесь». Такой разговор кажется быстрым, но он почти всегда ухудшает качество системы. Flux заставляет формулировать точнее: какое именно действие произошло, какой store за него отвечает, откуда берутся данные, кто на них подписан, где происходит обновление. Эта точность сначала может раздражать, но именно она и создаёт порядок.

Flux отнимает импровизацию, а в маленьком приложении только мешает

Конечно, у Flux есть и цена. Во-первых, он требует отказаться от части удобной импровизации, к которой многие привыкают в маленьких React-проектах. Уже нельзя просто так взять и поменять состояние там, где подвернулась возможность, если вы хотите сохранить архитектурную последовательность. Во-вторых, в очень маленьких приложениях Flux действительно может выглядеть как тяжеловесная конструкция. Если у вас пара экранов, минимум общей логики и почти нет пересекающихся состояний, то вводить dispatcher и систему store только ради красоты, скорее всего, не стоит. Архитектура должна отвечать на реальную сложность, а не на страх перед будущим.

Но как только приложение начинает страдать от расползания данных, Flux становится куда более убедительным. Особенно хорошо это видно в тех случаях, где у нескольких компонентов есть интерес к одним и тем же данным. Без упорядоченного подхода почти всегда возникает соблазн продублировать состояние или построить слишком запутанную цепочку передачи props и колбэков. Один компонент хранит копию данных для удобства, другой обновляет свою версию, третий зависит от вычисленного состояния, и в какой-то момент приложение начинает вести себя так, будто у него несколько разных истин одновременно. Flux в этом смысле жёстче: store становится местом, которое знает актуальное состояние, а интерфейс больше не обязан догадываться, у кого сейчас «правильная» версия данных.

Flux облегчает компоненты, забирая у них роль универсального мозга

Это особенно полезно для команд, которые уже почувствовали, что React-компоненты сами по себе не должны становиться контейнерами для всей логики приложения. Одна из частых ошибок раннего React-кода — перегрузка компонентов обязанностями. Они и рендерят, и грузят данные, и решают, как обновлять состояние, и синхронизируют несколько частей интерфейса, и обрабатывают действия пользователя, и координируют соседние блоки. На первых порах это кажется естественным: компонент ведь и так центральная единица интерфейса. Но довольно быстро становится ясно, что компонент, который знает слишком много, становится хрупким. Flux помогает вынести значительную часть ответственности из UI-слоя и тем самым облегчить сами компоненты.

В хорошем Flux-подходе компоненты ближе к роли представления, чем к роли универсального мозга приложения. Они получают данные, подписываются на изменения нужных store, инициируют action в ответ на пользовательские действия и перерисовываются. Главная логика потока данных живёт уже не в произвольных жизненных циклах компонентов и не в разбросанных обработчиках, а в более явной архитектуре. Это меняет весь характер проекта. Интерфейс перестаёт быть главным местом хранения смысла. Смысл начинает жить в действиях и состояниях, а интерфейс становится их отражением.

Однонаправленный поток нужен не ради схемы, а ради отлаживаемости

Очень важно и то, что Flux снижает соблазн строить в приложении двусторонние связи, которые почти всегда становятся источником проблем. Когда один компонент напрямую меняет состояние другого или когда части интерфейса начинают обмениваться командами туда-сюда, система быстро теряет прозрачность. Однонаправленный поток данных в Flux нужен не ради красоты схемы в презентации. Он нужен потому, что у сложной системы должен быть маршрут, по которому проходят изменения. Чем меньше перекрёстных дорог, тем легче отлаживать поведение приложения и тем меньше риск поймать странный побочный эффект.

На практике это означает очень приземлённую выгоду: баги становятся хотя бы объяснимыми. В хаотичном приложении поведение часто ломается так, что разработчик даже не понимает, где искать источник. Пользователь выполнил действие, интерфейс обновился не до конца, часть состояния осталась старой, какая-то панель не перерисовалась. Начинается охота по компонентам, ручная проверка того, кто и где дёргает setState, кто какие props передаёт и кто вообще должен был знать об изменении. Flux делает такую ситуацию неприятной, но не мистической. Раз есть формализованный поток, значит, можно проверять action, dispatcher, store и подписки компонентов по цепочке.

С ростом команды Flux работает как ограничитель произвола

Ещё один сильный аргумент в пользу Flux — масштабирование команды. Пока над React-приложением работает один человек, он ещё может держать в голове много неявных связей. Когда людей становится больше, хаос начинает дорожать особенно быстро. Один разработчик добавляет локальное состояние в одном месте, другой — в другом, третий протаскивает данные через несколько уровней, четвёртый решает обойтись без общего правила, потому что ему так быстрее прямо сейчас. Через некоторое время приложение перестаёт выглядеть как единая система. Flux в таком контексте полезен именно как ограничитель произвола. Он не делает код идеальным, но задаёт рамки, в которых команде труднее разрушить общую картину случайными решениями.

Разумеется, нельзя превращать Flux в религию. Вокруг React и связанных с ним подходов и так слишком много энтузиазма, чтобы не впасть в очередную волну избыточного усложнения. Flux — не волшебная таблетка и не обязательный ритуал для каждого приложения. Более того, плохо реализованный Flux может оказаться не менее болезненным, чем отсутствие структуры. Если actions расплывчаты, stores дублируют ответственность, dispatcher используется без дисциплины, а команда механически копирует шаблоны, не понимая зачем, результат будет тяжёлым и раздражающим. Порядок возникает не от наличия модных слов в проекте, а от ясности границ и последовательности решений.

React и Flux отвечают на разные вопросы и хорошо складываются вместе

Тем не менее именно в React-приложениях Flux оказывается особенно естественным, потому что хорошо сочетается с самой идеей React как слоя представления. React говорит: описывайте интерфейс через компоненты и состояния. Flux добавляет: а теперь давайте ещё договоримся, как именно эти состояния меняются и по какому маршруту проходят пользовательские действия. Вместе они создают более стройную картину, чем просто набор компонентов, которые как-то договариваются друг с другом по мере необходимости.

На практике начать применять Flux полезно не с тотального переписывания всего проекта, а с обнаружения точек, где хаос уже ощутим. Обычно это общие данные, которые нужны нескольким частям интерфейса, сложные пользовательские сценарии с несколькими последовательными обновлениями и места, где компоненты стали чересчур умными. Если именно туда аккуратно ввести actions и stores, выгода становится заметна довольно быстро. Команда начинает лучше понимать, где живёт состояние, как оно меняется и как интерфейс на него реагирует. И очень часто этого уже достаточно, чтобы приложение перестало расползаться.

Ещё одна полезная сторона Flux — он заставляет относиться к пользовательским действиям как к событиям предметной области, а не просто как к техническим кликам и вводам. Это важная разница. Нажатие кнопки — ещё не архитектурный смысл. А вот «пользователь сохранил запись», «фильтр изменён», «список загружен», «авторизация завершилась» — уже смысл. Когда actions называются в терминах того, что произошло в приложении, код становится ближе к поведению продукта, а не к механике DOM и обработчиков. Это снова улучшает обсуждаемость системы и делает её менее случайной.

Flux не делает приложение маленьким, но мешает ему стать бесформенным

В конечном счёте Flux-подход интересен не потому, что он модный и новый, а потому, что он пытается решить очень старую проблему: как не позволить данным и изменениям течь по приложению хаотично. В React эта проблема особенно заметна, потому что сами компоненты слишком соблазнительно использовать как универсальные контейнеры для всего. Flux ставит этому предел. Он говорит: нет, давайте разделим интерфейс и поток изменений, давайте сделаем состояния явными, а обновления — прослеживаемыми.

Это не окончательно устоявшийся канон, а важный и очень своевременный шаг в поиске порядка для растущих клиентских приложений. Не все команды примут его сразу. Не все приложения в нём нуждаются одинаково сильно. Но сам запрос, на который Flux отвечает, уже никуда не денется. React-приложения становятся сложнее, данных в них больше, пользовательские сценарии длиннее, а терпимость к хаосу — ниже. На этом фоне однонаправленный поток данных и явная модель обновления состояния выглядят не прихотью энтузиастов, а попыткой навести во фронтенде ту дисциплину, без которой рост очень быстро превращается в боль.

Если сформулировать совсем прямо: Flux не обещает сделать приложение маленьким — он помогает не дать ему стать бесформенным, и именно поэтому его стоит вводить не из любви к схемам, а ровно там, где поток данных уже начал расползаться.

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Обновлено

Читайте также