NetBeans Mini-Tutorials

Feedback

Fichier d'accompagnement de ce Mini-Didacticiel

midnight_fr.zip

Définitions

Module Web. Une application prête à être déployée construite sur la base de JavaTM 2 Platform, Enterprise Edition (J2EETM platform). Il s'agit de la plus petite unité déployable et utilisable d'une application J2EE. La structure d'un module web permet à l'outil de développement de garantir une packaging intégrant les descripteurs de déploiement nécessaires pour les conteneur web tels que Tomcat ou J2EE 1.4 SDK par exemple.

Servlets. Une servlet est une classe Java qui s'exécute dans une conteneur web qui est lui-même situé dans un serveur d'application J2EE ou dans un serveur web. Une servlet est utilisée pour:

  • Générer du contenu dynamique.
  • Etendre les capacités des serveurs Web.
  • Interagir avec des clients web (typiquement des navigateurs de type Netscape, Mozilla ou Internet Explorer) en utilisant un mécanisme de requête/réponse.

Pages JSP. Il s'agit de pages utilisées pour présenter de l'information à un utilisateur final mais également pour permettre la saisie de données et leur envoi vers le serveur. Une page JSP doit être  placée dans un module web correctement construit afin d'être exécutable directement depuis l'outil. Lors de sa première invocation, une page JSP est interprétée et traduite en servlet.

Contrôleur frontal. Un contrôleur frontal (Front Controller) est responsable du bon routage des requêtes des utilisateurs tout en appliquant les règles de navigation de l'application web. Pour de plus amples informations sur l'utilisation du modèle de conception (design pattern) du contrôleur frontal, se référer à la section "Front Controllers" du livre Building Web Components disponible sur le site Sun[tm] Java Studio Documentation.

Vue composée. Il s'agit d'un modèle de conception utilisé pour présenter de l'information dans une page JSP. Ce design pattern permet de construire une page à partir de vues composées. Chacune des ces vues peut contenir des portions dynamique de la page. Le modèle de vue composée permet de gérer des pages complexes dont les données proviennent de sources diverses. La mise en forme de la page est gérée indépendamment du contenu de chaque sous-vue. Par exemple, une vue peut contenir des sous-vues telles que "Navigation", "Recherche" ou "A la une".

Lorque l'on créé une vue composée, il est possible d'inclure du contenu statique ou dynamique. Le contenu statique peut-être composé d'une page HTML, alors que le contenu dynamique est un fragment de page JSP. Le contenu peut-être déterminé au moment de la traduction de la page ou bien lors de l'exécution.

Mini-Didacticiel "Midnight Cookie Company"
Basé sur NetBeans IDE 3.6 et Sun Java System Application Server 8 (J2EE 1.4 SDK)

Note: Ce mini-didacticiel est une adaptation libre de "The Midnight Cookie Company Mini-Tutorial".

L'application Midnight Cookie Company utilisée dans ce Didacticiel permet d'illustrer les points suivants:

  • Comment utiliser une servlet de type "contrôleur frontal"
  • Comment utiliser une vue composée dans une page créée avec la technologie JavaServer PagesTM (page JSPTM)

Cette application utilise la bibliothèque de balises standard JavaServer Pages (JSTL) pour récupérer des données dynamiques ainsi que pour internationaliser les différentes pages JSP utilisées.

Ce didacticiel vous permettra de:

  • Créer une servlet de type "contrôleur frontal"
  • Créer la page JSP qui reçoit les requêtes
  • Internationaliser l'application
  • Utiliser la fonction HTTP Monitor de l'outil

Pour créer l'application Midnight Cookie Company, il est nécessaire de récupérer le fichier midnight_fr.zip qui contient les fichiers source nécessaire pour débuter le développement. Cliquez sur midnight_fr.zip pour obtenir ces fichiers.

Ce didacticiel devrait durer environ deux heures et passer en revue les sujets suivants:

  1. Mise en place de votre environnement
  2. Obtention des fichiers source nécessaires
  3. Développement de l'application Midnight Cookie Company
  4. Déploiement et exécution de l'application Midnight Cookie Company
  5. Mise en pratique de ce que vous avez appris
  6. Pour aller plus loin
  7. Problèmes communs (et solutions) lors de l'exécution
  8. Vérifier que la fonction HTTP Monitor est opérationnelle avec Sun Java System Application Server 8
  9. Suppression de l'application Midnight Cookie Company


1. Mise en place de votre environnement

Cette partie décrit comment mettre en place votre environnement avant de démarrer le développement de l'application.

Obtention et installation des logiciels nécessaires

Pour récupérer les logiciels requis pour accompagner ce didacticiel:

Le téléchargement des différentes briques (J2SE SDK, NetBeans IDE 3.6, plugin NetBeans pour Sun Java Application Server 8 et Sun Java Application Server 8) peut également se faire séparément. Il faudra néanmoins, après installation de NetBeans IDE 3.6, récupérer le plugin Sun Java Application Server 8 (J2EE 1.4 SDK) sur l'Update Center et lui indiquer ensuite ou le serveur J2EE 1.4 est installé.

La documentation des produits individuels doit permettre d'arriver au même résultat que celui décrit ci-dessus.

Haut de page

Démarrage de l'outil NetBeans

Cette partie décrit une méthode pour démarre l'outil NetBeans. Pour plus d'information se reporter à Configuration de l'outil NetBeans.

Pour démarrer NetBeans:

  • Sur plate-forme Microsoft Windows

    Choisir Démarrer > Programmes > NetBeans IDE > NetBeans IDE version > NetBeans IDE.

  • Sur environnement Solaris, UNIX ou Linux

    Dans un terminal, taper sh chemin-install-netbeans/bin/runide.sh

La variable chemin-install-netbeans correspond au répertoire ou l'outil NetBeans est installé.

Une fois l'outil démarré, il est possible de vérifier si des mises à jour sont disponibles en utilisant Tools > Update Center. Le site "NetBeans Update Center" est le plus important à vérifier. La configuration du proxy de l'outil de développement est à faire avec le bouton "Proxy Configuration..." si nécessaire.

Haut de page

Mise en place du serveur J2EE par défaut

L'outil de développement NetBeans est fourni avec le conteneur Web Tomcat intégré. Dans ce tutorial, nous utiliserons un environnement J2EE 1.4 complet avec le serveur Sun Java Application Server 8 (J2EE 1.4 SDK). Pour définir ce dernier comme serveur J2EE par défaut, veuillez suivre les étapes suivantes:

  1. Dans l'onglet Runtime, observez le nom entre parenthèses affiché sur la droite du nœud "Server Registry".

  2. S'il ne s'agit pas du serveur Sun Java Application Server 8 (localhost J2EE), avec un clic droit sur le nœud "Server Registry" choisir "Set Default Server..." dans le menu contextuel qui apparaît.

  3. Une fenêtre de dialogue apparaît alors pour proposer une liste des conteneurs Web J2EE disponibles dans l'outil.

  4. Dans la fenêtre de dialogue, ouvrir le nœud "Sun Java System Application Server 8".

  5. Sélectionner l'instance (le nœud qui débute par localhost) et choisir OK.

Haut de page


2. Obtention des fichiers source nécessaires

Le fichier midnight_fr.zip contient les fichiers source nécessaires à la construction de l'application Midnight Cookie Company. Ces fichiers sources sont regroupés dans un répertoire WEB-INF qui contient les sous-répertoires classes, docs, tlds et lib qui seront utilisés pendant ce didacticiel.

Pour décompresser le fichier midnight_fr.zip:

  1. Créer une répertoire pour les fichiers sources. Dans cet exemple, le didacticiel fait référence au répertoire/midnight_fr. Sous Microsoft Windows, il peut s'agir de C:\midnight_fr.
  2. Utiliser un logiciel pour décompresser le fichier midnight_fr.zip dans le répertoire midnight_fr. Notez que l'utilitaire 'jar' peut être utilisé (commande jar xvf midnight_fr.zip).

Le répertoire midnight_fr possède alors un répertoire WEB-INF qui contient les fichiers et sous-répertoires suivants:

Fichier ou sous-répertoire
Description
web.xml
Descripteur de déploiement du module web.

classes

Contient les fichiers de jeu de ressource utilisés pour l'internationalisation des pages dans le sous-répertoire com/midnightcookies/taghandlers. Le sous-répertoire taghandler contient les classes de gestion des balises de contenu (ContentHandler), de bouton (ButtonHandler) et de lien (LinksHandler). La classe ContentHander procède à la construction de la page JSP réclamée. La classe ButtonHandler affiche un bouton de validation avec un message localisé. La classe LinksHandler affiche un ensemble de liens séparé par un "separator" qui est disponible sous forme d'attribut de balise.

docs

Contient les fichiers header.jsp, index.jsp et nonesuch.jsp.  Au cours de ce didacticiel, nous allons créer la page main.jsp et la rajouter à ce sous-répertoire.

Contient également le sous- répertoire cookies qui contient les fichiers CookieCutter.jsp et CookieMake.jsp. Au cours de ce didacticiel, nous allons créer la page  Tray.jsp et la rajouter à ce sous-répertoire. Le sous-répertoire about contient le fichier about.jsp qui explique en quelques mots l'architecture web de l'application.

lib
Ne contient aucun fichier. Avec un serveur d'application J2EE 1.3, ce répertoire doit contenir les fichiers standard.jar et jstl.jar qui contiennent les implémentations JSTL (TLD, gestionnaires de balises et autres API nécessaires à l'application).

tlds
Contient le fichier midnight.tld.

Haut de page


3. Développement de l'application Midnight Cookie Company

Cette partie explique en détails comment effectuer le montage du module web, comment créer le contrôleur frontal et comment créer les pages JSP nécessaires au développement de l'application Midnight Cookie Company.

Montage du module web et définition de son contexte

Il faut tout d'abord monter le module web dans l'outil de développement avant de pouvoir créer le contrôleur frontal et les pages JSP de l'application.

  1. Dans l'onglet "Filesystems", choisir File > Mount Filesystem... dans le menu principal.

    L'assistant "New wizard" apparaît. Choisir "Local Directory" et cliquer sur Next.

  2. Naviguer jusqu'au répertoire midnight_fr créé lors de la décompression du fichier midnight_fr.zip, sélectionner le répertoire et cliquer sur Finish.

Le répertoire midnight_fr est alors monté et accessible dans l'onglet "Filesystems".

Le nœud racine du module midnight_fr apparaît dans le système de fichiers. L'outil effectue également le montage du nœud WEB-INF/classes. Si le répertoire "lib" de l'application Web contient des bibliothèques JAR (comme standard.jar et jstl.jar dans le cas d'un serveur J2EE 1.3), l'outil effectue également le montage de ces fichiers pour que tous soient intégrés dans le Classpath du projet géré par l'outil NetBeans. Il est possible de naviguer dans les fichiers JAR comme dans tout autre répertoire.

  • Ouvrir le nœud racine de midnight_fr et effectuer un clic droit sur le nœud WEB-INF pour choisir Properties dans le menu contextuel.

    La fiche de propriétés du module web sont alors affichées dans la fenêtre "Properties".

  • Dans cette fenêtre de propriétés, choisir la Context Path et saisir la valeur /midnight_fr.

    Ce contexte est un moyen de distinguer les différentes ressources de l'application Midnight Cookie Company  des ressources dans d'autres applications déployées sur la même instance de ce serveur J2EE. Le contexte d'une application définit l'espace de nommage URL et le contenu de l'application web. Lorsque le contexte d'un module est positionné, l'accès à celui-ci se fait en utilisant l'URL http://nom_machine:port/contexte/servlet_ou_jsp. A titre d'exemple, avec une propriété /midnight_fr, l'accès au module web se fait à l'adresse http://nom_machine:port/midnight_fr/index.jsp.

  • Haut de page

    Définition des bibliothèques JSTL utilisées dans l'application

    Voici les étapes à suivre Afin de pouvoir utiliser les bibliothèques JSTL utilisées dans l'application (core et fmt/internationalisation) :

    1. Dans le menu Tools, choisir "JSP Tag Library Repository".
    2. Cliquer sur "Add..." et naviguer jusqu'au répertoire chemin-install-netbeans/SunAppServer8/lib
    3. Sélectionner le fichier appserv-jstl.jar
    4. Cliquer sur "Add", puis sur "Close".
    5. Avec un clic-droit sur le noeud WEB-INF, choisir Add JST Tag Library > Find in Tag Library Repository
    6. Sélectionner appserv-jstl

    Ceci permet de récupérer une définition des bibliothèques standard JSTL embarquées dans Sun Java System Application Server 8 afin de pouvoir valider les différents fichiers JSP qui y font référence. Un noeud "appserv-jstl" doit désormais figurer sous WEB-INF > lib.

    Haut de page

    Création d'un contrôleur frontal sous la forme d'une servlet

    Un contrôleur frontal a pour objectif d'effectuer le routage des requêtes des utilisateurs tout en appliquant les règles de navigation de l'application web. Ce contrôleur constitue un point d'entrée unique pour toutes les ressources du module web. Il permet de réduire la duplication de code dans les pages JSP, en particulier là ou différentes ressources nécessitent les mêmes traitements. Pour de plus amples informations sur l'utilisation du modèle de conception (design pattern) du contrôleur frontal, se référer à la section "Front Controllers" du livre Building Web Components disponible sur le site Sun Java Studio Documentation.

    Pour créer un contrôleur frontal:

    1. Ouvrir successivement les nœuds WEB-INF, classes et com dans l'onglet Filesystems.
    2. Avec un clic droit sur le nœud midnightcookies, choisir New > All Templates.

    La fenêtre New wizard apparaît et propose une liste d'assistants.

  • Ouvrir le nœud "JSPs & Servlets", choisir "Servlet" et cliquer sur Next.

    L'assistant "New wizard for Servlet" apparaît.

  • Remplacer NewServlet par FrontController dans le champs "Class Name" et cliquer sur "Next".
  • Dans la page "Servlet Deployment", spécifier les différentes URL qui doivent invoquer cette Servlet en utilisant la chaîne de correspondances "/docs/*, /" en remplacement de "/FrontController" dans le champ "URL Mapping(s)". Cliquer sur Finish.

    Notez que l'on utilise /docs/* plutôt que /* pour éviter que la servlet FrontController ne se transmette ses propres requêtes en boucle.

    Le nœud "FrontController" apparaît alors dans l'onglet "Filesystems" et l'éditeur de source affiche le contenu du fichier FrontController.java.

  • En double-cliquant sur le nœud web.xml situé sous WEB-INF, les correspondances établies lors de la création de la servlet de contrôle frontal doivent apparaître:
  • L'utilisation d'une deuxième correspondance "/" donne au contrôleur frontal la possibilité de traiter les requêtes de type http://nom_machine:port/midnight_fr/.

    Haut de page

    Rajout de méthodes pour traiter les requêtes et pour créer un Cookie

    Nous allons maintenant éditer le fichier FrontController.java pour y rajouter la logique nécessaire au traitement des requêtes reçues par l'application web. Nous allons modifier la méthode processRequest et créer une nouvelle méthode appelée createCookie dont l'objectif est de démontrer la création d'un cookie depuis une application web.

    1. Dans l'onglet "Filesystems", ouvrir les nœuds Midnightcookies, FrontController et class FrontController.

      L'outil propose alors les nœuds "Fields" (champs), "Constructors", "Methods" et "Bean Patterns".

      Filesystems window with FrontController and class FrontController nodes expanded
    2. Ouvrir le nœud "Methods" et double-cliquer sur le nœud processRequest.

      L'éditeur de source affiche la méthode processRequest.

    3. Dans l'éditeur de source, avec un click droit dans la marge gauche choisir "Show Line Numbers" dans le menu contextuel.
    4. Remplacer le corps de la méthode processRequest (lignes 39  à 54) par le texte suivant:
              protected void processRequest(HttpServletRequest request,
                                        HttpServletResponse response)
                         throws ServletException, IOException {
              String id = request.getRequestURI();
              id = id.substring(request.getContextPath().length());
              getServletContext().log
            ("Le controleur frontal a recu une requête pour " + id);
      
              // La variable page contient le chemin vers la page qui doit être intégrée
              // dans la page principale /WEB-INF/docs/main.jsp.
              // Elle est transmise à cette dernière dans un attribut de requête.
              String page;
      
              // Si aucune requête n'est reçue ou si la requête s'adresse
              // à la racine, renvoi de /WEB-INF/docs/index.jsp
              if (id == null || id.trim().equals("") || id.equals("/")){
                  page = "/WEB-INF/docs/index.jsp";
              }
              // Si une requête reçue ne concerne pas un fichier dont l'extension
              // n'est pas .jsp ou .html, il s'agit d'une erreur. Renvoi de la page
              // d'erreur (nonesuch.jsp) et modification de l'attribut nonesuch avec
              // le chemin demandé.
              else if (!id.endsWith(".jsp") && !id.endsWith(".html")) {
                  page = "/WEB-INF/docs/nonesuch.jsp";
                  request.setAttribute("nonesuch", id);
              }
              else {
                  page = "/WEB-INF".concat(id);
                  if (id.equals("/docs/cookies/CookieMake.jsp")) {
                      Cookie cookie = createCookie(request);
                      if (cookie == null) {
                          page = "/WEB-INF/docs/cookies/CookieCutter.jsp";
                      }
                      else {
                          response.addCookie(cookie);
                          request.setAttribute("cookie", cookie);
                      }
                  }
              }
              request.setAttribute("page", page);
              try {
                  request.getRequestDispatcher("/WEB-INF/docs/main.jsp").forward(request, response);
              }
              catch(Throwable t) {
                  getServletContext().log(t.getMessage());
              }
          }
                  

      Note: Après avoir saisi ce code (avec un copier-coller par exemple) dans l'éditeur de source, placer le curseur dans la fenêtre d'édition et appuyer sur Ctrl-Shift-F pour reformatter automatiquement le code.

      La ligne qui appelle la méthode createCookie doit être soulignée de rouge ce qui indique une erreur comme le montre l'illustration suivante. Ceci est normal car cette méthode n'existe pas encore. Nous allons créer la méthode createCookie dans les étapes suivantes. En plaçant le curseur sur la boîte d'erreur, l'outil fournit une description du problème.


    5. Dans l'éditeur de source, placer le curseur après la méthode getServletInfo près de la fin du fichier.
    6. Copier le texte suivant et le coller dans l'éditeur de source pour créer la méthode createCookie.
          private Cookie createCookie(HttpServletRequest request) {
              String name = (String)request.getParameter("name");
              if (name == null || name.trim().equals("")) {
                  request.setAttribute("noname", "noname");
                  request.setAttribute("error", "true");
               return null;
              }
      
              String value = (String)request.getParameter("value");
              if (value == null || value.trim().equals("")) {
                  request.setAttribute("novalue", "novalue");
                  request.setAttribute("error", "true");
                return null;
              }
      
         System.out.println(name);
         System.out.println(value);
      
            Cookie cookie = null;
             try {
                 cookie = new Cookie(name, value);
             }
         catch(IllegalArgumentException ex) {
                  // Probablement un nom illégal
           ex.printStackTrace();
             request.setAttribute("error", "true");
            request.setAttribute("noname", "badname");
                return null;
          }
      
             String maxage = request.getParameter("maxage");
           if (maxage != null && !maxage.trim().equals("")) {
            try {
                 cookie.setMaxAge(Integer.parseInt(maxage));
           }
                 catch(NumberFormatException nfe) {
                    nfe.printStackTrace();
                    request.setAttribute("badnumber", "badnumber");
                   request.setAttribute("error", "true");
                    return null;
                  }
             }
      
             String domain = request.getParameter("domain");
           if (domain != null && !domain.trim().equals("")) {
            cookie.setDomain(domain);
             }
      
             String path = request.getParameter("path");
       if (path != null && !path.trim().equals("")) {
                cookie.setPath(path);
         }
      
             String secure = request.getParameter("secure");
           if (secure != null && secure.equals("on")) {
                  cookie.setSecure(true);
       } else {
              cookie.setSecure(false);
              }
              return cookie;
          }
      
                              

      Pensez à reformater votre code.

    7. Appuyer sur Ctrl-S pour sauvegarder le document. L'astérisque dans l'onglet du fichier doit alors disparaître (tout comme l'erreur précédente). Cet astérisque apparaît à chaque fois qu'il y a des modifications non encore sauvées sur disque.
    8. Compiler la servlet FrontController pour vérifier qu'il n'y a eu pas d'erreur dans les étapes précédentes.
      1. Dans l'onglet "Filesystems", ouvrir les nœuds /midnight_fr et WEB-INF.
      2. Par un clic droit sur le nœud classes, choisir "Compile All" dans le menu contextuel.

      Une fenêtre "Output window" apparaît pour afficher les messages du compilateur et d'éventuelles erreurs. Il est possible de double-cliquer sur les liens dans les messages d'erreur pour localiser l'erreur dans le code source. Vous devez corriger toutes les erreurs énumérées avant de pouvoir poursuivre ce didacticiel.

    Haut de page

    Création de la page JSP qui reçoit toutes les requêtes

    La page main.jsp reçoit toutes les requêtes traitées par la servlet FrontController. L'instruction dynamique include et la classe LinksHandler sont utilisées pour créer la page.

    Pour créer la page main.jsp:

    1. Ouvrir les nœuds /midnight_fr et WEB-INF.
    2. Avec un clic droit sur le nœud docs, choisir New > All Templates.

      Une fenêtre apparaît pour proposer une liste des assistants disponibles.

    3. Ouvrir les nœuds "JSPs & Servlets",  et "JSPs", sélectionner JSP et cliquer sur Next.

      La page "General JSP Information" apparaît.

    4. Utiliser main (sans l'extension de fichier .jsp) dans le champ "Name" et cliquer sur "Finish".

      Un nouveau nœud main apparaît dans l'onglet "Filesystems" et l'éditeur de source affiche le contenu de la page main.jsp.

      Note: l'extension de fichier n'est pas nécessaire car l'outil rajoute automatiquement une extension .jsp à la création du fichier. Par défaut, les extensions de fichiers ne sont pas présentées dans l'onglet "Filesystems". Pour faire apparaître ces extensions, cocher la boîte suivante: menu Tools > Options > IDE Configuration > System > System Settings > Show File Extensions.

    5. Supprimer le contenu du fichier main.jsp.
    6. Copier le texte ci-dessous et le coller dans le fichier main.jsp.
      <%@page contentType="text/html;charset=UTF-8"%>
      <%@page buffer="none"%>
      <%-- La balise <midnight:content/> qui gère le contenu est simplifiée
      dans son utilisation des includes ce qui ne permet pas à cette page
      d'être utilisée dans un buffer. --%>
      
      <%@taglib prefix="midnight" uri="/WEB-INF/tlds/midnight.tld"%>
      
      <html>
          <head><title>Midnight Cookie Company</title></head>
          <body text="#996633" link="#cc6600" vlink="#993300" alink="#000000">
              <span font-style="sans-serif">
                  <TABLE border="0">
               <tr>
                    <table border="0">
                              <tr><td width="80" height="100">&nbsp;</td>
                             <td width="500" height="100"
                               text="#996633" bgcolor="#ffff99"
                                  valign="center"halign="center">
                                <jsp:include page="/WEB-INF/docs/header.jsp"
                                                flush="true"/>
                                </td>
                           </tr>
                       <tr><td width="90" height="300"
                                  text="#996633" bgcolor="#ffff99"
                                  valign="top">
                                  <midnight:links separator="<br>"/>
                                </td>
                               <td width="500" height="300"
                               valign="top"cellpadding="15"
                                      cellspacing="15">
                                      <midnight:content/>
                             </td>
                           </tr>
                   </table>
                </tr>
               <tr><td width="580" height="50" text="#996633"
                           bgcolor="#ffff99" valign="top">
                        <midnight:links separator="|"/>
                         </td>
                   </tr>
           </span>
         </table>
          </body>
      </html>
      
                              


    7. Appuyer sur Ctrl-S pour sauvegarder les modifications.

      La fenêtre "Output" affiche les éventuelles erreurs.

    Haut de page

    Création du fichier de saisie de paramètres par l'utilisateur

    Les fichiers de gestion des paramètres Input.jsp et Output.jsp illustrent l'utilisation de balises issues de la bibliothèque de balises standard (JSTL) pour gérer l'internationalisation. Ils présentent également comment les données saisies sont transmises avec le langage d'expression JSP ("JSP Expression Language" ou EL) ${param.input} dont la valeur a été positionnée dans la page Input.jsp.

    1. Avec un clic droit sur le nœud docs, choisir New > Folder dans le menu contextuel.

      L'assistant de nouveau répertoire apparaît.

    2. Taper parameters dans le champ "Name" et cliquer sur Finish.

      Un nouveau répertoire parameters apparaît dans l'onglet "Filesystems" sous le nœud docs.

    3. Avec un clic droit sur le nœud parameters, choisir "New > JSP" pour appeler l'assistant de création de JSP.

      Remarquez que le sous-menu propose désormais le choix "JSP". Ceci est lié au fait que le menu "New" propose les choix récents déjà utilisés.

    4. Taper Input dans le champ "Name" et cliquer sur "Finish".

      Le nœud Input apparaît dans l'onglet "Filesystems" et l'éditeur de source affiche le contenu du fichier Input.jsp.

    5. Supprimer le contenu du fichier Input.jsp.

    6. Copier le texte ci-dessous et le coller dans le fichier Input.jsp.

      <%@page contentType="text/html;charset=UTF-8"%>
      <%@taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %>
      <%@taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
      <%@taglib prefix="midnight" uri="/WEB-INF/tlds/midnight.tld"%>
      
      <fmt:setBundle basename="com.midnightcookies.Midnight" var="bundle"
                    scope="page"/>
      
      <h3><fmt:message key="provide_input" bundle="${bundle}"/></h3>
      <form method="POST" action="Output.jsp">
              <table>
                  <tr>
                     <td><fmt:message key="type_input" bundle="${bundle}"/>:<td>
                     <%-- La valeur du champ Input est placée dans un paramètre de
                     la requête nommé "input" pour être transmit à Output.jsp --%>
                 <td><input type="text" size="20" name="input" value=""></td>
                  </tr>
             <tr>
                    <td><fmt:message key="submit" bundle="${bundle}"
                                  var="buttonLabel" scope="page"/>
                           <midnight:button/>
                      </td>
                      <td></td>
                  </tr>
              </table>
      </form>
      
                              


    7. Appuyer sur Ctrl-S pour sauvegarder les modifications.

    8. Créer une fichier Output.jsp dans le répertoire parameters de la même manière que pour le fichier Input.jsp.

    9. Dans l'éditeur de source, remplacer le contenu du fichier Output.jsp par le texte suivant:

      <%@page contentType="text/html;charset=UTF-8"%>
      <%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %>
      <%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
      
      <fmt:setBundle basename="com.midnightcookies.Midnight" var="bundle" scope="page"/>
      <h3><fmt:message key="display_input" bundle="${bundle}"/></h3>
      <fmt:message key="datareceived" bundle="${bundle}"/>:
      
      <!--La ligne qui suit récupère la valeur du paramètre nommé "input".
      Ceci est une application de démonstration. Pour des raisons de sécurité,
      il est recommandé de ne jamais afficher les saisies d'un utilisateur sans
      les avoir analysé dans un premier temps. -->
      <c:out value="${param.input}"/>

    10. Appuyer sur Ctrl-S pour sauvegarder les modifications.

    Haut de page

    Utilisation de JSTL pour gérer l'internationalisation

    La page Tray.jsp qui est rédigée dans cette partie illustre l'utilisation de JSTL (JavaServer Pages Standard Tag Library) qui permet sans recours au scripting d'internationaliser le contenu des pages. Les fichiers CookieCutter.jsp et CookieMaker.jsp ainsi que les fichiers de propriétés des jeux de ressources sont fournis dans le fichier d'archive midnight_fr.zip. Le fichier Tray.jsp fournit un exemple de gestion de l'internationalisation dans une application Web.

    Pour créer la page Tray.jsp:

    1. Ouvrir le nœud docs pour faire apparaître le nœud cookies.

    2. Créer le fichier Tray.jsp dans le répertoire cookies en utilisant le même méthode que pour les autres fichiers JSP. S'assurer que le fichier est bien créer dans le répertoire cookies.

    3. Dans l'éditeur de source, remplacer le contenu du fichier Tray.jsp par le texte qui suit.

      <%@page contentType="text/html;charset=UTF-8"%>
      <%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
      <%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %>
      
      <fmt:setBundle basename="com.midnightcookies.Midnight"
               var="bundle" scope="page"/>
      <h3><fmt:message key="cookies" bundle="${bundle}"/></h3>
      
      <table border="1">
          <tr>
              <th halign="center">#</th>
           <th align="left">
               <fmt:message key="name" bundle="${bundle}"/>
              </th>
              <th align="left">
              <fmt:message key="value" bundle="${bundle}"/>
              </th>
           <tr>
           <%-- Utilisation d'une expression pour récupérer un tableau.
                L'utilisation de ${cookie} retournerait un objet Map et
                les entrées nécessiteraient un transtypage (cast) --%>
           <% request.setAttribute("cookies", request.getCookies()); %>
           <c:set var="i" value="0"/>
      
           <c:forEach var="ck" items="${cookies}">
           <c:set var="i" value="${i+1}"/>
             <tr>
            <td><c:out value="${i}"/></td>
                  <td><c:out value="${ck.name}"/></td>
            <td><c:out value="${ck.value}"/></td>
              </tr>
          </c:forEach>
      </table>
                              


    4. Appuyer sur Ctrl-S pour sauvegarder les modifications.

    Maintenant que tous les fichiers de l'application ont été créés, l'onglet "Filesystems" doit ressembler à ceci (l'ordre importe peu) :

    Filesystems window with files of completed Midnight Cookie Company application

    Haut de page


    4. Déploiement et exécution de l'application Midnight Cookie Company

    Le module web est la partie déployable et exécutable de l'application Midnight Cookie Company. Les étapes suivantes montrent comment déployer ce module web en utilisant le serveur d'application Sun Java Application Server 8 Platform Edition. Pour vérifier que le serveur de déploiement est le bon, veuillez vous référer au paragraphe Mise en place du serveur J2EE par défaut. Ainsi, lorsque vous exécuterez le module web, celui-ci utilisera ce serveur J2EE par défaut et votre navigateur pour afficher la première page de l'application.

    Avant de pouvoir déployer d'application et bénéficier du HTTP Monitor, il est nécessaire de vérifier que la fonction HTTP Monitor de l'IDE NetBeans est bien configurée.

    Pour déployer et exécuter l'application Midnight Cookie Company :

    1. Dans la fenêtre "Filesystems", ouvrir le nœud /midnight_fr.

    2. En utilisant un click droit sur le nœud WEB-INF, choisir "Execute" dans le menu contextuel.

      Une fenêtre de progression apparaît alors pendant les phases de préparation de l'application, de démarrage du serveur J2EE (si nécessaire) et de déploiement de l'application sur le serveur.

      Le navigateur défini par défaut dans NetBeans IDE démarre alors avec l'URL suivante http://nom_machine:port/midnight_fr/. Voici une capture d'écran de la page qui doit alors s'afficher.

      Contents of web browser after MCCWebApp web module is executed.

      Si la page n'apparaît pas ou si des erreurs sont signalées, se reporter au paragraphe Problèmes communs et solutions lors de l'exécution.

    3. Dans la fenêtre HTTP Monitor, sélectionner l'enregistrement "GET midnight_fr" sous le nœud "Current Records".

      Le dernier nœud représente la requête du module web.

    4. Sélectionner l'onglet Session pour visualiser des informations similaires à ceci:

      Session Tab in HTTP Monitor after the web application was executed.

      Cette fonctionnalité HTTP Monitor permet de capturer tous les échanges HTTP effectés entre le client (le navigateur) et le serveur J2EE. Pour chaque échange, on observe les entetes des requetes HTTP et leur résultats, les appels imbriqués (ouvrir le noeud "GET midnight_fr" pour le constater), les informations détaillées de session, les éventuels cookies (voir suite de l'exercice), etc.

    Note: Sun Java System Application Server 8 possède de nombreuses fonctionnalités d'administration à distance basées sur le standard JMX. Avec HTTP Monitor dans NetBeans 3.6, il est possible de voir apparaître des dialogues liés à cette administration. Ainsi, si la fenêtre HTTP Monitor affiche des requêtes intitulées POST remotejmx, celles-ci peuvent être simplement ignorées ou même supprimées.

    Note 2: Pour mieux visualiser les informations fournies par HTTP Monitor, il est possible de maximiser la fenêtre en utilisant le combinaison de touches Shift-Esc. Pour revenir à la situation initiale, il suffit de réutiliser la même combinaison Shift-Esc. Cette astuce est applicable à toutes les fenêtres de l'outil NetBeans 3.6 (particulièrement utile pour l'éditeur de code et les fichiers de log).

  • Dans le navigateur, cliquer sur le lien Paramètres pour afficher la page Input.jsp.

    Le navigateur doit alors afficher une page similaire à celle-ci:

    Web browser displaying Input.jsp page

  • Saisir Salut! dans le champ de texte et cliquer sur "Envoyer".
  • Le navigateur affiche alors le contenu de la page Output.jsp similaire à ceci:

    Web browser displaying Output.jsp page

  • Dans la fenêtre HTTP Monitor, sélectionner le dernier enregistrement sous le nœud "Current Records" et sélectionner l'onglet "Request".

    La fenêtre HTTP Monitor doit alors afficher quelque chose de similaire à ceci:

    HTTP Monitor displaying the records in the Request tab.

  • Dans le navigateur, choisir le lien "Biscuits".
  • Le navigateur affiche alors la page CookieCutter.jsp.

  • Dans le champ de texte "Nom", taper biscuit, et dans le champ "Valeur", taper brownie.

    Web browser displaying CookieCutter.jsp page with Name and Value text fields populated.

  • Cliquer alors sur "Fais-moi un biscuit!".

    Le navigateur affiche alors la page suivante:

    Web browser after entering values in the Name and Value text fields

  • Dans la fenêtre HTTP Monitor, sélectionner le dernier enregistrement sous le nœud "Current Records".
  • L'onglet "Cookies" dans la fenêtre HTTP Monitor affiche alors les informations suivantes:


    HTTP Monitor records after Cookie is made.

  • Dans le navigateur, cliquer sur le bouton "L'assiette entière s'il te plaît" pour afficher la page suivante:

  • Browser displaying the Tray.jsp page.

  • Dans la fenêtre HTTP Monitor, sélectionner le dernier enregistrement sous le nœud "Current Records" et sélectionner l'onglet "Cookies".
  • La fenêtre HTTP Monitor affiche alors les informations suivantes:

    Cookies tab in the HTTP Monitor after Tray.jsp page is displayed.

  • Sélectionner l'onglet "Request" afin que la fenêtre HTTP Monitor affiche les informations suivantes:

    Request tab on the HTTP Monitor after Tray.jsp page is displayed.

  • Dans la fenêtre HTTP Monitor, avec un clic-droit sur le dernier enregistrement (GET Tray.jsp) sous le nœud "Current Records" et choisir "Edit and Replay" dans le menu contextuel. Dans le dialogue qui apparaît, choisir l'onglet "Cookies" et cliquer sur "Add Cookie". Utiliser le nom herbe et la valeur aneth. Cliquer ensuite sur "Send HTTP Request". Le navigateur affiche de nouveau la page avec ce nouveau cookie.

  • Dans le navigateur, taper une adresse URL qui n'existe pas afin de voir comment page nonesuch.jsp est utilisée. Par exemple, l'adresse URL  suivante http://localhost:8081/midnight_fr/docs/Bake.jsp provoque l'affichage suivante dans le navigateur:
  • Web browser displaying contents of nonesuch.jsp after request was made for the non-existent Bake.jsp page

  • Dans la fenêtre HTTP Monitor, sélectionner l'onglet "Request" pour observer les informations suivantes:
  • HTTP Monitor's Request tab after the call to non-existent Bake.jsp page.

    On remarquera qu'il s'agit bien du contenu de la page nonesuch.jsp qui est utilisé et non celui de la page Bake.jsp qui n'existe pas.

    Note: comme le nœud "Saved Records" le laisse entendre, il est possible de sauvegarder des requêtes pour les rejouer ultérieurement, y compris après redémarrage de l'outil NetBeans.

  • Modifions maintenant le paramétrage du navigateur pour choisir l'anglais ou le suédois afin d'observer les capacité d'internationalisation de l'application web Midnight Cookie Company.
  • Note: il est peut-être nécessaire de rajouter ces langues à la liste des langues disponibles par défaut dans le navigateur.

    Note 2: il est également possible de simuler ce comportement en modifiant le paramètre accept-language (paramètre standard des requêtes HTTP) dans l'onglet "Headers" de l'HTTP Monitor et en rejouant la requête HTTP ainsi modifiée.

  • Rechargez et rafraîchissez les pages affichées dans les étapes précédentes.

    Remarquez la traduction des liens dans la barre de navigation à gauche, des liens du bas de page, ainsi que du contenu de certaines pages.

    L'application utilise pour ceci les fichiers de paquets de ressources pour servir de support à la traduction de cette application. Traduire une application n'est alors pas plus complexe que de fournir des traductions pour chaque entrée du fichier de paquets de ressources.

  • Vous avez maintenant terminé le mini-didacticiel Midnight Cookie Company. Vous pouvez redémarrer en cliquant sur le lien "Haut de page" ci dessous.

    Haut de page


    5. Mise en œuvre de ce qui a été appris

    A l'aide du contrôleur frontal, des paquets de ressources et d'une vue composée, rajouter un lien "Sortie" pour emmener l'utilisateur vers une page qui lui dise "Au revoir!" dans la langue choisie dans le navigateur.

    1. Avec un double-clic sur le fichier de propriétés com/midnightcookies/Midnight.properties ouvrir l'éditeur associé. Rajouter les mot-clés et valeurs suivants.

      Mot-clé Anglais Français Suédois
      exit Exit Sortie Utgång
      closingRemark Goodbye Au revoir Hej då

      Utiliser &ring; pour afficher le caractère å.

    2. Rajouter un fichier Exit.jsp et utiliser la balise de message issue de la bibliothèque fmt pour afficher le message pour le mot-clé closingRemark (Aide: regarder Output.jsp). Ne pas oublier de rajouter la directive d'utilisation de la bibliothèque de balises fmt.

    3. Ouvrir le fichier  com/midnightcookies/taghandlers/LinksHandler.java dans l'éditeur pour y rajouter un lien vers le fichier Exit.jsp. Utiliser le mot-clé exit pour récupérer le texte approprié dans le jeu de ressources. Recompiler alors la classe.

    4. Exécuter l'application ainsi modifiée.

    Haut de page


    6. Pour aller plus loin

    Voici quelques autres fonctionnalités de ce module web que vous souhaiterez peut-être examiner de plus près.

    Examen de la bibliothèque Midnight Tag Library

    Ouvrir le nœud tlds/Midnight pour observer la liste des balises de la bibliothèque. Ouvrir ensuite le nœud Tag:Links puis le nœud Attributes pour voir que cette balise possède un attribut separator. Avec un clic-droit sur le nœud Tag:Links, choisir "Customize" dans le menu contextuel pour spécialiser la balise. La fenêtre qui apparaît permet d'afficher des informations relatives à la balise, sa description, ainsi qu'un exemple d'utilisation. Tout en gardant cette fenêtre ouverte, il est possible de sélectionner les autres balises pour en observer les caractéristiques d'utilisation. Il est possible d'utiliser l'outil de développement NetBeans pour créer un fichier TLD et générer un squelette de code Java pour les gestionnaires de balises.

    Rendre les bibliothèques couramment utilisées disponibles dans l'IDE NetBeans

    Placer les fichiers JAR JSTL dans un endroit précis. Choisir "Tools" > "JSP Tag Library Repository" dans le menu principal et rajouter ces fichiers JAR. Il est alors possible de rajouter des bibliothèques de balises à n'importe quel module web en utilisant un clic de droite sur le nœud WEB-INF et en choisissant "Add JSP Tag Library" > "Find in Tag Library Repository" dans le menu contextuel. C'est en particulier ce qui est fait pour rajouter une référence vers les bibliothèques JSTL contenues par défaut par Sun Java System Application Server 8.

    Deboggage de modules web

    Ouvrir le fichier docs/main.jsp dans l'éditeur de source et positionner un point d'arrêt en cliquant dans la marge à la ligne 32 (ligne qui appelle midnight:content). Avec un click de droite sur le nœud WEB-INF, choisir "Run in Debugger" dans le menu contextuel. L'application web va alors démarrer puis s'arrêter là ou le point d'arrêt a été défini. En appuyant sur F7, le deboggeur rentre dans le code appelé. Si une fenêtre apparaît indiquant que le code source est manquant, cliquer simplement sur OK pour se retrouver à la première ligne de code source disponible. En continuant d'utiliser F7, s'arrêter dans la méthode otherDoStartTagOperations() de la classe ContentHandler. Positionner un point d'arrêt sur la ligne 50 (ligne  request.getRequestDispatcher(page).include(request, response)) et choisir "continue" (Ctrl-F5). Placer le curseur sur les variables page, request, et response pour observer leur valeurs. Il est également possible de consulter ses valeurs dans l'onglet "Local Variables". On remarquera que l'onglet "Call Stack" affiche à tout moment la correspondance entre le code JSP et les méthodes générées dans la servlet. Avec un clic-droit sur une variable quelconque, choisir  "New Watch" dans le menu contextuel. L'onglet "Watches" fait alors apparaître les changements de valeurs au cours de l'exécution des différentes pages de l'application. Pour terminer la session de debug, choisir "Debug" > "Finish Session".

    Test des pages JSP

    Pour exécuter une page JSP publique (située en dehors du répertoire WEB-INF), il suffit de choisir "Execute" dans le menu contextuel de la page JSP. L'utilisation du rafraîchissement de la page dans le navigateur fera alors apparaître les dernières modifications apportées à la page JSP. Les pages JSP privées comme celles de ce didacticiel sont plus difficiles à exécuter de manière isolée. Pour éviter de redémarrer tout le module web et naviguer jusqu'à la page à tester, il est possible d'utiliser la fonctionnalité "replay action" de HTTP Monitor. Après avoir modifié le fichier docs/cookies/Tray.jsp en positionnant la bordure du tableau à 10 et en sauvegardant les modifications, utiliser HTTP Monitor pour rejouer la requête "GET Tray.jsp" avec son menu contextuel "Replay". La page Tray.jsp doit alors apparaître dans le navigateur avec une bordure de tableau plus large.

    Haut de page


    7. Problèmes communs (et solutions) lors de l'exécution

    Si vous obtenez une erreur à l'exécution de l'application Midnight Cookie Company application, voici quelques conseils pour les corriger :

    • L'outil NetBeans lève une exception en tentant de démarrer le navigateur que vous avez spécifié.

      Solution: vérifier dans NetBeans la configuration du chemin vers le navigateur :

      1. Choisir "Tools" > "Options" dans la fenêtre principale de l'outil.

      2. Ouvrir les nœuds "IDE Configuration" et "Server and External Tool Settings".

      3. Sélectionner le navigateur Web approprié.

      4. Vérifier que le chemin vers votre navigateur est correctement spécifié. Dans le cas contraire, utiliser le bouton "Browse" pour naviguer vers le bon chemin. Si le navigateur par défaut est Netscape 6.0 ou 7.0, positionner la propriété "DDE Server" à NETSCAPE6.

    • Une erreur File Not Found apparaît dans le navigateur lors de l'accès à la page http://localhost:8081/midnight_fr/ en exécutant l'application Web.

      Solution 1: Si votre navigateur est configuré pour utiliser un serveur de proxy, il essayera de router toutes les demandes par ce serveur, y compris dans le cas de fichiers locaux. Il vous faut rajouter localhost et votre nom de machine à la liste des hôtes qui ne sont pas concernés par cette configuration du navigateur. Pour plus d'aide, consulter la page intitulée "Accessing Local Files Through a Proxy" dans l'aide de l'outil NetBeans (choisir Help > Help Sets > Core IDE Help).

      Solution 2: Vérifier le nom des différents fichiers JSP créés dans ce didacticiel. Vérifier en particulier de ne pas avoir utilisé l'extension de fichier .jsp dans l'assistant. Si nécessaire, renomer les fichiers.

    • L'application fonctionne correctement, mais le HTTP Monitor ne contient aucune information et le fichier de log du serveur d'application J2EE 1.4 contient une erreur "java.net.ConnectException: Connection refused: connect".

      Solution: Vérifier que le serveur HTTP interne est bien démarré (onglet "Runtime" -> nœud "HTTP Server" -> click-droit "Start HTTP Server") et que son port d'écoute est le bon (8082 par défaut).

    • L'application est bien déployée par NetBeans, mais le navigateur ne peut pas être lancé par l'IDE.

      Solution: Vérifier le choix du navigateur par défaut dans le menu suivant: Tools > Options > IDE Configuration > System > System Settings > Web Browser et si le choix est le bon, vérifier le script de lancement dans la propriété Tools > Options > IDE Configuration > Server and External Tool Settings > Web Browser.

    • Le serveur d'application ne démarre pas et une erreur "Port already in use, could not ping the application server".

      Solution: Vérifier que les ports d'écoute du serveur d'application (4848, 8080, etc..) ne sont pas déjà occupés. Attention à ne pas utiliser le port 8082 qui est destiné ici au serveur Web interne pour le bon fonctionnement de HTTP Monitor.

    • Le serveur d'application et le navigateur démarrent, mais rien n'apparaît dans le navigateur à l'URL http://localhost:8080/midnight_fr. Le log du serveur d'application indique un problème avec org.netbeans.modules.web.monitor.server.MonitorFilter.
    Solution: S'assurer du bon fonctionnement de HTTP Monitor.

    • La page principale de l'application ne s'affiche que partiellement et le fichier de log du serveur d'application J2EE 1.4 contient une erreur "D'après la TLD, l'attribut bundle n'accepte aucune expression".

      Solution: Le fichier web.xml est peut-être corrompu. Vérifier qu'il contient bien la balise <jsp-config> suivante:


    ...
    
      <jsp-config>
        <jsp-property-group>
        <url-pattern>*.jsp</url-pattern>
            <el-ignored>true</el-ignored>
        </jsp-property-group>
      </jsp-config>
    
    ...
                    

    Une autre solution consiste à rajouter la ligne suivante dans les pages JSP qui utilisent l'Expression Language (EL) :

    <%@page isELIgnored="true"%>


    Haut de page

    8. Vérifier que la fonction HTTP Monitor est opérationnelle avec Sun Java System Application Server 8

    Afin de pouvoir utiliser les fonctionnalités HTTP Monitor avec Sun Java System Application Server 8, il est nécessaire de procéder aux paramétrages suivants (ces étapes ne sont pas nécessaires avec le conteneur Web Tomcat fournit avec l'outil NetBeans):

    • Recopier le fichier httpmonitor.jar depuis le répertoire chemin-install-netbeans/modules/ext/ vers le répertoire chemin-install-appserver8/domains/domain1/lib. IMPORTANT: le serveur J2EE 1.4 SDK doit être redémarré après cette manipulation.
    • Vérifier que le serveur HTTP interne fonctionne et que son port d'écoute est le 8082. Dans l'onglet "Runtime', choisir le nœud "HTTP Server", puis vérifier ses propriétés et son état (le démarrer avec un click droit "start HTTP server" si nécessaire).
    • Modifier le fichier web.xml situé dans WEB-INF (dans l'onglet "Filesystems") pour y rajouter le filtre et le dispatcher suivant si ce n'est pas déjà fait. Notez la déclaration qui fait référence à une application J2EE 1.4, une autre syntaxe (disponible dans l'aide en ligne de NetBeans) étant nécessaire pour les applications J2EE 1.3 :
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://java.sun.com/xml/ns/j2ee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation=
                    "http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
               version="2.4">
    
    ...
    
      <filter>
       <filter-name>HTTPMonitorFilter</filter-name>
       <filter-class>org.netbeans.modules.web.monitor.server.MonitorFilter</filter-class>
         <init-param>
           <param-name>netbeans.monitor.ide</param-name>
           <param-value>localhost:8082</param-value>
         </init-param>
      </filter>
    
      <filter-mapping>
         <filter-name>HTTPMonitorFilter</filter-name>
         <url-pattern>/*</url-pattern>
         <dispatcher>FORWARD</dispatcher>
         <dispatcher>INCLUDE</dispatcher>
         <dispatcher>REQUEST</dispatcher>
         <dispatcher>ERROR</dispatcher>
      </filter-mapping>
    
      <jsp-config>
         <jsp-property-group>
            <url-pattern>*.jsp</url-pattern>
            <el-ignored>true</el-ignored>
         </jsp-property-group>
      </jsp-config>
    
    </web-app>
                    

    Notez que HTTP Monitor est une fonctionnalité de développement. Pour ne pas utiliser cette fonctionnalité (ne pas recopier de fichier, ne pas utiliser de serveur HTTP intermédiaire sur le port 8082), il suffit de supprimer les balises <filter> et <filter-mapping> du fichier web.xml. Une fois l'application développée et débugguée, cette fonction peut-être débranchée.


    9. Suppression de l'application Midnight Cookie Company

    Pour supprimer l'application Midnight Cookie Company de l'outil NetBeans :

    • Dans la fenêtre "Filesystems", avec un clic-droit sur le nœud "midnight_fr", choisir "Unmount Filesystem" dans le menu contextuel.

    Lors du "démontage" de ce répertoire de l'application, les fichiers sources ne sont plus accessibles depuis l'outil NetBeans, mais ils ne sont pas supprimés du système de fichier de votre système d'exploitation.

    Pour supprimer les fichiers source de l'application Midnight Cookie Company de votre système d'exploitation :

    • Utiliser les commandes du système d'exploitation pour supprimer le répertoire de l'application Midnight Cookie Company et son contenu.
    Pour supprimer l'application Midnight Cookie Company du serveur d'application :
    • Dans la fenêtre "Runtime", ouvrir les nœuds "Server Registry", "Sun Java System Application Server 8" et "localhost:4848". En ouvrant ensuite les nœuds "Applications" et "Web Applications", sélectionner l'application "/midnight_fr" et choisir "Undeploy" dans son menu contextuel (clic-droit).

    Haut de page

    Project Features

    About this Project

    fr was started in November 2009, is owned by petras, and has 104 members.
    By use of this website, you agree to the NetBeans Policies and Terms of Use (revision 20160708.bf2ac18). © 2014, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo
     
     
    Close
    loading
    Please Confirm
    Close