Capítulo 3. Desenvolvendo Aplicativos Usando o JBoss EAP

1. Faça o login no Portal do Cliente Red Hat.
2. Clique em Downloads.
3. Na lista Downloads de Produtos, clique em Red Hat JBoss Enterprise Application Platform.
4. Selecione 7.1 no menu suspenso Versão.
5. Encontre a entrada Red Hat JBoss Enterprise Application Platform 7.1.0 Quickstarts na tabela e clique em Download.
6. Salve o arquivo ZIP no diretório desejado.
7. Extraia o arquivo ZIP.

1. Inicie o JBoss Developer Studio.
2. Selecione Arquivo → Importar.

3. Selecione Maven → Projetos Maven Existentes e clique em Next.

   Figura 3.1. Importando Projetos Maven Existentes

   

4. Navegue até o diretório do início rápido desejado (por exemplo, o início rápido helloworld) e clique em OK. A caixa de listagem dos Projetos é preenchida pelo arquivo pom.xml do projeto de início rápido selecionado.

   Figura 3.2. Selecionando Projetos Maven

   
5. Clique em Concluir.

1. Se você ainda não definiu um servidor, adicione o servidor do JBoss EAP ao JBoss Developer Studio. Consulte Uso da detecção de tempo de detecção para configurar o JBoss EAP de dentro do IDE no guia Introdução às ferramentas do JBoss Developer Studio.

2. Clique com o botão direito do mouse no projeto helloworld na guia Explorador de projeto e selecione Executar como → Executar no servidor.

   Figura 3.3. Executar Como - Executar no Servidor

   

3. Selecione o servidor do JBoss EAP 7.1 na lista de servidores e clique em Próximo.

   Figura 3.4. Executar no Servidor

   

4. O início rápido helloworld já está listado para ser configurado no servidor. Clique em Concluir para implantar o início rápido.

   Figura 3.5. Modificando os Recursos Configurados no Servidor

   

5. Verifique os resultados.

   • Na guia Servidor, o status do servidor do JBoss EAP 7.1 muda para Iniciado .

   • A guia Console mostra as mensagens detalhando a inicialização do servidor do JBoss EAP e a implantação do início rápido helloworld.

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

   • O aplicativo helloworld está disponível em http://localhost:8080/helloworld e exibe o texto Hello World!.

1. Importe o início rápido bean-validation no JBoss Developer Studio.
2. Na guia Servidores, clique com o botão direito no servidor e escolha Iniciar para iniciar o servidor do JBoss EAP. Se você não encontrar uma guia Servidores ou ainda não tiver definido um servidor, adicione o servidor do JBoss EAP ao JBoss Developer Studio. Consulte Uso de detecção de tempo de execução para configurar o JBoss EAP de dentro do IDE no guia Introdução às ferramentas do JBoss Developer Studio.
3. Clique com o botão direito do mouse no projeto jboss-bean-validation na guia Explorador de projeto e selecione Executar como → Compilação do Maven.

4. Insira o seguinte no campo de entrada Metas e clique em executar.

   clean verify -Parq-remote

   Figura 3.6. Editando a Configuração

   

5. Verifique os resultados.

   A guia Console mostra os resultados dos testes Arquillian do 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] ------------------------------------------------------------------------

Executando o Início Rápido helloworld através da Linha de Comando

1. Revise o arquivo README.md no diretório raiz do início rápido helloworld.

2. Inicie o servidor do JBoss EAP.

   $ EAP_HOME/bin/standalone.sh

3. Navegue até o diretório de início rápido helloworld.

4. Compile e implante o início rápido usando o comando do Maven fornecido no arquivo README.md do início rápido.

   $ mvn clean install wildfly:deploy

5. O aplicativo helloworld está disponível agora em http://localhost:8080/helloworld e exibe o texto Hello World!.

1. Revise o código do qualificador Random.java

   Um qualificador é usado para remover a ambiguidade entre dois beans, ambos elegíveis para injeção com base no tipo. Para obter mais informações sobre qualificadores, consulte Uso de um qualificador para resolver uma injeção ambígua no Guia de desenvolvimento do JBoss EAP. O qualificador @Random é usado para injetar um número aleatório.

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

2. Revise o código do qualificador MaxNumber.java

   O qualificador @MaxNumber é usado para injetar o número máximo permitido.

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

3. Revise o código de Generator.java

   A classe Generator cria um número aleatório por meio de um método produtor, expondo o número máximo possível por meio dele. Essa classe está no escopo do aplicativo, então você não obterá um aleatório diferente a 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 o código de Game.java

   A classe no escopo de sessão Game é o ponto de entrada primário do aplicativo. É responsável por configurar ou redefinir o jogo, capturar e validar a adivinhação do usuário e fornecer feedback para o usuário com um FacesMessage. Ela usa o método de ciclo de vida pós constructo para inicializar o jogo recuperando um número aleatório do bean @Random Instance<Integer>.

   Observe a anotação @Named na classe. Essa anotação só é exigida quando você desejar tornar o bean acessível a uma exibição JSF usando a linguagem de expressão (EL), neste 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);
           }
       }
   }