Cette page représente le point de départ de découverte de l'application Directory Listing. Les rubriques suivantes sont traitées :
L'exemple d'application Directory Listing a été créée pour complémenter l'utilisation du magasin dojox.data.FileStore de Dojo Toolkit for JavaScript. L'exemple Directory Listing montre comment développer des applications Representational State Transfer (REST) JAX-RS pouvant recevoir des requêtes provenant du magasin de données dojox.data.FileStore et y répondre.
Le magasin de données dojox.data.FileStore représente une implémentation légère JavaScript pour accéder aux détails concernant un système de fichiers distant. Ce magasin de données et la ressource JAX-RS côté serveur n'accroissent pas toute la hiérarchie du chemin de système de fichiers requis. Ceci vous permet de renvoyer rapidement les informations pour le chemin demandé tout en fournissant des points d'ancrage pour un chargement des sous-répertoires. Il s'agit d'un exemple de la manière dont le magasin de données Dojo peut effectuer un chargement différé et de création de la ressource JAX-RS conforme aux attentes de dojox.data.FileStore.
L'objectif principal de cet exemple Directory Listing est de prouver la simplicité et la fonctionnalité de la classe de ressource JAX-RS. Toutefois, pour montrer complètement cette simplicité, le magasin de données dojox.data.FileStore est inclus à une application Dojo plus grande. Consultez les rubriques concernant l'application Directory Listing pour un exemple.
Prérequis produit | Version |
---|---|
Java Technology Edition | 5.0 et version ultérieure |
Serveur d'application Java Platform, Enterprise Edition 5 (Java EE) et version ultérieure | WebSphere Application Server Version 6.1.0.x et ultérieure WebSphere Application Server Community Edition Version 2.X. |
Navigateur Web | Tout navigateur Web moderne, tel que : Internet Explorer 7 et version ultérieure Mozilla Firefox 3.x et version ultérieure Google Chrome Safari Opera |
Développement IDE (facultatif) | Eclipse version 3.X |
L'exemple d'application Directory Listing n'est pas destiné à un déploiement sur les serveurs de production. Il est créé à des fins de développement et d'éducation uniquement.
Tout le code source de l'application JAX-RS application, de ressource et des pages Web est fourni tel quel pour que vous l'utilisiez, copiez et modifiez sans paiement de royaltie lorsque vous développez des applications exécutées avec le logiciel WebSphere. Vous pouvez utiliser les exemples de code pour vos besoins internes ou pour le redistribuer dans le cadre d'une application ou de vos produits.
La conception de l'exemple d'application Directory Listing montre comment approcher le développement d'applications basées sur Ajax avec le Dojo Toolkit dans un environnement Java EE. Pour cela, les deux parties d'une application Java EE, le côté client et le côté serveur, sont organisés en opérations simples effectuant une fonction utile. La conception suit le canevas de base des applications Java qui intègrent les technologies Ajax.
Les sections suivantes supposent que vous connaissez déjà l'infratructure JavaScript pour Dojo ; elles n'expliquent pas en détails l'exemple d'application client Dojo ou le magasin de données Dojo dojox.data.FileStore utilisé.
Le client n'est autre que la page Web qui est servie au navigateur. Dans la page Web, le magasin de données dojox.data.FileStore est instancié et déclaré en magasin dans dijit.tree.ForestStoreModel, qui est déclaré en modèle du widget dijit.Tree. Le widget dijit.Tree fournit la représentation visuelle de la hiérarchie de système de fichiers. Il présente des symboles plus et moins à côté des répertoire de l'arborescence sur lesquels les utilisateurs cliquent pour développer ou diminuer. Lorsque l'utilisateur clique sur le symbole plus, le chemin demandé est transmis à la ressource JAX-RS par le magasin de données the dojox.data.FileStore et effectue la fonction de chargement différée. Pour des informations plus spécifiques sur la conception côté client, consultez la rubrique sur la conception côté client de l'exemple d'application Directory Listing.
Le serveur fournit l'infrastructure du traitement des services et du service des pages Web. Dans cette application, le côté serveur est une classe de ressource JAX-RS qui reçoit et traite les requêtes GET à partir du magasin de données dojox.data.FileStore et répond selon les prérequis de ce magasin et de l'application Dojo intégrée. Pour des informations plus spécifiques sur la conception côté serveur, consultez la rubrique sur la conception côté serveur de l'exemple d'application Directory Listing.
L'exemple d'application Directory Listing utilise le magasin de données dojox.data.FileStore pour interroger la ressource JAX-RS pour des informations sur un chemin du système de fichiers du serveur. L'objet dojox.data.FileStore est configuré avec une chaîne d'options, une URL vers le service et l'indicateur pathAsQueryParam afin d'indiquer que le chemin demandé doit être envoyé en tant que paramètre de requête ?path=/the/path. Sans cet indicateur, la requête doit être envoyée en appendice de l'URL.
L'application créée avec dojox.data.FileStore, modèle et arborescence, inclut les widgets dojo.form.CheckBox pour activer ou désactiver la prise en charge de fonctions individuelles du magasin de données dojox.data.FileStore. Ils sont inclus dans le cadre de l'application pour démontrer la fonctionnalité du magasin de données.L'activation ou la désactivation d'une fonction via la coche d'une case requiert que le magasin de données réenvoie la requête initiale vers le serveur et actualise le modèle et l'arborescence, que vous verrez en testant ces fonctions.
Les fonctions de recherche de dojox.data.FileStore sont également gérées dans l'application. Un attribut de fichier disponible dans une liste déroulante peut être sélectionné avec du texte (incluant les astérisques génériques) pour la correspondance. La recherche peut être affinée si vous sélectionnez "Ignore capitalization" ou "Deep search". Finalement, pour limiter ou contrôler la quantité d'éléments renvoyés dans la recherche, l'index de démarrage peut être fourni avec le nombre maximal d'entrées pouvant être renvoyées.
En plus des fonctions attendues d'un magasin de données Dojo standard, d'un modèle, d'une arborescence, l'application appelle une fonction spéciale de la ressource JAX-RS pour préremplir une arborescence de répertoire de sorte que le client affiche un ensemble utile de données. L'application utilise dojo.xhrPut pour envoyer une requête PUT à la ressource JAX-RS, indiquant à la ressource JAX-RS qu'elle doit remplir une hiérarchie de répertoire à utiliser par l'exemple.
L'objectif principal de cet exemple d'application Directory Listing est de montrer la simplicité de l'obtention d'une ressource JAX-RS développée qui peut recevoir et traiter des requêtes de dojox.data.FileStore. Par conséquent, la compréhension et le codage du client sont laissés au lecteur. Toutefois, il est à noter que ce client est écrit pour utiliser les fonctions Dojo à l'aide d'un programme pour montrer toutes les fonctions de dojox.data.FileStore et éliminer le besoin de création manuelle d'une hiérarchie de système de fichiers. L'arborescence visuelle dijit.Tree, et son inclusion du modèle et magasin peuvent également avoir été écrits de manière déclarative dans quelques lignes de code HTML, par exemple :
<div dojoType="dojox.data.FileStore" jsId="myStore" url="rest/directorylisting" pathAsQueryParam="true"></div> <div dojoType="dijit.tree.ForestStoreModel" jsId="myModel" store="myStore" rootId="myfiles" rootLabel="Files" childrenAttrs="children"></div> <div dojoType="dijit.Tree" id="mytree" model="myModel"></div>
Pour en savoir plus sur l'utilisation du côté client, reportez-vous au code source de l'application. Chaque section du document HTML est commentée, avec des explications sur l'objectif du bloc de code.
Au minimum, l'exemple d'application Directory Listing pour le serveur doit être capable de recevoir une requête GET avec un chemin ajouté au chemin écoutant la requête ou un paramètre de requête ?path=/myPath joint à la requête GET. Pour que la configuration de l'exemple soit aussi pratique que possible, la ressource JAX-RS inclut une méthode d'écoute des requêtes PUT qui pré-rempliront une hiérarchie de répertoire de système de fichiers de sorte que le client Dojo puise l'appeler avant de démontrer les fonctions de dojox.data.FileStore. Ceci élimine le besoin de création manuelle d'une hiérarchie de système de fichiers.
L'environnement d'exécution JAX-RS a une fonction intégrée de division des paramètres de requêtes en paires nom/valeur, et de transmission de ces derniers en paramètres vers la méthode Java recevant la requête GET.
package com.ibm.websphere.mobile.appsvcs.sample.directorylisting.resources; import javax.ws.rs.Path; // Full import list not shown. @Path("/directorylisting") public class DirectoryListingService { // ... }
Notez que cette classe de ressource JAX-RS est déclarée avoir un segment d'URL de "/directorylisting". Cette classe de ressource va gérer les requêtes ciblées sur http://<server>:<port>/<context-root>/<uri-mapping>/directorylisting.
La racine de contexte est définie par le fichier application.xml si votre fichier archive Web (.war) est intégré à un fichier .ear. Si le fichier .war est installé seul, la racine de contexte est définie au moment de l'installation par l'utilisateur. Le mappage d'uri est défini dans le WEB-INF/web.xml dans le fichier .war.
Le magasin de données dojox.data.FileStore envoie des requêtes GET. Dans le client vers lequel il a été configuré pour envoyer le chemin souhaité en paramètre de requête et un sous-ensemble d'arguments facultatifs décrit dans dojox.data.FileStore, incluant le protocole de requête dojo.data.api.Read. Par exemple, le magasin de données dojox.data.FileStore peut envoyer une requête GET en http://<server>:<port>/<context-root>/<uri-mapping>/directorylisting?path=/the/path. Etant donné que nous devons gérer le chemin en tant que partie de l'URL ou en paramètre de requête, nous avons une méthode de ressource JAX-RS pour chacune de ces deux possibilités. Elles appellent chacune une méthode courante de gestion de logique du service.
// Query parameters and values private static final String QUERY_OPTIONS = "options"; private static final String QUERY_PATH = "path"; private static final String QUERY_QUERY = "query"; private static final String QUERY_QUERYOPTIONS = "queryOptions"; private static final String QUERY_START = "start"; private static final String QUERY_COUNT = "count"; // Default value for start and count query parameters. private static final String NO_VALUE_STRING = "-1"; private static final int NO_VALUE_INT = -1; @GET @Produces(MediaType.APPLICATION_JSON) public JSONObject getFileListWithPathInParam( @Context ServletConfig servletConfig, @Context HttpHeaders httpHeaders, // Note, the path is obtained with @QueryParam. @QueryParam(QUERY_PATH) String path, @QueryParam(QUERY_OPTIONS) String options, @QueryParam(QUERY_QUERY) String query, @QueryParam(QUERY_QUERYOPTIONS) String queryOptions, @DefaultValue(NO_VALUE_STRING) @QueryParam(QUERY_START) String startParam, @DefaultValue(NO_VALUE_STRING) @QueryParam(QUERY_COUNT) String countParam) { return getFileListCommon(servletConfig, path, options, query, queryOptions, startParam, countParam); } @GET // JAX-RS will call this method if the URL has more than the root path. @Path("{path:.*}") @Produces(MediaType.APPLICATION_JSON) public JSONObject getFileListWithPathInUri( @Context ServletConfig servletConfig, @Context HttpHeaders httpHeaders, // Note, the path is obtained with @PathParam. @PathParam(QUERY_PATH) String path, @QueryParam(QUERY_OPTIONS) String options, @QueryParam(QUERY_QUERY) String query, @QueryParam(QUERY_QUERYOPTIONS) String queryOptions, @DefaultValue(NO_VALUE_STRING) @QueryParam(QUERY_START) String startParam, @DefaultValue(NO_VALUE_STRING) @QueryParam(QUERY_COUNT) String countParam) { return getFileListCommon(servletConfig, path, options, query, queryOptions, startParam, countParam); }
La première annotation @GET déclare que la méthode reçoit des requêtes GET HTTP sur l'URL se terminant avec directorylisting par annotation @Path de niveau de classe. Notez l'utilisation de l'annotation @QueryParam pour accéder le chemin demandé dans le service.
La deuxième annotation @GET qualifie davantage le @Path avec une expression classique, "{path:.*}" qui mappe les caractères présents après l'annotation @Path de niveau de classe. Par conséquent, lorsque la seconde méthode est appelée, le chemin doit figurer dans l'URL. Notez l'utilisation de @PathParam pour accéder à la valeur du chemin demandé dans le service.
Chacune des deux méthodes inclut l'annotation @Produces. Ceci aide l'exécution JAX-RS à faire correspondre le message entrant à la méthode Java. L'exécution JAX-RS va essayer de faire correspondre l'en-tête Accept du message entrant à la valeur @Produces. Elle informe également l'exécution JAX-RS du format de la réponse à respecter.
A ce stade, une classe supplémentaire est requise pour terminer l'application. JAX-RS initialise une application et ses ressources et fournisseurs via la classe développant javax.ws.rs.core.Application. Par conséquent, créez la classe suivante.
package com.ibm.websphere.mobile.appsvcs.sample.directorylisting; import java.util.HashSet; import java.util.Set; import javax.ws.rs.core.Application; public class DirectoryListingApplication extends Application { @Override public Set<Class<?>> getClasses() { Set<Class<?>> classes = new HashSet<Class<?>>(); classes.add(DirectoryListingService.class); return classes; } }
Vous trouverez ci-dessous les parties critiques de l'activation de cette application JAX-RS.
... <servlet-name>JAXRSServlet</servlet-name> <servlet-class>com.ibm.websphere.jaxrs.server.IBMRestServlet</servlet-class> <init-param> <param-name>javax.ws.rs.Application</param-name> <param-value>com.ibm.websphere.mobile.appsvcs.sample.directorylisting.DirectoryListingApplication</param-value> </init-param> ... <servlet-mapping> <servlet-name>JAXRSServlet</servlet-name> <url-pattern>/rest/*</url-pattern> </servlet-mapping> ...
Notez la classe servlet-class et le paramètre init-param avec param-name "javax.ws.rs.Application". Il s'agit du moyen standard de déclarer l'implémentation servlet et transmettre la référence de la classe développant javax.ws.rs.core.Application dans l'exécution JAX-RS.
Avec l'inclusion de WEB-INF/web.xml, l'application compilée et les bons fichiers de bibliothèque dans le répertoire WEB-INF/lib/ du fichier .war, l'application peut être installée sur un serveur d'application. Voir le contenu de l'exemple inclus si vous souhaitez voir la liste des bibliothèques requises. L'exemple d'application incluse est sous la forme d'un fichier .war intégré à un fichier .ear. Dans le fichier .ear, vous trouverez le fichier application.xml standard, qui indique la raconte contexte URL de "/appsvcs-directorylisting". Par conséquent, l'URL vers le fichier index.html est http://<server>:<port>/appsvcs-directorylisting/. Notez que l'URL indiquée dans le fichier index.html dans l'exemple d'application est rest/directorylisting, relative à l'emplacement du fichier index.html ; il s'agit du résultat de la concaténation du modèle d'URL dan le fichier web.xml et de l'annotation @Path dans la classe de ressource JAX-RS.
La méthode getFileListCommon est appelée à partir de chacune des deux méthodes de ressources JAX-RS décrites précédemment. La liste ci-dessous décrit chaque paramètre. Le format et le contenu des paramètres s'alignent avec le documentation de dojox.data.FileStore. Les deux premiers paramètres sont toujours fournis par le conteneur de servlet sous-jacent. Les paramètres restants sont facultatifs. Par conséquent, vous pouvez spécifier null ou accepter les valeurs par défaut.
protected JSONObject getFileListCommon( ServletConfig servletConfig, HttpHeaders httpHeaders, String path, // Path of the request, from the URL or an HTTP parameter String options, // JSON array, could contain expand, showHiddenFiles, dirsOnly String query, // JSON array of name/value pairs for a filtered search String queryOptions, // JSON array of settings for a deep search and/or ignoreCase String startParam, // Index of results to start with in the returned list String countParam) // Number of items to return in the result list { // ... }
Les méthodes existant dans le code source pour valider chacun des paramètres et dans certains cas, les placer dans un format facile à interroger plus tard. Voir la documentation dojox.data.FileStore pour obtenir des descriptions de ces paramètres.
A ce stade, vous avez reçu la requête du magasin de données dojox.data.FileStore. Elle attend une réponse au format JSON, qui peut être créée à l'aide des informations du chemin demandé dans JSONObject. L'exemple de code montre ci-dessous comment créer la réponse au format JSON.
// Attribute names private static final String ATTRIB_ITEMS = "items"; private static final String ATTRIB_NAME = "name"; private static final String ATTRIB_PATH = "path"; private static final String ATTRIB_PARENTDIR = "parentDir"; private static final String ATTRIB_SIZE = "size"; private static final String ATTRIB_DIRECTORY = "directory"; private static final String ATTRIB_CHILDREN = "children"; private static final String ATTRIB_MODIFIED = "modified"; ... // Assume you have already found the file you want, // instantiated as a Java file in variable "file" JSONArray fileList = new JSONArray(); if (path.equals("/") && file.isDirectory()) { // Query param "path" was not passed, was blank, or "/" File[] children = file.listFiles(); if (children != null && children.length > 0) { for (int i = 0; i < children.length; i++) { // Call common code to append the list if the file is acceptable. // This also searches recursively if necessary. appendFileList(children[i], fileList); } } JSONObject items = new JSONObject(); items.put(ATTRIB_ITEMS, fileList); logger.exit(); return items; } else { // This is a single identity lookup for a specific path. // A JSONObject representing the file will be returned. JSONObject jsonFile = appendFileList(file, null); if (jsonFile == null) { // Handle error ... } else { logger.exit(); return jsonFile; } } ... ... private JSONObject appendFileList(File file, JSONArray fileList) { ... JSONObject item = new JSONObject(); if (file != null) { item.put(ATTRIB_NAME, file.getName()); item.put(ATTRIB_MODIFIED, new Long(file.lastModified())); item.put(ATTRIB_SIZE, new Long(file.length())); item.put(ATTRIB_PATH, getFileAttribute(ATTRIB_PATH, file)); item.put(ATTRIB_PARENTDIR, getFileAttribute(ATTRIB_PARENTDIR, file)); item.put(ATTRIB_DIRECTORY, new Boolean(file.isDirectory())); // See the sample code for details on traversing directory trees of files ... // Add another item to the list. fileList.add(item); } ... }
A ce stade, nous avons une ressource de service JAX-RS capable de répondre aux attentes du magasin de données dojox.data.FileStore. Les détails d'implémentation de traversée du système de fichiers, gestion des options du paramètre de requête des options et autorisation de configuration du répertoire racine sont laissés au lecteur, il les voit dans le code source.
Le code source de l'exemple d'application Directory Listing est fourni dan le fichier de module Web .war du fichier appsvcs-directorylisting.ear. Il y a deux moyens d'afficher le code source : via un IDE Eclipse ou en décompressant successivement le fichier appsvcs-directorylisting.ear et le fichier .war contenu dans le fichier ear.
La première chose à faire pour visualiser le code source est de repérer le fichier DirectoryListing.ear. Si vous avez installé la version IBM WebSphere Application Server Feature Pack for Web 2.0 and Mobile, vous trouverez le fichier EAR dans votre arborescence d'installation.
Par exemple, si vous avez installé le module de fonctions à l'emplacement :
Linux et UNIX : /opt/WebSphere/AppServer point de montage z/OS : <install_root> Windows : c:\WebSphere\AppServer
Vous trouverez alors le fichier EAR à l'emplacement suivant :
Linux et UNIX : /opt/WebSphere/AppServer/web2mobilefep_1.1/samples/directorylisting/appsvcs-directorylisting.ear z/OS : <install_root>/web2mobilefep_1.1/samples/directorylisting/appsvcs-directorylisting.ear Windows : c:\WebSphere\AppServer\web2mobilefep_1.1\samples\directorylisting\appsvcs-directorylisting.ear
Un IDE Eclipse est le moyen le plus simple d'examiner le code source du fichier WAR. Utilisez Eclipse 3.2.X, 3.3.X IDE avec Web Tools Project 2.5 ou version ultérieure, ou bien Rational Application Developer, Version 7.0 ou ultérieure, puis le fichier d'archive Web (WAR) en suivant la procédure comme suit :
Une fois l'importation terminée, un nouveau projet, DirectoryListing, existe dans l'espace de travail Eclipse. Le code source de l'application est accessible à partir du projet DirectoryListing. Pour accéder au code serveur ou client, consultez le tableau suivant qui donnent les emplacements du code source dans l'arborescence du projet Eclipse DirectoryListing.
Code source | Emplacement |
---|---|
Côté client (navigateur web) | WebContent/index.html : contient les définitions des widgets Dojo et fonctions de script client. Ce fichier charge le profil Dojo non optimisé. |
Côté serveur | Ressources Java : src/com.ibm.websphere.mobile.appsvcs.sample.directorylisting/ DirectoryListingApplication.java: Double-cliquez sur ce fichier pour charger le code source. |
Ressources Java : src/com.ibm.websphere.mobile.appsvcs.sample.directorylisting. resources/DirectoryListingService.java : double-cliquez sur ce fichier pour charger le code source. |
Les archives d'application Web sont des archives de fichiers compressés avec l'algorithme ZIP. L'archive peut donc être ouverte par plusieurs outils de compression de fichiers, dont le programme JAR. La procédure suivante suppoe que l'utilisateur choisisse son outil favori pour créer les fichiers compressés.
Une fois que vous avez décompressé le contenu du fichier EAR, développez également le contenu du fichier .war. Vous pouvez alors accéder au code source. Pour accéder au code du client ou du serveur, consultez le tableau suivant qui donne les emplacements du code source dans le répertoire EXPAND_DIR/DirectoryListing.
Code source | Emplacement |
---|---|
Côté client (navigateur web) | index.html : contient les définitions des widgets Dojo et fonctions de script client. |
Côté serveur | WEB-INF/classes/com/ibm/websphere/mobile/appsvcs/sample/directorylisting/ DirectoryListingApplication.java |
WEB-INF/classes/com/ibm/websphere/mobile/appsvcs/sample/directorylisting/ resources/DirectoryListingService.java |
Reportez-vous aux instructions d'installation spécifiques à chaque version :
Cette section décrit la procédure d'installation de l'exemple d'application Directory Listing sur la Version 6.1.0.X et ultérieure d'IBM WebSphere Application Server. Vous devez avoir des bonnes connaissances sur l'administration et l'installation de l'application pour le serveur d'application.
Localisez le fichier d'archive (EAR) de l'exemple d'application Directory Listing qui est fourni avec l'installation de votre produit. Vous le trouverez dans votre arborescence d'installation où vous avez installé IBM WebSphere Application Server Feature Pack for Web 2.0 and Mobile. Par exemple, si vous avez installé le module de fonctions à l'emplacement :
Linux et UNIX : /opt/WebSphere/AppServer point de montage z/OS : <install_root> Windows : c:\WebSphere\AppServer
Vous trouverez alors le fichier EAR à l'emplacement suivant :
Linux et UNIX : /opt/WebSphere/AppServer/web2mobilefep_1.1/samples/application_services/directorylisting/appsvcs-directorylisting.ear z/OS : <install_root>/web2mobilefep_1.1/samples/application_services/directorylisting/appsvcs-directorylisting.ear Windows : c:\WebSphere\AppServer\web2mobilefep_1.1\samples\application_services\directorylisting\appsvcs-directorylisting.ear
- Connectez-vous à la console d'administration du serveur d'applications.
- Naviguez jusqu'à Applications > Nouvelle application. (Note : dans WebSphere Application Server Version 6.1, sélectionnez Installation d'une nouvelle application)
- Sélectionnez New Enterprise Application. (Note : dans WebSphere Application Server Version 6.1, ignorez cette étape)
- Parcourez votre système de fichiers et sélectionnez le fichier appsvcs-graphics.ear localisé précédemment. Cliquez sur Suivant.
- Cliquez sur Suivant pour préparer l'installation d'application. (Note : dans WebSphere Application Server Version 6.1, ignorez cette étape)
- Cliquez sur Suivant pour accepter les options d'installation par défaut.
- Cliquez sur Suivant pour accepter les options par défaut pour le mappage des modules vers les serveurs.
- Cliquez sur Suivant pour accepter les options par défaut pour les métadonnées des modules. (Note : dans WebSphere Application Server Versions 6.1 et 7, ignorez cette étape)
- Cliquez sur Suivant pour accepter les options par défaut pour le mappage des hôtes virtuels pour les modules Web.
- Consultez le récapitulatif des options d'installation.
- Cliquez sur Terminer.
- Cliquez sur Sauvegarder dans la configuration principale.
- Naviguez jusqu'à Applications > Types d'application > WebSphere Enterprise Applications. (Note : dans WebSphere Application Server Version 6.1, naviguez jusqu'à Applications > Enterprise Applications)
- Sélectionnez IBM WebSphere Application Server - Directory Listing sample application, et cliquez sur Démarrer.
Pointez votre navigateur Web vers votre installation de serveur d'application : http://<nom d'hôte de serveur d'application>:<port>/appsvcs-directorylisting/
Les numéro de port et nom d'hôte du serveur d'application sont spécifiques à votre installation de serveur d'application. Le port de conteneur Web d'installation par défaut du serveur d'application est 9080. Si vous exécutez votre navigateur Web sur le même poste de travail que votre installation de serveur d'application et avez opté pour toutes les valeurs par défaut, utilisez l'URL suivante : http://localhost:9080/appsvcs-directorylisting/.
Cette section décrit la procédure d'installation de l'exemple d'application Directory Listing dans la Version 2.X d'IBM WebSphere Application Server Community Edition. Vous devez avoir des bonnes connaissances sur l'administration et l'installation de l'application pour le serveur d'application.
Localisez le fichier d'archive (EAR) de l'exemple d'application Directory Listing qui est fourni avec l'installation de votre produit. Vous le trouverez dans votre arborescence d'installation où vous avez installé IBM WebSphere Application Server Feature Pack for Web 2.0 and Mobile. Par exemple, si vous avez installé le module de fonctions à l'emplacement :
Linux et UNIX : /opt/WebSphere/AppServerCommunityEdition Windows : c:\WebSphere\AppServerCommunityEdition
Vous trouverez alors les fichiers de bibliothèque et EAR à l'emplacement suivant :
Linux et UNIX : /opt/WebSphere/AppServerCommunityEdition/web2mobilefep_1.1/AppServices/samples/directorylisting/appsvcs-directorylisting.ear Windows : c:\WebSphere\AppServerCommunityEdition\web2mobilefep_1.1\AppServices\samples\directorylisting\appsvcs-directorylisting.ear
Connectez-vous à la console d'administration du serveur d'applications.
- Cliquez sur Applications > Deployer dans le menu de gauche. (Note : dans WebSphere Application Server Community Edition Version 2.0, cliquez sur Applications > Déployer)
- Dans la zone Archive, parcourez votre système de fichiers et sélectionnez le fichier appsvcs-directorylisting.ear localisé précédemment. Laissez la zone Plan vide et les options par défaut sélectionnées. Cliquez alors sur Installer.
L'application démarre automatiquement ; l'installation est terminée.
Pointez votre navigateur Web vers votre installation de serveur d'application : http://<nom d'hôte de serveur d'application>:<port>/appsvcs-directorylisting/.
Les port et nom d'hôte du serveur d'application sont spécifiques à votre installation de serveur d'application. Le port de conteneur Web d'installation par défaut de serveur WebSphere Application Server Community Edition est 8080. Si vous exécutez votre navigateur Web sur le même poste de travail que votre installation de serveur d'application et avez opté pour toutes les valeurs par défaut, utilisez l'URL suivante :