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

   Copy to Clipboard Toggle word wrap

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>

   Copy to Clipboard Toggle word wrap
   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

   Copy to Clipboard Toggle word wrap

   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>

   Copy to Clipboard Toggle word wrap

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>

   Copy to Clipboard Toggle word wrap

Procedure

1. Create the directory to store class files:

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

   Copy to Clipboard Toggle word wrap

   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/

   Copy to Clipboard Toggle word wrap

   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 {
   
   }

   Copy to Clipboard Toggle word wrap

   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;
       }
   }

   Copy to Clipboard Toggle word wrap

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 + "\"}";
   	}
   }

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

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

8. Build the project:

   $ mvn clean install wildfly:deploy

   Copy to Clipboard Toggle word wrap

9. Test the output:

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

   Copy to Clipboard Toggle word wrap

   The following is the expected output:

   {"result":"Hello jim"}

   Copy to Clipboard Toggle word wrap

Procedure

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

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

   Copy to Clipboard Toggle word wrap

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

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

   Copy to Clipboard Toggle word wrap

3. Reload the server with the following management command:

   reload

   Copy to Clipboard Toggle word wrap

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

   Copy to Clipboard Toggle word wrap

   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>

   Copy to Clipboard Toggle word wrap

   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>

   Copy to Clipboard Toggle word wrap

Procedure

1. Create the directory to store class files:

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

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

   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;
       }
   }

   Copy to Clipboard Toggle word wrap

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 {
   }

   Copy to Clipboard Toggle word wrap

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());
       }
   }

   Copy to Clipboard Toggle word wrap

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));
       }
   }

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

8. Build the application using the following Maven command:

   $ mvn clean install wildfly:deploy

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

2. Enable the microprofile-jwt-smallrye subsystem:

   /subsystem=microprofile-jwt-smallrye:add

   Copy to Clipboard Toggle word wrap

3. Reload the server:

   reload

   Copy to Clipboard Toggle word wrap

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

   Copy to Clipboard Toggle word wrap

   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>

   Copy to Clipboard Toggle word wrap

   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>

   Copy to Clipboard Toggle word wrap

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

      Copy to Clipboard Toggle word wrap

   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));
          }
      }

      Copy to Clipboard Toggle word wrap

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>

   Copy to Clipboard Toggle word wrap

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.";
   
   	}
   
   }

   Copy to Clipboard Toggle word wrap

   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 {}

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

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"

   Copy to Clipboard Toggle word wrap

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

   $ mvn package wildfly:deploy

   Copy to Clipboard Toggle word wrap

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

     Copy to Clipboard Toggle word wrap

   • Call the Sample/birthday endpoint:

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

     Copy to Clipboard Toggle word wrap

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;
       }
   }

   Copy to Clipboard Toggle word wrap

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") + "\"}";
       }
   }

   Copy to Clipboard Toggle word wrap

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>

   Copy to Clipboard Toggle word wrap

4. Build the application using the following Maven command:

   $ mvn clean install wildfly:deploy

   Copy to Clipboard Toggle word wrap

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

      Copy to Clipboard Toggle word wrap

      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

      Copy to Clipboard Toggle word wrap
   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

      Copy to Clipboard Toggle word wrap

      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

      Copy to Clipboard Toggle word wrap

Procedure

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

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

   Copy to Clipboard Toggle word wrap

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

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

   Copy to Clipboard Toggle word wrap

3. Reload the server.

   reload

   Copy to Clipboard Toggle word wrap

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

   Copy to Clipboard Toggle word wrap

   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>

   Copy to Clipboard Toggle word wrap

   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/

   Copy to Clipboard Toggle word wrap

   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/

   Copy to Clipboard Toggle word wrap

   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 {
   }

   Copy to Clipboard Toggle word wrap

   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;
       }
   }

   Copy to Clipboard Toggle word wrap

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;
       }
   }

   Copy to Clipboard Toggle word wrap

6. Navigate to the root directory of the application:

   $ cd APPLICATION_ROOT

   Copy to Clipboard Toggle word wrap

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

   $ mvn wildfly:deploy

   Copy to Clipboard Toggle word wrap

8. Test the application.

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

     $ curl http://localhost:8080/openapi

     Copy to Clipboard Toggle word wrap

   • 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

     Copy to Clipboard Toggle word wrap

Procedure

1. Create a directory in the application source tree:

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

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap

4. Rebuild the application:

   $ mvn clean install

   Copy to Clipboard Toggle word wrap

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

   1. Undeploy the application:

      undeploy microprofile-openapi.war

      Copy to Clipboard Toggle word wrap

   2. Deploy the application:

      deploy APPLICATION_ROOT/target/microprofile-openapi.war

      Copy to Clipboard Toggle word wrap