Лекция 287: Как GraphQL упрощает взаимодействие с микросервисами

Представьте себе большой офис, в котором есть десятки отделов. Каждый отдел отвечает только за свой кусочек работы, а клиенты должны бегать между отделами, чтобы собрать всю нужную информацию. Этот офис — ваш микросервисный проект, а клиенты — это фронтенд-приложение. Беготня между отделами — это ваши HTTP-запросы к REST API. Ужас, правда? Здесь на помощь приходит GraphQL, который выступает как единая стойка информации, где вы запросите всё через одно окно.

Единая точка входа

GraphQL позволяет вам создать единый фасад для всех микросервисов. Весь трафик идёт через GraphQL-сервер, который агрегирует данные с каждого сервиса. Например:

• Сервис пользователей (User Service) хранит информацию о пользователях.
• Сервис заказов (Order Service) отвечает за заказы пользователей.
• Сервис отзывов (Review Service) управляет отзывами на продукты.

Вместо того чтобы клиент запрашивал данные через три отдельные точки REST API, он делает один запрос к GraphQL. GraphQL сервер сам разберётся, куда обратиться.

Пример архитектуры с GraphQL

+---------------+       +---------------------+
|    CLIENT     | -->   |     GraphQL API     |
+---------------+       +---------+-----------+
                                |
       +------------------------+------------------------+
       |                        |                        |
+---------------+      +---------------------+    +-----------------+
| User Service  |      |    Order Service    |    |  Review Service |
+---------------+      +---------------------+    +-----------------+

Почему это удобно? Потому что клиенту не нужно заботиться о том, где и как хранятся данные. Ему достаточно знать, что GraphQL API предоставит всю необходимую информацию.

Агрегация данных из нескольких микросервисов

Проблема REST

Допустим, вам нужно вывести на странице профиля пользователя:

1. Имя пользователя.
2. Список его заказов.
3. Отзывы об этих заказах.

С REST всё выглядит так:

1. Отправляется запрос в User Service для получения имени пользователя.
2. На основе ID пользователя отправляется второй запрос в Order Service для получения заказов.
3. Для каждого заказа отправляются запросы в Review Service, чтобы получить отзывы.

Это десятки запросов, которые занимают много времени и перегружают сеть. Это как ходить в три магазина, чтобы собрать один ужин.

Как GraphQL решает эту проблему

GraphQL позволяет объединить всю эту информацию в одном запросе. Вы создаёте схему, которая описывает все зависимости между данными, а сервер GraphQL выполняет сложную логику за вас. Вот пример:

query GetUserProfile($userId: ID!) {
  user(id: $userId) {
    name
    orders {
      id
      items
      reviews {
        rating
        comment
      }
    }
  }
}

В ответ вы получите единый JSON, содержащий нужные данные:

{
  "data": {
    "user": {
      "name": "Иван Иванов",
      "orders": [
        {
          "id": "123",
          "items": ["item1", "item2"],
          "reviews": [
            {
              "rating": 5,
              "comment": "Отлично!"
            }
          ]
        }
      ]
    }
  }
}

При этом клиенту совершенно не важно, из каких источников эти данные пришли — GraphQL Server уже всё сделал за него.

Улучшение клиентского взаимодействия

Проблема Over-fetching и Under-fetching

В REST API вы либо получаете слишком много данных (over-fetching), либо слишком мало (under-fetching). Например:

• Вы запрашиваете список пользователей, но REST возвращает не только имена, но и адреса, даты рождения и другие ненужные данные.
• Вы запрашиваете конкретного пользователя, но REST API не предоставляет поля orders, и вам приходится делать дополнительный запрос.

GraphQL позволяет клиентам запрашивать ровно то, что нужно. Если пользователю нужен только список имён, он может запросить только поле name:

query {
  users {
    name
  }
}

Ответ будет простым и аккуратным:

{
  "data": {
    "users": [
      { "name": "Иван" },
      { "name": "Мария" },
      { "name": "Петр" }
    ]
  }
}

Преимущества для фронтенда

1. Меньше запросов, меньше тормозов
   Теперь клиент выполняет всего один запрос, а не три-четыре, экономя сетевые ресурсы.
2. Гибкость UI
   Если дизайн страницы меняется, и нужно добавить или убрать данные, это решается изменением GraphQL-запроса без модификации серверного кода.
3. Реактивность
   С помощью подписок (Subscriptions) GraphQL позволяет клиентам получать обновления в реальном времени. Это особенно полезно для уведомлений, систем мессенджеров и динамических интерфейсов.

Практика: настройка микросервисов с GraphQL

Шаг 1. Создаём схему

Создайте файл schema.graphqls в вашем GraphQL-сервере. Например:

type User {
  id: ID
  name: String
  orders: [Order]
}

type Order {
  id: ID
  items: [String]
  reviews: [Review]
}

type Review {
  rating: Int
  comment: String
}

type Query {
  user(id: ID!): User
}

Шаг 2. Настраиваем резолверы

В GraphQL сервере (на Spring Boot) настройте резолверы. Например:

@Component
public class UserResolver implements GraphQLQueryResolver {
    private final UserService userService;

    public UserResolver(UserService userService) {
        this.userService = userService;
    }

    public User getUser(Long id) {
        return userService.getUserById(id);
    }
}

Теперь каждый раз, когда вы запрашиваете поле user, вызывается метод getUser.

Шаг 3. Агрегация данных

Если данные для полей orders и reviews находятся в разных микросервисах, настройте Data Fetchers:

@Component
public class OrderDataFetcher implements DataFetcher<List<Order>> {
    private final OrderService orderService;

    public OrderDataFetcher(OrderService orderService) {
        this.orderService = orderService;
    }

    @Override
    public List<Order> get(DataFetchingEnvironment env) {
        User user = env.getSource();
        return orderService.getOrdersForUser(user.getId());
    }
}

Шаг 4. Тестирование

Используйте GraphQL Playground для отправки запросов и проверки ответов. Например:

query {
  user(id: 1) {
    name
    orders {
      id
      items
      reviews {
        rating
        comment
      }
    }
  }
}

Теперь у вас есть представление, как GraphQL становится "всё-в-одном" фасадом для микросервисной системы. Он упрощает взаимодействие, делает API доступным и удобным, а клиентам обеспечивает гибкость в запросах.