Creating a RESTful web service

duration 30 minutes
Git clone to get going right away:
git clone https://github.com/OpenLiberty/guide-rest-intro.git
Copy Github clone command

Learn how to create a REST service with JAX-RS, JSON-P, and Open Liberty.

What you’ll learn

You will learn how to build and test a simple REST service with JAX-RS and JSON-P, which will expose the JVM’s system properties. The REST service will respond to GET requests made to the http://localhost:9080/LibertyProject/System/properties URL.

The service responds to a GET request with a JSON representation of the system properties, where each property is a field in a JSON object like this:

{
  "os.name":"Mac",
  "java.version": "1.8"
}

When you create a new REST application, the design of the API is important. The JAX-RS APIs could be used to create JSON-RPC, or XML-RPC APIs, but it wouldn’t be a RESTful service. A good RESTful service is designed around the resources that are exposed, and on how to create, read, update, and delete the resources.

The service responds to GET requests to the /System/properties path. The GET request should return a 200 OK response that contains all of the JVM’s system properties.

Getting started

The fastest way to work through this guide is to clone the Git repository and use the projects that are provided inside:

git clone https://github.com/openliberty/guide-rest-intro.git
cd guide-rest-intro

The start directory contains the starting project that you will build upon.

The finish directory contains the finished project that you will build.

Try what you’ll build

The finish directory in the root of this guide contains the finished application. Give it a try before you proceed.

To try out the application, first go to the finish directory and run the following Maven goal to build the application inside Open Liberty:

mvn install

Next, run the Maven liberty:start-server goal to start the application inside Open Liberty:

mvn liberty:start-server

Check out the service at the http://localhost:9080/LibertyProject/System/properties URL.

After you are done checking out the application, stop the Open Liberty server:

mvn liberty:stop-server

Creating a JAX-RS application

Navigate to the start directory to begin.

JAX-RS has two key concepts for creating REST APIs. The most obvious one is the resource itself, which is modelled as a class. The second is a JAX-RS application, which groups all exposed resources under a common path. You can think of the JAX-RS application as a wrapper for all of your resources. Having a single JAX-RS application is common, although multiple are possible.

Create the SystemApplication class.
src/main/java/io/openliberty/guides/rest/SystemApplication.java

The SystemApplication class extends the Application class, which in turn associates all JAX-RS resource classes in the WAR file with this JAX-RS application, making them available under the common path specified in the SystemApplication class. The @ApplicationPath annotation has a value that indicates the path within the WAR that the JAX-RS application accepts requests from.

SystemApplication.java

 1package io.openliberty.guides.rest;
 2
 3import javax.ws.rs.core.Application;
 4import javax.ws.rs.ApplicationPath;
 5
 6@ApplicationPath("System")
 7public class SystemApplication extends Application {
 8
 9}

Creating the JAX-RS resource

In JAX-RS, a single class should represent a single resource, or a group of resources of the same type. In this application, a resource might be a system property, or a set of system properties. It is easy to have a single class handle multiple different resources, but keeping a clean separation between types of resources helps with maintainability in the long run.

Create the PropertiesResource class.
src/main/java/io/openliberty/guides/rest/PropertiesResource.java

This resource class has quite a bit of code in it, so let’s break it down into manageable chunks.

The @Path annotation on the class indicates that this resource responds to the properties path in the JAX-RS application. The @ApplicationPath annotation in the SystemApplication class together with the @Path annotation in this class indicates that the resource is available at the System/properties path.

JAX-RS maps the HTTP methods on the URL to the methods on the class. The method to call is determined by the annotations specified on the methods. In the application you are building, an HTTP GET request to the System/properties path results in the system properties being returned.

The @GET annotation on the method indicates that this method is to be called for the HTTP GET method. The @Produces annotation indicates the format of the content that will be returned, the value of the @Produces annotation will be specified in the HTTP Content-Type response header. For this application, a JSON structure is to be returned. The desired Content-Type for a JSON response is application/json with MediaType.APPLICATION_JSON instead of the String content type. Using literal code such as MediaType.APPLICATION_JSON is better because in the event of a spelling error, a compile failure occurs.

JAX-RS supports a number of ways to marshal JSON. The JAX-RS specification mandates JSON-Processing (JSON-P) and JAX-B. Most JAX-RS implementations also support a Java POJO-to-JSON conversion, which allows the Properties object to be returned instead. Although this conversion would allow for a simpler implementation, it limits code portability as POJO-to-JSON conversion is non-standard.

The method body does the following actions:

  1. Creates a JsonObjectBuilder object using the Json class. The JsonObjectBuilder is then used to populate a JsonObject with values.

  2. Calls the getProperties method on the System class to get a Properties object that contains all the system properties.

  3. Calls the entrySet method on the Properties object to get a Set of all the entries.

  4. Convert the Set to a Stream by calling the stream method. Streams make working through all the entries in a list very simple.

  5. Calls the forEach method on the Stream passing in a function that will be invoked for each entry in the Stream. The function passed in will call the add method on the JsonObjectBuilder for every entry in the stream. The key and value for the JsonObject will be obtained by calling the getKey and getValue methods on the Map.Entry objects in the stream.

  6. Returns the JsonObject by calling the build method on the JsonObjectBuilder.

PropertiesResource.java

 1package io.openliberty.guides.rest;
 2
 3import javax.json.Json;
 4import javax.json.JsonObject;
 5import javax.json.JsonObjectBuilder;
 6import javax.ws.rs.GET;
 7import javax.ws.rs.Path;
 8import javax.ws.rs.Produces;
 9import javax.ws.rs.core.MediaType;
10
11@Path("properties")
12public class PropertiesResource {
13
14    @GET
15    @Produces(MediaType.APPLICATION_JSON)
16    public JsonObject getProperties() {
17
18        JsonObjectBuilder builder = Json.createObjectBuilder();
19
20        System.getProperties()
21              .entrySet()
22              .stream()
23              .forEach(entry -> builder.add((String)entry.getKey(),
24                                            (String)entry.getValue()));
25
26       return builder.build();
27    }
28}

SystemApplication.java

 1package io.openliberty.guides.rest;
 2
 3import javax.ws.rs.core.Application;
 4import javax.ws.rs.ApplicationPath;
 5
 6@ApplicationPath("System")
 7public class SystemApplication extends Application {
 8
 9}

Configuring the server

To get the service running, the Liberty server needs to be correctly configured.

Create the server configuration file.
src/main/liberty/config/server.xml

server.xml

 1<server description="Intro REST Guide Liberty server">
 2
 3  <featureManager>
 4      <feature>jaxrs-2.1</feature>
 5      <feature>jsonp-1.1</feature>
 6  </featureManager>
 7
 8  <httpEndpoint httpPort="${default.http.port}" httpsPort="${default.https.port}"
 9                id="defaultHttpEndpoint" host="*" />
10
11  <webApplication location="rest.war" contextRoot="${app.context.root}"/>
12</server>

The configuration does the following actions:

  1. Configures the server to support both JAX-RS and JSON-P. This is specified in the featureManager element.

  2. Configures the server to pick up the HTTP port numbers from variables, which are then specified in the Maven pom.xml file. This is specified in the <httpEndpoint/> element. Variables use the syntax ${variableName}.

  3. Configures the server to run the produced Web application on a context root specified in the Maven pom.xml file. This is specified in the <webApplication/> element.

pom.xml

  1<?xml version='1.0' encoding='utf-8'?>
  2<project xmlns="http://maven.apache.org/POM/4.0.0"
  3         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4         xsi:schemaLocation=
  5         "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  6    <modelVersion>4.0.0</modelVersion>
  7    <parent>
  8        <groupId>net.wasdev.wlp.maven.parent</groupId>
  9        <artifactId>liberty-maven-app-parent</artifactId>
 10        <version>RELEASE</version>
 11    </parent>
 12    <groupId>io.openliberty.guides</groupId>
 13    <artifactId>rest</artifactId>
 14    <version>1.0-SNAPSHOT</version>
 15    <packaging>war</packaging>
 16
 17    <properties>
 18        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 19        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 20        <maven.compiler.source>1.8</maven.compiler.source>
 21        <maven.compiler.target>1.8</maven.compiler.target>
 22        <app.name>LibertyProject</app.name>
 23        <testServerHttpPort>9080</testServerHttpPort>
 24        <testServerHttpsPort>9443</testServerHttpsPort>
 25        <warContext>${app.name}</warContext>
 26        <package.file>${project.build.directory}/${app.name}.zip</package.file>
 27        <packaging.type>usr</packaging.type>
 28    </properties>
 29
 30    <dependencyManagement>
 31        <dependencies>
 32            <dependency>
 33                <groupId>io.openliberty.features</groupId>
 34                <artifactId>features-bom</artifactId>
 35                <version>RELEASE</version>
 36                <type>pom</type>
 37                <scope>import</scope>
 38            </dependency>
 39        </dependencies>
 40    </dependencyManagement>
 41
 42    <dependencies>
 43        <!-- Open Liberty features -->
 44        <dependency>
 45            <groupId>io.openliberty.features</groupId>
 46            <artifactId>jaxrs-2.1</artifactId>
 47            <type>esa</type>
 48            <scope>provided</scope>
 49        </dependency>
 50        <dependency>
 51            <groupId>io.openliberty.features</groupId>
 52            <artifactId>jsonp-1.1</artifactId>
 53            <type>esa</type>
 54            <scope>provided</scope>
 55        </dependency>
 56        <!-- For tests -->
 57        <dependency>
 58            <groupId>junit</groupId>
 59            <artifactId>junit</artifactId>
 60            <version>4.12</version>
 61            <scope>test</scope>
 62        </dependency>
 63        <dependency>
 64            <groupId>org.apache.cxf</groupId>
 65            <artifactId>cxf-rt-rs-client</artifactId>
 66            <version>3.2.6</version>
 67            <scope>test</scope>
 68        </dependency>
 69        <dependency>
 70            <groupId>org.apache.cxf</groupId>
 71            <artifactId>cxf-rt-rs-extension-providers</artifactId>
 72            <version>3.2.6</version>
 73            <scope>test</scope>
 74        </dependency>
 75        <dependency>
 76            <groupId>org.glassfish</groupId>
 77            <artifactId>javax.json</artifactId>
 78            <version>1.0.4</version>
 79            <scope>test</scope>
 80        </dependency>
 81        <!-- For JDK 9 & 10 Support -->
 82        <dependency>
 83            <groupId>javax.xml.bind</groupId>
 84            <artifactId>jaxb-api</artifactId>
 85            <version>2.3.1</version>
 86        </dependency>
 87        <dependency>
 88            <groupId>com.sun.xml.bind</groupId>
 89            <artifactId>jaxb-core</artifactId>
 90            <version>2.3.0.1</version>
 91        </dependency>
 92        <dependency>
 93            <groupId>com.sun.xml.bind</groupId>
 94            <artifactId>jaxb-impl</artifactId>
 95            <version>2.3.2</version>
 96        </dependency>
 97        <dependency>
 98            <groupId>javax.activation</groupId>
 99            <artifactId>activation</artifactId>
100            <version>1.1.1</version>
101        </dependency>
102    </dependencies>
103
104    <build>
105        <plugins>
106            <plugin>
107                <groupId>org.apache.maven.plugins</groupId>
108                <artifactId>maven-war-plugin</artifactId>
109                <version>3.2.2</version>
110                <configuration>
111                    <failOnMissingWebXml>false</failOnMissingWebXml>
112                    <packagingExcludes>pom.xml</packagingExcludes>
113                </configuration>
114            </plugin>
115            <!-- Plugin to run unit tests -->
116            <plugin>
117                <groupId>org.apache.maven.plugins</groupId>
118                <artifactId>maven-surefire-plugin</artifactId>
119                <version>3.0.0-M1</version>
120                <executions>
121                    <execution>
122                        <phase>test</phase>
123                        <id>default-test</id>
124                        <configuration>
125                            <excludes>
126                                <exclude>**/it/**</exclude>
127                            </excludes>
128                            <reportsDirectory>${project.build.directory}/test-reports/unit
129                                             </reportsDirectory>
130                        </configuration>
131                    </execution>
132                </executions>
133            </plugin>
134            <!-- Enable liberty-maven plugin -->
135            <plugin>
136                <groupId>net.wasdev.wlp.maven.plugins</groupId>
137                <artifactId>liberty-maven-plugin</artifactId>
138                <configuration>
139                    <assemblyArtifact>
140                         <groupId>io.openliberty</groupId>
141                         <artifactId>openliberty-runtime</artifactId>
142                         <version>RELEASE</version>
143                        <type>zip</type>
144                    </assemblyArtifact>
145                    <configFile>src/main/liberty/config/server.xml</configFile>
146                    <packageFile>${package.file}</packageFile>
147                    <include>${packaging.type}</include>
148                    <bootstrapProperties>
149                        <default.http.port>${testServerHttpPort}</default.http.port>
150                        <default.https.port>${testServerHttpsPort}</default.https.port>
151                        <app.context.root>${warContext}</app.context.root>
152                    </bootstrapProperties>
153                </configuration>
154                <executions>
155                    <execution>
156                        <id>install-apps</id>
157                        <configuration>
158                            <looseApplication>true</looseApplication>
159                            <stripVersion>true</stripVersion>
160                            <installAppPackages>project</installAppPackages>
161                        </configuration>
162                    </execution>
163                    <execution>
164                        <id>package-app</id>
165                        <configuration>
166                            <outputDirectory>target/wlp-package</outputDirectory>
167                        </configuration>
168                    </execution>
169                </executions>
170            </plugin>
171            <!-- Plugin to run functional tests -->
172            <plugin>
173                <groupId>org.apache.maven.plugins</groupId>
174                <artifactId>maven-failsafe-plugin</artifactId>
175                <version>3.0.0-M1</version>
176                <executions>
177                    <execution>
178                        <phase>integration-test</phase>
179                        <id>integration-test</id>
180                        <goals>
181                            <goal>integration-test</goal>
182                        </goals>
183                        <configuration>
184                            <includes>
185                                <include>**/it/**/*.java</include>
186                            </includes>
187                            <systemPropertyVariables>
188                                <liberty.test.port>${testServerHttpPort}
189                                </liberty.test.port>
190                                <war.name>${warContext}</war.name>
191                            </systemPropertyVariables>
192                        </configuration>
193                    </execution>
194                    <execution>
195                        <id>verify-results</id>
196                        <goals>
197                            <goal>verify</goal>
198                        </goals>
199                    </execution>
200                </executions>
201                <configuration>
202                    <summaryFile>
203                        ${project.build.directory}/test-reports/it/failsafe-summary.xml
204                    </summaryFile>
205                    <reportsDirectory>
206                        ${project.build.directory}/test-reports/it
207                    </reportsDirectory>
208                </configuration>
209            </plugin>
210        </plugins>
211    </build>
212</project>

The variables being used in the server.xml file are provided by the <bootstrapProperties/> section of the Maven pom.xml.

Building and running the application

To build the application, run the Maven install phase from the command line in the start directory:

mvn install

This command builds the application and creates a .war file in the target directory. It also configures and installs Open Liberty into the target/liberty/wlp directory.

Next, run the Maven liberty:start-server goal:

mvn liberty:start-server

This goal starts an Open Liberty server instance. Your Maven pom.xml is already configured to start the application in this server instance.

Check out the service you created at the http://localhost:9080/LibertyProject/System/properties URL.

When you are done checking out the services, stop the Open Liberty server by running the following command:

mvn liberty:stop-server

Testing the service

You could test this service manually by starting a server and pointing a web browser at the http://localhost:9080/LibertyProject/System/properties URL. Automated tests are a much better approach because they will trigger a failure if a change introduces a bug. JUnit and the JAX-RS Client API provide a very simple environment to test the application.

You can write tests for the individual units of code outside of a running application server, or they can be written to call the application server directly. In this example, you will create a test that does the latter.

Create the EndpointTest class.
src/test/java/it/io/openliberty/guides/rest/EndpointTest.java

EndpointTest.java

 1package it.io.openliberty.guides.rest;
 2
 3import static org.junit.Assert.assertEquals;
 4
 5import javax.json.JsonObject;
 6import javax.ws.rs.client.Client;
 7import javax.ws.rs.client.ClientBuilder;
 8import javax.ws.rs.client.WebTarget;
 9import javax.ws.rs.core.Response;
10
11import org.apache.cxf.jaxrs.provider.jsrjsonp.JsrJsonpProvider;
12import org.junit.Test;
13
14public class EndpointTest {
15
16    @Test
17    public void testGetProperties() {
18        String port = System.getProperty("liberty.test.port");
19        String war = System.getProperty("war.name");
20        String url = "http://localhost:" + port + "/" + war + "/";
21
22        Client client = ClientBuilder.newClient();
23        client.register(JsrJsonpProvider.class);
24
25        WebTarget target = client.target(url + "System/properties");
26        Response response = target.request().get();
27
28        assertEquals("Incorrect response code from " + url,
29                     Response.Status.OK.getStatusCode(), response.getStatus());
30
31        JsonObject obj = response.readEntity(JsonObject.class);
32
33        assertEquals("The system property for the local and remote JVM should match",
34                     System.getProperty("os.name"),
35                     obj.getString("os.name"));
36        response.close();
37    }
38}

This test class has more lines of code than the resource implementation. This situation is common. The test method is indicated with the @Test annotation.

pom.xml

  1<?xml version='1.0' encoding='utf-8'?>
  2<project xmlns="http://maven.apache.org/POM/4.0.0"
  3         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4         xsi:schemaLocation=
  5         "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  6    <modelVersion>4.0.0</modelVersion>
  7    <parent>
  8        <groupId>net.wasdev.wlp.maven.parent</groupId>
  9        <artifactId>liberty-maven-app-parent</artifactId>
 10        <version>RELEASE</version>
 11    </parent>
 12    <groupId>io.openliberty.guides</groupId>
 13    <artifactId>rest</artifactId>
 14    <version>1.0-SNAPSHOT</version>
 15    <packaging>war</packaging>
 16
 17    <properties>
 18        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 19        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 20        <maven.compiler.source>1.8</maven.compiler.source>
 21        <maven.compiler.target>1.8</maven.compiler.target>
 22        <app.name>LibertyProject</app.name>
 23        <testServerHttpPort>9080</testServerHttpPort>
 24        <testServerHttpsPort>9443</testServerHttpsPort>
 25        <warContext>${app.name}</warContext>
 26        <package.file>${project.build.directory}/${app.name}.zip</package.file>
 27        <packaging.type>usr</packaging.type>
 28    </properties>
 29
 30    <dependencyManagement>
 31        <dependencies>
 32            <dependency>
 33                <groupId>io.openliberty.features</groupId>
 34                <artifactId>features-bom</artifactId>
 35                <version>RELEASE</version>
 36                <type>pom</type>
 37                <scope>import</scope>
 38            </dependency>
 39        </dependencies>
 40    </dependencyManagement>
 41
 42    <dependencies>
 43        <!-- Open Liberty features -->
 44        <dependency>
 45            <groupId>io.openliberty.features</groupId>
 46            <artifactId>jaxrs-2.1</artifactId>
 47            <type>esa</type>
 48            <scope>provided</scope>
 49        </dependency>
 50        <dependency>
 51            <groupId>io.openliberty.features</groupId>
 52            <artifactId>jsonp-1.1</artifactId>
 53            <type>esa</type>
 54            <scope>provided</scope>
 55        </dependency>
 56        <!-- For tests -->
 57        <dependency>
 58            <groupId>junit</groupId>
 59            <artifactId>junit</artifactId>
 60            <version>4.12</version>
 61            <scope>test</scope>
 62        </dependency>
 63        <dependency>
 64            <groupId>org.apache.cxf</groupId>
 65            <artifactId>cxf-rt-rs-client</artifactId>
 66            <version>3.2.6</version>
 67            <scope>test</scope>
 68        </dependency>
 69        <dependency>
 70            <groupId>org.apache.cxf</groupId>
 71            <artifactId>cxf-rt-rs-extension-providers</artifactId>
 72            <version>3.2.6</version>
 73            <scope>test</scope>
 74        </dependency>
 75        <dependency>
 76            <groupId>org.glassfish</groupId>
 77            <artifactId>javax.json</artifactId>
 78            <version>1.0.4</version>
 79            <scope>test</scope>
 80        </dependency>
 81        <!-- For JDK 9 & 10 Support -->
 82        <dependency>
 83            <groupId>javax.xml.bind</groupId>
 84            <artifactId>jaxb-api</artifactId>
 85            <version>2.3.1</version>
 86        </dependency>
 87        <dependency>
 88            <groupId>com.sun.xml.bind</groupId>
 89            <artifactId>jaxb-core</artifactId>
 90            <version>2.3.0.1</version>
 91        </dependency>
 92        <dependency>
 93            <groupId>com.sun.xml.bind</groupId>
 94            <artifactId>jaxb-impl</artifactId>
 95            <version>2.3.2</version>
 96        </dependency>
 97        <dependency>
 98            <groupId>javax.activation</groupId>
 99            <artifactId>activation</artifactId>
100            <version>1.1.1</version>
101        </dependency>
102    </dependencies>
103
104    <build>
105        <plugins>
106            <plugin>
107                <groupId>org.apache.maven.plugins</groupId>
108                <artifactId>maven-war-plugin</artifactId>
109                <version>3.2.2</version>
110                <configuration>
111                    <failOnMissingWebXml>false</failOnMissingWebXml>
112                    <packagingExcludes>pom.xml</packagingExcludes>
113                </configuration>
114            </plugin>
115            <!-- Plugin to run unit tests -->
116            <plugin>
117                <groupId>org.apache.maven.plugins</groupId>
118                <artifactId>maven-surefire-plugin</artifactId>
119                <version>3.0.0-M1</version>
120                <executions>
121                    <execution>
122                        <phase>test</phase>
123                        <id>default-test</id>
124                        <configuration>
125                            <excludes>
126                                <exclude>**/it/**</exclude>
127                            </excludes>
128                            <reportsDirectory>${project.build.directory}/test-reports/unit
129                                             </reportsDirectory>
130                        </configuration>
131                    </execution>
132                </executions>
133            </plugin>
134            <!-- Enable liberty-maven plugin -->
135            <plugin>
136                <groupId>net.wasdev.wlp.maven.plugins</groupId>
137                <artifactId>liberty-maven-plugin</artifactId>
138                <configuration>
139                    <assemblyArtifact>
140                         <groupId>io.openliberty</groupId>
141                         <artifactId>openliberty-runtime</artifactId>
142                         <version>RELEASE</version>
143                        <type>zip</type>
144                    </assemblyArtifact>
145                    <configFile>src/main/liberty/config/server.xml</configFile>
146                    <packageFile>${package.file}</packageFile>
147                    <include>${packaging.type}</include>
148                    <bootstrapProperties>
149                        <default.http.port>${testServerHttpPort}</default.http.port>
150                        <default.https.port>${testServerHttpsPort}</default.https.port>
151                        <app.context.root>${warContext}</app.context.root>
152                    </bootstrapProperties>
153                </configuration>
154                <executions>
155                    <execution>
156                        <id>install-apps</id>
157                        <configuration>
158                            <looseApplication>true</looseApplication>
159                            <stripVersion>true</stripVersion>
160                            <installAppPackages>project</installAppPackages>
161                        </configuration>
162                    </execution>
163                    <execution>
164                        <id>package-app</id>
165                        <configuration>
166                            <outputDirectory>target/wlp-package</outputDirectory>
167                        </configuration>
168                    </execution>
169                </executions>
170            </plugin>
171            <!-- Plugin to run functional tests -->
172            <plugin>
173                <groupId>org.apache.maven.plugins</groupId>
174                <artifactId>maven-failsafe-plugin</artifactId>
175                <version>3.0.0-M1</version>
176                <executions>
177                    <execution>
178                        <phase>integration-test</phase>
179                        <id>integration-test</id>
180                        <goals>
181                            <goal>integration-test</goal>
182                        </goals>
183                        <configuration>
184                            <includes>
185                                <include>**/it/**/*.java</include>
186                            </includes>
187                            <systemPropertyVariables>
188                                <liberty.test.port>${testServerHttpPort}
189                                </liberty.test.port>
190                                <war.name>${warContext}</war.name>
191                            </systemPropertyVariables>
192                        </configuration>
193                    </execution>
194                    <execution>
195                        <id>verify-results</id>
196                        <goals>
197                            <goal>verify</goal>
198                        </goals>
199                    </execution>
200                </executions>
201                <configuration>
202                    <summaryFile>
203                        ${project.build.directory}/test-reports/it/failsafe-summary.xml
204                    </summaryFile>
205                    <reportsDirectory>
206                        ${project.build.directory}/test-reports/it
207                    </reportsDirectory>
208                </configuration>
209            </plugin>
210        </plugins>
211    </build>
212</project>

The test code needs to know some information about the application in order to make requests. The server port and the application context root are key, and are dictated by the server configuration. While this information can be hardcoded, it is better to specify it in a single place like the Maven pom.xml file. Refer to the pom.xml file to see how the application information such as the <app.name/>, <testServerHttpPort/> and <testServerHttpsPort/> elements are provided in the file.

These Maven properties are then passed to the Java test program as the <systemPropertyVariables/> element in the pom.xml file.

Getting the values to create a representation of the URL is simple. The test class uses the getProperty method to get the application details.

The JAX-RS client can be used to make the REST call and convert the payload to and from a JSON-P representation. To get the JAX-RS client to do the conversion, the client needs to have the JsrJsonpProvider class registered with it by calling the register method and providing the Class object for the JsrJsonpProvider class.

To call the JAX-RS service using the JAX-RS client, you first create a WebTarget object by calling the target method providing the URL. To cause the HTTP request to occur first the request method on WebTarget and then the get method on the returned object need to be called. The get method call is a synchronous call that blocks until a response is received. This call returns a Response object, which can be interrogated to determine whether the request was successful.

The first thing to check is that a 200 response was received. The JUnit assertEquals method can be used for this. The first parameter is the error message that indicates why the test failed. The second parameter is the expected response code, and the third is the actual response code. It is important to associate the expected response code with the second parameter and the actual response with the third parameter. Otherwise, the error messages from JUnit will claim that the actual response is the expected one, which can cause confusion.

Check the response body to ensure it returned the right information. Since the client and the server are running on the same machine, it is reasonable to expect that the system properties for the local and remote JVM would be the same. In this case, an assertion is made that the os.name system property for both JVMs is the same. You could write additional assertions assertEquals to check for more values.

Running the tests

If the server is still running from the previous steps, stop it using the Maven liberty:stop-server goal from command line in the start directory:

mvn liberty:stop-server

To rebuild, run the tests, and see that the test passes, run the Maven install command:

mvn install

The Maven build takes a little longer than before the test existed, but expect to see the following information in the output:

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running it.io.openliberty.guides.rest.EndpointTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.884 sec - in it.io.openliberty.guides.rest.EndpointTest

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

To see whether the tests detect a failure, add an assertion that you know fails, or change the existing assertion to a constant value that doesn’t match the os.name system property.

Great work! You’re done!

You developed a REST service in Open Liberty by using JAX-RS and JSON-P.

Learn more about MicroProfile.

See the MicroProfile specs

View the MicroProfile API

Guide Attribution

Creating a RESTful web service by Open Liberty is licensed under CC BY-ND 4.0

Copied to clipboard
Copy code block
Copy file contents
Git clone this repo to get going right away:
git clone https://github.com/OpenLiberty/guide-rest-intro.git
Copy github clone command
Copied to clipboard

Nice work! Where to next?

What did you think of this guide?

Extreme Dislike Dislike Like Extreme Like

What could make this guide better?

Raise an issue to share feedback

Create a pull request to contribute to this guide

Need help?

Ask a question on Stack Overflow

Like Open Liberty? Star our repo on GitHub.

Star