Guide de développement

1. Visitez https://access.redhat.com/.
2. Sélectionnez Téléchargements du menu en haut de la page.
3. Cherchez Red Hat JBoss Developer Studio dans la liste et cliquez dessus.
4. Sélectionnez la version appropriée et cliquez sur Télécharger.

Procédure 1.1. Installer Red Hat JBoss Developer Studio

1. Ouvrir un terminal.
2. Aller dans le répertoire qui contient le fichier téléchargé .jar.
3. Exécuter la commande suivante pour lancer le GUI d'installation.

   java -jar jbdevstudio-build_version.jar

   Copy to Clipboard Toggle word wrap
4. Cliquer sur Suivant pour commencer le processus d'installation.
5. Sélectionner I accept the terms of this license agreement (J'accepte les conditions de licence) et cliquer sur Suivant.
6. Ajuster le chemin d'accès de l'installation et cliquer sur Suivant.

   Note

   Si le dossier de chemin d'installation n'existe pas, vous verrez une invite. Cliquer alors sur Ok pour créer le dossier.
7. Choisir une JVM, ou bien conserver la JVM sélectionnée par défaut, et cliquer sur Suivant.
8. Ajouter une plateforme d'applications disponible, et cliquer sur Suivant.
9. Vérifier les informations d'installation et cliquer sur Suivant.
10. Cliquer sur Suivant une fois le processus d'installation terminé.
11. Configurer les raccourcis bureau pour Red Hat JBoss Developer Studio et cliquer sur Next (suivant).
12. Cliquer sur le bouton Done (Terminé).

Procédure 1.2. Commande de démarrage de Red Hat JBoss Developer Studio

1. Ouvrir un terminal.
2. Aller dans le répertoire d'installation.
3. Lancer la commande suivante pour démarrer JBoss Developer Studio :

   [localhost]$ ./jbdevstudio

   Copy to Clipboard Toggle word wrap

Procédure 1.3. Ajouter le serveur

1. Ouvrir l'onglet Serveurs. S'il n'y a pas d'onglet Serveurs, l'ajouter au panneau comme suit :
   1. Cliquer sur Window → Show View → Other....
   2. Sélectionner Servers à partir du dossier Server et cliquer sur OK.
2. Cliquer sur le lien No servers are available. Click this link to create a new server... (Aucun serveur disponible. Cliquer sur ce lien pour créer un nouveau serveur...) ou bien, cliquer à droite dans le panneau vide Serveur, et sélectionner New → Server.
   

   View larger image

   

   Figure 1.1. Ajouter un nouveau serveur - Aucun serveur disponible

3. Étendre JBoss Enterprise Middleware et choisir JBoss Enterprise Application Platform 6.1+. Saisir un nom de serveur, comme par exemple "JBoss Enterprise Application Platform 6.4", puis cliquer sur Next pour créer le JBoss Runtime et définir le serveur. La prochaine fois que vous définirez un nouveau serveur, ce dialogue affichera un menu de sélection Server runtime environment avec la nouvelle définition de runtime.
   

   View larger image

   

   Figure 1.2. Définir un nouveau serveur

4. Créer un Adaptateur de serveur pour gérer le démarrage et l'arrêt du serveur. Conserver les valeurs par défaut, et cliquer sur Next.
   

   View larger image

   

   Figure 1.3. Créer un nouvel Adpatateur de serveur

5. Saisir un nom comme "JBoss EAP 6.4 Runtime". Sous Home Directory, cliquer sur Browse puis, naviguer vers l'emplacement de l'installation de JBoss EAP. Puis, cliquer sur Next.
   

   View larger image

   

   Figure 1.4. Ajouter un environnement de runtime du nouveau serveur

   Note

   Certains quickstarts exigent que vous exécutiez le serveur avec un profil différent ou avec des arguments supplémentaires. Pour déployer un quickstart qui nécessite le profil full, vous devez définir un nouveau serveur et ajouter un Server Runtime Environment qui spécifie standalone-full.xml dans le Configuration file. Veillez à bien donner un nom descriptif au nouveau serveur.
6. Vous permet de configurer les projets existants pour le nouveau serveur. Puisque vous n'avez pas de projet à ce stade, cliquer sur Finish.
   

   View larger image

   

   Figure 1.5. Modifier les ressources dans le nouveau serveur de JBoss

Procédure 1.4. Télécharger les quickstarts

1. Ouvrir un navigateur web, et accéder à cet URL: https://access.redhat.com/jbossnetwork/restricted/listSoftware.html?product=appplatform.
2. Trouver "Quickstarts" dans la liste.
3. Cliquer sur le bouton Télécharger pour télécharger un fichier ZIP contenant les exemples.
4. Décompressez l'archive dans un répertoire de votre choix.

Procédure 1.5. Importer les quickstarts dans Red Hat JBoss Developer Studio

1. Si vous ne l'avez pas encore fait, Section 2.3.2, « Configurer le référentiel JBoss EAP 6 Platform Maven Repository par les paramètres de configuration de Maven ».

2. Démarrer Red Hat JBoss Developer Studio.

3. À partir du menu, sélectionner Fichier → Importer.

4. Dans la liste sélectionnée, choisir Maven → Projets Maven existants, puis cliquer sur Suivant.
   

   View larger image

   

   Figure 1.7. Importer les projets Maven existants

5. Naviguer vers le répertoire du quickstart que vous souhaitez tester, comme helloworld, et cliquer sur OK. La zone de liste Projects verra apparaître le fichier pom.xml du projet quickstart sélectionné.
   

   View larger image

   

   Figure 1.8. Sélectionner les projets Maven

6. Cliquer sur Terminé.

Procédure 1.6. Générer et déployer le Quickstart helloworld

1. Si vous ne voyez pas l'onglet Servers ou si vous n'avez pas encore défini de serveur, suivre les instructions suivantes : Section 1.3.1.5, « Ajouter le serveur de JBoss EAP en utilisant Define New Server ». Si vous avez l'intention de déployer un quickstart qui requiert un profil full et des arguments de démarrage supplémentaires, veillez bien à créer un environnement de runtime selon les instructions de quickstart.
2. Cliquer à droite sur jboss-helloworld sur l'onglet Project Explorer, puis sélectionner Run As. On vous présentera une liste de choix. Sélectionner Run on Server.
   

   View larger image

   

   Figure 1.9. Run As - Run on Server

3. Sélectionner JBoss EAP 6.1+ Runtime Server de la liste de serveurs, et cliquer sur Next.
   

   View larger image

   

   Figure 1.10. Exécuter sur le serveur

4. L'écran suivant affiche les ressources qui sont configurées sur le serveur. Le quickstart de jboss-helloworld est configuré pour vous. Cliquer sur Finish pour déployer le quickstart.
   

   View larger image

   

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

5. Vérifier les résultats.

   • Dans l'onglet Server, le statut de JBoss EAP 6.x Runtime Server passe à [Started, Republish] .
   • L'onglet Console du serveur affiche des messages détaillant le démarrage du serveur JBoss EAP 6.x et le déploiement du quickstart helloworld.
   • Un onglet helloworld apparaîtra avec l'URL http://localhost:8080/jboss-helloworld/HelloWorld et le texte "Hello World!".
   • Les messages suivants de la Console confirment le déploiement du fichier jboss-helloworld.war :

     JBAS018210: Register web context: /jboss-helloworld
     JBAS018559: Deployed "jboss-helloworld.war" (runtime-name : "jboss-helloworld.war")
     

     Copy to Clipboard Toggle word wrap

     Le contexte web enregistré se rajoute à http://localhost:8080 pour fournir l'URL utilisé pour accéder à l'application qui est déployée.
6. Pour vérifier que le Quickstart helloworld a été déployé correctement dans le serveur JBoss, ouvrir le navigateur web, et accéder à l'application dans l'URL : http://localhost:8080/jboss-helloworld

Procédure 1.7. Exécuter les tests Arquillian du quickstart bean-validation

1. Suivre la procédure ci-dessus pour importer le quickstart bean-validation dans le Red Hat JBoss Developer Studio.
2. Dans l'onglet Servers, cliquer à droite dans le serveur et sélectionner le bouton Start pour démarrer le serveur JBoss EAP. Si vous n'apercevez pas l'onglet Servers et ou si vous n'avez pas encore défini de serveur, suivre les instructions suivantes : Section 1.3.1.5, « Ajouter le serveur de JBoss EAP en utilisant Define New Server ».
3. Cliquer à droite sur le projet jboss-bean-validation qui se trouve dans l'onglet Project Explorer et sélectionner Run As. On vous présentera une liste d'options. Sélectionner Maven Build.
4. Dans le champ d'entrée Goals du dialogue Edit Configuration, saisir : clean test -Parq-jbossas-remote
   Puis cliquer sur Run.
   

   View larger image

   

   Figure 1.12. Modifier la configuration

5. Vérifier les résultats.
   L'onglet de serveur Console affiche des messages donnant des informations sur le démarrage du serveur JBoss EAP et la sortie des tests Arquillian de quickstart 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] ------------------------------------------------------------------------
   

   Copy to Clipboard Toggle word wrap

Procédure 1.8. Générer et déployer les quickstarts par la Ligne de commande

1. Si vous ne l'avez pas encore fait, Section 2.3.2, « Configurer le référentiel JBoss EAP 6 Platform Maven Repository par les paramètres de configuration de Maven ».
2. Vérifier le fichier README.html qui se trouve dans le répertoire racine des quickstarts.
   Ce fichier contient des informations générales sur les prérequis de systèmes, sur la façon de configurer Maven, comment ajouter des utilisateurs, et comment exécuter les quickstarts. Lisez attentivement avant de commencer.
   Il contient également un tableau qui répertorie les quickstarts disponibles. Le tableau répertorie chaque nom de quickstart et chaque technologie dont il s'agit. Il y a une brève description pour chaque quickstart et une indication du niveau d'expérience requis pour l'installer. Pour des informations plus détaillées, cliquez sur le nom du quickstart.
   Certains quickstarts sont conçus pour améliorer ou étendre d'autres quickstarts. Ils sont indiqués dans la colonne Prérequis. Si un quickstart est associé à une liste de prérequis, vous devrez les installer avant d'utiliser le quickstart.
   Certains quickstart ont besoin de l'installation et de la configuraiton des composants optionnels. Ne pas installer ces composants à moins que le quickstart ne l'exige.
3. Exécuter le quickstart helloworld
   Le quickstart helloworld est l'un des quickstarts les plus simples, et représente un bon moyen de vérifier si le serveur JBoss est configuré et exécute correctement. Ouvrir le fichier README.html dans la racine du quickstart helloworld. Il contient des instructions détaillées sur la façon de construire et de déployer le quickstart et accéder à l'application en cours.
4. Exécuter d'autres quickstarts.
   Suivre les instructions dans le fichier README.html que se trouve dans le dossier racine de chaque quickstart pour exécuter l'exemple.

Procédure 1.9. Observer la structure du répertoire

1. Le fichier beans.xml se trouve dans le dossier WEB-INF/ qui se trouve dans le répertoire src/main/webapp/ du Quickstart.
2. Le répertoire src/main/webapp/ inclut également un fichier index.html qui utilise une simple réactualisation meta pour rediriger le navigateur de l'utilisateur vers le Servlet, qui se trouve à http://localhost:8080/jboss-helloworld/HelloWorld.
3. Tous les fichiers de configuration de cet exemple se trouvent dans WEB-INF/, qui se trouve dans le répertoire src/main/webapp/ de l'exemple.
4. Notez que le Quickstart n'a pas même besoin d'un fichier web.xml!

Procédure 1.10. Examiner le code

1. Vérifier le code HelloWorldServlet

   Le fichier HelloWorldServlet.java se trouve dans le répertoire src/main/java/org/jboss/as/quickstarts/helloworld/. Le Servlet envoie les informations dans le navigateur.

   42.  @SuppressWarnings("serial")
   43.  @WebServlet("/HelloWorld")
   44.  public class HelloWorldServlet extends HttpServlet {
   45.  
   46.      static String PAGE_HEADER = "<html><head><title>helloworld</title></head><body>";
   47.  
   48.      static String PAGE_FOOTER = "</body></html>";
   49.  
   50.      @Inject
   51.      HelloService helloService;
   52.  
   53.      @Override
   54.      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
   55.          resp.setContentType("text/html");
   56.          PrintWriter writer = resp.getWriter();
   57.          writer.println(PAGE_HEADER);
   58.          writer.println("<h1>" + helloService.createHelloMessage("World") + "</h1>");
   59.          writer.println(PAGE_FOOTER);
   60.          writer.close();
   61.      }
   62.  
   63.  }
   

   Copy to Clipboard Toggle word wrap
   Expand

   Tableau 1.1. Infos HelloWorldServlet

   Ligne	Note
   43	Avant Java EE 6, on utilisait un fichier XML pour enregistrer les Servlets. C'est bien plus clean. Tout ce qu'il vous reste à faire est d'ajouter l'annotation @WebServlet et de fournir un mappage vers un URL qui est utilisé pour accéder au serveur.
   46-48	Chaque page web a besoin d'HTML formé correctement. Ce Quickstart utilise les Strings statiques pour écrire les sorties minimum de l'en-tête et du pied de page.
   50-51	Ces lignes injectent le bean CDI HelloService, qui génère le message réel. Tant que nous ne changeons pas les API de HelloService, cette approche nous permet de modifier l'implémentation de HelloService à une date ultérieure sans changer l'affichage.
   58	Cette ligne appelle le service pour générer le message "Hello World", et l'écrire dans la requête HTTP.

   Show more

2. Vérifier le code HelloService

   Le fichier HelloService.java se trouve dans le répertoire src/main/java/org/jboss/as/quickstarts/helloworld/. Ce service est très simple. Il renvoie un message. Nul besoin d'enregistrement d'annotation ou d'XML.

   public class HelloService {
   
       String createHelloMessage(String name) {
           return "Hello " + name + "!"; 
       }
   }
   

   Copy to Clipboard Toggle word wrap

Procédure 1.11. Examiner les fichiers de configuration

1. Examiner le fichier faces-config.xml.
   Ce Quickstart utilise la version de JSF 2.0 de faces-config.xml. Une version normalisée de Facelets correspond au gestionnaire d'affichage par défaut de JSF 2.0, donc il n'y a pas vraiment grand chose à configurer. JBoss EAP 6 va au-delà de Java EE ici. Il va automatiquement configurer JSF pour vous, si vous incluez ce fichier de configuration. En conséquence, la configuration ne consistera uniquement en l'élément racine :

   19. <faces-config version="2.0"
   20.    xmlns="http://java.sun.com/xml/ns/javaee"
   21.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   22.    xsi:schemaLocation="
   23.       http://java.sun.com/xml/ns/javaee>
   24.       http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd">
   25.      
   26. </faces-config>
   

   Copy to Clipboard Toggle word wrap
2. Examiner le fichier beans.xml.
   Il y a également un fichier beans.xml qui indique à JBoss EAP 6 de chercher des beans dans cette application et d'activer le CDI.
3. Il n'y a pas de fichier web.xml
   Notez que le Quickstart n'a pas même besoin d'un fichier web.xml!

Procédure 1.12. Examiner le code JSF

• Examiner le code home.xhtml.
  Le fichier home.xhtml se trouve dans le répertoire src/main/webapp/.

  19. <html xmlns="http://www.w3.org/1999/xhtml"
  20.    xmlns:ui="http://java.sun.com/jsf/facelets"
  21.    xmlns:h="http://java.sun.com/jsf/html"
  22.    xmlns:f="http://java.sun.com/jsf/core">
  23.
  24. <head>
  25. <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
  26. <title>Numberguess</title>
  27. </head>
  28.
  29. <body>
  30.    <div id="content">
  31.       <h1>Guess a number...</h1>
  32.       <h:form id="numberGuess">
  33.
  34.          <!-- Feedback for the user on their guess -->
  35.          <div style="color: red">
  36.             <h:messages id="messages" globalOnly="false" />
  37.             <h:outputText id="Higher" value="Higher!"
  38.                rendered="#{game.number gt game.guess and game.guess ne 0}" />
  39.             <h:outputText id="Lower" value="Lower!"
  40.                rendered="#{game.number lt game.guess and game.guess ne 0}" />
  41.          </div>
  42.
  43.          <!-- Instructions for the user -->
  44.          <div>
  45.             I'm thinking of a number between <span
  46.                id="numberGuess:smallest">#{game.smallest}</span> and <span
  47.                id="numberGuess:biggest">#{game.biggest}</span>. You have
  48.             #{game.remainingGuesses} guesses remaining.
  49.          </div>
  50.
  51.          <!-- Input box for the users guess, plus a button to submit, and reset -->
  52.          <!-- These are bound using EL to our CDI beans -->
  53.          <div>
  54.             Your guess:
  55.             <h:inputText id="inputGuess" value="#{game.guess}"
  56.                required="true" size="3"
  57.                disabled="#{game.number eq game.guess}"
  58.                validator="#{game.validateNumberRange}" />
  59.             <h:commandButton id="guessButton" value="Guess"
  60.                action="#{game.check}"
  61.                disabled="#{game.number eq game.guess}" />
  62.          </div>
  63.          <div>
  64.             <h:commandButton id="restartButton" value="Reset"
  65.                action="#{game.reset}" immediate="true" />
  66.          </div>
  67.       </h:form>
  68.
  69.    </div>
  70.
  71.    <br style="clear: both" />
  72.
  73. </body>
  74. </html>
  

  Copy to Clipboard Toggle word wrap
  Expand

  Tableau 1.2. Infos JSF

  Ligne	Remarque
  36-40	Voici les messages qui peuvent être envoyés par l'utilisateur : "Higher!" et "Lower!"
  45-48	Au fur et à mesure que l'utilisateur devine, l'étendue des nombres qu'ils devinent se rétrécit. Cette phrase change pour s'assurer qu'ils connaissent la portée d'une tentative valide.
  55-58	Ce champ d'entrée est lié à une propriété de bean qui utilise une expression de valeur.
  58	On utilise une liaison de validateur pour s'assurer que l'utilisateur ne mette pas le nombre qu'il devine en dehors de la limite. Si le validateur n'était pas présent, l'utilisateur peut deviner un nombre en dehors de la limite.
  59-61	Il doit y avoir un moyen pour que l'utilisateur envoie le nombre qu'il devine au serveur. Ici, on associe une méthode d'action sur le bean.

  Show more

Procédure 1.13. Examiner les fichiers de classe

1. Vérifier le code du qualificateur Random.java.
   Un qualificateur est utilisé pour supprimer l'ambiguïté entre deux beans, qui sont tous deux candidats pour l'injection selon leur type. Pour plus d'informations sur les qualificateurs, se référer à Section 10.2.3.3, « Utiliser un qualificateur pour résoudre une injection ambigue. »
   Le qualificateur @Random est utilisé pour injecter un nombre au hasard.

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

   Copy to Clipboard Toggle word wrap
2. Vérifier le 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 {
   
   }

   Copy to Clipboard Toggle word wrap
3. Vérifier le code Generator.java.
   La classe Generator est chargée de créer le nombre aléatoire par une méthode de producteur. Elle indique également le nombre maximum possible par une méthode de producteur. Cette classe reste dans la portée de l'application, donc, vous n'obtenez pas un nombre différent au hasard à chaque fois.

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

   Copy to Clipboard Toggle word wrap
4. Vérifier le code Game.java.
   La classe session scoped Game est le point d'entrée principal de l'application. Elle est là pour initialiser et réinitialiser le jeu, pour capturer et valider la tentative de numéro de l'utilisateur, et afin de fournir un commentaire de retour à l'utilisateur avec un FacesMessage. Elle utilise une méthode de cycle de vie de post-construction pour initialiser le jeu, en tirant un nombre au hasard du bean @Random Instance<Integer>.
   Notez l'annotation @Named dans la classe. Cette annotation est uniquement requise quand on veut rendre le bean accessible à une vue JSF via Expression Language (EL), et 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);
           }
       }
   }

   Copy to Clipboard Toggle word wrap

Procédure 6.1. Créer un lot de messages log internationalisés

1. Créer une interface de Message Logger

   Ajouter une interface Java à votre projet pour contenir les définitions de messages log. Définir l'interface de façon descriptive pour les messages log qui seront définis à l'intérieur.
   L'interface de messages log ont les prérequis suivants :
   • Doit être annotée par @org.jboss.logging.MessageLogger.
   • Doit étendre org.jboss.logging.BasicLogger.
   • L'interface doit définir un champ qui est un Logger typed qui impléemente cette interface. Procédez par la méthode getMessageLogger() de org.jboss.logging.Logger.

   package com.company.accounts.loggers;
   
   import org.jboss.logging.BasicLogger;
   import org.jboss.logging.Logger;
   import org.jboss.logging.MessageLogger;
   
   @MessageLogger(projectCode="")
   interface AccountsLogger extends BasicLogger
   {
      AccountsLogger LOGGER = Logger.getMessageLogger(
            AccountsLogger.class,
            AccountsLogger.class.getPackage().getName() );
   }

   Copy to Clipboard Toggle word wrap

2. Ajouter les définitions de méthode

   Ajouter une définition de méthode à l'interface de chaque message log. Nommez chaque méthode descriptivement par rapport au message log qu'elle représente.
   Chaque méthode a les prérequis suivants :
   • La méthode doit renvoyer void.
   • La méthode doit être annotée par @org.jboss.logging.LogMessage.
   • La méthode doit être annotée par @org.jboss.logging.Message.
   • L'attribut de @org.jboss.logging.Message contient le message log par défaut. Il s'agit du message qui est utilisé s'il n'y a pas de traduction.

   @LogMessage
   @Message(value = "Customer query failed, Database not available.")
   void customerQueryFailDBClosed();

   Copy to Clipboard Toggle word wrap
   Le niveau de journalisation par défaut est INFO.

3. Invoquer les méthodes

   Ajouter les appels aux méthodes d'interface dans votre code là où les messages doivent être journalisés. Il n'est pas utile de créer des implémentations des interfaces, le processeur d'annotations le fait pour vous quand le projet est compilé.

   AccountsLogger.LOGGER.customerQueryFailDBClosed();

   Copy to Clipboard Toggle word wrap
   Les loggers personnalisés sont des sous-classes de BasicLogger, donc les méthodes de journalisation de BasicLogger (debug(), error() etc) peuvent également être utilisées. Il n'est pas utile de créer d'autres loggers pour enregistrer les messages non internationalisés.

   AccountsLogger.LOGGER.error("Invalid query syntax.");

   Copy to Clipboard Toggle word wrap

Procédure 6.2. Créer et utiliser des messages internationalisés

1. Créer une interface pour les exceptions.

   JBoss Logging Tools définit les messages internationalisés dans les interfaces. Nommer chaque interface de manière descriptive pour les messages qui seront définis à l'intérieur.
   L'interface possède les prérequis suivants :
   • Elle doit être déclarée publique
   • Elle doit être annotée par @org.jboss.logging.MessageBundle.
   • L'interface doit définir un champ qui corresponde à un lot de messages du même type que l'interface.

   @MessageBundle(projectCode="")
   public interface GreetingMessageBundle 
   {
      GreetingMessageBundle MESSAGES = Messages.getBundle(GreetingMessageBundle.class);
   }

   Copy to Clipboard Toggle word wrap

2. Ajouter les définitions de méthode

   Ajouter une définition de méthode dans l'interface de chaque message.
   Chaque méthode a les prérequis suivants :
   • Elle doit renvoyer un objet de type String.
   • La méthode doit être annotée par @org.jboss.logging.Message.
   • L'attribut @org.jboss.logging.Message doit être défini à la valeur par défaut du message. Il s'agit du message qui est utilisé si aucune traduction n'est disponible.

   @Message(value = "Hello world.")
      String helloworldString();

   Copy to Clipboard Toggle word wrap

3. Méthodes d'invocation

   Invoquer les méthodes d'interface dans votre application quand vous aurez besoin d'obtenir le message.

   System.console.out.println(helloworldString());

   Copy to Clipboard Toggle word wrap

Procédure 6.3. Créer et utiliser des exceptions internationalisées

1. Ajouter une configuration JBoss Logging Tools

   Ajouter la configuration de projet qui convient pour prendre en charge JBoss Logging Tools. Voir Section 6.2.6.1, « Configuration Maven JBoss Logging Tools »

2. Créer une interface pour les exceptions.

   JBoss Logging Tools définit les exceptions internationalisées dans les interfaces. Nommer chaque interface de façon descriptive pour les exceptions qui seront décrites à l'intérieur.
   L'interface possède les prérequis suivants :
   • Elle doit être déclarée public.
   • Elle doit être annotée par @org.jboss.logging.MessageBundle.
   • L'interface doit définir un champ qui corresponde à un lot de messages du même type que l'interface.

   @MessageBundle(projectCode="")
   public interface ExceptionBundle 
   {
      ExceptionBundle EXCEPTIONS = Messages.getBundle(ExceptionBundle.class);
   }
   

   Copy to Clipboard Toggle word wrap

3. Ajouter les définitions de méthode

   Ajouter une définition de méthode à l'interface pour chaque exception. Nommez chaque méthode de façon descriptive pour chaque exception qu'elle représente.
   Chaque méthode a les prérequis suivants :
   • Elle doit renvoyer un objet du type Exception ou bien un sous-type d' Exception.
   • La méthode doit être annotée par @org.jboss.logging.Message.
   • L'attribut de @org.jboss.logging.Message doit être défini à la valeur du message d'exception par défaut. Il s'agit du message qui est utilisé s'il n'y a pas de traduction.
   • Si l'exception est retournée à un constructeur qui nécessite des paramètres en plus d'une chaîne de message, alors ces paramètres doivent être fournis dans la définition de méthode à l'aide de l'annotation @param. Les paramètres doivent être du même type et du même ordre que le constructeur.

   @Message(value = "The config file could not be opened.")
   IOException configFileAccessError();
   
   @Message(id = 13230, value = "Date string '%s' was invalid.")
   ParseException dateWasInvalid(String dateString, @Param int errorOffset);

   Copy to Clipboard Toggle word wrap

4. Méthodes d'invocation

   Invoquer les méthodes d'interface de votre code quand vous devrez obtenir une des exceptions. Les méthodes ne lancent pas d'exceptions, elles envoient l'objet d'exception que vous pourrez alors envoyer vous-même.

   try 
   {
      propsInFile=new File(configname);
      props.load(new FileInputStream(propsInFile));
   }
   catch(IOException ioex) //in case props file does not exist
   {
      throw ExceptionBundle.EXCEPTIONS.configFileAccessError(); 
   }

   Copy to Clipboard Toggle word wrap