1. Melden Sie sich beim Red Hat Kundenportal an.
2. Klicken Sie auf Downloads.
3. Klicken Sie in der Produkt Downloads Liste auf Red Hat JBoss Enterprise Application Platform.
4. Wählen Sie 7.1 in der Auswahlliste Version aus.
5. Suchen Sie den Eintrag Red Hat JBoss Enterprise Application Platform 7.1.0 Quickstarts in der Tabelle und klicken Sie auf Download.
6. Speichern Sie die Zip-Datei im gewünschten Verzeichnis.
7. Entpacken Sie die Zip-Datei.

1. Starten Sie das JBoss Developer Studio.
2. Wählen Sie Datei → Import.

3. Wählen Sie Maven → Bestehende Maven Projekte und klicken Sie dann auf Weiter.

   Abbildung 3.1. Import bestehender Maven Projekte

   

4. Gehen Sie zum gewünschten Quickstart-Verzeichnis (zum Beispiel helloworld Quickstart) und klicken Sie auf OK. Das Projekte Listenfeld wird mit der pom.xml Datei des gewählten Quickstart-Projekts bestückt.

   Abbildung 3.2. Auswahl von Maven-Projekten

   
5. Klicken Sie auf Fertigstellen.

1. Wenn Sie noch keinen Server definiert haben, fügen Sie den JBoss EAP-Server dem JBoss Developer Studio hinzu. Siehe Verwendung der Runtime Detection zur Einrichtung von JBoss EAP über die IDE im Leitfaden Erste Schritte mit JBoss Developer Studio Tools.

2. Klicken Sie rechts auf das Projekt helloworld in der Registerkarte Project Explorer und wählen SieAusführen als → Ausführung auf Server aus.

   Abbildung 3.3. Ausführen als - Ausführen auf Server

   

3. Wählen Sie den JBoss EAP 7.1 Server aus der Serverliste aus und klicken Sie auf Weiter.

   Abbildung 3.4. Ausführen auf Server

   

4. Der helloworld Quickstart ist bereits zur Konfiguration auf dem Server aufgelistet. Klicken Sie auf Fertigstellen um den Quickstart bereitzustellen.

   Abbildung 3.5. Bearbeiten von auf dem Server konfigurierten Ressourcen

   

5. Überprüfen Sie die Ergebnisse.

   • In der Registerkarte Server ändert sich der JBoss EAP 7.1 Serverstatus auf Started .

   • Der Konsole Reiter zeigt Nachrichten zum JBoss EAP Server-Start und zum Deployment des helloworld Quickstarts.

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

   • Die Anwendung helloworld finden Sie unter http://localhost:8080/helloworld, sie zeigt den Text Hello World! an.

1. Importieren Sie den bean-validation Quickstart ins JBoss Developer Studio.
2. Klicken Sie auf der Registerkarte Servers rechts auf den Server und wählen Sie Start aus, um den JBoss EAP-Server zu starten. Wenn Sie keine Registerkarte Servers sehen oder noch keinen Server definiert haben, fügen Sie den JBoss EAP-Server dem JBoss Developer Studio hinzu. Siehe Verwendung der Runtime Detection zur Einrichtung von JBoss EAP über die IDE im Leitfaden Erste Schritte mit JBoss Developer Studio Tools.
3. Klicken Sie rechts auf das Projekt bean-validation auf der Registerkarte Project Explorer und wählen Sie Ausführen als → Maven Build aus.

4. Geben Sie Folgendes in das Ziele Eingabe-Feld ein und klicken Sie dann auf Ausführen.

   clean verify -Parq-remote

   Abbildung 3.6. Konfiguration bearbeiten

   

5. Überprüfen Sie die Ergebnisse.

   Der Konsole Reiter zeigt die Ergebnisse des 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] ------------------------------------------------------------------------

Führen Sie den helloworld Quickstart von der Befehlszeile aus

1. Überprüfen Sie die README.md Datei im root-Verzeichnis des helloworld Quickstarts.

2. Starten Sie den JBoss EAP-Server.

   $ EAP_HOME/bin/standalone.sh

3. Gehen Sie zum helloworld Quickstart-Verzeichnis.

4. Build und Deployment des Quickstarts über den in der README.md Datei angegebenen Maven-Befehl.

   $ mvn clean install wildfly:deploy

5. Die Anwendung helloworld ist nun unter http://localhost:8080/helloworld verfügbar und zeigt den Text Hello World! an.

1. Gehen Sie den Random.java Qualifikator-Code durch

   Ein Qualifikator wird verwendet, um Unklarheiten zwischen den zwei Beans zu vermeiden, die beide für eine Injektion auf Grundlage ihres Typs in Frage kommen. Weitere Informationen zu Qualifikatoren finden Sie unter Einen Qualifikator verwenden, um eine unklare Injektion zu lösen im JBoss EAP Entwicklerleitfaden. Der Qualifikator @Random wird zur Injektion einer Zufallszahl verwendet.

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

2. Gehen Sie den MaxNumber.java Qualifikator-Code durch

   Der @MaxNumber Qualifikator wird zur Injektion der erlaubten Höchstzahl verwendet.

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

3. Gehen Sie den Generator.java Code durch

   Die Klasse Generator erstellt die Zufallszahl über eine Producer-Methode und stellt die mögliche Höchstzahl über dieselbe Methode zur Verfügung. Diese Klasse ist auf Anwendungsebene ausgelegt, damit nicht jedes Mal eine andere Zufallszahl erstellt wird.

   @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. Gehen Sie den Game.java Code durch

   Die auf Sitzungsebene ausgelegte Klasse Game ist der primäre Zugangspunkt für die Anwendung. Sie ist dafür verantwortlich, das Spiel einzurichten oder zurückzusetzen, den Rateversuch des Benutzers zu erfassen und zu validieren und dem Benutzer über eine FacesMessage Feedback zu geben. Sie verwendet eine Post-Construct-Lifecycle-Methode, um das Spiel zu initialisieren, indem eine Zufallszahl aus der Bean @Random Instance<Integer> abgerufen wird.

   Beachten Sie die Annotation@Named in der Klasse. Diese Annotation ist nur erforderlich, wenn die Bean über Expression Language (EL), in diesem Fall #{game}, für eine JSF-Ansicht verfügbar gemacht werden soll.

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