DEV Community

Cover image for GraphQL - simple backend - SpringBoot application

Posted on • Updated on • Originally published at

GraphQL - simple backend - SpringBoot application

Cross-posting from my blog

In this post, I'll cover how to create a simple GraphQL server with Springboot and Netflix DGS. DGS is chosen because you start with GraphQL schema and then build server-side logic around it.


Initial setup

To start with SpringBoot has set of templates. Head over there and add Spring Web dependency. Select — Kotlin, jar, Java 8 as project base in lefet pane. Hit Generate button and extract the downloaded zip to a project folder.


Know the project structure

Our application is a single module project in the below tree format. Now it has bare minimum classes to just start the server.

│  └─ wrapper
│      ├─ gradle-wrapper.jar
│      └─
   ├─ main
   │   ├─ kotlin
   │   │   └─ com.ex2.gql.expense   //package
   │   │        └─ ExpenseApplication.kt
   │   └─ resources
   │       ├─
   │       ├─ static
   │       └─ templates
   └─ test
       └─ kotlin
           └─ com.ex2.gql.expense
                └─ ExpenseApplicationTests.kt
Enter fullscreen mode Exit fullscreen mode

fig. Springboot - initial project structure

Know about few files from the project structure.

  1. build.gralde.kts - is where we add our project dependencies [database / logger / graphql]
  2. ExpenseApplication.kt is the starting point of our application. Java main method is placed here
  3. Files and folders of name gradle* are present here to build our app
  4. resources directory is where we place out graphql schemas
  5. src/main/kotlin is we actually code our business logic

How to run the project?

Start terminal at the project root and run.

./gradlew bootRun

Enter fullscreen mode Exit fullscreen mode

— or —

For development, we'll use Intellij. So, select the bootRun gradle task in the gradle tool window and start.


On both cases, gradle wrapper will download all the dependencies (including the gradle distribution itself), and then start the application.

Netflix DGS framework setup

Netflix has released the dgs framework as open source on 2020. It powers the netflix API layer for over a year now. DGS plugin is available in mavencentral for us to use - Add the below dependency to your project.


Enter fullscreen mode Exit fullscreen mode

This plugin provides set of annotations that will connect our data fetchers / queries to our main application ExpenseApplication and generates graphiql playground for us to play around with our data.

GraphQL schema setup

schema is the contract between client and server. DGS is a schema first framework. i.e we define a schema and DGS generate model classes for us. Let's start by creating a schema file in resource directory.

    ├─ schema
    │   └─ schema.graphqls
    ├─ static
    └─ templates

Enter fullscreen mode Exit fullscreen mode

Create file schema.graphqls in the resources/schema directory. And define an operation and a data model as below.

type Query {
    expenses : [Expense]

type Expense {
    id: ID
    remarks: String
    amount: Int
    isIncome: Boolean

Enter fullscreen mode Exit fullscreen mode

Mapping java model to the schema

To get basic understanding on how model/entity is connected to the schema, Let's create a data class for Expense and corresponding fetcher. Fetchers are the helper classes that acts as an adapter between schema and data model.


class ExpenseDataFetcher {

    private val expenses = mutableListOf(
        Expense(id = 1, amount = 10, remarks = "Expense 1", isIncome = false),
        Expense(id = 2, amount = 120, remarks = "Expense 2", isIncome = false),
        Expense(id = 3, amount = 110, remarks = "Income 3", isIncome = false),

    fun expenses(): List<Expense> {
        return expenses

    data class Expense(
        val id: Int,
        val amount: Int,
        val remarks: String,
        val isIncome: Boolean

Enter fullscreen mode Exit fullscreen mode

Tips: To fill in the data class, you can use the Fill data class plugin. It can generate default values for all the parameters. Inside the Expenses block invoke suggestions by Alt(Option) + Return(Enter) key.


That's it!!

Now we have a working setup of a GraphQL query to play with. Annotations DgsQuery and DgsComponent will connect our model to the schema and register our component with main application.

GraphiQL playground

Now run the application and visit http://localhost:8080/graphiql. You should see the GraphiQL page — A visual tool where you construct your queries and verify the fetcher.

query MyQuery { 
  expenses {
Enter fullscreen mode Exit fullscreen mode


fig. Query call to the server

Adding a mutation

To add a mutation, head over to the schema file and add input type and a mutation for expense.

type Mutation {
    createExpense(data: ExpenseInput) : Expense

input ExpenseInput {
    remarks: String
    amount: Int
    isIncome: Boolean

Enter fullscreen mode Exit fullscreen mode

Add a bit of code to insert an element into the list. Give matching names and a method to create field [auto generated id]. And an annotation to connect function to the mutation query.

 private val random = Random(10000)
  private fun randomInt() = random.nextInt()

  fun createExpense(data: ExpenseInput): Expense {
      val expense = Expense(
          id = randomInt(),
          amount = data.amount,
          remarks = data.remarks,
          isIncome = data.isIncome,
      expenses.add(0, expense)
      return expense

  data class ExpenseInput(
      val amount: Int,
      val remarks: String,
      val isIncome: Boolean

Enter fullscreen mode Exit fullscreen mode

Now try the mutation in GraphiQL playground. You should see the new Expense object is returned. Verify the entry added to the list by again running MyQuery in the playground.

mutation MyMutation {  createExpense(data: {remarks: "From GraphiQL", amount: 100, isIncome: true}) {    id    remarks    amount    isIncome  }}
Enter fullscreen mode Exit fullscreen mode

image-20210517231344271{:.lead loading="lazy"}

fig.Mutation call to the server


Accessing the GraphQL endpoint in client apps and Insomnia / Postman

If you're fond of a REST/GraphQL client or to use the API in your client already, use the following endpoint.

// Endpoint for Client

// GraphiQL playground 

Enter fullscreen mode Exit fullscreen mode

Note there is no i in endpoint.


fig. GraphQL query in Insomnia

Source code

Entire source code is available in Github.

GitHub logo mahendranv / spring-expenses

An expense manager backend using SpringBoot and Netflix DGS - GraphQL


An expense manager backend using SpringBoot and Netflix DGS - GraphQL

Posts related to this repo


This the the bare minimum setup to make Create / Read requests to the backend using GraphQL. It is a steep learning curve to write queries for nested objects and connecting to a persistent database. Also there are other components available in DGS framework for codegen and custom scalars. I'll explore and add each usecase to this series.

Top comments (0)