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