Quarkus - Using the REST Client

This guide explains how to use the MicroProfile REST Client in order to interact with REST APIs with very little effort.


To complete this guide, you need:

  • less than 15 minutes

  • an IDE

  • JDK 1.8+ installed with JAVA_HOME configured appropriately

  • Apache Maven 3.5.3+


We recommend that you follow the instructions in the next sections and create the application step by step. However, you can go right to the completed example.

Clone the Git repository: git clone https://github.com/quarkusio/quarkus-quickstarts.git, or download an archive.

The solution is located in the rest-client directory.

Creating the Maven project

First, we need a new project. Create a new project with the following command:

mvn io.quarkus:quarkus-maven-plugin:0.19.1:create \
    -DprojectGroupId=org.acme \
    -DprojectArtifactId=rest-client \
    -DclassName="org.acme.restclient.CountriesResource" \
    -Dpath="/country" \
    -Dextensions="rest-client, resteasy-jsonb"

This command generates the Maven project with a REST endpoint and imports the smallrye-rest-client and resteasy-jsonb extensions.

Setting up the model

In this guide we will be demonstrating how to consume part of the REST API supplied by the restcountries.eu service. Our first order of business is to setup the model we will be using, in the form of a Country POJO.

Create a src/main/java/org/acme/restclient/Country.java file and set the following content:

package org.acme.restclient;

import java.util.List;

public class Country {

    private String name;
    private String alpha2Code;
    private String capital;
    private List<Currency> currencies;

    public String getName() {
        return name;

    public void setName(String name) {
        this.name = name;

    public String getAlpha2Code() {
        return alpha2Code;

    public void setAlpha2Code(String alpha2Code) {
        this.alpha2Code = alpha2Code;

    public String getCapital() {
        return capital;

    public void setCapital(String capital) {
        this.capital = capital;

    public List<Currency> getCurrencies() {
        return currencies;

    public void setCurrencies(List<Currency> currencies) {
        this.currencies = currencies;

    public static class Currency {
        private String code;
        private String name;
        private String symbol;

        public String getCode() {
            return code;

        public void setCode(String code) {
            this.code = code;

        public String getName() {
            return name;

        public void setName(String name) {
            this.name = name;

        public String getSymbol() {
            return symbol;

        public void setSymbol(String symbol) {
            this.symbol = symbol;


The model above in only a subset of the fields provided by the service, but it suffices for the purposes of this guide.

Create the interface

Using the MicroProfile REST Client is as simple as creating an interface using the proper JAX-RS and MicroProfile annotations. In our case the interface should be created at src/main/java/org/acme/restclient/CountriesService.java and have the following content:

package org.acme.restclient;

import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import java.util.Set;

public interface CountriesService {

    Set<Country> getByName(@PathParam("name") String name);

The getByName method gives our code the ability to query a country by name from the REST Countries API. The client will handle all the networking and marshalling leaving our code clean of such technical details.

The purpose of the annotations in the code above is the following:

  • @RegisterRestClient allows Quarkus to know that this interface is meant to be available for CDI injection as a REST Client

  • @Path, @GET and @PathParam are the standard JAX-RS annotations used to define how to access the service

  • @Produces defines the expected content-type

While @Consumes and @Produces are optional as auto-negotiation is supported, it is heavily recommended to annotate your endpoints with them to define precisely the expected content-types.

It will allow to narrow down the number of JAX-RS providers (which can be seen as converters) included in the native executable.

Create the configuration

In order to determine the base URL to which REST calls will be made, the REST Client uses configuration from application.properties. The name of the property needs to follow a certain convention which is best displayed in the following code:

# Your configuration properties
org.acme.restclient.CountriesService/mp-rest/url=https://restcountries.eu/rest # (1)
org.acme.restclient.CountriesService/mp-rest/scope=java.inject.Singleton # (2)
1 Having this configuration means that all requests performed using org.acme.restclient.CountriesService will use https://restcountries.eu/rest as the base URL. Using the configuration above, calling the getByName method of CountriesService with a value of France would result in an HTTP GET request being made to https://restcountries.eu/rest/v2/name/France.
2 Having this configuration means that the default scope of org.acme.restclient.CountriesService will be @Singleton. Supported scope values are @Singleton, @Dependent, @ApplicationScoped and @RequestScoped. The default scope is @Dependent. The default scope can also be defined on the interface.

Note that org.acme.restclient.CountriesService must match the fully qualified name of the CountriesService interface we created in the previous section.

Update the JAX-RS resource

Open the src/main/java/org/acme/restclient/CountriesResource.java file and update it with the following content:

import org.eclipse.microprofile.rest.client.inject.RestClient;

import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import java.util.Set;

public class CountriesResource {

    CountriesService countriesService;

    public Set<Country> name(@PathParam("name") String name) {
        return countriesService.getByName(name);

Note that in addition to the standard CDI @Inject annotation, we also need to use the MicroProfile @RestClient annotation to inject CountriesService.

Update the test

We also need to update the functional test to reflect the changes made to the endpoint. Edit the src/test/java/org/acme/restclient/CountriesResourceTest.java file and change the content of the testCountryNameEndpoint method to:

package org.acme.restclient;

import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.Test;

import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.is;

public class CountriesResourceTest {

    public void testCountryNameEndpoint() {
             .body("$.size()", is(1),
                     "[0].alpha2Code", is("GR"),
                     "[0].capital", is("Athens"),
                     "[0].currencies.size()", is(1),
                     "[0].currencies[0].name", is("Euro")


The code above uses REST Assured's json-path capabilities.

Package and run the application

Run the application with: ./mvnw compile quarkus:dev. Open your browser to http://localhost:8080/country/name/greece.

You should see a JSON object containing some basic information about Greece.

As usual, the application can be packaged using ./mvnw clean package and executed using the -runner.jar file. You can also generate the native executable with ./mvnw clean package -Pnative.