React Query, Redux или Context: кто должен отвечать за серверные данные

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

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

К началу 2020 года у React-команд накопилась очень характерная усталость. Несколько лет подряд фронтенд учился работать с состоянием все серьезнее: сначала почти все более или менее сложное пытались складывать в Redux, потом пришел новый Context и стал казаться более легкой альтернативой для части задач, затем Hooks изменили стиль написания компонентов, а теперь все громче звучит еще один важный вопрос: а кто вообще должен отвечать за серверные данные? Потому что именно здесь многие проекты до сих пор страдают сильнее всего. Не от отсутствия глобального состояния как такового, а от того, что данные с сервера годами пытались запихнуть в те же инструменты и в ту же ментальную модель, что и локальное состояние интерфейса.

И вот на этом фоне совсем молодой React Query начинает выглядеть не просто еще одной библиотекой вокруг асинхронного кода, а довольно серьезной попыткой развести два разных мира, которые слишком долго смешивали. Есть клиентское состояние: открыт ли сайдбар, какой фильтр выбран, в каком режиме работает форма, какой таб активен, что выбрано в таблице. А есть серверное состояние: список пользователей, заказов, товаров, профиля, комментариев, отчетов и всех прочих сущностей, источником правды для которых является не браузер, а сервер. И если смотреть на реальные React-приложения конца 2019 и начала 2020 года честно, то очень часто выясняется: огромная часть боли возникает не из-за плохого выбора между Redux и Context вообще, а из-за того, что серверные данные долго пытались обслуживать инструментами, которые изначально были придуманы для другой природы состояния.

Именно поэтому вопрос из заголовка так важен. Не в абстрактном смысле «какая библиотека круче», а в очень практическом: кто в реальном React-проекте должен брать на себя заботу о загрузке, кэшировании, повторных запросах, синхронизации, refetch, флагах загрузки, ошибках, устаревании данных и всех тех вещах, которые появляются, как только UI начинает опираться на серверную информацию? Redux? Context? React Query? Ответ здесь уже не выглядит таким однозначным, как несколько лет назад.

Чтобы разобраться спокойно, полезно сначала убрать одно распространенное недоразумение. Очень многие разговоры о состоянии в React долго шли так, будто вся проблема сводится к вопросу: где хранить данные, чтобы компоненты могли их читать. Но это слишком бедная постановка. Для серверных данных недостаточно просто «где-то хранить». Нужно еще знать, когда их загружать, как кэшировать, как не делать повторные одинаковые запросы, как обновлять устаревшую информацию, как обрабатывать ошибки, как инвалидировать кэш после мутации, как синхронизировать несколько компонентов, которым нужен один и тот же ресурс, и как сделать так, чтобы UI не превращался в бесконечную ручную оркестровку флагов isLoading, isError, didLoad, needsRefresh и прочих полуслучайных признаков жизни.

Серверные данные — это не «где хранить», а особый класс состояния

Именно здесь становится видно, что Redux, Context и React Query на самом деле отвечают на разные по глубине вопросы. Context в своей основе — это способ передавать значения глубоко по дереву компонентов без проп-дриллинга. Redux — это архитектурная модель централизованного и предсказуемого изменения состояния приложения. React Query — это инструмент для работы именно с серверным состоянием, то есть с данными, которые живут не в браузере как первичном источнике, а приходят извне, могут устаревать, переиспользоваться, кэшироваться и требовать синхронизации с источником правды. Эти инструменты пересекаются, но не являются прямыми заменами друг друга. И большая часть путаницы возникает именно тогда, когда их начинают сравнивать как будто они решают одну и ту же задачу одинаковым способом.

Context хорош как транспорт, но не как движок кэша для remote data

Если начать с Context, то его сила и слабость в этой теме довольно очевидны. Context отлично подходит для распространения по дереву каких-то широко используемых значений: текущего пользователя, темы, локали, настроек окружения, доступа к сервисам, feature-флагов, UI-параметров. Он также может вполне нормально обслуживать часть локально-глобального состояния, если оно относится к определенному поддереву приложения. Но как только команда начинает использовать Context как полноценный контейнер для серверных данных, быстро обнаруживается, что сам по себе он не дает почти ничего из того, что реально нужно для remote data. Context может раздать данные вниз. Но он не решает кэширование. Не решает дедупликацию запросов. Не определяет политику повторной загрузки. Не знает, когда данные считаются свежими или устаревшими. Не помогает инвалидации после мутаций. И не дает встроенной модели работы с асинхронным жизненным циклом ресурса.

Конечно, все это можно построить вокруг Context вручную. И именно так многие команды и делают. Они создают provider, внутри него хранят данные, флаги загрузки, ошибки, методы обновления, иногда даже локальный reducer и довольно быстро получают что-то вроде собственного мини-хранилища для серверного состояния. На старте это кажется легким и приятным: никакого Redux, все ближе к React, меньше церемоний. Но по мере роста проекта очень быстро выясняется, что команда просто заново собирает своими руками то, что оказывается довольно сложной системой: загрузка, refetch, race conditions, stale данные, повторное использование между экранами, инвалидация, обновление после мутаций, optimistic-поведение, синхронизация нескольких подписчиков. Иными словами, Context здесь слишком часто становится лишь транспортом, на который навешивается самодельная система управления server state.

Это не значит, что Context бесполезен. Он очень полезен. Но именно как транспорт и как легкий слой организации данных по дереву, а не как готовая модель для всех проблем серверного состояния. Если команда использует его, чтобы распространить уже полученные данные или дать доступ к какому-то data-layer API, это одно. Если она пытается сделать из него универсальную замену специализированному инструменту для remote data, очень быстро появляется новый тип хаоса: несколько контекстов с похожей логикой, разные паттерны refetch, ручная работа с loading/error состояниями и растущее количество кода, который вроде бы выглядит React-нативно, но на деле обслуживает сложную и довольно однотипную инфраструктурную задачу.

Redux прекрасен для client state, но не обязан тащить весь remote-data lifecycle

Теперь о Redux. Он долгое время был почти естественным ответом на любую более или менее серьезную работу с состоянием, и серверные данные тоже очень часто отправлялись именно туда. Это было логично по историческим причинам. Redux давал единый store, предсказуемые обновления, ясный поток данных, возможность нормально читать и менять состояние из разных частей приложения. Для многих команд он действительно навел порядок там, где до этого была смесь локальных загрузок, prop drilling и хаотичных side effects. И все же сейчас уже становится заметно, что складывать серверное состояние в Redux не всегда означает использовать его сильные стороны оптимально.

Проблема здесь опять-таки не в том, что Redux плох. Проблема в несовпадении модели. Redux прекрасно подходит для того, что действительно является клиентским состоянием приложения: то, что принадлежит UI и управляется самим приложением как первичным источником правды. Но серверные данные — это другая природа. Они приходят извне. Они имеют жизненный цикл загрузки и устаревания. Их нужно кэшировать. Они могут быть одними и теми же для нескольких экранов и компонентов. Их нужно обновлять после мутаций. И если вся эта работа организуется вручную через actions, reducers, thunks, selectors и отдельные куски async-логики, то команда довольно быстро получает огромное количество инфраструктурного кода, который не столько выражает доменную сложность, сколько компенсирует отсутствие специализированной модели для remote data.

Именно отсюда и выросла усталость от хранения серверных данных в Redux почти по умолчанию. Да, это работает. Да, можно сделать хорошо. Да, можно даже очень хорошо, особенно если проект и команда дисциплинированны. Но цена часто оказывается высокой. Нужно руками описывать загрузку, ошибку, успех, ручные invalidation-последовательности, обновления после мутаций, кэширование, дедупликацию и многое другое. Для части приложений это все еще оправдано, особенно если серверные данные тесно вплетены в более широкий client-state workflow. Но для огромного числа обычных React-проектов получается странная картина: Redux вроде бы дает порядок, но вокруг каждого серверного запроса приходится строить довольно много кода, который по смыслу почти повторяет один и тот же жизненный цикл.

React Query — это не конкурент Redux, а более точный ответ на природу remote data

И вот здесь React Query начинает выглядеть не как конкурент Redux вообще, а как более точный ответ на именно эту часть проблемы. Он исходит из другой предпосылки: серверное состояние — это особый класс состояния, и к нему нужно относиться как к кэшу данных с определенной политикой жизни, а не как к просто еще одному объекту в глобальном store. Если принять эту мысль, многое начинает складываться удивительно естественно. У вас есть запрос. У него есть ключ. У него есть данные. Есть состояние загрузки. Есть ошибка. Есть момент, когда данные считаются свежими или уже устарели. Есть повторные подписчики на тот же ресурс. Есть повторная загрузка в фоне. Есть инвалидирование после мутаций. Есть кэш, которым библиотека управляет системно, а не вручную в каждом feature-модуле.

Для React-команды это очень мощное облегчение. Самая вредная реакция на React Query — услышать слово «кэш» и решить, что библиотека волшебным образом делает всю работу с данными легкой. Это не так: дело не в магии, а в том, что React Query возвращает серверные данные в более честную модель. Вместо того чтобы делать вид, будто серверный список заказов — это просто еще одна часть глобального client-state, библиотека говорит: нет, это удаленные данные, и их нужно обслуживать как удаленные данные. Это очень важный сдвиг мышления. Он позволяет перестать писать много инфраструктурного кода не потому, что команда стала ленивее, а потому, что наконец появился инструмент, который берет на себя именно те обязанности, которые раньше приходилось постоянно собирать руками.

Общий кэш делает повторное использование ресурса встроенным поведением, а не ad hoc решением

Особенно заметен выигрыш в сценариях, где несколько компонентов используют один и тот же ресурс. В Redux или Context-подходе это обычно требует либо явного общего хранилища и координации загрузки, либо более сложной самодельной организации provider-логики. У React Query сама идея общего кэша встроена глубже. Если один компонент уже запросил ресурс, другой может получить его из кэша, а система сама решит, когда refetch действительно нужен. То же касается повторной загрузки в фоне, повторного фокуса окна, stale-логики, инвалидации после мутаций. Все это вдруг перестает быть набором ad hoc решений в проекте и становится частью стандартного поведения.

Засунуть в React Query открытый модал и dirty-поле формы — та же старая ошибка, только наоборот

Но именно здесь важно не впасть в новый фанатизм. Потому что React Query не заменяет весь state management. Он не решает локальное UI-состояние. Он не является полной моделью бизнес-логики приложения. Он не обязан быть местом, где хранится то, открыт ли модал, какой фильтр сейчас выбран на клиенте до отправки, какой step у мастера, какое поле формы сейчас dirty и тому подобное. Это другая территория. И если команды раньше перегружали Redux серверным состоянием, то теперь есть риск начать перегружать React Query клиентским. А это уже зеркальная ошибка. Библиотека сильна именно там, где речь идет о серверном источнике данных и его кэшированном представлении в UI. Не больше и не меньше.

За серверные данные должен отвечать тот, кто понимает их природу, а не тот, кто ближе

Поэтому самый зрелый ответ на вопрос «кто должен отвечать за серверные данные», пожалуй, звучит так: в большинстве современных React-приложений за серверные данные должен отвечать инструмент, специально предназначенный для серверного состояния, а не тот, кто случайно оказался ближе. Если у команды есть React Query и реальная проблема состоит именно в загрузке, кэшировании, refetch и жизненном цикле remote data, то именно он выглядит наиболее естественным владельцем этой зоны. Context может помогать с распространением некоторых значений или с feature-уровневой организацией, но не обязан быть data-cache-движком. Redux может оставаться отличным слоем для client state и сложных переходов, но не обязан по умолчанию тащить на себе весь remote-data lifecycle.

Разделять состояние стоит по природе, а не по привычке

Это особенно хорошо видно, если разделить состояние по природе, а не по привычке. Есть UI state: открытость панелей, локальные фильтры, модалы, текущая вкладка, режим отображения, черновые поля форм, выделение строк, временные настройки экрана. Есть domain client state: например, набор локальных пользовательских действий, неотправленные изменения, workflow, который живет в браузере и не сводится к одному запросу. И есть server state: списки, сущности, детали, связанные ресурсы, которые приходят с сервера и должны поддерживаться в актуальном и кэшируемом виде. Когда эти три слоя не смешаны в одну массу, становится легче понять, что Context, Redux и React Query могут сосуществовать, а не воевать за статус единственного правильного решения.

Зрелый ответ — комбинация ролей, а не победа одной библиотеки

И это, пожалуй, самый важный практический вывод. Вопрос не обязательно должен ставиться как «React Query, Redux или Context». Для зрелой React-команды гораздо полезнее мыслить комбинацией, а не заменой любой ценой. React Query отвечает за server state. Context — за широкие значения окружения и часть feature-level shared UI state, где он действительно естественен. Redux — за то сложное клиентское состояние, которому нужен единый предсказуемый поток изменений и которое не сводится к кэшированию удаленных данных. Такой расклад звучит менее эффектно, чем победа одной библиотеки над другой. Но в реальных приложениях он часто оказывается куда честнее.

Чем явнее различие клиентского и серверного состояния, тем спокойнее архитектура

Конечно, есть проекты, где Redux уже настолько глубоко переплетен с серверными данными, что резкий переход на React Query вряд ли будет оправдан мгновенно. Есть и такие приложения, где Context плюс аккуратные hooks вполне закрывают весь необходимый уровень работы с remote data просто потому, что продукт не так уж сложен. Но если смотреть вперед, становится ясно: чем явнее команда различает клиентское и серверное состояние, тем спокойнее становится архитектура. И React Query как раз помогает сделать это различие не только теоретическим, но и практическим.

Он также очень хорошо отвечает на ту усталость, которая накопилась от универсализма старого state management подхода. Долгое время фронтенд вел себя так, будто есть одно главное «состояние приложения», и нужно только выбрать правильный инструмент, чтобы его хранить. Сейчас уже видно, что это слишком грубая картина. Состояние в приложении разное по происхождению, по жизненному циклу, по стоимости ошибки, по характеру обновлений. И чем более точно мы подбираем инструмент под природу состояния, тем меньше boilerplate и меньше архитектурного самообмана получаем на выходе.

Если сформулировать совсем практично: Redux хорош там, где важен явный контроль над клиентскими переходами состояния. Context хорош там, где нужно передавать по дереву относительно простые и широкие значения без излишней инфраструктуры. React Query хорош там, где данные приходят с сервера и должны жить как кэш с понятной политикой свежести, повторного запроса и инвалидации. Как только команда начинает требовать от одного инструмента решить все три задачи разом, почти неизбежно рождается лишняя сложность. А когда каждый инструмент остается в своей сильной зоне, архитектура становится заметно спокойнее.

Итог

Поэтому в феврале 2020 года, если меня спросить, кто должен отвечать за серверные данные, я бы ответил так: не тот, кто исторически уже есть в проекте, и не тот, кто выглядит проще в первом демо, а тот, кто лучше понимает саму природу server state. И на этой территории React Query очень убедительно показывает, что вопрос можно наконец поставить точнее. Не «где нам еще хранить JSON», а «кто умеет жить с удаленными данными как с удаленными данными». Для очень многих React-приложений это и будет тем самым недостающим поворотом, после которого Redux и Context перестают казаться либо перегруженными, либо недостающими, а начинают занимать свои более честные места в общей системе.

Именно это, пожалуй, и делает нынешний момент таким важным. React-команда больше не обязана выбирать один универсальный state-инструмент ради всего на свете. Можно наконец разделить роли. И как только это разделение становится ясным, большая часть спора превращается не в войну библиотек, а в более зрелое архитектурное решение: server state — туда, где им действительно умеют управлять как server state; client state — туда, где его удобно и предсказуемо контролировать; широкий context — туда, где он действительно является контекстом, а не самодельным кэшем. Это не такая эффектная история, как победа одного лагеря. Но для реального React-проекта это куда более полезная форма взрослости.

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

Автор

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

Обновлено

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