Назовите ключевые принципы (constraints) REST

Ответ

REST (Representational State Transfer) — это архитектурный стиль, а не протокол, для создания масштабируемых и надежных веб-сервисов. Он определяет набор ограничений (constraints) для проектирования сетевых приложений.

Ключевые принципы:

  1. Клиент-серверная архитектура (Client-Server): Четкое разделение. Клиент (UI) не зависит от сервера (хранение данных), что позволяет им развиваться независимо.

  2. Отсутствие состояния (Stateless): Каждый запрос от клиента к серверу должен содержать всю информацию, необходимую для его выполнения. Сервер не хранит состояние клиента между запросами. Это повышает надежность и масштабируемость.

  3. Кэширование (Cacheable): Ответы сервера должны явно помечаться как кэшируемые или некэшируемые. Это позволяет клиентам и промежуточным узлам сохранять копии ответов для улучшения производительности.

  4. Единообразие интерфейса (Uniform Interface): Фундаментальный принцип, который стандартизирует взаимодействие. Он включает:

    • Идентификация ресурсов: Ресурсы идентифицируются через URI (например, /users/123).
    • Манипуляция ресурсами через представления: Клиент работает с представлением ресурса (например, JSON), а не с самим ресурсом на сервере.
    • Самодостаточные сообщения: Каждый ответ содержит достаточно информации для его интерпретации (например, Content-Type: application/json).
  5. Слоистая система (Layered System): Клиент не знает, подключен ли он напрямую к конечному серверу или к промежуточному (например, кэш, прокси, балансировщик нагрузки).

  6. Код по требованию (Code on Demand, опционально): Сервер может временно расширить функциональность клиента, передав ему исполняемый код (например, JavaScript).

Пример использования принципов в API:

  • Получение пользователя (ресурс): GET /users/42
  • Создание пользователя: POST /users с телом {"name": "Alice"}
  • Обновление пользователя: PUT /users/42 с телом {"name": "Alice", "email": "alice@example.com"}
  • Удаление пользователя: DELETE /users/42

Этот подход, использующий стандартные методы HTTP для операций над ресурсами, является основой RESTful API.

Ответ 18+ 🔞

А, ну вот, опять про этот ваш REST, блядь! Слушай, сейчас я тебе так объясню, что ты, сука, навсегда запомнишь, как это работает, без всяких этих заумных книжек, в рот меня чих-пых!

Представь себе, что у тебя есть огромный склад, ёпта. Это и есть сервер. А ты — это клиент, который пришёл на этот склад что-то взять или положить. И вот тут начинается магия, блядь.

Первое, главное правило, на котором всё держится: ты, как клиент, — полный мудак с дырявой памятью. Каждый раз, когда ты приходишь на склад, ты нихуя не помнишь, кто ты такой и что делал в прошлый раз. Поэтому ты обязан каждый раз говорить: «Я — Вася Пупкин, я пришёл забрать коробку номер 42». И склад-сервер, такой: «А, ну ладно, Вася, держи свою коробку». И всё! Никаких «помнишь, я вчера был?». Не помнит он тебя, блядь, и не должен! Это и есть Stateless, отсутствие состояния. Просто, как три копейки, а масштабируется — овердохуища! Можно хоть двадцать таких складов поставить.

Второе: у всего на этом складе есть чёткий адрес, табличка. Не просто «та коробка в углу», а «Стеллаж 5, Полка 3, Ячейка 42». Это твой URI, /users/42. И ты общаешься с этой ячейкой только четырьмя волшебными словами, как заклинаниями:

  • Пришёл, посмотрел что в ячейке — это GET. «Что там у меня в /users/42
  • Принёс новую коробку и поставил в пустую ячейку — это POST на /users.
  • Взял и полностью заменил всё содержимое ячейки на новое — это PUT на /users/42.
  • Взял и выкинул нахуй всю коробку вместе с ячейкой — это DELETE на /users/42.

Вот это и есть Uniform Interface, единообразие, блядь! Всё по полочкам, никакой самодеятельности.

Третье, про кэширование. Допустим, ты спросил, что в ячейке 42. Тебе сказали: «Там гвозди, и это ответ на неделю». Ну ты и не ходишь туда неделю, просто помнишь, что там гвозди. А если тебе сказали: «Там скоропортящийся творог, ответ на 5 секунд», то через 5 секунд ты идешь уточнять. Сервер должен явно говорить: «Эту хуйню можно запомнить надолго, а эту — нет». Иначе будет пиздец.

Четвёртое. Ты, клиент, вообще не должен знать, с кем ты говоришь. Может, ты говоришь не со складом, а с охранником у ворот, который сам сбегал на склад и тебе ответ принёс. А может, этот охранник — вообще хитрый кэш, который тебе вчерашний, но ещё годный ответ отдаёт. Это Layered System, слоистая система. Главное — тебе дали то, что ты просил, а как они это там между собой организовали — твои собачьи дела.

И последнее, опциональное: код по требованию. Это когда ты пришёл на склад, а тебе кроме коробки дали ещё и волшебную отвёртку-самоучку и говорят: «На, мудак, сам собери то, что в коробке». Как JavaScript в браузере, блядь. Но это уже высший пилотаж, можно без этого.

Короче, вот тебе живой пример, как это всё вместе работает:

GET /users/42 HTTP/1.1
Host: api.example.com
Authorization: Bearer my_token

(Ты: «Эй, дайте-ка мне пользователя под номером 42, вот мой пропуск, я Вася!»)

HTTP/1.1 200 OK
Content-Type: application/json
Cache-Control: max-age=3600

{
  "id": 42,
  "name": "Василий",
  "email": "vasya@example.com"
}

(Склад: «На, Вася, держи данные в формате JSON. И запомни этот ответ на час, не дергай меня по пустякам!»)

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