query {
  user(id: 42) {
    name
    avatar
    posts(limit: 3) {
      title
      likes
    }
  }
}

{
  "data": {
    "user": {
      "name": "Den",
      "avatar": "https://example.com/den.jpg",
      "posts": [
        { "title": "gRPC и Java", "likes": 120 },
        { "title": "GraphQL под капотом", "likes": 80 },
        { "title": "Spring Boot и микросервисы", "likes": 95 }
      ]
    }
  }
}

type User {
  id: ID!
  name: String!
  avatar: String
  posts(limit: Int): [Post]
}

type Post {
  id: ID!
  title: String!
  likes: Int!
}

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


type — описание структуры данных, аналог класса в Java.

Query — “входная точка”, через которую клиент получает данные.

! — обязательное поле.

[Post] — список постов.

type User {
  id: ID!
  name: String!
  posts: [Post!]!
}

type Post {
  id: ID!
  title: String!
  content: String
}

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

query {
  user(id: 42) {
    name
    posts {
      title
    }
  }
}

{
  "data": {
    "user": {
      "name": "Den",
      "posts": [
        { "title": "gRPC и Java" },
        { "title": "GraphQL под капотом" }
      ]
    }
  }
}

mutation {
  createUser(input: { name: "Alex" }) {
    id
    name
  }
}

subscription {
  userCreated {
    id
    name
  }
}

{
  "query": "query { user(id: 42) { name posts { title } } }"
}

GraphQL-запрос — это декларативное описание структуры данных, не код и не SQL.

GraphQLObjectType userType = newObject()
    .name("User")
    .field(field -> field
        .name("id")
        .type(Scalars.GraphQLID))
    .field(field -> field
        .name("name")
        .type(Scalars.GraphQLString))
    .field(field -> field
        .name("posts")
        .type(new GraphQLList(postType))
        .dataFetcher(env -> postService.getByUser(env.getSource())))
    .build();

{
  "data": {
    "user": {
      "name": "Den",
      "posts": [{ "title": "gRPC и Java" }]
    }
  }
}

{
  "data": { "user": null },
  "errors": [{ "message": "User not found" }]
}

@Component
public class UserResolver implements GraphQLQueryResolver {
    private final UserService userService;
    public UserResolver(UserService userService) { this.userService = userService; }

    public User user(Long id) {
        return userService.findById(id);
    }

    public List<User> allUsers() {
        return userService.findAll();
    }
}

type User {
  id: ID!
  name: String!
  posts: [Post!]!
}

Типы описывают структуру данных — аналог классов/DTO.

input CreateUserInput {
  name: String!
  age: Int
}

enum Role {
  ADMIN
  USER
  GUEST
}

interface Entity {
  id: ID!
}

type User implements Entity {
  id: ID!
  name: String!
}

type Post implements Entity {
  id: ID!
  title: String!
}

Клиент может запросить id для любого, кто реализует Entity.

union SearchResult = User | Post | Comment

schema {
  query: Query
  mutation: Mutation
}

Сущности
type User {
  id: ID!
  name: String!
  role: Role!
  posts: [Post!]!
}

type Post {
  id: ID!
  title: String!
  content: String
  author: User!
  comments: [Comment!]!
}

type Comment {
  id: ID!
  text: String!
  author: User!
}

Перечисления
enum Role {
  ADMIN
  USER
  GUEST
}

Входные данные
input CreatePostInput {
  title: String!
  content: String
}

Запросы
type Query {
  user(id: ID!): User
  users: [User!]!

  post(id: ID!): Post
  posts(limit: Int, authorId: ID): [Post!]!
}

Мутации
type Mutation {
  createPost(input: CreatePostInput!): Post!
  deletePost(id: ID!): Boolean!
}

Подписки
type Subscription {
  postCreated: Post!
}

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

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

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

    public User user(Long id) {
        return service.findById(id);
    }
}

type User {
  id: ID!
  name: String!
  email: String # новое поле
}

type User {
  id: ID!
  name: String!

  # старое поле
  username: String @deprecated(reason: "Use 'name' instead")
}

Старое:
input CreatePostInput {
  title: String!
}

Новое:
input CreatePostInput {
  title: String!
  content: String @deprecated(reason: "Use body instead")
  body: String
}

query {
  user(id: 42) {
    name
    avatar
  }
}

{
  "data": {
    "user": {
      "name": "Den",
      "avatar": "https://example.com/den.png"
    }
  }
}

Никаких “лишних” полей.

type Query {
  posts(limit: Int, authorId: ID): [Post!]!
}

query {
  posts(limit: 5, authorId: 42) {
    id
    title
  }
}

{
  "data": {
    "posts": [
      { "id": "101", "title": "GraphQL SDL" },
      { "id": "102", "title": "gRPC vs GraphQL" }
    ]
  }
}

query GetUser($id: ID!) {
  user(id: $id) {
    name
    avatar
  }
}

{
  "id": 42
}

type Mutation {
  createPost(input: CreatePostInput!): Post!
}

mutation {
  createPost(input: { title: "GraphQL", content: "SDL explained" }) {
    id
    title
  }
}

{
  "data": {
    "createPost": {
      "id": "501",
      "title": "GraphQL"
    }
  }
}

query {
  user(id: 1) {
    name
    posts(limit: 2) {
      title
      comments {
        text
      }
    }
  }
}

{
  "data": {
    "user": {
      "name": "Den",
      "posts": [
        {
          "title": "GraphQL Basics",
          "comments": [
            { "text": "Отличная статья" }
          ]
        },
        {
          "title": "SDL Tutorial",
          "comments": []
        }
      ]
    }
  }
}

Сервер не может изменить структуру ответа — она определяется клиентом.

data

errors

query {
  user(id: 1) {
    name
    posts {
      title
      likes
    }
  }
}

{
  "data": {
    "user": {
      "name": "Den",
      "posts": null
    }
  },
  "errors": [
    {
      "message": "Database timeout",
      "path": ["user", "posts"]
    }
  ]
}

{
  "data": {
    "createPost": null
  },
  "errors": [
    {
      "message": "User not authorized",
      "path": ["createPost"]
    }
  ]
}

query {
  user(id: 1) {
    id
    name
    avatar
  }
  post(id: 10) {
    author {
      id
      name
      avatar
    }
  }
}

Повторяются три поля id, name, avatar.

fragment UserBasic on User {
  id
  name
  avatar
}

query {
  user(id: 1) {
    ...UserBasic
  }
  post(id: 10) {
    author {
      ...UserBasic
    }
  }
}

Теперь изменения структуры (например, добавление role) делаются в одном месте — фрагменте.

query GetUser($showAvatar: Boolean!) {
  user(id: 1) {
    name
    avatar @include(if: $showAvatar)
  }
}

Переменные:

{ "showAvatar": true }

Если showAvatar = false, поле avatar пропадёт из ответа целиком.

avatar @skip(if: $binaryMode)

Если binaryMode = true, поле будет пропущено.

type User {
  username: String @deprecated(reason: "Use 'name' instead")
}

Эта директива влияет на документацию и IDE, но не на данные.

directive @upper on FIELD_DEFINITION

query GetPost($id: ID!) {
  post(id: $id) {
    title
    content
  }
}

{
  "id": 100
}

mutation CreatePost($input: CreatePostInput!) {
  createPost(input: $input) {
    id
    title
  }
}

{
  "input": {
    "title": "GraphQL",
    "content": "Powerful queries"
  }
}

query User(
  $id: ID!,
  $withPosts: Boolean!
) {
  user(id: $id) {
    name
    posts @include(if: $withPosts) {
      title
    }
  }
}

query User(
  $id: ID!,
  $isMobile: Boolean!
) {
  user(id: $id) {
    name
    avatar @skip(if: $isMobile)
    posts @include(if: $isMobile) {
      title
    }
  }
}

fragment UserCard on User {
  id
  name
  avatar
}

query PageData {
  recommendedUsers { ...UserCard }
  recentVisitors { ...UserCard }
  followers { ...UserCard }
}

username @deprecated(reason: "Use 'login' instead")

query FilterPosts($filter: PostFilter!) {
  posts(filter: $filter) {
    id
    title
  }
}

{
  "filter": {
    "authorId": 1,
    "tags": ["graphql", "java"],
    "minLikes": 10
  }
}

@Component
public class UserQueryResolver implements GraphQLQueryResolver {

    private final UserService service;

    public UserQueryResolver(UserService service) {
        this.service = service;
    }

    public User userById(Long id) {
        return service.findById(id);
    }
}

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

type User {
    id: ID!
    name: String!
    posts: [Post!]!
}

@Component
public class UserResolver implements GraphQLResolver<User> {

    private final PostService postService;

    public UserResolver(PostService postService) {
        this.postService = postService;
    }

    public List<Post> posts(User user) {
        return postService.findByUserId(user.getId());
    }
}

GraphQL вызывает posts() только если клиент запросит поле posts.
Если клиент запросит только user { id name }, резолвер posts не будет вызван вообще.

/graphql
  /schema
    schema.graphqls

/resolvers
  QueryResolver.java
  MutationResolver.java
  UserResolver.java
  PostResolver.java

/services
  UserService.java
  PostService.java

/repositories
  UserRepository.java
  PostRepository.java

query {
    user(id: 10) {
        id
        name
        posts {
            id
            title
        }
    }
}