Capítulo 3. Desarrollo de aplicaciones mediante JBoss EAP

1. Ingrese al Portal del cliente de Red Hat.
2. Haga clic en Downloads.
3. En la lista Product Downloads, haga clic en Red Hat JBoss Enterprise Application Platform.
4. Seleccione 7.1 en el menú desplegable Version (Versión).
5. Busque la entrada Red Hat JBoss Enterprise Application Platform 7.1.0 Quickstarts en la tabla y haga clic en Download (Descargar).
6. Guarde el archivo ZIP para el directorio deseado.
7. Extraer el archivo ZIP.

1. Inicie JBoss Developer Studio.
2. Seleccione File Import.

3. Seleccione Maven Existing Maven Projects, luego haga clic en Next.

   Figura 3.1. Importación de proyectos existentes de Maven

   

4. Navegue al directorio de inicio rápido (por ejemplo el inicio rápido helloworld), y haga clic en OK. La caja de listas Projects se generará con el archivo pom.xml del proyecto de inicio rápido seleccionado.

   Figura 3.2. Seleccione proyectos Maven

   
5. Haga clic en Finish.

1. Si aún no definió un servidor, añada el servidor JBoss EAP a JBoss Developer Studio. Consulte Uso de la detección del tiempo de ejecución para configurar JBoss EAP desde dentro de IDE en la guía Introducción a las herramientas de JBoss Developer Studio.

2. Haga clic en el proyecto helloworld en la pestaña Project Explorer (Explorador de proyectos) y seleccione Run As (Ejecutar como) Run on Server (Ejecutar en el servidor).

   Figura 3.3. Ejecutar como - Ejecutar en servidor

   

3. Seleccione el servidor JBoss EAP 7.1 desde la lista de servidores y haga clic en Next (Siguiente).

   Figura 3.4. Ejecute en el servidor

   

4. El inicio rápido helloworld ya figura como configurado en el servidor. Haga clic en Finish (Finish) para implementar el inicio rápido.

   Figura 3.5. Modifique los recursos configurados en el servidor

   

5. Verifique los resultados

   • En la pestaña Server (Servidor), el estado del servidor JBoss EAP 7.1 cambia a Started (Iniciado).

   • La pestaña Console muestra mensajes que detallan el inicio del servidor JBoss EAP y la implementación de inicio rápido helloworld.

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

   • La aplicación helloworld está disponible en http://localhost:8080/helloworld y muestra el texto Hello World! (¡Hola, mundo!).

1. Importe el inicio rápido bean-validation a JBoss Developer Studio.
2. En la pestaña Servers (Servidores), haga clic derecho en el servidor y elija Start (Inicio) para iniciar el servidor JBoss EAP. Si no ve una pestaña Servers (Servidores) o aún no definió un servidor, añada el servidor JBoss EAP a JBoss Developer Studio. Consulte Uso de la detección del tiempo de ejecución para configurar JBoss EAP desde dentro de IDE en la guía Inicio de las herramientas de JBoss Developer Studio.
3. Haga clic derecho en el proyecto bean-validation en la pestaña Project Explorer (Explorador de proyectos) y seleccione Run As (Ejecutar como) Maven Build.

4. Entre lo siguiente en el campo de entrada Goals y luego haga clic en Run.

   clean verify -Parq-remote

   Figura 3.6. Modifique la configuración

   

5. Verifique los resultados

   La pestaña Console muestra los resultados de las pruebas 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] ------------------------------------------------------------------------

Ejecute el Quickstart helloworld desde la línea de comandos

1. Revise el archivo README.md en el directorio raíz del inicio rápido helloworld .

2. Inicie el servidor JBoss EAP

   $ EAP_HOME/bin/standalone.sh

3. Navegue al directorio de inicio rápido helloworld.

4. Compile e implemente el inicio rápido mediante el comando de Maven provisto en el archivo README.md del inicio rápido.

   $ mvn clean install wildfly:deploy

5. La aplicación helloworld está disponible en http://localhost:8080/helloworld y muestra el texto Hello World! (¡Hola, mundo!).

1. Revise el Código del calificador Random.java.

   Se utiliza un calificador para eliminar la ambigüedad entre dos beans, cuando ambos son eligibles para inyección según su tipo. Para obtener más información sobre los calificadores, consulte Usar un calificador para resolver una inyección ambigua en la Guía de desarrollo de JBoss EAP. El calificador @Random se usa para inyectar un número aleatorio.

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

2. Revise el Código del calificador MaxNumber.java.

   El calificador @MaxNumber se usa para inyectar la cantidad máxima permitida.

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

3. Revise el Código Generator.java.

   La clase Generator crea el número aleatorio a través de un método de productor, exponiendo el máximo número posible a través de este. Esta clase tiene el alcance de la aplicación, por lo que no obtiene un número aleatorio diferente cada vez.

   @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. Revise el Código Game.java.

   La clase Game con alcance de la sesión es el principal punto de entrada de la aplicación. Es responsable de configurar o reconfigurar el juego, capturar y validar los intentos del usuario, y proporcionar una retroalimentación al usuario mediante un FacesMessage. Usa el método de ciclo de vida posterior al desarrollo para iniciar el juego, obteniendo un número aleatorio del bean @Random Instance<Integer>.

   Observe la anotación @Named en la clase. Esta anotación solo es requerida cuando desea que el bean sea accesible a una vista JSF mediante el lenguaje de expresión (Expression Language, EL), en este caso, #{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);
           }
       }
   }