Implementing Spring Boot 3.x with GraphQL for Efficient Data Fetching

Master Spring Ter
3 min readJun 16, 2024

GraphQL is an API query language that provides a more efficient and flexible alternative to REST APIs. With GraphQL, clients can request exactly the data they need, and nothing more. Spring Boot 3.x makes it easier than ever to integrate GraphQL into your applications. In this article, we’ll explore how to set up and use GraphQL with Spring Boot 3.x, following best practices and using the latest versions.

Setting Up the Project

Create a new Spring Boot project using Spring Initializr with the following dependencies:

  • Spring Web
  • Spring Boot GraphQL
  • Spring Data JPA (optional, for database operations)
  • H2 Database (for demonstration purposes)
  • Lombok (for reducing boilerplate code)

Adding Dependencies

Add the necessary dependencies to your pom.xml (for Maven) or build.gradle (for Gradle) file.

pom.xml:

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-graphql</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.22</version>
<scope>provided</scope>
</dependency>

build.gradle:

dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-graphql'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
runtimeOnly 'com.h2database:h2'
compileOnly 'org.projectlombok:lombok:1.18.22'
annotationProcessor 'org.projectlombok:lombok:1.18.22'
}

Configuring the Database

Configure the H2 database in your application.yml file for simplicity.

application.yml:

spring:
datasource:
url: jdbc:h2:mem:testdb
driverClassName: org.h2.Driver
username: sa
password: password
h2:
console:
enabled: true
jpa:
hibernate:
ddl-auto: update
show-sql: true

Creating a JPA Entity

Define a simple JPA entity to represent your data.

Book.java:

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String title;
private String author;
private String publisher;
}

Creating a Repository

Create a repository interface to handle database operations.

BookRepository.java:

import org.springframework.data.jpa.repository.JpaRepository;

public interface BookRepository extends JpaRepository<Book, Long> {
}

Defining the GraphQL Schema

Define the GraphQL schema to specify the data structure and queries.

schema.graphqls:

type Query {
books: [Book]
bookById(id: ID!): Book
}

type Mutation {
addBook(title: String!, author: String!, publisher: String!): Book
}

type Book {
id: ID
title: String
author: String
publisher: String
}

Place this file in the src/main/resources/graphql directory.

Creating the GraphQL Service

Create a service to handle GraphQL queries and mutations.

BookService.java:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;

@Service
public class BookService {

@Autowired
private BookRepository bookRepository;

public List<Book> getAllBooks() {
return bookRepository.findAll();
}

public Optional<Book> getBookById(Long id) {
return bookRepository.findById(id);
}

public Book addBook(String title, String author, String publisher) {
Book book = new Book(null, title, author, publisher);
return bookRepository.save(book);
}
}

Creating the GraphQL Controller

Create a controller to map GraphQL queries and mutations to the service methods.

BookController.java:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.graphql.data.method.annotation.Argument;
import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.graphql.data.method.annotation.MutationMapping;
import org.springframework.stereotype.Controller;

import java.util.List;

@Controller
public class BookController {

@Autowired
private BookService bookService;

@QueryMapping
public List<Book> books() {
return bookService.getAllBooks();
}

@QueryMapping
public Book bookById(@Argument Long id) {
return bookService.getBookById(id).orElse(null);
}

@MutationMapping
public Book addBook(@Argument String title, @Argument String author, @Argument String publisher) {
return bookService.addBook(title, author, publisher);
}
}

Running the Application

Create the main application class and run the application.

DemoApplication.java:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}

Start your Spring Boot application and navigate to http://localhost:8080/graphiql to test your GraphQL queries and mutations using the GraphiQL interface.

Conclusion

Integrating GraphQL with Spring Boot 3.x provides a powerful way to build flexible and efficient APIs. By following this guide, you can set up a GraphQL server with Spring Boot, define your schema, and implement resolvers for queries and mutations. This setup allows clients to request exactly the data they need, reducing over-fetching and under-fetching issues commonly associated with REST APIs.

Explore further enhancements such as adding security, implementing subscriptions for real-time updates, and optimizing data fetching to build a robust GraphQL API with Spring Boot 3.x. Happy coding!

This tutorial was generated using ChatGPT, specifically the Master Spring TER model. For more information, visit ChatGPT Master Spring TER.

Sign up to discover human stories that deepen your understanding of the world.

Free

Distraction-free reading. No ads.

Organize your knowledge with lists and highlights.

Tell your story. Find your audience.

Membership

Read member-only stories

Support writers you read most

Earn money for your writing

Listen to audio narrations

Read offline with the Medium app

Master Spring Ter
Master Spring Ter

Written by Master Spring Ter

https://chatgpt.com/g/g-dHq8Bxx92-master-spring-ter Specialized ChatGPT expert in Spring Boot, offering insights and guidance for developers.

No responses yet

Write a response