How do you create a GraphQL schema in Spring Boot?

Table of Contents

• Introduction
• Steps to Create a GraphQL Schema in Spring Boot
  • 1. Add the Required Dependencies
  • 2. Create the GraphQL Schema Definition
  • 3. Define Resolvers for Queries and Mutations
    • Query Resolver Example
    • Mutation Resolver Example
  • 4. Create a Service Layer
  • 5. Create a Repository Layer
  • 6. Enable GraphQL in the Application
  • 7. Test the GraphQL API
    • Example Query:
    • Example Mutation:
  • 8. Run and Test Your Application
• Conclusion

Introduction

Creating a GraphQL schema in Spring Boot is a fundamental step in integrating GraphQL with your application. A GraphQL schema defines the structure of your API, including the types of data that can be queried and mutated, and how those queries and mutations are resolved. In this guide, we’ll walk you through how to create a GraphQL schema in a Spring Boot application, define queries and mutations, and connect them with resolvers to fetch data.

Steps to Create a GraphQL Schema in Spring Boot

1. Add the Required Dependencies

To create a GraphQL schema in Spring Boot, you need to include the necessary dependencies. These dependencies will help you integrate GraphQL into your Spring Boot application.

In your pom.xml (for Maven) or build.gradle (for Gradle), add the following dependency:

For Maven:

For Gradle:

This dependency includes everything needed to set up a basic GraphQL API in Spring Boot.

2. Create the GraphQL Schema Definition

A GraphQL schema is written in a file with the .graphqls extension. This file defines the types, queries, mutations, and other components of the API.

Create a file called schema.graphqls in the src/main/resources directory.

Here is an example schema that defines a simple User type, a Query for retrieving a user by ID, and a Mutation for creating a new user:

3. Define Resolvers for Queries and Mutations

Resolvers are responsible for implementing the logic behind the queries and mutations defined in the GraphQL schema. In Spring Boot, you create resolver classes to handle these operations.

Query Resolver Example

Create a resolver for the Query type to handle fetching user data.

Mutation Resolver Example

Create a resolver for the Mutation type to handle creating a new user.

4. Create a Service Layer

The service layer contains the business logic for fetching and manipulating data. In this example, we use a UserService class to interact with the data repository (e.g., database).

5. Create a Repository Layer

If you're using a database, you'll need to define a repository to interact with your data. In this example, we use Spring Data JPA for the UserRepository.

6. Enable GraphQL in the Application

Spring Boot automatically enables GraphQL once the required dependencies are added. However, you can configure the GraphQL servlet in the application.properties or application.yml file to set up the GraphQL endpoint and enable the GraphQL Playground for testing.

Add the following to application.properties:

This configuration enables the /graphql endpoint and the interactive GraphQL Playground for testing.

7. Test the GraphQL API

Once the schema, resolvers, and services are set up, you can run your Spring Boot application. You can test your GraphQL queries and mutations using GraphQL Playground, available at http://localhost:8080/graphql.

Example Query:

Example Mutation:

8. Run and Test Your Application

To test the API, run your Spring Boot application, and navigate to http://localhost:8080/graphql in your browser to access GraphQL Playground. Here, you can write and execute queries and mutations to interact with your API.

Conclusion

Creating a GraphQL schema in Spring Boot involves defining a schema file that specifies your data types, queries, and mutations. You also need to implement resolvers that connect the GraphQL operations to your application’s data layer. The spring-boot-starter-graphql dependency simplifies the process, automatically setting up key components like the GraphQL servlet and schema management. By following these steps, you can quickly build and test a powerful GraphQL API in a Spring Boot application.