Tutorial of Building Java REST API using Spring Boot and MongoDB

A comprehensive step by step tutorial on how to build Java REST API or RESTful web service using the latest Spring Boot and MongoDB. REST API is today's requirements for Mobile Apps, Web Application or Desktop Application that need to connect with Database. That's why we need to create a step by step tutorial of building Java REST API server using Spring Boot and MongoDB. The data store in MongoDB server and accessible everywhere via Java REST API. Previously, we have to create REST API in different technology and framework using Grails and Node.js. Now, we are using Spring Boot for it. After all, you can compare which technology or framework that fits your needs.

Table of Contents:

• Java REST API: Generate a New Spring Boot Gradle Project
• Java REST API: Create Model or Entity Class
• Java REST API: Create a New Repository Interface for Product Model
• Java REST API: Create a New RESTful Controller for Accessing Product Data
• Java REST API: Run and Test the Spring Boot MongoDB RESTful Web Service

Before we start, the following tools, framework, library, and dependencies are required:

1. JDK 8
2. Gradle
3. Spring Boot
4. Spring Data MongoDB
5. Spring Initializr
6. IDE (Netbeans, Eclipse, Spring Tool Suite or IntellijIdea)
7. Terminal or Command Line

Java REST API: Generate a New Spring Boot Gradle Project

We assume that you have installed JDK 8, Gradle and IDE (Netbeans, Eclipse, STS or IntellijIdea). Next, we will create a new Spring Boot Gradle project of Java REST API using Spring Initializer. Spring Initializr provides an extensible API to generate quickstart projects, and to inspect the metadata used to generate projects, for instance, to list the available dependencies and versions. Just go to Spring Initializr web-based Spring project generator then fill the required frameworks and libraries.

After filling all fields, click Generate Project. It will automatically download the zipped project. Next, extract the zipped project to your java projects folder. On the project folder root, you will find `build.gradle` file for register dependencies, initially it looks like this.

buildscript {
    ext {
        springBootVersion = '1.5.7.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.spring'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
    mavenCentral()
}


dependencies {
    compile('org.springframework.boot:spring-boot-starter-data-mongodb')
    compile('org.springframework.boot:spring-boot-starter-web')
    testCompile('org.springframework.boot:spring-boot-starter-test')
}

Open another terminal then run MongoDB server. In current terminal go to the newly extracted Spring Boot project folder then type this command to compile the application.

./gradlew compile

Open and edit `src/resources/application.properties` then add this lines of strings.

spring.data.mongodb.database=springmongodb
spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017

Java REST API: Create a Model or Entity Class

We are not accessing directly to MongoDB collections and fields but we have to access it via Java Object. For that, we have to create a new Java Class as a model or entity. If you are using Netbeans (similar with some IDE), right-click project name then click `New` then click `Java Class`.

Fill necessary fields like above screenshot then click Finish button. Netbeans will automatically open the newly created file, replace all codes with this.

package com.spring.restapi.models;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "products")
public class Product {
    @Id
    String id;
    String prodName;
    String prodDesc;
    Double prodPrice;
    String prodImage;

    public Product() {
    }

    public Product(String prodName, String prodDesc, Double prodPrice, String prodImage) {
        this.prodName = prodName;
        this.prodDesc = prodDesc;
        this.prodPrice = prodPrice;
        this.prodImage = prodImage;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getProdName() {
        return prodName;
    }

    public void setProdName(String prodName) {
        this.prodName = prodName;
    }

    public String getProdDesc() {
        return prodDesc;
    }

    public void setProdDesc(String prodDesc) {
        this.prodDesc = prodDesc;
    }

    public Double getProdPrice() {
        return prodPrice;
    }

    public void setProdPrice(Double prodPrice) {
        this.prodPrice = prodPrice;
    }

    public String getProdImage() {
        return prodImage;
    }

    public void setProdImage(String prodImage) {
        this.prodImage = prodImage;
    }
}

That product Class mapping to products collections of MongoDB which has 5 fields (id, prodName, prodDesc, prodPrice, prodImage). Each field has a getter and setter.

Java REST API: Create a New Repository Interface for Product Model

Now, we need to create an interface for connecting the Product model and controller. On Netbeans right-click project name on projects left panel then choose `New` then choose `Java Interface`.

Fill necessary fields like above screenshot then click Finish button. Netbeans will automatically open the new `ProductRepository.java` interface file. Replace all codes with this.

package com.spring.restapi.repositories;

import com.spring.restapi.models.Product;
import org.springframework.data.repository.CrudRepository;

public interface ProductRepository extends CrudRepository<Product, String> {
    @Override
    Product findOne(String id);

    @Override
    void delete(Product deleted);
}

We only add `findOne` and `delete` method to the interface because the rest method already handled by `CrudRepository` of Spring Data MongoDB.

Java REST API: Create a New RESTful Controller for Accessing Product Data

Now, it's time for RESTful Web Service (REST API) implementation by creating a new RESTful controller file. On the Netbeans right-click project name then click `New` then click `Java Class` again.

Fill necessary fields like above screenshot then click Finish button. Netbeans will automatically open the new `ProductController.java` class file. Replace all codes with this.

package com.spring.restapi.controllers;

import com.spring.restapi.models.Product;
import com.spring.restapi.repositories.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {

    @Autowired
    ProductRepository productRepository;

    @RequestMapping(method=RequestMethod.GET, value="/products")
    public Iterable<Product> product() {
        return productRepository.findAll();
    }

    @RequestMapping(method=RequestMethod.POST, value="/products")
    public String save(@RequestBody Product product) {
        productRepository.save(product);

        return product.getId();
    }

    @RequestMapping(method=RequestMethod.GET, value="/products/{id}")
    public Product show(@PathVariable String id) {
        return productRepository.findOne(id);
    }

    @RequestMapping(method=RequestMethod.PUT, value="/products/{id}")
    public Product update(@PathVariable String id, @RequestBody Product product) {
        Product prod = productRepository.findOne(id);
        if(product.getProdName() != null)
            prod.setProdName(product.getProdName());
        if(product.getProdDesc() != null)
            prod.setProdDesc(product.getProdDesc());
        if(product.getProdPrice() != null)
            prod.setProdPrice(product.getProdPrice());
        if(product.getProdImage() != null)
            prod.setProdImage(product.getProdImage());
        productRepository.save(prod);
        return prod;
    }

    @RequestMapping(method=RequestMethod.DELETE, value="/products/{id}")
    public String delete(@PathVariable String id) {
        Product product = productRepository.findOne(id);
        productRepository.delete(product);

        return "product deleted";
    }
}

We are using the same URL for each endpoint but the differences are `Request Method` that used. Here's the table of endpoint examples:

Java REST API: Run and Test the Spring Boot MongoDB RESTful Web Service

For testing purpose, we use curl from the terminal or command line. Let's start the server by type this command.

./gradlew bootRun

Open another terminal tab then type this command for post data to REST API.

curl -i -X POST -H "Content-Type: application/json" -d '{"prodName":"Dummy Product 1","prodDesc":"The Fresh Dummy Product in The world part 1","prodPrice":100,"prodImage":"https://dummyimage.com/600x400/000/fff"}' localhost:8080/products

You will see the successful response like this.

HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 24
Date: Sun, 17 Sep 2017 10:14:39 GMT

59be4b0fb1a2416a11a43c21

To get all product data type this command.

curl -i -H "Accept: application/json" localhost:8080/products

You will see all data as JSON array like this.

HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Transfer-Encoding: chunked
Date: Sun, 17 Sep 2017 10:17:08 GMT

[{"id":"59be4b0fb1a2416a11a43c21","prodName":"Dummy Product 1","prodDesc":"The Fresh Dummy Product in The world part 1","prodPrice":100.0,"prodImage":"https://dummyimage.com/600x400/000/fff"}]

To get single data, type this command.

curl -i -H "Accept: application/json" localhost:8080/products/59be4b0fb1a2416a11a43c21

You will see the single object of JSON data.

HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Transfer-Encoding: chunked
Date: Sun, 17 Sep 2017 10:17:08 GMT

{"id":"59be4b0fb1a2416a11a43c21","prodName":"Dummy Product 1","prodDesc":"The Fresh Dummy Product in The world part 1","prodPrice":100.0,"prodImage":"https://dummyimage.com/600x400/000/fff"}

To update the specific data by ID type this command.

curl -i -X PUT -H "Content-Type: application/json" -d '{"prodPrice":220}'

You will see this response on successful update.

HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Transfer-Encoding: chunked
Date: Sun, 17 Sep 2017 10:26:08 GMT

{"id":"59be4b0fb1a2416a11a43c21","prodName":"Dummy Product 1","prodDesc":"The Fresh Dummy Product in The world part 1","prodPrice":220.0,"prodImage":"https://dummyimage.com/600x400/000/fff"}

To delete specific data by ID, type this command.

curl -i -X DELETE localhost:8080/products/59be4b0fb1a2416a11a43c21

You will see this response if successful delete.

HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 15
Date: Sun, 17 Sep 2017 10:28:38 GMT

product deleted

That it's, the simple way to create Java RESTful web service or REST API using Spring Boot and MongoDB. You can find the full source code on our GitHub.

That just the basic. If you need more deep learning about Java and Spring Framework you can take the following cheap course:

• Master Java Web Services and REST API with Spring Boot
• JDBC Servlets and JSP - Java Web Development Fundamentals
• The Complete Java Web Development Course
• Spring MVC For Beginners: Build Java Web App in 25 Steps
• Practical RESTful Web Services with Java EE 8 (JAX-RS 2.1)

Thanks!