REST

Spring Boot adopts the simplest approach to building a standalone application that runs on an embedded web server. It creates an executable archive (JAR) file that contains everything, including an entry point defined by a class that contains the main() method. For making it an executable JAR file, you use Spring's support for embedding the Jetty servlet container as the HTTP runtime, instead of deploying it to an external instance for execution.

Therefore, we would create the executable JAR file in place of the WAR that needs to be deployed on external web servers, which is a part of the rest module. We'll define the domain models in the lib module and API related classes in the rest module.

We need to create separate pom.xml files for the lib and rest modules, respectively.

The pom.xml file of the lib module is as follows:

<?xml version="1.0" encoding="UTF-8"?> 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
    <modelVersion>4.0.0</modelVersion> 
    <parent> 
        <groupId>com.packtpub.mmj</groupId> 
        <artifactId>11537_chapter2</artifactId> 
        <version>1.0-SNAPSHOT</version> 
    </parent> 
    <artifactId>lib</artifactId> 
</project> 

The pom.xml file of the rest module is as follows:

    <modelVersion>4.0.0</modelVersion> 
    <parent> 
        <groupId>com.packtpub.mmj</groupId> 
        <artifactId>11537_chapter2</artifactId> 
        <version>1.0-SNAPSHOT</version> 
    </parent> 
    <artifactId>rest</artifactId> 
  <dependencies> 
        <dependency> 
            <groupId>com.packtpub.mmj</groupId> 
            <artifactId>lib</artifactId> 
        </dependency> 
        <dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-web</artifactId> 
    ... 
    ...  

Here, the spring-boot-starter-web dependency is used for developing the standalone executable REST service.

Now, we need to define modules using the module-info.java class in the lib and rest modules in their default package, respectively.

The module-info.java file in the lib module is as follows:

module com.packtpub.mmj.lib { 
    exports com.packtpub.mmj.lib.model to com.packtpub.mmj.rest; 
    opens com.packtpub.mmj.lib.model; 
} 

Here, we are exporting the com.packtpub.mmj.lib.model package to com.packtpub.mmj.rest, which allows access on the part of the lib model classes to the rest module classes.

The module-info.java file in the lib module is as follows:

module com.packtpub.mmj.rest { 
 
    requires spring.core; 
    requires spring.beans; 
    requires spring.context; 
    requires spring.aop; 
    requires spring.web; 
    requires spring.expression; 
 
    requires spring.boot; 
    requires spring.boot.autoconfigure; 
 
    requires com.packtpub.mmj.lib; 
 
    exports com.packtpub.mmj.rest; 
    exports com.packtpub.mmj.rest.resources; 
 
    opens com.packtpub.mmj.rest; 
    opens com.packtpub.mmj.rest.resources; 
} 

Here, module definition contains all the requisite spring modules and our own created com.packtpub.mmj.lib packages by using the requires statement. This allows rest module classes to use classes defined in the spring modules and the newly created lib module. Also, we're exporting and opening the com.packt.mmj.rest and com.packt.mmj.rest.resources packages.

Now, as you are ready regarding which module to utilize, you can create a sample web service. You will create a math API that performs simple calculations and generates the response in JSON format.

Let's discuss how we can call and get responses from REST services.

The service will handle the GET requests for /calculation/sqrt or /calculation/power, and so on. The GET request should return a 200 OK response with JSON in the body that represents the square root of a given number. It should look something like this:

{ 
  "function": "sqrt", 
  "input": [ 
    "144" 
  ], 
  "output": [ 
    "12.0" 
  ] 
} 

The input field is the input parameter for the square root function, and the content is the textual representation of the result.

You could create a resource representation class to model the representation by using Plain Old Java Object (POJO) with fields, constructors, setters, and getters for the input, output, and function data. Since it is a model, we'll create it in the lib module:

package com.packtpub.mmj.lib.model; 
 
import java.util.List; 
 
public class Calculation { 
 
    String function; 
    private List<String> input; 
    private List<String> output; 
 
    public Calculation(List<String> input, 
    List<String> output, String function) { 
        this.function = function; 
        this.input = input; 
        this.output = output; 
    }  
    public List<String> getInput() { 
        return input; 
    }  
    public void setInput(List<String> input) { 
        this.input = input; 
    }  
    public List<String> getOutput() { 
        return output; 
    } 
 
    public void setOutput(List<String> output) { 
        this.output = output; 
    }  
    public String getFunction() { 
        return function; 
    }  
    public void setFunction(String function) { 
        this.function = function; 
    }  
}