1. Se connecter au Portail Clients de Red Hat.
2. Cliquer sur Téléchargements.
3. À partir de la liste Téléchargements de produits, cliquer sur Red Hat JBoss Enterprise Application Platform.
4. Sélectionnez 7.1 dans le menu déroulant Version.
5. Recherchez l'entrée Red Hat JBoss Enterprise Application Platform 7.1.0 Quickstarts dans le tableau et cliquez ensuite sur Download.
6. Enregistrer le fichier ZIP sur le répertoire souhaité.
7. Veuillez extraire le fichier ZIP.

1. Démarrer JBoss Developer Studio.
2. Sélectionner File → Import.

3. Sélectionner Maven → Projets Maven existants, puis cliquer sur Suite.

   Figure 3.1. Importer les projets Maven existants

   

4. Naviguer vers le répertoire de quickstart souhaité (par exemple le quickstart helloworld) puis cliquer sur OK. Le champ de la liste Projects se remplit avec le fichier pom.xml du projet de quickstart sélectionné.

   Figure 3.2. Sélectionner les projets Maven

   
5. Cliquer sur Finish.

1. Si vous n'avez pas encore défini de serveur, ajoutez le serveur JBoss EAP à JBoss Developer Studio. Reportez-vous à la section Using Runtime Detection to Set Up JBoss EAP from within the IDE (Utilisation de la détection d'exécution pour configurer JBoss EAP à partir de l'IDE) du guide Getting Started with JBoss Developer Studio Tools (Prise en main de JBoss Developer Studio Tools).

2. Cliquez avec le bouton droit de la souris sur le projet helloworld dans l'onglet Project Explorer et sélectionnez ensuite Run As → Run on Server.

   Figure 3.3. Run As - Run on Server

   

3. Sélectionnez le serveur JBoss EAP 7.1 dans la liste des serveurs, puis cliquez sur Next.

   Figure 3.4. Run on Server

   

4. Le Quickstart helloworld est déjà répertorié comme devant être configuré sur le serveur. Cliquez sur Finish pour le déployer.

   Figure 3.5. Modifier les ressources configurées sur le serveur

   

5. Vérifier les résultats.

   • Dans l'onglet Server, l'état du serveur JBoss EAP 7.1 est alors défini sur Started.

   • L'onglet Console montre des messages détaillant le démarrage du serveur JBoss EAP et le déploiement du quickstart helloworld.

     WFLYUT0021 : contexte web enregistré : /helloworld
     WFLYSRV0010 : "helloworld.war" déployé (runtime-name : "helloworld.war")

   • L'application helloworld est disponible à l'adresse http://localhost:8080/helloworld et affiche le texte Hello World!.

1. Importer le quickstart bean-validation dans JBoss Developer Studio.
2. Dans l'onglet Servers, cliquez avec le bouton droit de la souris sur le serveur et sélectionnez ensuite Start pour démarrer le serveur JBoss EAP. Si l'onglet Servers n'est pas visible ou si vous n'avez pas encore défini de serveur, ajoutez le serveur JBoss EAP à JBoss Developer Studio. Reportez-vous à la section Using Runtime Detection to Set Up JBoss EAP from within the IDE (Utilisation de la détection d'exécution pour configurer JBoss EAP à partir de l'IDE) du guide Getting Started with JBoss Developer Studio Tools (Prise en main de JBoss Developer Studio Tools).
3. Cliquez avec le bouton droit de la souris sur le projet bean-validation dans l'onglet Project Explorer et sélectionnez ensuite Run As → Maven Build.

4. Saisir ce qui suit dans le champ de saisie Goals puis cliquer sur Run.

   clean verify -Parq-remote

   Figure 3.6. Modifier la configuration

   

5. Vérifier les résultats.

   L'onglet Console affiche les résultats des tests Arquillian bean-validation :

   -------------------------------------------------------
    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] ------------------------------------------------------------------------

Exécuter le quickstart helloworld à partir de la ligne de commandes

1. Vérifier le fichier README.md dans le répertoire racine du quickstart helloworld.

2. Démarrer le serveur JBoss EAP.

   $ EAP_HOME/bin/standalone.sh

3. Navuguez dans le répertoire quickstart helloworld.

4. Construire et déployer le quickstart à l'aide de la commande Maven fournie dans le fichier README.md du quickstart.

   $ mvn clean install wildfly:deploy

5. L'application helloworld est désormais disponible à l'adresse http://localhost:8080/helloworld et affiche le texte Hello World!.

1. Vérification du code du qualificateur Random.java

   Un qualificateur est utilisé pour supprimer toute ambiguïté entre deux beans réunissant les conditions nécessaires pour une injection en fonction de leur type. Pour plus d'informations sur les qualificateurs, reportez-vous à la section Use a Qualifier to Resolve an Ambiguous Injection (Utilisation d'un qualificateur pour résoudre une injection ambiguë) du Guide de développement de JBoss EAP. Le qualificateur @Random est utilisé pour l'injection d'un nombre aléatoire.

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

2. Vérification du code du qualificateur MaxNumber.java

   Le qualificateur @MaxNumber est utilisé pour injecter le nombre maximum autorisé.

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

3. Vérification du code Generator.java

   La classe Generator crée le nombre aléatoire au moyen d'une méthode producteur, exposant ainsi le nombre maximum autorisé via celle-ci. Cette classe étant basée sur l'étendue de l'application, vous recevez à chaque fois le même nombre aléatoire.

   @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. Vérification du code Game.java

   La classe Game basée sur la session constitue le point d'entrée principal de l'application. Elle est chargée de configurer ou de réinitialiser le jeu, de collecter et de valider les propositions de l'utilisateur, et de fournir des commentaires à l'utilisateur avec un FacesMessage. Elle utilise la méthode de cycle de vie postérieure à la construction (PostConstruct) pour initialiser le jeu en récupérant un nombre aléatoire du bean @Random Instance<Integer>.

   Notez l'annotation @Named dans cette classe. Cette annotation n'est nécessaire que si vous souhaitez que le bean soit accessible à une vue JSF en utilisant le langage d'expression (EL) ; dans ce cas #{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 JSF 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);
           }
       }
   }