Где RTK проигрывает middleware и RxJS: сложная асинхронщина без упрощений
Текст написан с позиции января 2023 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Redux Toolkit давно стал фактическим стандартом для Redux-приложений. Это уже не просто удобная надстройка, а основной рекомендованный способ писать Redux без лишнего шаблонного кода.createSlice, createAsyncThunk, встроенный Immer, хорошие дефолты, понятная организация стора — всё это действительно сделало RTK сильным шагом вперёд по сравнению с «классическим» Redux-подходом. Но вместе с популярностью пришёл и побочный эффект: у части команд возникло ощущение, будто RTK решает вообще всю проблему асинхронности внутри фронтенд-приложения.
Зафиксируем сразу: это не так. И самая вредная реакция на успех RTK — услышать, что он закрывает асинхронность, и решить, что одного этого инструмента хватит на любую динамику приложения. RTK очень хорош там, где нужно удобно организовать состояние, типовые асинхронные запросы, предсказуемые reducer-сценарии и простые жизненные циклы загрузки данных. Но как только асинхронщина становится действительно сложной — с отменами, конкуренцией потоков, реакцией на несколько источников событий, синхронизацией времени, последовательностями с branching-логикой, долгоживущими процессами и многослойной orchestration-механикой — начинают проявляться ограничения подхода. И дело здесь не в том, что RTK плох, а в том, что у каждого инструмента есть естественный диапазон задач. Именно в этих зонах middleware-подходы и RxJS оказываются не «старомодной экзотикой», а инструментами, которые решают класс задач точнее.
Почему RTK стал таким популярным
Для начала важно отдать RTK должное. Его успех не случаен. Redux долго критиковали за многословность, дублирование, громоздкие action types и обилие рутинного кода вокруг простых сценариев. Redux Toolkit снял значительную часть этой боли. Теперь можно быстро собрать slice, описать reducers в одном месте, не писать вручную иммутабельные обновления и без особых мучений подцепить асинхронный запрос через createAsyncThunk. Это была не косметика, а взросление: Redux перестал быть синонимом boilerplate.
Для большинства прикладных интерфейсов это действительно огромный выигрыш. Типовой CRUD, загрузка списка, отправка формы, обновление одной сущности, базовая индикация статусов idle / pending / fulfilled / rejected — со всем этим RTK справляется очень хорошо. Более того, именно такие задачи и встречаются в приложениях чаще всего. Поэтому неудивительно, что многие команды на каком-то этапе начинают рассматривать RTK не просто как способ управления состоянием, а как универсальную среду для всей бизнес-логики вокруг асинхронности.
Проблема в том, что удобство для простых сценариев и выразительность для сложных процессов — это не одно и то же. Здесь важно не перепутать: то, что отлично работает для одного запроса и его трёх статусов, может оказаться слишком грубым инструментом для асинхронного поведения, похожего уже не на запрос, а на поток событий. Это не вопрос качества RTK, а вопрос уровня абстракции, на котором он работает.
Где начинается «сложная асинхронщина»
Очень часто разговор о сложности асинхронного кода сводят к размеру функции. Но проблема не в количестве строк. Сложная асинхронщина начинается там, где приложение больше не живет в модели «по событию пользователя сделали запрос и получили ответ». Она начинается, когда есть конкурирующие запросы, зависимые шаги, отмена старых сценариев, повторные попытки с правилами, таймауты, дебаунс и троттлинг, синхронизация с WebSocket, реакция на роутинг, работу вкладки, авторизацию, сетевой статус и множество действий из разных зон приложения одновременно.
Именно в этот момент приложение перестает быть набором изолированных загрузок и превращается в систему процессов. Одни процессы стартуют по действиям пользователя, другие — по входящим событиям, третьи — по изменению состояния, четвертые — по таймерам, пятые — по комбинации условий. И здесь главный вопрос уже не в том, как удобно записать pending в стор, а в том, как выразить и контролировать саму динамику процесса.
RTK по своей природе все-таки ближе к модели «запусти асинхронный эффект и отрази его результат в состоянии». Middleware и RxJS гораздо ближе к модели «опиши правила жизни процессов, их взаимодействие, отмену, приоритеты и реакции на поток событий». Разница именно в этом уровне абстракции.
Почему createAsyncThunk хорош, но не всемогущ
createAsyncThunk — один из самых полезных инструментов RTK. Он снимает массу рутины, автоматически создает жизненный цикл actions и хорошо ложится на типовой запрос. Если задача звучит как «получить список пользователей» или «сохранить форму», решение получается быстрым и читаемым.
Но у этого удобства есть скрытая цена. createAsyncThunk понимает единицу асинхронной работы как сравнительно автономную операцию: старт, успешное завершение, ошибка. Даже если внутрь thunk можно положить более сложную логику, сама модель вокруг него остается линейной. В простых случаях это идеально. В сложных — становится тесно.
Скажем, если у вас есть несколько конкурирующих загрузок, которые должны взаимно отменяться по типу takeLatest, или цепочка, где следующий шаг зависит не только от ответа сервера, но и от новых событий пользователя, или процесс, который должен слушать несколько action-потоков в течение долгого времени, thunk быстро превращается в контейнер для ручного управления хаосом. Формально он все еще работает, но код перестает быть декларативным и начинает распадаться на проверочные флаги, ручные guards, промежуточные dispatch-вызовы и трудно читаемые ветвления.
Главное ограничение RTK: слабая выразительность для процессов
Если описать проблему в одном предложении, то RTK силен как инструмент описания состояния и типовых side effects, но слабее как язык описания долгоживущих асинхронных процессов. Его базовая сила — reducers, actions, slices, thunks, store wiring. А вот сложная конкуренция задач, управление жизненным циклом потоков, координация между несколькими источниками событий и реактивное комбинирование сигналов — это не те задачи, где он выглядит естественно.
Да, все это можно сделать и на RTK. Но ключевой вопрос не в возможности, а в цене решения. Если для описания процесса вам приходится вручную собирать отмены, держать request ids, сохранять актуальность, проверять версию данных, делать cascade-dispatch, опрашивать state внутри thunk и городить вокруг этого дополнительный протокол, значит инструмент уже работает на пределе своего естественного диапазона.
Middleware и RxJS выигрывают не потому, что умеют какую-то магию, а потому, что их модель ближе к самой природе такой задачи. Почему это так важно? Потому что они рассматривают асинхронность не как побочный факт запроса, а как первичный объект управления — а значит, отмена, конкуренция и время становятся встроенными понятиями модели, а не тем, что приходится дописывать руками поверх неё.
Где middleware выигрывает у RTK
Под middleware здесь стоит понимать не просто технический слой Redux, а полноценный архитектурный подход, в котором сложные side effects и реакция на действия вынесены в самостоятельный оркестрационный уровень. Исторически это могли быть разные решения: кастомные middleware, redux-thunk в более свободном виде, redux-saga, redux-observable и другие модели. Их общее достоинство в том, что они отделяют хранение состояния от механики процессов.
Это важно, потому что состояние и процесс — не одно и то же. State отвечает на вопрос «что сейчас известно приложению». Процесс отвечает на вопрос «что сейчас происходит, что должно произойти дальше, что надо отменить, а на что подписаться». Когда обе роли начинают жить в одном месте и одними примитивами, код быстро теряет форму.
Middleware-подход позволяет выделить orchestration как отдельную ответственность. Стор остается источником состояния. Reducers остаются детерминированными. А сложная асинхронная динамика оказывается в слое, который для этого и предназначен. В результате приложение становится проще читать: одно место отвечает за данные, другое — за поведение процессов.
Сценарий 1: отмена, конкуренция и актуальность данных
Первый класс задач, где RTK быстро начинает уступать, — конкурирующие асинхронные операции. Классический пример: пользователь быстро меняет фильтры в поиске или типовом data grid, приложение запускает несколько запросов подряд, а в интерфейсе должен остаться только самый актуальный результат. Формально это можно решить с помощью локальных проверок, AbortController, request id или guards в thunk. Но с ростом сложности такой код становится все менее прозрачным.
Middleware-подходы давно оперируют такими сценариями как базовыми примитивами. Идея «отменяй старое, сохраняй последнее», «игнорируй новые, пока работает текущее», «параллель, но с контролируемым fan-out», «гонка между несколькими источниками» — это естественный язык более специализированных инструментов. В RTK это чаще всего придется собирать вручную из отдельных деталей.
Ключевая проблема здесь в том, что конкуренция задач — это не просто деталь запроса. Это самостоятельная логика управления потоками. И чем раньше команда это признает, тем проще ей выбрать подходящий уровень абстракции.
Сценарий 2: долгоживущие процессы против разовых запросов
RTK особенно удобен для дискретных операций: отправить, получить, обновить, удалить. Но многие интерфейсы живут не только такими действиями. Есть процессы, которые существуют долго: подписка на WebSocket, live-обновление данных, отслеживание сетевого статуса, контроль сессии пользователя, периодический polling с условиями остановки, фоновые синхронизации, реакция на смену вкладки или экрана.
Запихивать такие процессы в createAsyncThunk обычно неудобно. Сам инструмент задуман скорее как оболочка для конечной асинхронной операции, а не как среда жизни для процессов, которые могут стартовать, приостанавливаться, возобновляться, переинициализироваться и завершаться по разным внешним сигналам. Да, можно стартовать отдельный цикл, диспатчить промежуточные события, хранить флаги в сторе. Но чем сложнее жизненный цикл, тем заметнее архитектурное напряжение.
Middleware и реактивные инструменты, напротив, естественно подходят к долгоживущим процессам. Для них поток событий и его трансформации — не исключение, а основа модели.
Сценарий 3: логика зависит от нескольких потоков событий
Очень часто сложный бизнес-сценарий зависит не от одного экшена и не от одного ответа сервера, а от комбинации событий. Например, нужно обновлять данные, только если пользователь авторизован, экран активен, фильтр валиден и сеть доступна. Или нужно запустить загрузку после двух независимых шагов настройки, но отменить ее, если пользователь ушел со страницы. Или нужно объединять поток пользовательского ввода с таймером, чтобы не перегружать сервер и при этом не терять отзывчивость интерфейса.
RTK не дает для этого особенно выразительного синтаксиса. В итоге разработчик начинает писать логику вида «в этом thunk прочитай state, проверь несколько флагов, потом dispatch другого thunk, затем снова проверь state, затем пропусти шаг, если условия уже изменились». Такой код может работать, но читать его и развивать заметно тяжелее.
RxJS выигрывает здесь потому, что сам язык этой библиотеки построен вокруг композиции потоков. Когда задача действительно описывается как взаимодействие нескольких stream-источников, реактивная модель часто оказывается не усложнением, а наоборот, способом наконец описать то, что на самом деле происходит.
Почему RxJS выглядит сложным — и где эта сложность оправдана
У RxJS репутация сложного инструмента, и она во многом заслужена. Это не библиотека для «быстренько получить список товаров». Она требует другого способа мышления: не через последовательные вызовы, а через потоки, операторы, композицию, трансформацию, объединение, отмену и реакцию во времени. Для команд, привыкших к обычному async/await и редьюсерной логике, входной порог действительно ощутим.
Но важно не путать субъективную непривычность с объективной избыточностью. RxJS становится оправданным ровно там, где сама задача имеет реактивную природу. Если интерфейс живет в пересечении пользовательских действий, таймеров, сетевых ответов, внешних подписок, live-событий и отменяемых процессов, попытка описать это как набор отдельных thunk-операций часто не упрощает, а искажает проблему.
Иначе говоря, RxJS сложен не потому, что «слишком умный», а потому, что умеет описывать сложные временные зависимости. Там, где этих зависимостей действительно много, он может быть честнее по отношению к задаче, чем более простой на вид инструмент.
Где именно RxJS выигрывает у RTK
Самое сильное преимущество RxJS — выразительность при работе с асинхронными потоками. Дебаунс, троттлинг, переключение на последний запрос, отмена предыдущего, объединение нескольких источников, ожидание нужного условия, повторные попытки по правилам, таймауты, буферизация, группировка событий, реакция на изменение состояния во времени — все это родные сценарии для реактивного подхода.
В RTK такие вещи обычно приходится раскладывать на вспомогательные конструкции вокруг thunk или побочных dispatch-цепочек. В RxJS они становятся частью языка решения. Это особенно видно в интерфейсах с живым поиском, автокомплитом, подписками, дашбордами, потоками уведомлений, режимами онлайн-синхронизации, сложной форменной логикой и любыми сценариями, где важен не просто ответ сервера, а временное поведение всей системы.
Еще одна важная победа RxJS — управляемость отмены. В обычном императивном коде отмена часто выглядит как дополнительная обязанность, которую нужно не забыть протащить через все уровни. В реактивной модели это чаще оказывается встроенной частью цепочки.
RTK и middleware решают разные задачи, а не одну и ту же
Одна из причин вечных споров о Redux Toolkit, middleware и RxJS — ложная постановка вопроса. Часто обсуждение выглядит так, будто все эти инструменты претендуют на одну и ту же роль, и нужно выбрать «победителя». В реальности границы более тонкие. RTK отлично решает задачу организации стора, reducers, actions и стандартных асинхронных сценариев вокруг данных. Middleware и RxJS лучше решают задачу orchestration сложных процессов.
Проблемы начинаются тогда, когда один инструмент пытаются растянуть на территорию другого. Если использовать RTK как универсальный язык асинхронного поведения, появится перегрузка thunk-логикой. Если тянуть RxJS туда, где нужен просто список и один запрос, получится неоправданная тяжесть. Поэтому зрелая архитектура чаще строится не на противопоставлении, а на честном распределении ролей.
Это особенно важно сейчас, потому что фронтенд-приложения стали слишком разными. В одном месте действительно достаточно RTK и пары thunks. В другом уже нужен полноценный orchestration-слой, иначе сложность не исчезнет, а просто сменит форму — переедет из честного слоя в комментарии, флаги и устные договорённости команды.
Характерный антипример: когда thunk становится мини-сагой вручную
Один из самых надежных сигналов, что RTK используется не по адресу, — когда обычный thunk начинает незаметно превращаться в самодельную сагу. Внутри него появляются циклы ожидания, проверка нескольких условий, ручные отмены, чтение state на каждом шаге, каскадные dispatch-вызовы, флаги актуальности, контроль версий данных, логика повторов, таймеры и ветвление в зависимости от внешних событий.
Формально такой код может выглядеть как «всего лишь один thunk», но по сути он уже описывает полноценный процессор событий. И если команда продолжает держать эту механику внутри thunk только потому, что «мы же на RTK», она просто отказывается назвать проблему своим именем.
Такие конструкции обычно особенно неприятны в поддержке. Они плохо тестируются, тяжело читаются и очень легко ломаются при незначительном изменении бизнес-логики. Причина не в плохом разработчике, а в том, что инструмент с линейной моделью пытаются использовать для нелинейной задачи.
Что насчет RTK Query
К началу 2023 года RTK Query уже занял заметное место в экосистеме как удобное решение для data fetching, кэширования, статусов загрузки и синхронизации серверного состояния. Для большого класса задач это очень сильный инструмент. Он снимает много рутины вокруг запросов, инвалидации и повторного использования данных. Но и здесь стоит сохранять трезвость и не услышать в его появлении обещание, которого он не давал.
RTK Query отлично работает для server state и стандартного жизненного цикла запросов. Но сам по себе он не превращает Redux Toolkit в универсальный движок сложной асинхронной оркестрации. Если проблема у вас именно в потоках событий, сложных правилах отмены, многошаговых сценариях и длительных процессах, RTK Query не решит это автоматически. Он может закрыть часть инфраструктуры запросов, но не заменяет middleware-модель там, где нужна именно процессная логика.
Когда стоит оставаться на RTK
Чтобы не превратить эту статью в несправедливую атаку на RTK, важно сказать и обратное. Во множестве приложений нет смысла тащить сложные middleware или RxJS. Если большая часть асинхронности у вас состоит из стандартных запросов, загрузки списков, отправки форм, обновления записей, кэширования и типовых UI-состояний, RTK остается отличным выбором. Он проще в команде, понятнее новичкам, требует меньше входного обучения и позволяет быстро держать кодовую базу в хорошем состоянии.
Даже если отдельные сложные сценарии существуют, это не всегда значит, что весь проект нужно перестраивать вокруг реактивного мышления. Иногда достаточно локально выделить orchestration-слой для конкретной зоны, а остальную часть приложения оставить на привычном RTK-подходе. Это часто оказывается намного разумнее, чем идеологический разворот всей архитектуры.
Когда пора смотреть в сторону middleware или RxJS
Есть несколько признаков, что проект подошел к этой границе. Первый — в thunk-логике все чаще появляются ручные отмены и контроль конкуренции. Второй — бизнес-сценарии начинают зависеть не от одного запроса, а от комбинации событий во времени. Третий — появляются долгоживущие процессы, которые плохо описываются как «один async-вызов». Четвертый — код orchestration начинает размазываться между компонентами, thunk и reducers, и никто уже не может быстро ответить, где именно живет логика процесса.
Пятый признак особенно важен: если разработчики постоянно спорят о том, какой thunk должен диспатчить другой thunk и в каком месте правильнее проверять актуальность состояния, значит проблема уже не в стиле кода, а в неудачном уровне абстракции. В такой момент специализированный middleware- или reactive-слой обычно дает не усложнение, а структурное облегчение.
Архитектурный вывод: state management и async orchestration надо разделять
Главный практический вывод звучит так: управление состоянием и управление сложной асинхронной динамикой — это близкие, но разные задачи. RTK очень силён в первой. Middleware и RxJS часто сильнее во второй. Проблемы возникают не тогда, когда выбран «не тот» инструмент, а когда одна из этих задач маскируется под другую и решается чужими примитивами.
Если смотреть на фронтенд как на систему состояний, RTK кажется почти полным ответом. Если смотреть на него как на систему процессов, событий, подписок, гонок, отмен и временных зависимостей, становится ясно, что одних reducer- и thunk-примитивов иногда недостаточно. В этом и состоит зрелость архитектурного решения: не искать одну библиотеку «на все», а признавать, что разные уровни сложности требуют разных моделей описания.
Заключение
Redux Toolkit — сильный и современный инструмент, который отлично решает огромный класс практических задач в React- и Redux-приложениях. Но его удобство на типовой асинхронности не означает универсального превосходства над middleware-подходами и RxJS. Как только в приложении появляются конкурирующие процессы, долгоживущие сценарии, реакция на несколько потоков событий, сложная отмена, временные зависимости и orchestration-логика, RTK начинает терять выразительность.
Middleware выигрывает там, где нужно явно отделить процессы от состояния и держать сложные side effects в самостоятельном слое. RxJS выигрывает там, где сама природа задачи потоковая и реактивная, а значит временные отношения между событиями важнее, чем линейный жизненный цикл одного запроса. Это не делает RTK плохим. Это просто возвращает его на правильное место: мощный инструмент state management и стандартной асинхронности, но не обязательно лучший язык для всей сложной динамики приложения.
По-настоящему зрелый подход состоит не в том, чтобы выбрать одно знамя и подчинить ему всю архитектуру. Он состоит в том, чтобы честно посмотреть на форму своей асинхронности. Если она простая, RTK даст максимальную пользу при минимальной цене. Если она сложная, middleware и RxJS перестают быть «излишеством» и становятся теми инструментами, которые позволяют наконец описывать систему без самообмана и без опасных упрощений. И стоит честно сказать про цену второго пути: за выразительность RxJS платят входным порогом и риском over-engineering там, где хватило бы одного thunk, — поэтому реактивный слой имеет смысл вводить точечно, под конкретную зону сложности, а не как идеологию на весь проект.
Если сформулировать главный вывод совсем прямо, он будет таким: RTK проигрывает middleware и RxJS не в качестве, а в природе задачи — это язык описания состояния и разовых side effects, тогда как конкуренция потоков, отмена, долгоживущие процессы и временные зависимости требуют отдельного orchestration-слоя; и когда вы держите всю эту динамику внутри thunk, вы не убираете сложность, а лишь прячете её туда, где её тяжелее всего читать, тестировать и менять через полгода.