0Pricing
GraphQL APIs with Spring Boot · 课时

建模嵌套对象与关系

设计能够表示层次化数据的模式，并定义不同类型之间的关系。

建模嵌套对象与关系 是 CoddyKit 上的免费 GraphQL APIs with Spring Boot 课时。 这是第 1 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 GraphQL APIs with Spring Boot 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 GraphQL APIs with Spring Boot 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Why Nested Data Matters

Real-world data is rarely flat. It has connections and hierarchies, like an author having multiple books, or a product having many reviews. GraphQL excels at modeling these complex relationships naturally.

This lesson explores how to design your schema to represent data with nested objects and various relationships, making your API more intuitive and powerful.

Understanding Nested Types

A nested object means one type contains another type as a field. For example, an Author might have a list of Book objects they've written.

This allows clients to fetch related data (like all books by an author) in a single GraphQL request, reducing over-fetching and under-fetching.

Defining Nested Types in SDL

In GraphQL's Schema Definition Language (SDL), you define nested types directly. Here, an Author type includes a list of Book objects.

Notice the [Book!]! syntax, meaning a non-null list of non-null books.

type Book {
  id: ID!
  title: String!
  publicationYear: Int
}

type Author {
  id: ID!
  name: String!
  books: [Book!]! # List of books by this author
}

type Query {
  author(id: ID!): Author
}

Java Models for Nested Data

In Spring Boot, your Java data models (POJOs or records) should mirror your GraphQL schema. This makes mapping data between your backend and the GraphQL API straightforward.

You'll typically have separate classes for each GraphQL type, with fields matching the schema.

// src/main/java/com/example/model/Author.java
class Author {
  private String id;
  private String name;
  private List<Book> books;

  // Constructor, getters, setters...
}

// src/main/java/com/example/model/Book.java
class Book {
  private String id;
  private String title;
  private Integer publicationYear;

  // Constructor, getters, setters...
}

How Nested Fields are Resolved

When a client requests an Author and its books, Spring Boot GraphQL will first resolve the Author object. Then, it will look for a way to resolve the books field on that Author.

Often, if your Java object has a matching getter (e.g., getBooks()), Spring Boot GraphQL can automatically fetch the nested list.

Querying Nested Data

Clients can fetch all nested data with a single, clear query. This is a major advantage of GraphQL compared to traditional REST APIs, where you might need multiple requests or complex join logic on the client.

Notice how books and its fields are queried directly within the author field.

query GetAuthorWithBooks {
  author(id: "author-1") {
    id
    name
    books {
      id
      title
      publicationYear
    }
  }
}

Simulating Nested Data Resolution

This simplified Java code demonstrates how a data fetcher might prepare an Author object that already contains its associated Book objects. This structure is then ready for GraphQL to expose.

Run it to see how the nested data is represented.

import java.util.Arrays;
import java.util.List;

// Simplified Book class
class Book {
  String id;
  String title;
  Integer publicationYear;

  public Book(String id, String title, Integer publicationYear) {
    this.id = id;
    this.title = title;
    this.publicationYear = publicationYear;
  }

  // Getters for GraphQL to access fields
  public String getId() { return id; }
  public String getTitle() { return title; }
  public Integer getPublicationYear() { return publicationYear; }
}

// Simplified Author class
class Author {
  String id;
  String name;
  List<Book> books;

  public Author(String id, String name, List<Book> books) {
    this.id = id;
    this.name = name;
    this.books = books;
  }

  // Getters for GraphQL to access fields
  public String getId() { return id; }
  public String getName() { return name; }
  public List<Book> getBooks() { return books; }
}

public class Main {
  public static void main(String[] args) {
    // Create some books
    Book book1 = new Book("b1", "The Martian", 2011);
    Book book2 = new Book("b2", "Project Hail Mary", 2021);
    List<Book> authorsBooks = Arrays.asList(book1, book2);

    // Create an author with their books
    Author author = new Author("a1", "Andy Weir", authorsBooks);

    // Demonstrate accessing the nested data
    System.out.println("Author: " + author.getName());
    System.out.println("Books written:");
    for (Book book : author.getBooks()) {
      System.out.println("  - " + book.getTitle() + " (" + book.getPublicationYear() + ")");
    }
  }
}

Understanding Relationships: One-to-Many

The Author to Book example we've used is a classic "one-to-many" relationship: one author can write many books.

GraphQL schema naturally supports this by defining a field as a list of another type (e.g., books: [Book!]!), making it easy to fetch all related items.

Referencing Related Objects

Sometimes, data isn't directly embedded or available in a single object. For instance, a Book might only store an authorId internally, not the full Author object.

You can still model this in GraphQL by making Author a field on Book. Spring Boot GraphQL will then resolve the Author field by fetching the complete Author object based on the authorId.

type Book {
  id: ID!
  title: String!
  author: Author! # Reference to the Author type
}

type Author {
  id: ID!
  name: String!
}

Check Your Understanding

Consider a GraphQL schema for an e-commerce application. A Product can have many Reviews, and each Review is written by a specific User.

Recap: Modeling Relationships

In this lesson, you learned how to model nested objects and relationships in your GraphQL schema. We covered:

  • Defining fields that are lists of other types (e.g., books: [Book!]!) to represent one-to-many relationships.
  • Mirroring these hierarchical structures in your Spring Boot data models.
  • Understanding how GraphQL automatically resolves these nested fields, often via Java getters.
  • Querying complex, hierarchical data efficiently with a single GraphQL request.

Mastering nested objects and relationships is key to building powerful and intuitive GraphQL APIs that truly reflect your application's data structure.

常见问题解答

「建模嵌套对象与关系」课时是免费的吗？

是的 — 「建模嵌套对象与关系」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 GraphQL APIs with Spring Boot 课程的其余内容，请升级到 CoddyKit PRO。 GraphQL APIs with Spring Boot 课程共包含 4 节课。

「建模嵌套对象与关系」这节课中我会学到什么？

设计能够表示层次化数据的模式，并定义不同类型之间的关系。 你通过在浏览器中直接运行的动手代码来练习 GraphQL APIs with Spring Boot，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 GraphQL APIs with Spring Boot 需要有经验吗？

无需任何先前经验。CoddyKit 上的 GraphQL APIs with Spring Boot 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 1 节课，共 4 节。

「建模嵌套对象与关系」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 GraphQL APIs with Spring Boot 课中编写并运行代码吗？

能。每节 GraphQL APIs with Spring Boot 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 建模嵌套对象与关系
  2. 实现接口与联合类型
  3. 利用输入类型实现变更
  4. 枚举与自定义标量类型
← 返回 GraphQL APIs with Spring Boot