Chapter 2. Developing Applications Using JBoss EAP

1. Log in to the JBoss EAP download page on the Red Hat Customer Portal.
2. Select 7.4 in the Version drop-down menu.
3. Find the Red Hat JBoss Enterprise Application Platform 7.4.0 Quickstarts entry in the list and click Download to download a ZIP file containing the quickstarts.
4. Save the ZIP file to the desired directory.
5. Extract the ZIP file.

1. Start Red Hat CodeReady Studio.
2. Select File → Import.

3. Choose Maven → Existing Maven Projects, then click Next.

   Figure 2.1. Import Existing Maven Projects

   

4. Browse to the desired quickstart’s directory (for example the helloworld quickstart), and click OK. The Projects list box is populated with the pom.xml file of the selected quickstart project.

   Figure 2.2. Select Maven Projects

   
5. Click Finish.

1. If you have not yet defined a server, add the JBoss EAP server to Red Hat CodeReady Studio. See Downloading, Installing, and Setting Up JBoss EAP from within the IDE in the Getting Started with CodeReady Studio Tools guide.

2. Right-click the helloworld project in the Project Explorer tab and select Run As → Run on Server.

   Figure 2.3. Run As - Run on Server

   

3. Select the JBoss EAP 7.4 server from the server list and click Next.

   Figure 2.4. Run on Server

   

4. The helloworld quickstart is already listed to be configured on the server. Click Finish to deploy the quickstart.

   Figure 2.5. Modify Resources Configured on the Server

   

5. Verify the results.

   • In the Server tab, the JBoss EAP 7.4 server status changes to Started .

   • The Console tab shows messages detailing the JBoss EAP server start and the helloworld quickstart deployment.

     WFLYUT0021: Registered web context: /helloworld
     WFLYSRV0010: Deployed "helloworld.war" (runtime-name : "helloworld.war")

   • The helloworld application is available at http://localhost:8080/helloworld and displays the text Hello World!.

1. Import the bean-validation quickstart into Red Hat CodeReady Studio.
2. In the Servers tab, right-click on the server and choose Start to start the JBoss EAP server. If you do not see a Servers tab or have not yet defined a server, add the JBoss EAP server to Red Hat CodeReady Studio. See Downloading, Installing, and Setting Up JBoss EAP from within the IDE in the Getting Started with CodeReady Studio Tools guide.
3. Right-click on the bean-validation project in the Project Explorer tab and select Run As → Maven Build.

4. Enter the following in the Goals input field and then click Run.

   clean verify -Parq-remote

   Figure 2.6. Edit Configuration

   

5. Verify the results.

   The Console tab shows the results of the bean-validation Arquillian tests:

   -------------------------------------------------------
    T E S T S
   -------------------------------------------------------
   Running org.jboss.as.quickstarts.bean_validation.test.MemberValidationTest
   Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.189 sec
   
   Results :
   
   Tests run: 5, Failures: 0, Errors: 0, Skipped: 0
   
   [INFO] ------------------------------------------------------------------------
   [INFO] BUILD SUCCESS
   [INFO] ------------------------------------------------------------------------

Run the helloworld Quickstart from the Command Line

1. Review the README.md file in the root directory of the helloworld quickstart.

2. Start the JBoss EAP server.

   $ EAP_HOME/bin/standalone.sh

3. Navigate to the helloworld quickstart directory.

4. Build and deploy the quickstart using the Maven command provided in the quickstart’s README.md file.

   $ mvn clean install wildfly:deploy

5. The helloworld application is now available at http://localhost:8080/helloworld and displays the text Hello World!.

1. Review the Random.java Qualifier Code

   A qualifier is used to remove ambiguity between two beans, both of which are eligible for injection based on their type. For more information on qualifiers, see Use a Qualifier to Resolve an Ambiguous Injection in the JBoss EAP Development Guide. The @Random qualifier is used for injecting a random number.

   @Target({ TYPE, METHOD, PARAMETER, FIELD })
   @Retention(RUNTIME)
   @Documented
   @Qualifier
   public @interface Random {
   
   }

2. Review the MaxNumber.java Qualifier Code

   The @MaxNumber qualifier is used for injecting the maximum number allowed.

   @Target({ TYPE, METHOD, PARAMETER, FIELD })
   @Retention(RUNTIME)
   @Documented
   @Qualifier
   public @interface MaxNumber {
   }

3. Review the Generator.java Code

   The Generator class creates the random number via a producer method, exposing the maximum possible number via the same. This class is application-scoped, so you don’t get a different random each time.

   @SuppressWarnings("serial")
   @ApplicationScoped
   public class Generator implements Serializable {
   
       private java.util.Random random = new java.util.Random(System.currentTimeMillis());
   
       private int maxNumber = 100;
   
       java.util.Random getRandom() {
           return random;
       }
   
       @Produces
       @Random
       int next() {
           // a number between 1 and 100
           return getRandom().nextInt(maxNumber - 1) + 1;
       }
   
       @Produces
       @MaxNumber
       int getMaxNumber() {
           return maxNumber;
       }
   }

4. Review the Game.java Code

   The session-scoped Game class is the primary entry point of the application. It is responsible for setting up or resetting the game, capturing and validating the user’s guess, and providing feedback to the user with a FacesMessage. It uses the post-construct lifecycle method to initialize the game by retrieving a random number from the @Random Instance<Integer> bean.

   Notice the @Named annotation in the class. This annotation is only required when you want to make the bean accessible to the Jakarta Server Faces view by using Jakarta Expression Language, in this case #{game}.

   @SuppressWarnings("serial")
   @Named
   @SessionScoped
   public class Game implements Serializable {
   
       /**
        * The number that the user needs to guess
        */
       private int number;
   
       /**
        * The users latest guess
        */
       private int guess;
   
       /**
        * The smallest number guessed so far (so we can track the valid guess range).
        */
       private int smallest;
   
       /**
        * The largest number guessed so far
        */
       private int biggest;
   
       /**
        * The number of guesses remaining
        */
       private int remainingGuesses;
   
       /**
        * The maximum number we should ask them to guess
        */
       @Inject
       @MaxNumber
       private int maxNumber;
   
       /**
        * The random number to guess
        */
       @Inject
       @Random
       Instance<Integer> randomNumber;
   
       public Game() {
       }
   
       public int getNumber() {
           return number;
       }
   
       public int getGuess() {
           return guess;
       }
   
       public void setGuess(int guess) {
           this.guess = guess;
       }
   
       public int getSmallest() {
           return smallest;
       }
   
       public int getBiggest() {
           return biggest;
       }
   
       public int getRemainingGuesses() {
           return remainingGuesses;
       }
   
       /**
        * Check whether the current guess is correct, and update the biggest/smallest guesses as needed. Give feedback to the user
        * if they are correct.
        */
       public void check() {
           if (guess > number) {
               biggest = guess - 1;
           } else if (guess < number) {
               smallest = guess + 1;
           } else if (guess == number) {
               FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Correct!"));
           }
           remainingGuesses--;
       }
   
       /**
        * Reset the game, by putting all values back to their defaults, and getting a new random number. We also call this method
        * when the user starts playing for the first time using {@linkplain PostConstruct @PostConstruct} to set the initial
        * values.
        */
       @PostConstruct
       public void reset() {
           this.smallest = 0;
           this.guess = 0;
           this.remainingGuesses = 10;
           this.biggest = maxNumber;
           this.number = randomNumber.get();
       }
   
       /**
        * A Jakarta Server Faces validation method which checks whether the guess is valid. It might not be valid because there are no guesses left,
        * or because the guess is not in range.
        *
        */
       public void validateNumberRange(FacesContext context, UIComponent toValidate, Object value) {
           if (remainingGuesses <= 0) {
               FacesMessage message = new FacesMessage("No guesses left!");
               context.addMessage(toValidate.getClientId(context), message);
               ((UIInput) toValidate).setValid(false);
               return;
           }
           int input = (Integer) value;
   
           if (input < smallest || input > biggest) {
               ((UIInput) toValidate).setValid(false);
   
               FacesMessage message = new FacesMessage("Invalid guess");
               context.addMessage(toValidate.getClientId(context), message);
           }
       }
   }