Say goodbye to REST’s limitations and control your data with GraphQL

GraphQL has rapidly gained popularity as an alternative to REST APIs for its ability to provide more flexible and efficient data queries. In contrast to REST’s fixed endpoints, GraphQL allows clients to specify the exact data they need, reducing over-fetching or under-fetching of information. In this post, we’ll dive into how to set up a GraphQL API using Spring Boot, giving you all the necessary code snippets to get started quickly.

What is GraphQL?

GraphQL is a query language for APIs, developed by Facebook, that allows clients to request exactly the data they need. The server exposes a schema describing the types of data it supports, and the client queries the schema to retrieve specific fields or nested data. Unlike REST, where each resource has its own URL, GraphQL uses a single endpoint for all queries and mutations, making it more efficient and flexible.

Why Use GraphQL with Spring Boot?

Spring Boot is well-known for its simplicity in building production-ready applications, and it integrates seamlessly with GraphQL libraries. By combining the two, you can build APIs that provide efficient data retrieval, better performance, and a more intuitive experience for API consumers.

Setting Up a Spring Boot Project with GraphQL

Add Dependencies

First, you’ll need to add the necessary GraphQL dependencies to your pom.xml file if you're using Maven:

<dependencies>
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphql-spring-boot-starter</artifactId>
        <version>11.1.0</version>
    </dependency>
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphiql-spring-boot-starter</artifactId>
        <version>11.1.0</version>
    </dependency>
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphql-java-tools</artifactId>
        <version>11.0.0</version>
    </dependency>
</dependencies>

These dependencies include:

graphql-spring-boot-starter: The main GraphQL Spring Boot starter.
graphiql-spring-boot-starter: A GraphiQL UI that allows you to easily test your queries.
graphql-java-tools: Helps you build your GraphQL schema using annotations.

Define the GraphQL Schema

GraphQL requires a schema definition, which specifies what queries and mutations are available. Create a file schema.graphqls under the src/main/resources/graphql directory.

Example schema:

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

type User {
    id: ID!
    name: String!
    email: String!
}

This defines a query getUser that returns a User object, which has an id, name, and email.

Create the Data Model

Next, create a Java class to represent the User type in your GraphQL schema.

public class User {
    private String id;
    private String name;
    private String email;

    // Getters and setters
}

Create a Service Layer

You’ll need a service to fetch the user data. In a real-world scenario, this might involve querying a database, but for simplicity, we’ll use an in-memory map.

@Service
public class UserService {

    private static final Map<String, User> users = new HashMap<>();

    static {
        users.put("1", new User("1", "John Doe", "john@example.com"));
        users.put("2", new User("2", "Jane Doe", "jane@example.com"));
    }

    public User getUserById(String id) {
        return users.get(id);
    }
}

Create the GraphQL Query Resolver

The query resolver handles incoming GraphQL queries. You map the schema's Query type to a Spring Boot service.

@Component
public class UserQueryResolver implements GraphQLQueryResolver {

    private final UserService userService;

    @Autowired
    public UserQueryResolver(UserService userService) {
        this.userService = userService;
    }

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

With the GraphQLQueryResolver interface, Spring Boot can resolve the query and invoke the corresponding service method.

Run and Test the API

Once your Spring Boot application is up and running, you can use GraphiQL or any GraphQL client to test your API. Open GraphiQL at http://localhost:8080/graphiql, and try running this query:

{
  getUser(id: "1") {
    id
    name
    email
  }
}

This query will return:

{
  "data": {
    "getUser": {
      "id": "1",
      "name": "John Doe",
      "email": "john@example.com"
    }
  }
}

Conclusion

In this post, we walked through the basics of creating a GraphQL API using Spring Boot. By integrating GraphQL into your Spring Boot application, you gain the ability to serve flexible, efficient data queries to your clients. As seen, Spring Boot’s ease of use combined with GraphQL’s query capabilities make for a powerful combination, giving developers more control over the data they send and receive. Now, it’s time to go beyond this basic implementation and explore advanced features like mutations, subscriptions, and integrating GraphQL with databases for more dynamic data handling.

Let’s connect!

📧 Don't Miss a Post! Subscribe to my Newsletter!
➡️ LinkedIn
🚩 Original Post
☕ Buy me a Coffee

Spring Boot and GraphQL: Creating a GraphQL API