Веб-фреймворки в разных экосистемах: что происходит с некорректным запросом

Двенадцать приложений с одним и тем же API — минимальный и полный фреймворк в Go, Rust, Python, Node, Java и C# — и одинаковые запросы к ним. Что фреймворк делает по умолчанию, а что остаётся на вас: 405 или 404 на неверный метод, принимает ли тело без обязательного поля, ограничивает ли размер запроса, что отдаёт клиенту при исключении в обработчике. Ответ — поведение фреймворка вместе с кодом примера и режимом запуска, и «полный» не значит «проверяет больше»: NestJS и Spring Boot без настроенной валидации принимают тело без обязательного поля так же, как net/http

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

Веб-фреймворки в разных экосистемах: что происходит с некорректным запросом

Статья серии «Поперёк языков». Стенд — digital-cookbook/architecture/web-frameworks: двенадцать приложений, по паре «минимальный — полный» в шести экосистемах, реализуют один и тот же маленький API и получают одни и те же запросы.

Пары и правило честного сравнения

экосистема минимальный полный
Go net/http (Go 1.27) Gin 1.12.0
Rust axum 0.8.9 actix-web 4.15.0
Python Flask 3.1.3 FastAPI 0.142.2 + uvicorn 0.54.0
Node Express 5.2.1 NestJS 12.1.2
Java Javalin 7.2.3 (Jackson 2.22.3) Spring Boot 4.1.1
C# ASP.NET Core Minimal API (.NET SDK 10.0.401) ASP.NET Core MVC (.NET SDK 10.0.401)

«Минимальный» и «полный» здесь — рабочая классификация, а не оценка. Минимальный — это роутер и разбор запроса, остальное подключается отдельно. Полный сам несёт модель приложения: контейнер зависимостей, контроллеры или модели данных, конвейер обработки запроса. Ответы на запросы полноту не определяют — они показывают умолчания.

API у всех один: GET /items/{id}, POST /items с полями name и qty, и GET /boom, где обработчик бросает исключение. Контракт, по которому читаются результаты:

  • id — десятичное целое, весь сегмент пути; 0 допустим, 1abc — нет;
  • name — обязательный ключ со строкой, пустая строка допустима;
  • qty — целое число; строка (в том числе числовая, "1") и дробь — ошибка клиента;
  • тело — ровно один JSON-объект, остаток после него — ошибка клиента;
  • ошибка клиента — 400 или 422, а не 201 и не 500.

Правило — короткий идиоматичный код без библиотек сверх самого фреймворка, как в его руководстве для начала работы. Если валидация в экосистеме — отдельный пакет (class-validator для NestJS, spring-boot-starter-validation для Spring), его нет. Поэтому каждый ответ ниже — поведение фреймворка вместе с кодом примера. Где пример сам выбирает правило — binding:"required" в Gin, Integer.parseInt в Javalin, item["name"] во Flask, — это сказано рядом с результатом.

Режим запуска тоже часть условий: от него зависят ошибки и старт.

приложение как запущено
net/http http.ListenAndServe, без настроек
Gin gin.Default() (Logger и Recovery), режим ReleaseMode
axum, actix-web сборка --release, без слоёв сверх роутера
Flask flask run — сервер разработки Werkzeug, отладка выключена; не для продакшена
FastAPI uvicorn app:app, один процесс
Express, NestJS node, NODE_ENV не задан — режим разработки
Javalin Javalin.create(...).start(), встроенный Jetty
Spring Boot java -jar, профиль по умолчанию, встроенный Tomcat
Minimal API, MVC dotnet app.dll, ASPNETCORE_ENVIRONMENT не задан — среда Production

Версии, закреплённые зависимости и устройство опытов — в README стенда. C++ и Scala, которые были в плане статьи, в стенд не вошли: сборка Drogon и http4s заняла бы больше, чем дала бы сравнению. Их сильные стороны — в статьях о веб-фреймворках C++ и о типобезопасном вебе на Scalaготовится, с 1 января 2027.

Контроль: все двенадцать работают

Прежде чем сравнивать отказы, надо убедиться, что приложения отвечают на корректный запрос по контракту: POST — 201 и переданное name в ответе, GET — 200 и id в ответе. Иначе «400» может значить не строгую валидацию, а сломанный обработчик.

$ python3 scripts/run-checks.py control
{"variant": "control", "outcome": "match", "detail": "корректный POST: net/http — 201, Gin — 201, axum — 201, actix-web — 201, Flask — 201, FastAPI — 201, Express — 201, NestJS — 201, Javalin — 201, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 201; name в ответе: net/http — да, Gin — да, axum — да, actix-web — да, Flask — да, FastAPI — да, Express — да, NestJS — да, Javalin — да, Spring Boot — да, Minimal API — да, ASP.NET MVC — да; GET: net/http — 200, Gin — 200, axum — 200, actix-web — 200, Flask — 200, FastAPI — 200, Express — 200, NestJS — 200, Javalin — 200, Spring Boot — 200, Minimal API — 200, ASP.NET MVC — 200; id в ответе: net/http — да, Gin — да, axum — да, actix-web — да, Flask — да, FastAPI — да, Express — да, NestJS — да, Javalin — да, Spring Boot — да, Minimal API — да, ASP.NET MVC — да; Javalin со штатным валидатором, GET /typed/items/1: да"}

Маршрутизация: 405 или 404, слэш и разбор id

фреймворк DELETE на путь с GET Allow при 405 GET /items/1/ POST /items/ /items/abc /items/1abc /items/0
net/http 405 да 404 404 400 400 200
Gin 404 — 301 307 400 400 400
axum 405 да 404 404 400 400 200
actix-web 404 — 404 404 404 404 200
Flask 405 да 404 404 404 404 200
FastAPI 405 да 307 307 422 422 200
Express 404 — 200 201 400 200 200
NestJS 404 — 200 201 400 400 200
Javalin 404 — 200 201 500 500 200
Spring Boot 405 да 404 404 400 400 200
Minimal API 405 да 200 201 404 404 200
MVC 405 да 200 201 404 404 200

Неверный метод. По HTTP запрос DELETE к пути, где есть только GET, должен получить 405 с заголовком Allow.

404 вместо 405 отвечают пять из двенадцати: Gin, actix-web, Express, NestJS и Javalin. У всех, кто отвечает 405, есть заголовок Allow со списком разрешённых методов.

Для клиента это разная диагностика: 404 отправит искать опечатку в адресе, 405 — проверять метод. В Gin 405 включается флагом HandleMethodNotAllowed, в Javalin — настройкой маршрутизатора.

Слэш в конце. /items/1/ — это тот же ресурс или нет? На GET Gin отвечает 301, FastAPI — 307: оба перенаправляют на путь без слэша. Express, NestJS, Javalin и ASP.NET Core считают пути равными, остальные отвечают 404. По GET нельзя судить о POST: Gin выбирает код по методу — 301 для GET, 307 для остальных.

На POST /items/ с телом перенаправляют Gin и FastAPI — оба кодом 307, который сохраняет метод и тело; повтор того же POST по Location в стенде дошёл до обработчика с тем же телом: Gin — да, FastAPI — да.

С 301 клиенту разрешено (не предписано) сменить POST на GET, и браузеры так делают; 307 и 308 метод и тело сохраняют. А если перед сервисом стоит прокси, нормализующий пути по-своему, расхождение правил превращается в 404 «только иногда».

Разбор id. Ошибка привязки параметра — ошибка клиента, 400 или 422. Но три приложения отвечают 404, и причины у них две. Во Flask (конвертер int) и ASP.NET Core (ограничение маршрута {id:int}) путь не совпал с шаблоном — маршрута для /items/abc просто нет. В actix-web маршрут /items/{id} совпал, но экстрактор web::Path<i64> не смог разобрать значение, и его ошибка по умолчанию превращается в 404; поменять это можно обработчиком ошибок в PathConfig::error_handler. Javalin отвечает 500 — это выбор примера, а не фреймворка: Integer.parseInt в обработчике бросил исключение, которое никто не перехватил. Тот же маршрут со штатным ctx.pathParamAsClass("id", Integer.class).get() отвечает 400 — это контрольный маршрут стенда. Два края того же правила: Express берёт из 1abc число 1 (Number.parseInt читает префикс), а Gin отвергает 0 — binding:"required" в примере понимает обязательность как «не нулевое значение».

$ python3 scripts/run-checks.py routing
{"variant": "routing", "outcome": "match", "detail": "DELETE на существующий путь: net/http — 405, Gin — 404, axum — 405, actix-web — 404, Flask — 405, FastAPI — 405, Express — 404, NestJS — 404, Javalin — 404, Spring Boot — 405, Minimal API — 405, ASP.NET MVC — 405; Allow при 405: net/http — да, Gin — —, axum — да, actix-web — —, Flask — да, FastAPI — да, Express — —, NestJS — —, Javalin — —, Spring Boot — да, Minimal API — да, ASP.NET MVC — да; GET со слэшем в конце: net/http — 404, Gin — 301, axum — 404, actix-web — 404, Flask — 404, FastAPI — 307, Express — 200, NestJS — 200, Javalin — 200, Spring Boot — 404, Minimal API — 200, ASP.NET MVC — 200; POST со слэшем в конце: net/http — 404, Gin — 307, axum — 404, actix-web — 404, Flask — 404, FastAPI — 307, Express — 201, NestJS — 201, Javalin — 201, Spring Boot — 404, Minimal API — 201, ASP.NET MVC — 201; тело дошло при повторе POST по Location: net/http — —, Gin — да, axum — —, actix-web — —, Flask — —, FastAPI — да, Express — —, NestJS — —, Javalin — —, Spring Boot — —, Minimal API — —, ASP.NET MVC — —; id=abc: net/http — 400, Gin — 400, axum — 400, actix-web — 404, Flask — 404, FastAPI — 422, Express — 400, NestJS — 400, Javalin — 500, Spring Boot — 400, Minimal API — 404, ASP.NET MVC — 404; id=1abc: net/http — 400, Gin — 400, axum — 400, actix-web — 404, Flask — 404, FastAPI — 422, Express — 200, NestJS — 400, Javalin — 500, Spring Boot — 400, Minimal API — 404, ASP.NET MVC — 404; id=0: net/http — 200, Gin — 400, axum — 200, actix-web — 200, Flask — 200, FastAPI — 200, Express — 200, NestJS — 200, Javalin — 200, Spring Boot — 200, Minimal API — 200, ASP.NET MVC — 200; неизвестный путь: net/http — 404, Gin — 404, axum — 404, actix-web — 404, Flask — 404, FastAPI — 404, Express — 404, NestJS — 404, Javalin — 404, Spring Boot — 404, Minimal API — 404, ASP.NET MVC — 404; Javalin со штатным валидатором, id=abc: 400"}

Валидация: «полный» не значит «проверяет»

Главный вопрос: что будет, если клиент пришлёт тело без обязательного поля name.

фреймворк битый JSON без name name: "" qty: "many" qty: "1" qty: 1.5 мусор после JSON
net/http 400 201 201 400 400 400 201
Gin 400 400 400 400 400 400 201
axum 400 422 201 422 422 422 400
actix-web 400 400 201 400 400 400 400
Flask 400 500 201 201 201 201 400
FastAPI 422 422 201 422 201 422 422
Express 400 201 201 201 201 201 400
NestJS 400 201 201 201 201 201 400
Javalin 500 201 201 500 201 201 201
Spring Boot 400 201 201 400 201 201 400
Minimal API 400 201 201 400 201 400 400
MVC 400 400 201 400 201 400 400

Тело без name приняли с 201 шесть из двенадцати: net/http, Express, NestJS, Javalin, Spring Boot и Minimal API.

Среди них не только минимальные фреймворки. NestJS описывает тело классом-DTO, но сам класс ничего не проверяет: типовые аннотации стираются при компиляции, а проверку запроса делает ValidationPipe. Для показанного DTO нужны и настроенный ValidationPipe, и пакеты class-validator и class-transformer, и декораторы правил на полях. Для этого контракта — @IsString() на name: при настройках по умолчанию отсутствующее поле он отвергает, а пустую строку пропускает. Spring Boot разбирает тело в record и отдаёт null в поле name; одного стартера валидации и @Valid мало — на компоненте record нужно ограничение по контракту, здесь @NotNull. @IsNotEmpty и @NotBlank запретили бы пустую строку — это уже другой контракт, и та же ошибка, что у binding:"required" в Gin. Minimal API в .NET тоже не проверяет атрибуты без явной регистрации.

Проверяют те, у кого валидация — часть привязки тела: Gin (binding:"required" в примере), actix-web и axum (обязательное поле в структуре serde), FastAPI (модель pydantic), MVC ([ApiController] и неявная обязательность ненулевого string при включённых nullable-аннотациях). Flask отвечает 500 — KeyError в обработчике примера, который полагался на наличие поля.

Два запроса показывают, что «строгость» — не одно свойство. Пустая строка в name по контракту допустима; её отвергает только Gin — тот же binding:"required", что и у /items/0. MVC, который отвергает отсутствующее name, пустую строку пропускает. А тело с мусором после объекта, {"name":"x","qty":1} garbage, приняли оба Go-приложения и Javalin: json.Decoder в Go и Jackson 2 с настройками по умолчанию читают первое значение и остаток не проверяют. Одного запроса {bad для вывода о строгости разбора недостаточно.

Целое qty числовой строкой "1" приняли с 201 восемь из двенадцати: Flask, FastAPI, Express, NestJS, Javalin, Spring Boot, Minimal API и MVC. Дробь 1.5 вместо целого приняли пять: Flask, Express, NestJS, Javalin и Spring Boot.

Отказ на "many" ничего не говорит о строгости типов: непреобразуемую строку отвергает каждый, у кого тип вообще проверяется. Числовую строку "1" pydantic в нестрогом режиме, Jackson и System.Text.Json с настройками ASP.NET Core по умолчанию молча превращают в число. Строгость включается явно: strict в pydantic, отключение ALLOW_COERCION_OF_SCALARS и ACCEPT_FLOAT_AS_INT в Jackson, JsonNumberHandling.Strict в ASP.NET Core.

$ python3 scripts/run-checks.py validation
{"variant": "validation", "outcome": "match", "detail": "битый JSON: net/http — 400, Gin — 400, axum — 400, actix-web — 400, Flask — 400, FastAPI — 422, Express — 400, NestJS — 400, Javalin — 500, Spring Boot — 400, Minimal API — 400, ASP.NET MVC — 400; без name: net/http — 201, Gin — 400, axum — 422, actix-web — 400, Flask — 500, FastAPI — 422, Express — 201, NestJS — 201, Javalin — 201, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 400; name пустой строкой: net/http — 201, Gin — 400, axum — 201, actix-web — 201, Flask — 201, FastAPI — 201, Express — 201, NestJS — 201, Javalin — 201, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 201; qty строкой \"many\": net/http — 400, Gin — 400, axum — 422, actix-web — 400, Flask — 201, FastAPI — 422, Express — 201, NestJS — 201, Javalin — 500, Spring Boot — 400, Minimal API — 400, ASP.NET MVC — 400; qty числовой строкой \"1\": net/http — 400, Gin — 400, axum — 422, actix-web — 400, Flask — 201, FastAPI — 201, Express — 201, NestJS — 201, Javalin — 201, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 201; qty дробью 1.5: net/http — 400, Gin — 400, axum — 422, actix-web — 400, Flask — 201, FastAPI — 422, Express — 201, NestJS — 201, Javalin — 201, Spring Boot — 201, Minimal API — 400, ASP.NET MVC — 400; мусор после JSON: net/http — 201, Gin — 201, axum — 400, actix-web — 400, Flask — 400, FastAPI — 422, Express — 400, NestJS — 400, Javalin — 201, Spring Boot — 400, Minimal API — 400, ASP.NET MVC — 400"}

Разные коды ответа — тоже контракт. 400 и 422 значат «исправьте запрос», 500 — «у нас что-то сломалось», и клиент с ретраями на 5xx будет повторять запрос, который не пройдёт никогда. FastAPI и axum отвечают на ошибки содержимого 422, а на битый JSON — кто 400, кто 422: если клиенты различают эти коды, это надо записать в контракт API, а не выяснять в продакшене.

Размер тела

Один большой запрос не отличает «лимита нет» от «лимит выше этого размера». Поэтому стенд шлёт серию тел — чуть ниже и чуть выше известных порогов (express.json, maxRequestSize Javalin, лимит экстрактора Json в axum и JsonConfig в actix-web, MaxRequestBodySize Kestrel) — и самое большое в 40 МиБ.

фреймворк наибольшее принятое тело, байт наименьшее отвергнутое, байт
net/http 41 943 040 —
Gin 41 943 040 —
axum 2 000 000 2 200 000 (413)
actix-web 2 000 000 2 200 000 (413)
Flask 41 943 040 —
FastAPI 41 943 040 —
Express 90 000 110 000 (413)
NestJS 90 000 110 000 (413)
Javalin 900 000 1 100 000 (413)
Spring Boot 41 943 040 —
Minimal API 29 000 000 31 000 000 (413)
MVC 29 000 000 31 000 000 (413)

Тело в 41 943 040 байт — самое большое в серии — приняли пять из двенадцати: net/http, Gin, Flask, FastAPI и Spring Boot.

Точный вывод опыта узкий: этот обработчик принял тело такого размера. Это не доказывает, что лимитов нет вовсе. Общий лимит HTTP-тела и ограничения JSON-парсера — разные вещи: у Jackson, например, свои StreamReadConstraints на длину строки, число и вложенность, и в стенде большая строка — одно поле name. Но для этих пяти приложений серия не нашла порога ниже 40 МиБ, и защиту от больших тел надо ставить самому.

У остальных порог виден по соседним размерам серии. Лимит стоит задавать явно, в одном месте — обычно на прокси перед сервисом и в самом сервисе, — а не полагаться на то, что фреймворк его поставил.

$ python3 scripts/run-checks.py limits
{"variant": "limits", "outcome": "match", "detail": "тело 90000 байт: net/http — 201, Gin — 201, axum — 201, actix-web — 201, Flask — 201, FastAPI — 201, Express — 201, NestJS — 201, Javalin — 201, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 201; тело 110000 байт: net/http — 201, Gin — 201, axum — 201, actix-web — 201, Flask — 201, FastAPI — 201, Express — 413, NestJS — 413, Javalin — 201, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 201; тело 900000 байт: net/http — 201, Gin — 201, axum — 201, actix-web — 201, Flask — 201, FastAPI — 201, Express — 413, NestJS — 413, Javalin — 201, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 201; тело 1100000 байт: net/http — 201, Gin — 201, axum — 201, actix-web — 201, Flask — 201, FastAPI — 201, Express — 413, NestJS — 413, Javalin — 413, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 201; тело 2000000 байт: net/http — 201, Gin — 201, axum — 201, actix-web — 201, Flask — 201, FastAPI — 201, Express — 413, NestJS — 413, Javalin — 413, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 201; тело 2200000 байт: net/http — 201, Gin — 201, axum — 413, actix-web — 413, Flask — 201, FastAPI — 201, Express — 413, NestJS — 413, Javalin — 413, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 201; тело 29000000 байт: net/http — 201, Gin — 201, axum — 413, actix-web — 413, Flask — 201, FastAPI — 201, Express — 413, NestJS — 413, Javalin — 413, Spring Boot — 201, Minimal API — 201, ASP.NET MVC — 201; тело 31000000 байт: net/http — 201, Gin — 201, axum — 413, actix-web — 413, Flask — 201, FastAPI — 201, Express — 413, NestJS — 413, Javalin — 413, Spring Boot — 201, Minimal API — 413, ASP.NET MVC — 413; тело 41943040 байт: net/http — 201, Gin — 201, axum — 413, actix-web — 413, Flask — 201, FastAPI — 201, Express — 413, NestJS — 413, Javalin — 413, Spring Boot — 201, Minimal API — 413, ASP.NET MVC — 413"}

Исключение в обработчике

фреймворк исключение в обработчике сообщение или стек в теле заголовки о сервере
net/http нет ответа: соединение закрыто нет —
Gin 500 нет —
axum нет ответа: соединение закрыто нет —
actix-web нет ответа: соединение закрыто нет —
Flask 500 нет Server: Werkzeug/3.1.9 Python/3.14.7
FastAPI 500 нет Server: uvicorn
Express 500 да X-Powered-By: Express
NestJS 500 нет X-Powered-By: Express
Javalin 500 нет —
Spring Boot 500 нет —
Minimal API 500 нет Server: Kestrel
MVC 500 нет Server: Kestrel

Не отвечают вовсе три: net/http, axum и actix-web. Отвечают 500 без сообщения исключения и стека в теле восемь из двенадцати, с сообщением или стеком — одно: Express.

Ответа нет вовсе. net/http, axum и actix-web на панику в обработчике закрывают соединение без ответа: сервер не падает, но клиент получает обрыв, а не 500. Стенд отличает это от таймаута по классу транспортной ошибки: соединение закрыто сразу. Ретраи прокси или клиента могут повторить запрос — и повторить панику. В Gin это закрыто middleware Recovery, которое входит в gin.Default(); в axum — слоем CatchPanic из tower-http.

Стек в ответе. Express без NODE_ENV=production отдаёт в теле ответа текст исключения и стек с путями к файлам. Это поведение режима разработки, и переменную окружения забывают чаще, чем кажется. Проверка ищет уникальную метку из сообщения исключения и следы стека в сыром теле, в HTML-раскодированном и в строках разобранного JSON: экранирование \uXXXX или &#…; не должно прятать утечку. У самого детектора свои контроли — те же утечки в разных представлениях и общий текст ошибки без утечки.

Имя сервера. Flask (Werkzeug с версиями Werkzeug и Python), uvicorn, Express и NestJS (X-Powered-By: Express) и Kestrel раскрывают себя в заголовках. Само по себе это не уязвимость, но облегчает подбор известных уязвимостей под версию; отключается одной настройкой в каждом.

$ python3 scripts/run-checks.py errors
{"variant": "errors", "outcome": "match", "detail": "исключение в обработчике: net/http — нет ответа, Gin — 500, axum — нет ответа, actix-web — нет ответа, Flask — 500, FastAPI — 500, Express — 500, NestJS — 500, Javalin — 500, Spring Boot — 500, Minimal API — 500, ASP.NET MVC — 500; транспорт: net/http — closed, Gin — ok, axum — closed, actix-web — closed, Flask — ok, FastAPI — ok, Express — ok, NestJS — ok, Javalin — ok, Spring Boot — ok, Minimal API — ok, ASP.NET MVC — ok; сообщение или стек в теле: net/http — нет, Gin — нет, axum — нет, actix-web — нет, Flask — нет, FastAPI — нет, Express — да, NestJS — нет, Javalin — нет, Spring Boot — нет, Minimal API — нет, ASP.NET MVC — нет; сервер раскрывает себя в заголовках: net/http — нет, Gin — нет, axum — нет, actix-web — нет, Flask — да, FastAPI — да, Express — да, NestJS — да, Javalin — нет, Spring Boot — нет, Minimal API — да, ASP.NET MVC — да; контроли детектора утечки: сошлись"}

Цена полноты: старт

Полный фреймворк обычно дольше стартует: сканирует классы, строит контейнер зависимостей, регистрирует обработчики. Абсолютное время зависит от машины, поэтому стенд сравнивает только время до первого ответа полного фреймворка к минимальному в своей экосистеме.

$ python3 scripts/run-checks.py footprint
{"variant": "footprint", "outcome": "match", "detail": "старт до первого ответа, медиана трёх запусков: Spring Boot дольше Javalin больше чем в 1,5 раза — да; Gin и net/http в пределах двух раз — да"}

Время до первого ответа полного к минимальному в этом прогоне (медиана трёх запусков): Gin к net/http — 1,31; actix-web к axum — 0,73; FastAPI к Flask — 1,49; NestJS к Express — 1,56; Spring Boot к Javalin — 2,11; MVC к Minimal API — 0,91.

Устойчиво заметна разница только в Java: Spring Boot до первого ответа в каждом прогоне вдвое с лишним дольше Javalin. NestJS тоже медленнее Express, но насколько — от прогона к прогону меняется от полутора до двух с лишним раз: Express стартует так быстро, что почти всё время до первого ответа уходит на запуск контейнера, и его разброс решает исход. Поэтому стенд проверяет только пару Java, а соотношение Node показывает без вывода. В Go, Rust и C# пары стартуют примерно одинаково. Для долгоживущего сервиса это не важно; для функций, которые стартуют на каждый запрос, и для автоскейлинга с частыми запусками — важно. Отношение памяти стенд тоже снимает, но оно шумит от прогона к прогону сильнее, чем различается между фреймворками, и выводов из него не делает.

Как выбирать

Минимальный фреймворк не делает меньше работы — он оставляет её вам, и в первую очередь ту, которую не видно, пока не случится отказ. Полный делает больше, но не обязательно то, что вы ждёте: валидация в NestJS и Spring Boot — отдельный пакет с отдельной настройкой, а не часть «полноты».

Ниже — точки настройки: где в каждом фреймворке задаётся правило. Само правило берётся из контракта: преобразование типов, остаток после JSON, разбор параметров пути, пустые строки. Подключить механизм мало — нужно выставить в нём именно эти правила и проверить их запросами, как в стенде.

фреймворк валидатор тела строгие типы и остаток JSON параметры пути лимит тела исключение в обработчике режим
net/http проверки в коде целевой тип поля; остаток — второй Decode должен вернуть io.EOF strconv в обработчике http.MaxBytesReader свой middleware с recover —
Gin теги binding с нужной семантикой как в net/http: проверка остатка тела тег uri без required для допустимого 0 http.MaxBytesReader в middleware Recovery уже в gin.Default() ReleaseMode
axum типы serde строгие по умолчанию Path<T>; ответ на ошибку — свой экстрактор или Rejection DefaultBodyLimit CatchPanicLayer из tower-http —
actix-web типы serde строгие по умолчанию PathConfig::error_handler вместо 404 JsonConfig::limit перехват паники вокруг обработчика —
Flask pydantic или marshmallow строгая схема конвертер int даёт 404 — свой конвертер или проверка в коде MAX_CONTENT_LENGTH errorhandler WSGI-сервер вместо сервера разработки
FastAPI модель pydantic strict в модели аннотация типа, ответ 422 middleware или прокси exception_handler —
Express схема (zod, ajv) строгая схема; express.json и так отвергает остаток проверка всего сегмента, не parseInt express.json({ limit }) обработчик ошибок (err, req, res, next) NODE_ENV=production
NestJS ValidationPipe + class-validator + декораторы @IsInt() без преобразования ParseIntPipe useBodyParser с лимитом фильтр исключений NODE_ENV=production
Javalin bodyValidator, pathParamAsClass ALLOW_COERCION_OF_SCALARS, ACCEPT_FLOAT_AS_INT, FAIL_ON_TRAILING_TOKENS в Jackson pathParamAsClass вместо parseInt maxRequestSize обработчик exception —
Spring Boot стартер валидации, @Valid и ограничения на полях ALLOW_COERCION_OF_SCALARS, ACCEPT_FLOAT_AS_INT в Jackson @PathVariable с типом фильтр или прокси @ControllerAdvice профиль продакшена
Minimal API AddValidation() и атрибуты на модели JsonNumberHandling.Strict ограничение маршрута даёт 404 — привязка без ограничения даёт 400 MaxRequestBodySize UseExceptionHandler среда Production
MVC атрибуты на модели JsonNumberHandling.Strict как в Minimal API MaxRequestBodySize UseExceptionHandler среда Production

Независимо от выбора стоит проверить на своём сервисе то же, что проверяет стенд:

  • корректный запрос — проходит, и ответ по контракту (контроль);
  • тело без обязательного поля, с числовой строкой и дробью вместо целого и с мусором после JSON — 400 или 422, а не 201 и не 500;
  • параметр пути с цифровым префиксом и граничные значения — по контракту;
  • тело чуть больше вашего лимита — 413;
  • неверный метод — 405 с Allow;
  • POST на путь со слэшем — либо тот же обработчик, либо 307/308;
  • исключение в обработчике — 500 с общим текстом, без стека, и ответ, а не обрыв соединения;
  • заголовки ответа не раскрывают сервер и версию.

Это десяток запросов, и их стоит держать в тестах сервиса, а не выяснять по логам продакшена. Подробнее о каждой экосистеме — в статьях о net/http в Go, веб-фреймворках Rust, Python, NodeСкоро, Spring Boot и ASP.NET CoreСкоро.

Обсуждение в Telegram

Присоединиться →