Chapter 4. Develop Eclipse MicroProfile Applications for JBoss EAP

Procedure

1. Open a browser and log in to the Red Hat Customer Portal.
2. Select Downloads from the menu at the top of the page.
3. Find the Red Hat JBoss Enterprise Application Platform entry in the list and select it.
4. From the Product drop-down list, select JBoss EAP XP.
5. From the Version drop-down list, select 2.0.0.
6. Click the Releases tab.
7. Find JBoss EAP XP 2.0.0 Incremental Maven Repository in the list, and then click Download.
8. Save the archive file to your local directory.

Procedure

1. Locate the path to your Red Hat JBoss Enterprise Application Platform 7.3.0.GA Maven repository. For example, /path/to/repo/jboss-eap-7.3.0.GA-maven-repository/maven-repository/.

2. Extract the downloaded JBoss EAP XP 2.0.0 Incremental Maven repository directly into the directory of the Red Hat JBoss Enterprise Application Platform 7.3.0.GA Maven repository. For example, open a terminal and issue the following command, replacing the value for your Red Hat JBoss Enterprise Application Platform 7.3.0.GA Maven repository path:

   $ unzip -o jboss-eap-xp-2.0.0-incremental-maven-repository.zip -d EAP_MAVEN_REPOSITORY_PATH

Procedure

1. Choose a configuration method and configure the JBoss EAP Eclipse MicroProfile Maven repository.

2. After you have configured the JBoss EAP Eclipse MicroProfile Maven repository, add the jboss-eap-xp-microprofile BOM to the project POM file. The following example shows how to configure the BOM in the <dependencyManagement> section of the pom.xml file:

   <dependencyManagement>
     <dependencies>
       ...
       <dependency>
         <groupId>org.jboss.bom</groupId>
         <artifactId>jboss-eap-xp-microprofile</artifactId>
         <version>2.0.0.GA</version>
         <type>pom</type>
         <scope>import</scope>
     </dependency>
       ...
     </dependencies>
   </dependencyManagement>

   Note

   If you do not specify a value for the type element in the pom.xml file, Maven specifies a jar value for the element.

Procedure

1. Set up the Maven project.

   $ mvn archetype:generate \
       -DgroupId=com.example \
       -DartifactId=microprofile-config \
       -DinteractiveMode=false \
       -DarchetypeGroupId=org.apache.maven.archetypes \
       -DarchetypeArtifactId=maven-archetype-webapp
   cd microprofile-config

   This creates the directory structure for the project and pom.xml configuration file.

2. To let the POM file automatically manage the versions for the Eclipse MicroProfile Config artifact and the Eclipse MicroProfile REST Client artifact in the jboss-eap-xp-microprofile BOM, import the BOM to the <dependencyManagement> section of the project POM file.

   <dependencyManagement>
     <dependencies>
       <!-- importing the microprofile BOM adds MicroProfile specs -->
       <dependency>
           <groupId>org.jboss.bom</groupId>
           <artifactId>jboss-eap-xp-microprofile</artifactId>
           <version>2.0.0.GA</version>
           <type>pom</type>
           <scope>import</scope>
       </dependency>
     </dependencies>
   </dependencyManagement>

3. Add the Eclipse MicroProfile Config artifact and the Eclipse MicroProfile REST Client artifact and other dependencies, managed by the BOM, to the <dependency> section of the project POM file. The following example demonstrates adding the Eclipse MicroProfile Config and the Eclipse MicroProfile REST Client dependencies to the file:

   <!-- Add the MicroProfile REST Client API. Set provided for the <scope> tag, as the API is included in the server. -->
   <dependency>
     <groupId>org.eclipse.microprofile.rest.client</groupId>
     <artifactId>microprofile-rest-client-api</artifactId>
     <scope>provided</scope>
   </dependency>
   <!-- Add the MicroProfile Config API. Set provided for the <scope> tag, as the API is included in the server. -->
   <dependency>
     <groupId>org.eclipse.microprofile.config</groupId>
     <artifactId>microprofile-config-api</artifactId>
     <scope>provided</scope>
   </dependency>
   <!-- Add the JAX-RS API. Set provided for the <scope> tag, as the API is included in the server. -->
   <dependency>
     <groupId>org.jboss.spec.javax.ws.rs</groupId>
     <artifactId>jboss-jaxrs-api_2.1_spec</artifactId>
     <scope>provided</scope>
   </dependency>
   <!-- Add the CDI API. Set provided for the <scope> tag, as the API is included in the server. -->
   <dependency>
     <groupId>jakarta.enterprise</groupId>
     <artifactId>jakarta.enterprise.cdi-api</artifactId>
     <scope>provided</scope>
   </dependency>

Procedure

1. Create the directory to store class files:

   $ mkdir -p APPLICATION_ROOT/src/main/java/com/example/microprofile/config/

   Where APPLICATION_ROOT is the directory containing the pom.xml configuration file for the application.

2. Navigate to the new directory:

   $ cd APPLICATION_ROOT/src/main/java/com/example/microprofile/config/

   Create all class files described in this procedure in this directory.

3. Create a class file named HelloApplication.java with the following content:

   package com.example.microprofile.config;
   
   import javax.ws.rs.ApplicationPath;
   import javax.ws.rs.core.Application;
   
   @ApplicationPath("/")
   public class HelloApplication extends Application {
   
   }

   This class defines the application as a JAX-RS application.

4. Create a class file named HelloService.java with the following content:

   package com.example.microprofile.config;
   
   public class HelloService {
   	String createHelloMessage(String name){
           return "Hello " + name;
       }
   }

5. Create a class file named HelloWorld.java with the following content:

   package com.example.microprofile.config;
   
   import javax.inject.Inject;
   import javax.ws.rs.GET;
   import javax.ws.rs.Path;
   import javax.ws.rs.Produces;
   import org.eclipse.microprofile.config.inject.ConfigProperty;
   
   @Path("/config")
   public class HelloWorld {
   
       @Inject
       @ConfigProperty(name="name", defaultValue="jim") 

   1

   
       String name;
   
      	@Inject
      	HelloService helloService;
   
      	@GET
      	@Path("/json")
      	@Produces({ "application/json" })
      	public String getHelloWorldJSON() {
           String message = helloService.createHelloMessage(name);
          	return "{\"result\":\"" + message + "\"}";
   	}
   }

   1

   A MicroProfile Config property is injected into the class with the annotation @ConfigProperty(name="name", defaultValue="jim"). If no ConfigSource is configured, the value jim is returned.

6. Create an empty file named beans.xml in the src/main/webapp/WEB-INF/ directory:

   $ touch APPLICATION_ROOT/src/main/webapp/WEB-INF/beans.xml

   Where APPLICATION_ROOT is the directory containing the pom.xml configuration file for the application.

7. Navigate to the root directory of the application:

   $ cd APPLICATION_ROOT

   Where APPLICATION_ROOT is the directory containing the pom.xml configuration file for the application.

8. Build the project:

   $ mvn clean install wildfly:deploy

9. Test the output:

   $ curl http://localhost:8080/microprofile-config/config/json

   The following is the expected output:

   {"result":"Hello jim"}

Procedure

1. Add the MicroProfile Fault Tolerance extension using the following management CLI command:

   /extension=org.wildfly.extension.microprofile.fault-tolerance-smallrye:add

2. Enable the microprofile-fault-tolerance-smallrye subsystem using the following managenent command:

   /subsystem=microprofile-fault-tolerance-smallrye:add

3. Reload the server with the following management command:

   reload

Procedure

1. Set up the Maven project:

   mvn archetype:generate \
       -DgroupId=com.example.microprofile.faulttolerance \
       -DartifactId=microprofile-fault-tolerance \
       -DarchetypeGroupId=org.apache.maven.archetypes \
       -DarchetypeArtifactId=maven-archetype-webapp \
       -DinteractiveMode=false
   cd microprofile-fault-tolerance

   The command creates the directory structure for the project and the pom.xml configuration file.

2. To let the POM file automatically manage the versions for the Eclipse MicroProfile Fault Tolerance artifact in the jboss-eap-xp-microprofile BOM, import the BOM to the <dependencyManagement> section of the project POM file.

   <dependencyManagement>
     <dependencies>
       <!-- importing the microprofile BOM adds MicroProfile specs -->
       <dependency>
           <groupId>org.jboss.bom</groupId>
           <artifactId>jboss-eap-xp-microprofile</artifactId>
           <version>${version.microprofile.bom}</version>
           <type>pom</type>
           <scope>import</scope>
       </dependency>
     </dependencies>
   </dependencyManagement>

   Replace ${version.microprofile.bom} with the installed version of BOM.

3. Add the Eclipse MicroProfile Fault Tolerance artifact, managed by the BOM, to the <dependency> section of the project POM file. The following example demonstrates adding the Eclipse MicroProfile Fault Tolerance dependency to the file:

   <!-- Add the MicroProfile Fault Tolerance API. Set provided for the <scope> tag, as the API is included in the server. -->
   <dependency>
     <groupId>org.eclipse.microprofile.fault.tolerance</groupId>
     <artifactId>microprofile-fault-tolerance-api</artifactId>
     <scope>provided</scope>
   </dependency>

Procedure

1. Create the directory to store class files:

   $ mkdir -p APPLICATION_ROOT/src/main/java/com/example/microprofile/faulttolerance

   APPLICATION_ROOT is the directory containing the pom.xml configuration file for the application.

2. Navigate to the new directory:

   $ cd APPLICATION_ROOT/src/main/java/com/example/microprofile/faulttolerance

   For the following steps, create all class files in the new directory.

3. Create a simple entity representing a coffee sample as Coffee.java with the following content:

   package com.example.microprofile.faulttolerance;
   
   public class Coffee {
   
       public Integer id;
       public String name;
       public String countryOfOrigin;
       public Integer price;
   
       public Coffee() {
       }
   
       public Coffee(Integer id, String name, String countryOfOrigin, Integer price) {
           this.id = id;
           this.name = name;
           this.countryOfOrigin = countryOfOrigin;
           this.price = price;
       }
   }

4. Create a class file CoffeeApplication.java with the following content:

   package com.example.microprofile.faulttolerance;
   
   import javax.ws.rs.ApplicationPath;
   import javax.ws.rs.core.Application;
   
   @ApplicationPath("/")
   public class CoffeeApplication extends Application {
   }

5. Create a CDI Bean as CoffeeRepositoryService.java with the following content:

   package com.example.microprofile.faulttolerance;
   
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   import java.util.stream.Collectors;
   import javax.enterprise.context.ApplicationScoped;
   
   @ApplicationScoped
   public class CoffeeRepositoryService {
   
       private Map<Integer, Coffee> coffeeList = new HashMap<>();
   
       public CoffeeRepositoryService() {
           coffeeList.put(1, new Coffee(1, "Fernandez Espresso", "Colombia", 23));
           coffeeList.put(2, new Coffee(2, "La Scala Whole Beans", "Bolivia", 18));
           coffeeList.put(3, new Coffee(3, "Dak Lak Filter", "Vietnam", 25));
       }
   
       public List<Coffee> getAllCoffees() {
           return new ArrayList<>(coffeeList.values());
       }
   
       public Coffee getCoffeeById(Integer id) {
           return coffeeList.get(id);
       }
   
       public List<Coffee> getRecommendations(Integer id) {
           if (id == null) {
               return Collections.emptyList();
           }
           return coffeeList.values().stream()
                   .filter(coffee -> !id.equals(coffee.id))
                   .limit(2)
                   .collect(Collectors.toList());
       }
   }

6. Create a class file CoffeeResource.java with the following content:

   package com.example.microprofile.faulttolerance;
   
   import java.util.List;
   import java.util.Random;
   import java.util.concurrent.atomic.AtomicLong;
   import javax.inject.Inject;
   import javax.ws.rs.GET;
   import javax.ws.rs.Path;
   import javax.ws.rs.Produces;
   import javax.ws.rs.core.MediaType;
   import java.util.Collections;
   import javax.ws.rs.PathParam;
   import org.eclipse.microprofile.faulttolerance.Fallback;
   import org.eclipse.microprofile.faulttolerance.Timeout;
   import org.eclipse.microprofile.faulttolerance.Retry;
   
   @Path("/coffee")
   @Produces(MediaType.APPLICATION_JSON)
   public class CoffeeResource {
   
       @Inject
       private CoffeeRepositoryService coffeeRepository;
   
       private AtomicLong counter = new AtomicLong(0);
   
       @GET
       @Retry(maxRetries = 4) 

   1

   
       public List<Coffee> coffees() {
           final Long invocationNumber = counter.getAndIncrement();
           return coffeeRepository.getAllCoffees();
       }
   
   
       @GET
       @Path("/{id}/recommendations")
       @Timeout(250) 

   2

   
       public List<Coffee> recommendations(@PathParam("id") int id) {
               return coffeeRepository.getRecommendations(id);
           }
   
       @GET
       @Path("fallback/{id}/recommendations")
       @Fallback(fallbackMethod = "fallbackRecommendations") 

   3

   
       public List<Coffee> recommendations2(@PathParam("id") int id) {
           return coffeeRepository.getRecommendations(id);
           }
   
       public List<Coffee> fallbackRecommendations(int id) {
           //always return a default coffee
           return Collections.singletonList(coffeeRepository.getCoffeeById(1));
       }
   }

   1

   Define number of re-tries to 4.

   2

   Define the timeout interval in milliseconds.

   3

   Define a fallback method to call when invocation fails.

7. Navigate to the root directory of the application:

   $ cd APPLICATION_ROOT

8. Build the application using the following Maven command:

   $ mvn clean install wildfly:deploy

   Access the application at http://localhost:8080/microprofile-fault-tolerance/coffee.

Procedure

1. Enable the MicroProfile JWT smallrye extension in JBoss EAP:

   /extension=org.wildfly.extension.microprofile.jwt-smallrye:add

2. Enable the microprofile-jwt-smallrye subsystem:

   /subsystem=microprofile-jwt-smallrye:add

3. Reload the server:

   reload

Procedure

1. Set up the maven project:

   $ mvn archetype:generate -DinteractiveMode=false \
       -DarchetypeGroupId=org.apache.maven.archetypes \
       -DarchetypeArtifactId=maven-archetype-webapp \
       -DgroupId=com.example -DartifactId=microprofile-jwt \
       -Dversion=1.0.0.Alpha1-SNAPSHOT
     cd microprofile-jwt

   The command creates the directory structure for the project and the pom.xml configuration file.

2. To let the POM file automatically manage the versions for the Eclipse MicroProfile JWT artifact in the jboss-eap-xp-microprofile BOM, import the BOM to the <dependencyManagement> section of the project POM file.

   <dependencyManagement>
     <dependencies>
       <!-- importing the microprofile BOM adds MicroProfile specs -->
       <dependency>
           <groupId>org.jboss.bom</groupId>
           <artifactId>jboss-eap-xp-microprofile</artifactId>
           <version>${version.microprofile.bom}</version>
           <type>pom</type>
           <scope>import</scope>
       </dependency>
     </dependencies>
   </dependencyManagement>

   Replace ${version.microprofile.bom} with the installed version of BOM.

3. Add the Eclipse MicroProfile JWT artifact, managed by the BOM, to the <dependency> section of the project POM file. The following example demonstrates adding the Eclipse MicroProfile JWT dependency to the file:

   <!-- Add the MicroProfile JWT API. Set provided for the <scope> tag, as the API is included in the server. -->
   <dependency>
     <groupId>org.eclipse.microprofile.jwt</groupId>
     <artifactId>microprofile-jwt-auth-api</artifactId>
     <scope>provided</scope>
   </dependency>

Procedure

1. Create a token generator.

   This step serves as a reference. For a production environment, implement your own token generator.

   1. Create a directory src/test/java for token the generator utility and navigate to it:

      $ mkdir -p src/test/java
      $ cd src/test/java

   2. Create a class file TokenUtil.java with the following content:

      package  com.example.mpjwt;
      
      import java.io.FileInputStream;
      import java.io.InputStream;
      import java.nio.charset.StandardCharsets;
      import java.security.KeyFactory;
      import java.security.PrivateKey;
      import java.security.spec.PKCS8EncodedKeySpec;
      import java.util.Base64;
      import java.util.UUID;
      
      import javax.json.Json;
      import javax.json.JsonArrayBuilder;
      import javax.json.JsonObjectBuilder;
      
      import com.nimbusds.jose.JOSEObjectType;
      import com.nimbusds.jose.JWSAlgorithm;
      import com.nimbusds.jose.JWSHeader;
      import com.nimbusds.jose.JWSObject;
      import com.nimbusds.jose.JWSSigner;
      import com.nimbusds.jose.Payload;
      import com.nimbusds.jose.crypto.RSASSASigner;
      
      public class TokenUtil {
      
          private static PrivateKey loadPrivateKey(final String fileName) throws Exception {
              try (InputStream is = new FileInputStream(fileName)) {
                  byte[] contents = new byte[4096];
                  int length = is.read(contents);
                  String rawKey = new String(contents, 0, length, StandardCharsets.UTF_8)
                          .replaceAll("-----BEGIN (.*)-----", "")
                          .replaceAll("-----END (.*)----", "")
                          .replaceAll("\r\n", "").replaceAll("\n", "").trim();
      
                  PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(rawKey));
                  KeyFactory keyFactory = KeyFactory.getInstance("RSA");
      
                  return keyFactory.generatePrivate(keySpec);
              }
          }
      
          public static String generateJWT(final String principal, final String birthdate, final String...groups) throws Exception {
          	PrivateKey privateKey = loadPrivateKey("private.pem");
      
              JWSSigner signer = new RSASSASigner(privateKey);
              JsonArrayBuilder groupsBuilder = Json.createArrayBuilder();
              for (String group : groups) { groupsBuilder.add(group); }
      
              long currentTime = System.currentTimeMillis() / 1000;
              JsonObjectBuilder claimsBuilder = Json.createObjectBuilder()
                      .add("sub", principal)
                      .add("upn", principal)
                      .add("iss", "quickstart-jwt-issuer")
                      .add("aud", "jwt-audience")
                      .add("groups", groupsBuilder.build())
                      .add("birthdate", birthdate)
                      .add("jti", UUID.randomUUID().toString())
                      .add("iat", currentTime)
                      .add("exp", currentTime + 14400);
      
              JWSObject jwsObject = new JWSObject(new JWSHeader.Builder(JWSAlgorithm.RS256)
                      .type(new JOSEObjectType("jwt"))
                      .keyID("Test Key").build(),
                      new Payload(claimsBuilder.build().toString()));
      
              jwsObject.sign(signer);
      
              return jwsObject.serialize();
          }
      
          public static void main(String[] args) throws Exception {
              if (args.length < 2) throw new IllegalArgumentException("Usage TokenUtil {principal} {birthdate} {groups}");
              String principal = args[0];
              String birthdate = args[1];
              String[] groups = new String[args.length - 2];
              System.arraycopy(args, 2, groups, 0, groups.length);
      
              String token = generateJWT(principal, birthdate, groups);
              String[] parts = token.split("\\.");
              System.out.println(String.format("\nJWT Header - %s", new String(Base64.getDecoder().decode(parts[0]), StandardCharsets.UTF_8)));
              System.out.println(String.format("\nJWT Claims - %s", new String(Base64.getDecoder().decode(parts[1]), StandardCharsets.UTF_8)));
              System.out.println(String.format("\nGenerated JWT Token \n%s\n", token));
          }
      }

2. Create the web.xml file in the src/main/webapp/WEB-INF directory with the following content:

   <context-param>
       <param-name>resteasy.role.based.security</param-name>
       <param-value>true</param-value>
   </context-param>
   
   <security-role>
       <role-name>Subscriber</role-name>
   </security-role>

3. Create a class file SampleEndPoint.java with the following content:

   package com.example.mpjwt;
   
   import javax.ws.rs.GET;
   import javax.ws.rs.Path;
   
   import java.security.Principal;
   import javax.ws.rs.core.Context;
   import javax.ws.rs.core.SecurityContext;
   
   import javax.annotation.security.RolesAllowed;
   import javax.inject.Inject;
   
   import java.time.LocalDate;
   import java.time.Period;
   import java.util.Optional;
   
   import org.eclipse.microprofile.jwt.Claims;
   import org.eclipse.microprofile.jwt.Claim;
   
   import org.eclipse.microprofile.jwt.JsonWebToken;
   
   @Path("/Sample")
   public class SampleEndPoint {
   
       @GET
       @Path("/helloworld")
       public String helloworld(@Context SecurityContext securityContext) {
           Principal principal = securityContext.getUserPrincipal();
           String caller = principal == null ? "anonymous" : principal.getName();
   
           return "Hello " + caller;
       }
   
       @Inject
   	JsonWebToken jwt;
   
   	@GET()
   	@Path("/subscription")
   	@RolesAllowed({"Subscriber"})
   	public String helloRolesAllowed(@Context SecurityContext ctx) {
       	Principal caller =  ctx.getUserPrincipal();
       	String name = caller == null ? "anonymous" : caller.getName();
       	boolean hasJWT = jwt.getClaimNames() != null;
       	String helloReply = String.format("hello + %s, hasJWT: %s", name, hasJWT);
   
       	return helloReply;
   	}
   
   	@Inject
   	@Claim(standard = Claims.birthdate)
   	Optional<String> birthdate;
   
   	@GET()
   	@Path("/birthday")
   	@RolesAllowed({ "Subscriber" })
   	public String birthday() {
       	if (birthdate.isPresent()) {
           	LocalDate birthdate = LocalDate.parse(this.birthdate.get().toString());
           	LocalDate today = LocalDate.now();
           	LocalDate next = birthdate.withYear(today.getYear());
           	if (today.equals(next)) {
               	return "Happy Birthday";
           }
           if (next.isBefore(today)) {
               next = next.withYear(next.getYear() + 1);
           }
   
           Period wait = today.until(next);
   
           return String.format("%d months and %d days until your next birthday.", wait.getMonths(), wait.getDays());
       }
   
       return "Sorry, we don't know your birthdate.";
   
   	}
   
   }

   The methods annotated with @Path are the JAX-RS endpoints.

   The annotation @Claim defines a JWT claim.

4. Create a class file App.java to enable JAX-RS:

   package com.example.mpjwt;
   
   import javax.ws.rs.ApplicationPath;
   import javax.ws.rs.core.Application;
   
   import org.eclipse.microprofile.auth.LoginConfig;
   
   @ApplicationPath("/rest")
   @LoginConfig(authMethod="MP-JWT", realmName="MP JWT Realm")
   public class App extends Application {}

   The annotation @LoginConfig(authMethod="MP-JWT", realmName="MP JWT Realm") enables JWT RBAC during deployment.

5. Compile the application with the following Maven command:

   $ mvn package

6. Generate JWT token using the token generator utility:

   $ mvn exec:java -Dexec.mainClass=org.wildfly.quickstarts.mpjwt.TokenUtil -Dexec.classpathScope=test -Dexec.args="testUser 2017-09-15 Echoer Subscriber"

7. Build and deploy the application using the following Maven command:

   $ mvn package wildfly:deploy

8. Test the application.

   • Call the Sample/subscription endpoint using the bearer token:

     $ curl -H "Authorization: Bearer ey..rg" http://localhost:8080/microprofile-jwt/rest/Sample/subscription

   • Call the Sample/birthday endpoint:

     $ curl -H "Authorization: Bearer ey..rg" http://localhost:8080/microprofile-jwt/rest/Sample/birthday

Procedure

1. Create a class file HelloService.java with the following content:

   package com.example.microprofile.metrics;
   
   public class HelloService {
       String createHelloMessage(String name){
           return "Hello" + name;
       }
   }

2. Create a class file HelloWorld.java with the following content:

   package com.example.microprofile.metrics;
   
   import javax.inject.Inject;
   import javax.ws.rs.GET;
   import javax.ws.rs.Path;
   import javax.ws.rs.Produces;
   import org.eclipse.microprofile.metrics.annotation.Counted;
   
   @Path("/")
   public class HelloWorld {
   @Inject
       HelloService helloService;
   
   @GET
   @Path("/json")
       @Produces({ "application/json" })
       @Counted(name = "requestCount",
     		 absolute = true,
   description = "Number of times the getHelloWorldJSON was requested")
       public String getHelloWorldJSON() {
           return "{\"result\":\"" + helloService.createHelloMessage("World") + "\"}";
       }
   }

3. Update the pom.xml file to include the following dependency:

   <dependency>
       <groupId>org.eclipse.microprofile.metrics</groupId>
       <artifactId>microprofile-metrics-api</artifactId>
       <scope>provided</scope>
   </dependency>

4. Build the application using the following Maven command:

   $ mvn clean install wildfly:deploy

5. Test the metrics:

   1. Issue the following command in the CLI:

      $ curl -v http://localhost:9990/metrics |  grep request_count | grep helloworld-rs-metrics

      Expected output:

      jboss_undertow_request_count_total{deployment="helloworld-rs-metrics.war",servlet="org.jboss.as.quickstarts.rshelloworld.JAXActivator",subdeployment="helloworld-rs-metrics.war",microprofile_scope="vendor"} 0.0

   2. In a browser, navigate to the URL http://localhost:8080/helloworld-rs/rest/json.

   3. Re-Issue the following command in the CLI:

      $ curl -v http://localhost:9990/metrics |  grep request_count | grep helloworld-rs-metrics

      Expected output:

      jboss_undertow_request_count_total{deployment="helloworld-rs-metrics.war",servlet="org.jboss.as.quickstarts.rshelloworld.JAXActivator",subdeployment="helloworld-rs-metrics.war",microprofile_scope="vendor"} 1.0

Procedure

1. Enable the MicroProfile OpenAPI smallrye extension in JBoss EAP:

   /extension=org.wildfly.extension.microprofile.openapi-smallrye:add()

2. Enable the microprofile-openapi-smallrye subsystem using the following management command:

   /subsystem=microprofile-openapi-smallrye:add()

3. Reload the server.

   reload

Procedure

1. Initialize the project:

   mvn archetype:generate \
        -DgroupId=com.example.microprofile.openapi \
        -DartifactId=microprofile-openapi\
        -DarchetypeGroupId=org.apache.maven.archetypes \
        -DarchetypeArtifactId=maven-archetype-webapp \
        -DinteractiveMode=false
   cd microprofile-openapi

   The command creates the directory structure for the project and the pom.xml configuration file.

2. Edit the pom.xml configuration file to contain:

   <?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>
   
       <groupId>com.example.microprofile.openapi</groupId>
       <artifactId>microprofile-openapi</artifactId>
       <version>1.0-SNAPSHOT</version>
       <packaging>war</packaging>
   
       <name>microprofile-openapi Maven Webapp</name>
       <!-- Update the value with the URL of the project -->
       <url>http://www.example.com</url>
   
       <properties>
           <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
           <maven.compiler.source>1.8</maven.compiler.source>
           <maven.compiler.target>1.8</maven.compiler.target>
           <version.server.bom>2.0.0.GA</version.server.bom>
       </properties>
   
       <dependencyManagement>
           <dependencies>
               <dependency>
                   <groupId>org.jboss.bom</groupId>
                   <artifactId>jboss-eap-xp-microprofile</artifactId>
                   <version>${version.server.bom}</version>
                   <type>pom</type>
                   <scope>import</scope>
               </dependency>
           </dependencies>
       </dependencyManagement>
   
       <dependencies>
           <dependency>
               <groupId>org.jboss.spec.javax.ws.rs</groupId>
               <artifactId>jboss-jaxrs-api_2.1_spec</artifactId>
               <scope>provided</scope>
           </dependency>
       </dependencies>
   
       <build>
           <!-- Set the name of the archive -->
           <finalName>${project.artifactId}</finalName>
           <plugins>
               <plugin>
                   <artifactId>maven-clean-plugin</artifactId>
                   <version>3.1.0</version>
               </plugin>
               <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
               <plugin>
                   <artifactId>maven-resources-plugin</artifactId>
                   <version>3.0.2</version>
               </plugin>
               <plugin>
                   <artifactId>maven-compiler-plugin</artifactId>
                   <version>3.8.0</version>
               </plugin>
               <plugin>
                   <artifactId>maven-surefire-plugin</artifactId>
                   <version>2.22.1</version>
               </plugin>
               <plugin>
                   <artifactId>maven-war-plugin</artifactId>
                   <version>3.2.2</version>
               </plugin>
               <plugin>
                   <artifactId>maven-install-plugin</artifactId>
                   <version>2.5.2</version>
               </plugin>
               <plugin>
                   <artifactId>maven-deploy-plugin</artifactId>
                   <version>2.8.2</version>
               </plugin>
               <!-- Allows to use mvn wildfly:deploy -->
               <plugin>
                   <groupId>org.wildfly.plugins</groupId>
                   <artifactId>wildfly-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>
   </project>

   Use the pom.xml configuration file and directory structure to create an application.

Procedure

1. Create the directory to store class files:

   $ mkdir -p APPLICATION_ROOT/src/main/java/com/example/microprofile/openapi/

   APPLICATION_ROOT is the directory containing the pom.xml configuration file for the application.

2. Navigate to the new directory:

   $ cd APPLICATION_ROOT/src/main/java/com/example/microprofile/openapi/

   All the class files in the following steps must be created in this directory.

3. Create the class file InventoryApplication.java with the following content:

   package com.example.microprofile.openapi;
   
   import javax.ws.rs.ApplicationPath;
   import javax.ws.rs.core.Application;
   
   @ApplicationPath("/inventory")
   public class InventoryApplication extends Application {
   }

   This class serves as the REST endpoint for the application.

4. Create a class file Fruit.java with the following content:

   package com.example.microprofile.openapi;
   
   public class Fruit {
   
       private final String name;
       private final String description;
   
       public Fruit(String name, String description) {
           this.name = name;
           this.description = description;
       }
   
       public String getName() {
           return this.name;
       }
   
       public String getDescription() {
           return this.description;
       }
   }

5. Create a class file FruitResource.java with the following content:

   package com.example.microprofile.openapi;
   
   import java.util.Collections;
   import java.util.LinkedHashMap;
   import java.util.Set;
   
   import javax.ws.rs.Consumes;
   import javax.ws.rs.DELETE;
   import javax.ws.rs.GET;
   import javax.ws.rs.POST;
   import javax.ws.rs.Path;
   import javax.ws.rs.Produces;
   import javax.ws.rs.core.MediaType;
   
   @Path("/fruit")
   @Produces(MediaType.APPLICATION_JSON)
   @Consumes(MediaType.APPLICATION_JSON)
   public class FruitResource {
   
       private final Set<Fruit> fruits = Collections.newSetFromMap(Collections.synchronizedMap(new LinkedHashMap<>()));
   
       public FruitResource() {
           this.fruits.add(new Fruit("Apple", "Winter fruit"));
           this.fruits.add(new Fruit("Pineapple", "Tropical fruit"));
       }
   
       @GET
       public Set<Fruit> all() {
           return this.fruits;
       }
   
       @POST
       public Set<Fruit> add(Fruit fruit) {
           this.fruits.add(fruit);
           return this.fruits;
       }
   
       @DELETE
       public Set<Fruit> remove(Fruit fruit) {
           this.fruits.removeIf(existingFruit -> existingFruit.getName().contentEquals(fruit.getName()));
           return this.fruits;
       }
   }

6. Navigate to the root directory of the application:

   $ cd APPLICATION_ROOT

7. Build and deploy the application using the following Maven command:

   $ mvn wildfly:deploy

8. Test the application.

   • Access the OpenAPI documentation of the sample application using curl:

     $ curl http://localhost:8080/openapi

   • The following output is returned:

     openapi: 3.0.1
     info:
       title: Archetype Created Web Application
       version: "1.0"
     servers:
     - url: /microprofile-openapi
     paths:
       /inventory/fruit:
         get:
           responses:
             "200":
               description: OK
               content:
                 application/json:
                   schema:
                     type: array
                     items:
                       $ref: '#/components/schemas/Fruit'
         post:
           requestBody:
             content:
               application/json:
                 schema:
                   $ref: '#/components/schemas/Fruit'
           responses:
             "200":
               description: OK
               content:
                 application/json:
                   schema:
                     type: array
                     items:
                       $ref: '#/components/schemas/Fruit'
         delete:
           requestBody:
             content:
               application/json:
                 schema:
                   $ref: '#/components/schemas/Fruit'
           responses:
             "200":
               description: OK
               content:
                 application/json:
                   schema:
                     type: array
                     items:
                       $ref: '#/components/schemas/Fruit'
     components:
       schemas:
         Fruit:
           type: object
           properties:
             description:
               type: string
             name:
               type: string

Procedure

1. Create a directory in the application source tree:

   $ mkdir APPLICATION_ROOT/src/main/webapp/META-INF

   APPLICATION_ROOT is the directory containing the pom.xml configuration file for the application.

2. Query the OpenAPI endpoint, redirecting the output to a file:

   $ curl http://localhost:8080/openapi?format=JSON > src/main/webapp/META-INF/openapi.json

   By default, the endpoint serves a YAML document, format=JSON specifies that a JSON document is returned.

3. Configure the application to skip annotation scanning when processing the OpenAPI document model:

   $ echo "mp.openapi.scan.disable=true" > APPLICATION_ROOT/src/main/webapp/META-INF/microprofile-config.properties

4. Rebuild the application:

   $ mvn clean install

5. Deploy the application again using the following management CLI commands:

   1. Undeploy the application:

      undeploy microprofile-openapi.war

   2. Deploy the application:

      deploy APPLICATION_ROOT/target/microprofile-openapi.war