理解 GraphQL 订阅

Welcome! In this lesson, we'll dive into GraphQL Subscriptions, a powerful feature for real-time data updates. Imagine getting instant notifications or live data streams directly from your server!

Subscriptions allow clients to receive updates automatically when data on the server changes, without needing to constantly ask for new information.

GraphQL has three main operation types:

• Queries: Used to fetch data. Think of it as a GET request.
• Mutations: Used to modify data (create, update, delete). Like POST, PUT, DELETE.
• Subscriptions: Used to subscribe to real-time events, receiving data as it happens.

Each serves a distinct purpose in interacting with your API.

Why are subscriptions so important? They solve the problem of keeping client applications fresh with the latest data without constant polling.

• Chat applications: New messages appear instantly.
• Live dashboards: Metrics update in real-time.
• Notifications: Get alerts as events occur.
• Stock tickers: See price changes immediately.

They provide a seamless, dynamic user experience.

Unlike queries and mutations, which are single request/response cycles, subscriptions establish a persistent connection between the client and the server.

When a client subscribes, it sends a subscription query to the server. The server then holds this connection open and pushes data to the client whenever the requested event occurs.

GraphQL Subscriptions primarily rely on WebSockets. A WebSocket is a communication protocol that provides full-duplex communication channels over a single TCP connection.

Think of it as a two-way street that stays open, allowing both the client and server to send messages to each other at any time, unlike traditional HTTP which is request-response.

Before a WebSocket connection is fully established, a special HTTP request called a handshake occurs.

The client sends an HTTP request with an "Upgrade" header. If the server supports WebSockets, it responds with an "Upgrade" header, switching the protocol from HTTP to WebSocket. After this, all communication happens over the WebSocket protocol.

Here's a simplified lifecycle:

1. Connect: Client sends a WebSocket handshake.
2. Subscribe: Client sends a GraphQL subscription query over the WebSocket.
3. Event Trigger: Data changes on the server, triggering an event.
4. Publish: Server pushes the new data (payload) to the subscribed client.
5. Unsubscribe/Disconnect: Client closes the subscription or connection.

In your GraphQL schema, you define subscriptions using the subscription root type. Just like query and mutation, it lists the available real-time events.

Each field within the subscription type represents an event that a client can subscribe to. It specifies the type of data that will be returned when the event occurs.

Here's how you might define a subscription for a new comment in your Schema Definition Language (SDL):

type Subscription {
  commentAdded(postId: ID!): Comment!
}

type Comment {
  id: ID!
  content: String!
  author: String
  postId: ID!
}

Clients can subscribe to commentAdded, providing a postId, and receive a Comment object whenever a new comment is posted for that ID.

Subscriptions are powerful for real-time data. Let's test your understanding of how they work and their underlying technology.

Great job! You've learned the fundamentals of GraphQL Subscriptions.

• They provide real-time data updates.
• They use persistent connections, often WebSockets.
• They are different from queries and mutations.
• The server pushes data to clients upon events.

Next, we'll dive into implementing these in Spring Boot!