153
Sommaire Questionnaire 1....................................................................................................... 8 Définitions et API J2EE............................................................................................... 8 Qu'est ce que J2EE ?.................................................................................................8 Que sont les Servlets ?..............................................................................................9 Que sont les JSP ?...................................................................................................9 Que sont les JSP Taglibs ?...........................................................................................9 Quels sont les objectifs de la JSTL ?...............................................................................10 Que sont les EJB ?..................................................................................................11 Qu'est ce que JDBC ?................................................................................................11 Qu'est ce que JAXP ?................................................................................................11 Qu'est ce que JAXB ?................................................................................................12 Qu'est ce que SAAJ ?................................................................................................12 Qu'est ce que JAXR ?................................................................................................12 Qu'est ce que JAX-RPC ?.............................................................................................13 Qu'est ce que JAAS ?................................................................................................13 Généralités applications web......................................................................................... 13 Comment définir une page de bienvenue pour un contexte ?............................................................13 Comment modifier le Time Out d'une session ?........................................................................13 Comment connaître le navigateur utilisé par un utilisateur ?........................................................14 Comment charger des servlets de l'application au démarrage du conteneur ?...........................................14 Quelles sont les différentes portées existantes ?...................................................................14 Comment partager le context entre 2 webapps, avec Tomcat ?..........................................................15

Questionnaire SGAM

Embed Size (px)

Citation preview

SommaireQuestionnaire 1..................................................................................................................................................................................................................................................... 8Définitions et API J2EE........................................................................................................................................................................................................................................ 8

Qu'est ce que J2EE ?......................................................................................................................................................................................................................................... 8Que sont les Servlets ?...................................................................................................................................................................................................................................... 9Que sont les JSP ?............................................................................................................................................................................................................................................. 9Que sont les JSP Taglibs ?................................................................................................................................................................................................................................. 9Quels sont les objectifs de la JSTL ?............................................................................................................................................................................................................... 10Que sont les EJB ?.......................................................................................................................................................................................................................................... 11Qu'est ce que JDBC ?...................................................................................................................................................................................................................................... 11Qu'est ce que JAXP ?...................................................................................................................................................................................................................................... 11Qu'est ce que JAXB ?...................................................................................................................................................................................................................................... 12Qu'est ce que SAAJ ?...................................................................................................................................................................................................................................... 12Qu'est ce que JAXR ?...................................................................................................................................................................................................................................... 12Qu'est ce que JAX-RPC ?................................................................................................................................................................................................................................ 13Qu'est ce que JAAS ?...................................................................................................................................................................................................................................... 13

Généralités applications web............................................................................................................................................................................................................................... 13Comment définir une page de bienvenue pour un contexte ?........................................................................................................................................................................... 13Comment modifier le Time Out d'une session ?............................................................................................................................................................................................... 13Comment connaître le navigateur utilisé par un utilisateur ?............................................................................................................................................................................ 14Comment charger des servlets de l'application au démarrage du conteneur ?................................................................................................................................................... 14Quelles sont les différentes portées existantes ?............................................................................................................................................................................................... 14Comment partager le context entre 2 webapps, avec Tomcat ?........................................................................................................................................................................ 15

Servlets............................................................................................................................................................................................................................................................... 15C’est quoi un servlet ? Quelles sont les méthodes emblématiques des servlets ?.............................................................................................................................................. 15la méthode init().............................................................................................................................................................................................................................................. 16la méthode getServletConfig()......................................................................................................................................................................................................................... 16la méthode service()........................................................................................................................................................................................................................................ 16la méthode destroy()........................................................................................................................................................................................................................................ 16

Fournir des informations sur la servlet............................................................................................................................................................................................................. 16Quelle est l'utilité des sessions ?...................................................................................................................................................................................................................... 17Comment créer un objet session ?................................................................................................................................................................................................................... 17Comment les sessions sont-elles gérées ?......................................................................................................................................................................................................... 17Quelle est la différence entre les méthodes doGet() et doPost() ?..................................................................................................................................................................... 18Pourquoi n'y a-t-il pas de constructeur dans une servlet ?................................................................................................................................................................................ 19Comment connaitre la version de l'API servlet utilisée par un moteur de servlet ?........................................................................................................................................... 19Comment accéder à un JavaBean depuis une servlet ?..................................................................................................................................................................................... 20Quel est l'objet ServletConfig et quelle est son utilité ?................................................................................................................................................................................... 21Comment uploader un fichier depuis une applet vers une servlet ?.................................................................................................................................................................. 21Comment télécharger un fichier depuis une servlet ?....................................................................................................................................................................................... 22Comment placer et récupérer un paramètre d'initialisation d'une servlet ?....................................................................................................................................................... 23

JSP (Java Server Pages)...................................................................................................................................................................................................................................... 24Comment mettre un header et un footer a chaque jsp ?.................................................................................................................................................................................... 24Créer sa propre page d'erreur ?........................................................................................................................................................................................................................ 24Comment appliquer ma page d'erreur à toutes mes pages JSP ?....................................................................................................................................................................... 26Comment afficher tous les paramêtres d'une requete ?..................................................................................................................................................................................... 26Comment afficher tous les attributs du scope request ?.................................................................................................................................................................................... 27Que sont les objets implicites?........................................................................................................................................................................................................................ 27Comment utiliser une librairie de tag (taglib) ?................................................................................................................................................................................................ 28Comment l'interface Tag fonctionne-t-elle ?.................................................................................................................................................................................................... 29Comment l'interface IterationTag fonctionne-t-elle ?....................................................................................................................................................................................... 29Comment l'interface BodyTag fonctionne-t-elle ?........................................................................................................................................................................................... 29Comment écrire le descripteur de taglib (TLD) ?............................................................................................................................................................................................. 30Comment faire le mapping entre un nom de balise et une classe Tag ?............................................................................................................................................................ 31Comment écrire un Tag ?................................................................................................................................................................................................................................ 32Comment utiliser des attributs de balise ?........................................................................................................................................................................................................ 33Comment créer un tag conditionnel ?.............................................................................................................................................................................................................. 35Comment créer un tag itératif ?....................................................................................................................................................................................................................... 35Comment interagir avec le contenu du tag ?.................................................................................................................................................................................................... 37Comment définir/modifier des variables de script dans un Tag ?..................................................................................................................................................................... 39Comment modifier le corps du tag ?................................................................................................................................................................................................................ 40Comment valider les attributs du tag avec TagExtraInfo ?............................................................................................................................................................................... 42Comment empêcher le compilateur d'interpréter le corps du Tag ?.................................................................................................................................................................. 42Comment gérer les exceptions d'un tag ?......................................................................................................................................................................................................... 43Comment écrire des tags collaboratifs ?.......................................................................................................................................................................................................... 44

Divers................................................................................................................................................................................................................................................................. 44Comment gérer une connexion JDBC avec Tomcat ?...................................................................................................................................................................................... 44Comment lire un message d'erreur de Tomcat ?............................................................................................................................................................................................... 46

2/122

Comment faire pour appeler dans le constructeur d'une classe fille une méthode de la classe mère avant d'appeler le constructeur super de la classe mère? ............................46Concepts fondamentaux...................................................................................................................................................................................................................................... 47

Que sont le JRE, le JDK et le SDK ?............................................................................................................................................................................................................... 47Quelles sont les différences entre application, applet et servlet ?..................................................................................................................................................................... 47Qu'est-ce que Java Web Start ?........................................................................................................................................................................................................................ 48Comment connaître la version de la JVM installée ?....................................................................................................................................................................................... 48Quelles sont les conventions de nommage en Java ?....................................................................................................................................................................................... 49Qu'est qu'un obfuscateur ?............................................................................................................................................................................................................................... 50

Les mots-clés...................................................................................................................................................................................................................................................... 50Que signifient les mots-clés public, private et protected ?................................................................................................................................................................................ 50Que signifie le mot-clé static ?........................................................................................................................................................................................................................ 51Que signifie le mot-clé final ?......................................................................................................................................................................................................................... 52Que signifient les mots-clés this et super ?...................................................................................................................................................................................................... 53Que signifie le mot-clé strictfp ?..................................................................................................................................................................................................................... 55Que signifie le mot-clé transient ?................................................................................................................................................................................................................... 56Que signifie le mot-clé volatile ?..................................................................................................................................................................................................................... 56Comment utiliser les mots-clés break et continue ?......................................................................................................................................................................................... 56

Les notions objet................................................................................................................................................................................................................................................. 57Qu'est-ce que l'héritage ?................................................................................................................................................................................................................................. 57Qu'est ce qu'une interface ?............................................................................................................................................................................................................................. 59Qu'est ce qu'une méthode 'deprecated' ?.......................................................................................................................................................................................................... 59Qu'est-ce que la sérialisation ?......................................................................................................................................................................................................................... 60Qu’est-ce que le polymorphisme ? + En termes simples ? + 1 Exemple concret compris par un passant dans la rue.........................................................................................61

Chaines de caractères.......................................................................................................................................................................................................................................... 61Comment comparer des chaînes de caractères ?............................................................................................................................................................................................... 61Comment convertir une chaîne en nombre ?.................................................................................................................................................................................................... 62Comment convertir un nombre en chaîne formatée ?....................................................................................................................................................................................... 63Comment convertir une date en chaîne ?......................................................................................................................................................................................................... 63Comment convertir une chaîne en Date ?........................................................................................................................................................................................................ 64Comment convertir des 'char' en ASCII ?........................................................................................................................................................................................................ 64Comment changer l'encodage d'une chaîne de caractères ?.............................................................................................................................................................................. 65Quelle est la longueur maximale d'une chaîne de caractères ?......................................................................................................................................................................... 65

Les dates............................................................................................................................................................................................................................................................. 66Comment connaître l'heure courante ?............................................................................................................................................................................................................. 66Comment mettre à jour l'heure courante du système ?..................................................................................................................................................................................... 66Comment faire des opérations sur des dates ?.................................................................................................................................................................................................. 66Comment convertir une chaîne en Date ?........................................................................................................................................................................................................ 66Comment connaître la date de création d'un fichier ?....................................................................................................................................................................................... 67

Les threads.......................................................................................................................................................................................................................................................... 67

3/122

Qu'est ce qu'un thread ?................................................................................................................................................................................................................................... 67Comment créer un thread ?.............................................................................................................................................................................................................................. 68Pourquoi toutes les méthodes de la classe Thread sont marquées "deprecated" ?.............................................................................................................................................. 68Comment terminer un thread sans la méthode stop() ?..................................................................................................................................................................................... 68Comment faire un minuteur (timer) facilement ?............................................................................................................................................................................................. 70Comment faire une "pause" dans mon application ?........................................................................................................................................................................................ 71Quand instancier un thread directement, et quand se contenter d'implémenter l'Interface Runnable, pourquoi et dans quel cas, quelle est la différence  ?................................71

Les structures de données.................................................................................................................................................................................................................................... 71Quelle est la différence entre HashSet, TreeSet et LinkedHashSet ?............................................................................................................................................................... 71Quelles différences entre ArrayList, LinkedList et Vector ?............................................................................................................................................................................ 72Quels sont les différents types de Map ?.......................................................................................................................................................................................................... 73Comment créer une pile (LIFO) ?.................................................................................................................................................................................................................... 74Comment augmenter la taille d'un tableau ?.................................................................................................................................................................................................... 74Comment fonctionne un ArrayList ?................................................................................................................................................................................................................ 74Comment trier une List (ArrayList, Vector, ...) ou un tableau?........................................................................................................................................................................ 75Comment déterminer si un objet est un tableau ?............................................................................................................................................................................................. 76Comment déterminer le nombre de dimensions d'un tableau ?......................................................................................................................................................................... 76Comment agrandir un tableau ?....................................................................................................................................................................................................................... 76

L'API de reflection.............................................................................................................................................................................................................................................. 77A quoi sert l'introspection ou la réflexivité, et comment l'utiliser ?.................................................................................................................................................................. 77Comment connaître l'ensemble des classes dont hérite une classe ?................................................................................................................................................................. 78Comment connaître l'ensemble des interfaces qu'implémente une classe ?....................................................................................................................................................... 78Comment connaître le nom du paquetage dans lequel se situe une classe ?...................................................................................................................................................... 78Comment récupérer la liste des méthodes d'une classe ?.................................................................................................................................................................................. 78Comment connaître la signature d'une méthode ?............................................................................................................................................................................................ 78Comment récupérer la liste des champs d'une classe ?..................................................................................................................................................................................... 79Comment savoir si une méthode ou un champ est de classe ?.......................................................................................................................................................................... 79Comment déterminer l'ensemble des informations concernant un champ ?...................................................................................................................................................... 79Comment accéder dynamiquement à la valeur d'un champ donné d'un objet ?................................................................................................................................................. 80Comment lancer dynamiquement une méthode donnée d'un objet ?................................................................................................................................................................. 80Comment passer les types primitifs en paramètre lors de l'utilisation de la réflexivité ?................................................................................................................................... 81Comment lancer dynamiquement une méthode de classe donnée ?.................................................................................................................................................................. 81Y a-t-il un moyen de consulter et/ou de modifier la valeur d'un champ privé ?................................................................................................................................................ 82Est-il possible d'avoir la liste des champs/méthodes privés et protégés d'une classe ?...................................................................................................................................... 82

Les fichiers......................................................................................................................................................................................................................................................... 82Comment connaître les racines des arborescences de fichiers ?........................................................................................................................................................................ 82Comment parcourir une arborescence de fichiers ?.......................................................................................................................................................................................... 83Comment copier ou déplacer un fichier ?........................................................................................................................................................................................................ 83Comment supprimer un fichier ou un répertoire ?............................................................................................................................................................................................ 85

4/122

Comment renommer/déplacer un fichier ?....................................................................................................................................................................................................... 86Comment créer un fichier temporaire ?........................................................................................................................................................................................................... 86Comment écrire à la fin d'un fichier ?.............................................................................................................................................................................................................. 87Comment connaître le type MIME d'un fichier ?............................................................................................................................................................................................. 87Comment connaître la date de création d'un fichier ?....................................................................................................................................................................................... 88Comment connaître l'espace libre d'un disque ?............................................................................................................................................................................................... 88Comment indiquer la position d'un fichier en conservant la portabilité ?......................................................................................................................................................... 88Comment lire des informations sur l'entrée standard ?..................................................................................................................................................................................... 89Comment charger une ressource présente dans le CLASSPATH (répertoire ou jar) ?....................................................................................................................................... 90Comment changer l'encodage d'un fichier texte ?............................................................................................................................................................................................ 90Comment connaître les Charset disponibles et leurs alias ?.............................................................................................................................................................................. 91Peut-on modifier l'encodage de la sortie standard ?......................................................................................................................................................................................... 91

Réseaux.............................................................................................................................................................................................................................................................. 92Comment puis-je faire un 'ping' en Java ?........................................................................................................................................................................................................ 92Comment connaître l'adresse IP de sa machine ?............................................................................................................................................................................................. 92Comment spécifier un proxy pour se connecter à un serveur ?......................................................................................................................................................................... 93Comment envoyer une requête de type POST en utilisant une URL ?.............................................................................................................................................................. 94Comment établir une communication entre une applet et une servlet ?............................................................................................................................................................ 94

L’exécution......................................................................................................................................................................................................................................................... 96Comment créer un programme Java exécutable ?............................................................................................................................................................................................ 96Comment créer un jar exécutable ?.................................................................................................................................................................................................................. 96Comment signer un JAR ?............................................................................................................................................................................................................................... 98Comment obtenir la pile d'exécution d'une méthode ?..................................................................................................................................................................................... 98Comment avoir une seule instance de mon application qui tourne ?................................................................................................................................................................. 99

Système............................................................................................................................................................................................................................................................ 100Comment connaître le système d'exploitation depuis le programme ?............................................................................................................................................................ 100Comment accéder aux valeurs des variables d'environnement ?..................................................................................................................................................................... 100Comment exécuter une application externe ?................................................................................................................................................................................................. 101Comment lancer une application sans le terminal (Windows uniquement) ?.................................................................................................................................................. 101Comment trouver le répertoire contenant le jar où est ma classe ?................................................................................................................................................................. 102Comment faire en sorte que le paramètre int de ma méthode soit modifié en retour ?.................................................................................................................................... 103Comment gérer les fermetures accidentelles ( Contrôle-C et kill -9 ) ?.......................................................................................................................................................... 104Comment forcer le passage du 'Garbage collector' ?...................................................................................................................................................................................... 104Comment faire une énumération en Java ?..................................................................................................................................................................................................... 104Comment recharger dynamiquement une classe ?.......................................................................................................................................................................................... 106

Design patterns................................................................................................................................................................................................................................................. 107Qu'est ce que le pattern Transfer Object?....................................................................................................................................................................................................... 107Quels sont les design patterns que vous connaissez ?..................................................................................................................................................................................... 108Citer les DP des Gang of 4, Etat, singleton, façade........................................................................................................................................................................................ 109

5/122

Questionnaire 2................................................................................................................................................................................................................................................. 109Que permet la classe ThreadLocal ?.............................................................................................................................................................................................................. 109Qu’est ce qu’un template ?............................................................................................................................................................................................................................ 109Qu’est ce que la surcharge des opérateurs ?................................................................................................................................................................................................... 109Une classe abstraite peut-elle étendre une classe concrète ?........................................................................................................................................................................... 109C’est quoi un JSP ?........................................................................................................................................................................................................................................ 109Le Javascript s’exécute côté client ou côté serveur ?...................................................................................................................................................................................... 110Par défaut, les Servlets sont multithreadés ou par instance ?.......................................................................................................................................................................... 110Citez 2 classes emblématiques de Struts........................................................................................................................................................................................................ 110C’est quoi les EJB ?...................................................................................................................................................................................................................................... 110Qu’est ce qu’une classe anonyme ?............................................................................................................................................................................................................... 110Dans quels cas, peut-on attribuer des attributs private ?................................................................................................................................................................................. 111Quelle est le gros inconvénient du « garbage collector » ?............................................................................................................................................................................. 111String, c’est quoi ?........................................................................................................................................................................................................................................ 111Transiant, c’est quoi ?................................................................................................................................................................................................................................... 111Comment stopper le dérivé d’une classe ?..................................................................................................................................................................................................... 111Quelle est la méthode interne de la classe string ?......................................................................................................................................................................................... 111Comment interdire la méthode ?.................................................................................................................................................................................................................... 111C’est quoi synchronized ?.............................................................................................................................................................................................................................. 111La réflexivité, c’est quoi ?............................................................................................................................................................................................................................. 111Connaissez-vous les proxy class ? C’est quoi ?.............................................................................................................................................................................................. 111Quels DP avez-vous utilisés ?........................................................................................................................................................................................................................ 111A faire le Composite en UML ? Quel est l’intérêt de ce patern ?.................................................................................................................................................................. 112L’Abstract Factory, à quoi ça sert ? comment le modéliser ? Pourquoi ce nom Abstract Factory par rapport à Abstract ?..............................................................................112Visiteur : comment ajouter des fonctionnements à une classe sans toucher à la classe ?................................................................................................................................. 113Inconvénient de ce pattern............................................................................................................................................................................................................................. 113Quand la méthode « Finalize » d’un objet est-elle appelée ?.......................................................................................................................................................................... 113On met quoi dans le Finalize ?...................................................................................................................................................................................................................... 114Si une classe comporte un bloc déclaré « static »{}, est-il exécuté à chaque instanciation de celle-ci ? Static, ça sert à quoi ?.......................................................................114Une méthode statique d’une classe peut-elle manipuler les variables non statiques de cette classe ?............................................................................................................. 114Les membres protected d’une classe sont-elles accessibles depuis des classes du même package n’ayant aucune relation d’héritage avec elle  ?............................................1142 instances d’une même classe ne peuvent pas accéder mutuellement à leurs membres privés. Vrai ou faux ?...............................................................................................114Dans quel cas peut-on manipuler des attributs private ?................................................................................................................................................................................. 114Lequel de ces gestionnaires récupère toutes les exceptions ?......................................................................................................................................................................... 114Des classes anonymes sont :.......................................................................................................................................................................................................................... 114Existent-ils des héritages entre tableaux ?...................................................................................................................................................................................................... 114Une classe A peut-elle hériter d’une classe B et d’une classe abstraite C ?..................................................................................................................................................... 114La visibilité par défaut d’un attribut ou d’une fonction est-il protected, private ou public  ?........................................................................................................................... 115Dans une relation d’héritage, certains membres de la classe mère sont inaccessibles à la classe fille. Lesquels sont-ils  ? Les membres protected, private ou les 2................115

6/122

Qu’est-ce qu’un constructeur......................................................................................................................................................................................................................... 115Pouvez-vous me citer les 3 notions de l’objet ?.............................................................................................................................................................................................. 115Définir l'encapsulation................................................................................................................................................................................................................................... 115Expliquez le fonctionnement du BorderLayout (Java Swing)......................................................................................................................................................................... 115Peut-on mettre un Jpanel dans un Jpanel ? Pourquoi? Quelle utilité ?............................................................................................................................................................ 115Que fait la méthode run () d'un Thread (en détail) ?....................................................................................................................................................................................... 115Comment fonctionne un environnement multi-threadé ?................................................................................................................................................................................ 115Comment le gère-t-on? Quelles classes /mécanismes ?................................................................................................................................................................................. 115Comment fonctionne le mode cluster en JBOSS? Détaillez. Expliquer le paramétrage.................................................................................................................................. 115Que contient un Jar? et si le jar contient des javabeans ?............................................................................................................................................................................... 115Citez quelques mots clés de la gestion d'exception........................................................................................................................................................................................ 115Si on a un return () dans le try avant le catch et le finally est-ce que l'on passe dans le finally ?..................................................................................................................... 116Une variable déclarée de type « long » est codée sur :................................................................................................................................................................................... 116A quoi sert la méthode run() d’un thread ?..................................................................................................................................................................................................... 116Différence entre Collection et Collections ?.................................................................................................................................................................................................. 116C’est quoi un DBLink ?................................................................................................................................................................................................................................. 116

Questions personnelles...................................................................................................................................................................................................................................... 116

7/122

Questionnaire 1

Définitions et API J2EE

Qu'est ce que J2EE ?La plateforme Java entreprise (J2EE) est un ensemble de spécifications coordonnées et pratiques qui permettent ensemble des solutions pour le développement, le déploiement, et de la gestion des applications multitiers centralisées sur un serveur. Construit sur la plateforme de Java 2 édition standard (J2SE), la plateforme J2EE ajoute les possibilités nécessaires pour fournir une plateforme complète, stable, sécurisée, et rapide de Java au niveau entreprise. La plateforme entreprise fournit un ensemble de services permettant aux composants de dialoguer entre eux:

HTTP et HTTPS

Java Transaction API (JTA)

Remote Method Invocation/Internet Inter-ORB Protocol (RMI/IIOP)

Java Interface Definition Language (Java IDL)

Java DataBase Connectivity (JDBC)

Java Message Service (JMS)

Java Naming and Directory Interface (JNDI)

API JavaMail et JAF (JavaBeans Activation Framework)

Java API for XML Processing (JAXP)

J2EE Connector Architecture

8/122

Gestionnaires de ressources

Entreprise Java Beans (EJB)

Java Server Pages (JSP)

Servlet

Java API for XML-Based RPC (JAX-RPC)

SOAP with Attachments API for Java (SAAJ)

Java API for XML Registries (JAXR)

Que sont les Servlets ?Techonologie Java utilisée pour effectuer des traitements coté serveur en réponse aux requêtes provenant en général de poste clients distants. Bien que les servlets puissent répondre à n'importe quel type de requête, elles sont généralement employées pour répondre à des requêtes de type HTTP et qui permettent de retourner dynamiquement des pages html.

Que sont les JSP ?Les JavaServerPages (JSP) permettent d'insérer des petits bouts de code Java (scriptlets) directement dans du code html. Une page JSP est un document qui contient deux types de texte:

des données statiques (qui peuvent être exprimées en n'importe quel format texte tel que le HTML, le WML, et le XML)

des éléments de JSP, qui déterminent comment la page construit le contenu dynamique.

Que sont les JSP Taglibs ?Une JSP Taglib est une collection d'actions prédéfinies destinées à être utilisée dans une page JSP sous forme de tag (balise XML). Elle se compose d'un descripteur de taglib (Tag Library Descriptor) et d'un ensemble de classes Java implémentant l'interface JspTag. Le descripteur de taglib (*.tld) est un document XML qui décrit les associations entre les balises et la classe Java.

9/122

Ces actions sont représentées dans le source JSP comme une balise XML. Lors de la compilation de la JSP, ces balises sont remplacées par des appels vers la classe Java correspondante.

On peut citer comme exemple les balises standards préfixées avec jsp : <jsp:useBean id="monBean" scope="session" class="package.MonObject" > <jsp:setProperty name="monBean" property="monAttribut" value="1.0" /></jsp:useBean><jsp:include page="maPage.jsp"/><jsp:redirect page="maPage.jsp"/>etc...

L'utilisation de taglib permet de limiter l'utilisation de code Java dans une page JSP, voir de totalement le supprimer.

Une Taglib est composé de trois éléments:

Le Tag Librarie Descriptor qui effectue le mapping entre les tags et les classes Java.

Les classes Java implémentant les différents Tag (implémentant l'interface Tag, ou une de ses interfaces filles IterationTag et BodyTag.

Les classes Java implémentant TagExtraInfo afin d'apporter des informations supplémentaires sur les tags (optionnel).

Quels sont les objectifs de la JSTL ?Le but de la JSTL est de simplifier le travail des auteurs de page JSP, c'est à dire la personne responsable de la couche présentation d'une application web J2EE.En effet, un web designer peut avoir des problèmes pour la conception de pages JSP du fait qu'il est confronté à un langage de script complexe qu'il ne maîtrise pas forcément.

La JSTL permet de développer des pages JSP en utilisant des balises XML, donc avec une syntaxe proche des langages utilisés par les web designers, et leurs permet donc de concevoir des pages dynamiques complexes sans connaissances du langage Java.

Sun a donc proposé une spécification pour une librairie de tags standard : la Java Standard Tag Library (JSTL). C'est à dire qu'il spécifie les bases de cette librairie, mais qu'il laisse l'implémentation libre (de la même manière que pour les serveurs J2EE qui sont des implémentations de la spécification J2EE).

10/122

Que sont les EJB ?Un composant Entreprise JavaBeans (EJB) est une classe ayant des champs et des méthodes pour mettre en application des modules de la logique métier (Business logic). On peut penser à un entreprise bean comme à un module pouvant être employé seul ou avec d'autres entreprise bean pour exécuter la logique métier sur le serveur J2EE. Il existe actuellement trois types d'entreprise bean :

les bean session (Session Bean)

les bean entité (Entity Bean)

les bean contrôlés par message (Message Driven Bean)

Les entreprise bean interagissent le plus souvent avec des bases de données.

Qu'est ce que JDBC ?JDBC est une API (Application Programming Interface) java disponible depuis la version 1.1 du JDK. Pour note, JDBC est un nom déposé et non un acronyme, même si en général on lui donne la définition suivante : Java DataBase Connectivity.

Cette API est constituée d'un ensemble d'interfaces et de classes qui permettent l'accès, à partir de programmes java, à des données tabulaires (i.e. triées sous forme de table ou de tableur). Par données tabulaires, on entend généralement des bases de données contenues dans des SGBD relationnels. Mais, JDBC n'est pas restreinte à ce type de source de données. On peut aussi accéder à des sources de données sous forme de fichiers (fichiers XML par exemple).

Qu'est ce que JAXP ?JAXP (Java API for XML Processing) est l'API "standard" (appartenant au JDK) pour la manipulation du format XML. Cette API met à la disposition du développeur trois ensembles de fonctionnalités : la modélisation, le parsing et la transformation. Elle est composée de quatre packages principaux.

javax.xml.parsers : Ce package contient un ensemble d'interfaces devant être implémentées par les différents parseurs (SAX ou DOM). Ce

11/122

package fournit aussi un ensemble de factory permettant l'accès aux parseurs.

org.w3c.dom : Ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec DOM (modélisation).

org.xml.sax : Ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec SAX (parsing).

javax.xml.transform : Ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec XSLT (transformation).

Attention, JAXP n'est pas limitée à SAX, DOM, XSLT et ces quatre packages. Elle offre bien plus de fonctionnalités. Il est aussi important de noter que, même si au départ JAXP fut créée comme une API J2EE, elle est désormais intégrée au J2SDK standard.

Qu'est ce que JAXB ?JAXB (Java Architecture for XML Binding) offre les outils et API nécessaires pour "lier" des objets java à des documents XML. JAXB utilise des schémas (W3C XML Schema) pour faire ce lien. Une fois ce lien créé (grâce à un compilateur qui va générer les packages correspondant à un schéma donné), vous pouvez facilement sérialiser/desérialiser les objet java sous un format XML.

Pour le moment, JAXB permet juste de partir d'un Schéma XML pour générer les classes correspondantes (interfaces à implémenter). JAXB 2.0 devrait palier à cette limitation en permettant de créer des schémas à partir de classes Java déjà définies.

Qu'est ce que SAAJ ?SAAJ (SOAP with Attachments API for Java) est une API Java permettant l'envoi et la réception de messages XML sur le réseau. Ces messages obéissent à la spécification SOAP (Simple Object Access Protocol) 1.1.

SAAJ est souvent utilisée par des API de plus haut niveau comme JAXR et JAX-RPC. Mais, elle peut tout à fait être utilisée de manière indépendante.

Qu'est ce que JAXR ?JAXR (Java API for XML Registries) est une API intégrée à J2EE qui permet l'accès à différents types de registres XML. Ces registres XML sont une infrastucture permettant la construction, le déploiement et la découverte de Web services.

12/122

JAXR permet l'interaction avec plusieurs standards, dont UDDI (Universal Description, Discovery, and Integration) et ebXML Registry and Repository standard.

Pour note, JAXR est intégré au JWSDP (Java Web Services Developer Pack), mais il est également téléchargeable séparément.

Qu'est ce que JAX-RPC ?JAX-RPC (Java API for XML-based Remote Procedure Call) est une API permettant de créer des services et clients Web basés XML et RPC.

RPC (Remote Procedure Calls), ou appels de procédures à distance, est un système permettant à des clients d'exécuter des procédures sur des systèmes distants. Ces appels de procédures et les réponses retournées se font grâce au protocole HTTP et à SOAP (messages XML).

Qu'est ce que JAAS ?Java Authentication and Authorisation Service.

Il s'agit d'un package fournissant des services d'authentification (login) et d'autorisation (vérification de permissions pour l'exécution de méthodes).

JAAS fait partie de la distribution de base du SDK depuis la version 1.4 .

JAAS est hautement configurable, et permet aux développeurs d'écrire leurs propres modules.

Généralités applications web

Comment définir une page de bienvenue pour un contexte ?

13/122

Comment modifier le Time Out d'une session ?Dans le fichier web.xml situé dans le répertoire WEB-INF de l'application, il suffit d'ajouter les lignes suivantes:

<session-config> <session-timeout>60</session-timeout> </session-config>

L’unité du session-timeout est la minute.On peut également, le modifier par programmation comme ceci

request.getSession().setMaxInactiveInterval(int);

Comment connaître le navigateur utilisé par un utilisateur ?Cette information peut être retrouvée dans le header de la requête:

String browser = request.getHeader("user-agent");

Comment charger des servlets de l'application au démarrage du conteneur ?Dans le fichier web.xml du répertoire WEB-INF lors de la déclaration du servlet, rajouter la ligne:

<load-on-startup>1</load-on-startup>

Exemple:<servlet> <servlet-name>Controller</servlet-name> <display-name>Controller</display-name> <servlet-class>com.company.Controller</servlet-class> <init-param> <param-name>index</param-name> <param-value>/index.jsp</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet>

Quelles sont les différentes portées existantes ?Les objets créés que ce soit dans les JSP ou les Servlets ont une certaine portée, c'est à dire une certaine durée de vie.Les différentes portées existantes sont:

page: les objets ne sont accessibles que dans la page où ils sont définis

14/122

request: les objets sont accessibles pendant toute la durée de la requête

session: les objets sont accessibles pendant toute la durée de la session

application: les objets sont accessibles pendant toute la durée de vie de l'application et dans l'application complète

Comment partager le context entre 2 webapps, avec Tomcat ?Voici un exemple des lignes à rajouter dans le fichier conf/server.xml:

<Context path="/webapp1" docBase="webapps/webapp1" crossContext="true" debug="0" reloadable="true" > </Context> <Context path="/webapp2" docBase="webapps/webapp2" crossContext="true" debug="0" reloadable="true" > </Context>

Ne pas oublir d'inclure dans le <Context> l'attribut:crossContext="true"

Ensuite au niveau de la servlet on accède à la seconde webapp de la manière suivante:ServletContext myContext = this.getServletContext(); ServletContext otherContext = myContext.getContext("/webapp1");

Servlets

C’est quoi un servlet ? Quelles sont les méthodes emblématiques des servlets ?Techonologie Java utilisée pour effectuer des traitements coté serveur en réponse aux requêtes provenant en général de poste clients distants. Bien que les servlets puissent répondre à n'importe quel type de requête, elles sont généralement employées pour répondre à des requêtes de type HTTP et qui permettent de

15/122

retourner dynamiquement des pages html.

cinq méthodes :

la méthode init()

la méthode service()

la méthode getServletConfig()

la méthode getServletInfo()

la méthode destroy()

la méthode init()

La méthode init() est appelée par le conteneur à chaque instanciation de la servlet public void init(ServletConfig config)

throws ServletExceptionLors de l'instanciation, le conteneur de servlet passe en argument à la méthode init() un objet ServletConfig permettant de charger des paramètres de configuration propres à la servlet.

En cas d'anomalie lors de l'appel de la méthode init(), celle-ci renvoie une exception de type ServletException et la servlet n'est pas initialisée.

la méthode getServletConfig()

La méthode getServletConfig() public ServletConfig getservletConfig()

la méthode service()

La méthode service() est appelée à chaque requête d'un client. public void service(ServletRequest req, ServletResponse res)

throws ServletException, IOExceptionLes objets ServletRequest et ServletResponse sont automatiquement passés en paramètre à la méthode service() par le conteneur. la méthode destroy()

La méthode destroy() est appelée par le conteneur lors de l'arrêt du serveur Web. public void destroy()La méthode destroy() attend la fin de tous les threads lancés par la méthode service() avant de mettre fin à l'exécution de la servlet.

16/122

Fournir des informations sur la servlet

Certaines applications (comme Java Web Server Administration Tool) permettent d'obtenir des informations sur la servlet et de les afficher.

La méthode getServletInfo() lorsqu'elle est surchargée permet de retourner cette information sous forme d'objet String (elle retourne null par défaut). public String getServletInfo()

Voici un exemple d'utilisation de cette méthode : public class MaClasse extends HttpServlet {

...public String getServletInfo() {

return "infos de la servlet";

Quelle est l'utilité des sessions ?La plupart des applications web utilisent le protocole HTTP. Malheureusement ce protocole est ce que l'on appelle un protocole sans état, c'est à dire que le serveur web ne maintient pas les informations à propos du client entre deux requêtes. De ce fait le serveur ne sait pas déterminer si une requête ou une réponse provient du même client. C'est pour cela que les applications web utilisent le concept de session. Une session représente l'ensemble des interactions pouvant intervenir entre un client et le serveur

Comment créer un objet session ?Il existe deux méthodes permettant de créer des sessions :

HttpSession getSession()et

HttpSession getSession(boolean)Voici un petit exemple permettant de comprendre la différence entre ces 2 méthodes

// Si la session existe, ces 2 méthodes renvoient la session existante, sinon ces 2 méthodes créent une nouvelle sessionHttpSession session = request.getSession();

HttpSession session = request.getSession(true)

// Si la session existe, cette méthode renvoie la session existante, sinon la méthode retourne la valeur nullHttpSession session = request.getSession(false);

17/122

Comment les sessions sont-elles gérées ?Il existe 2 moyens de gérer les sessions :

à l'aide de cookies

à l'aide de la réécriture d'URL

Cookies

A chaque session créée, le serveur envoie un identificateur (sous la forme d'un cookie) correspondant au client. Ensuite le client renverra ce cookie au serveur lors de sa prochaine requête permettant ainsi au serveur d'identifier le client.

Voici un petit exemple permettant d'ajouter un cookie dans l'entête de la réponse. javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("user","abc123456");response.addCookie(cookie);

Mais il arrive assez souvent que le client refuse de recevoir des cookies. Dans ce cas il vous reste une 2è solution qui consiste en la réécriture d'URL

Réécriture d'URL

Par cette technique le serveur ajoute l'identificateur de session à la fin de chaque URL des pages envoyées par celui-ci. Mais malheureusement cette technique a un coût car le serveur doit effectuer une opération supplémentaire. Celui-ci doit personnifier l'url en y incluant l'identifiant de session.2 méthodes existent pour individualiser les URL:

encodeURL(String)et

encodeRedirectURL(String)Ces méthodes réécrivent l'URL uniquement si le client n'accepte pas les cookies. Dans l'autre cas les URL resteront inchangées.La 2è méthode est utilisée lorsque la servlet utilise la méthode

sendRedirect(String)Exemple :

response.sendRedirect(response.encodeRedirectURL("maServlet");

Quelle est la différence entre les méthodes doGet() et doPost() ?doGet() est appelée à la suite d'une requête de type HTTP GET. Cela se passe généralement lorsqu'un utilisateur clique sur un lien ou lorsque celui-

18/122

ci entre une URL dans la barre d'adresse du navigateur.

La méthode doPost() est appelée en réponse d'une requête HTTP POST.

Les 2 méthodes sont appelées à partir de l'implémentation par défaut de la méthode service() se trouvant dans la classe de base HttpServlet

Fondamentalement le navigateur demande toujours des pages par l'intermédiaire de GET et peut envoyer des données sous les 2 formes GET et POST. Les 2 seules différences résident dans le fait que :

GET est restreint au niveau de la taille des paramètres envoyés au serveur. Cela veut dire qu'il est, la plupart du temps, préférable d'envoyer des données avec la méthode POST.

En envoyant des données par l'intermédiaire de GET évoque également une question concernant la sécurité puisqu'elles sont ajoutées à la suite de l'URL. Pour cette raison il est plus prudent d'utiliser la méthode POST pour envoyer des données au serveur.

Pourquoi n'y a-t-il pas de constructeur dans une servlet ?Un servlet est un peu comme un applet par le fait qu'elle possède une méthode init() qui agit en tant que constructeur. Puisque l'environnement de servlet prend soin d'instancier la servlet, un constructeur explicite n'est pas nécessaire. N'importe quel code d'initialisation que vous devez utiliser devrait être placé dans la méthode init() puisque cette méthode est appelée lorsque le servlet est chargée par le conteneur de servlet.

Comment connaitre la version de l'API servlet utilisée par un moteur de servlet ?L'interface ServletContext inclut les méthodes getMajorVersion() et getMinorVersion() pour vous indiquer quelle version de l'API Servlet est utilisée.

Un petit exemple : //Si le moteur de servlet implémente la spec 2.4 de l'API servlet//majorVersion est égal à 2int majorVersion = getServletContext().getMajorVersion();//minorVersion est égal à 4int minorVersion = getServletContext().getMinorVersion();

Comment accéder à un JavaBean depuis une servlet ?Pour pouvoir partager des variables entre vos pages JSP et vos servlets, vous devez savoir comment créer et accéder à ces variables depuis vos servlets.

19/122

Les différents exemples qui vont suivre dépendent de la portée, ou si vous préférez, la durée de vie de vos objets.

page :

Dans cet exemple, le Bean est instancié comme une variable locale est n'est donc pas partageable entre différentes servlets.com.developpez.beans.MyBean myBean = new com.developpez.beans.MyBean();

request :

Dans cet exemple, le Bean instancié sera accessible pendant toute la durée de la requêtecom.developpez.beans.MyBean myBean = (com.developpez.beans.MyBean) request.getAttribute("myBean");if (myBean == null) { myBean = new com.developpez.beans.MyBean();request.setAttribute("myBean", myBean); }

session :

Dans cet exemple, lorsque le Bean est instancié il est placé dans la session actuelle.HttpSession session = request.getSession(true);com.developpez.beans.MyBean myBean = (com.developpez.beans.MyBean) session.getAttribute("myBean");if (myBean == null) { myBean = new com.developpez.beans.MyBean();session.setAttribute("myBean", myBean); }

application :

Dans ce dernier exemple, lorsque le Bean est instancié il est placé dans le contexte de la servlet.com.developpez.beans.MyBean myBean = (com.developpez.beans.MyBean) getServletContext().getAttribute("myBean");if (myBean == null) { myBean = new com.developpez.beans.MyBean();getServletContext().setAttribute("counter", counter); }

20/122

Quel est l'objet ServletConfig et quelle est son utilité ?L'objet ServletConfig est une interface. Cette interface contient les 4 méthodes suivantes

getInitParameter(java.lang.String name)

o Cette méthode retourne un String contenant le paramètre d'initialisation de la servlet correspondant au paramètre name

getInitParameterNames()

o Cette méthode retourne un objet Enumération contenant les paramètres d'initialisation de la servlet

getServletContext()

o Cette méthode retourne une référence de l'interface ServletContextC'est la méthode la plus valable car elle permet de partager l'information à travers l'application

getServletName()

o Cette méthode retourne un String contenant le nom de l'instance de la servlet

Comment uploader un fichier depuis une applet vers une servlet ?Coté applet :

URL urlservlet = new URL("http://localhost:8080/imed/ImageMapServlet"); HttpURLConnection connExtension = (HttpURLConnection)urlservlet.openConnection(); FileInputStream in = new FileInputStream(image); in.read(tableauImage); in.close(); HttpURLConnection connImage = (HttpURLConnection)urlservlet.openConnection(); connImage.setDoInput(true); connImage.setDoOutput(true); connImage.setUseCaches(false);

21/122

connImage.setRequestProperty("Content-Type","application/octet-stream"); DataOutputStream out = new DataOutputStream(connImage.getOutputStream()); out.write(tableauImage, 0, tableauImage.length); out.flush(); out.close();

Coté servlet// Récupération du flux entrant java.io.DataInputStream dis = new java.io.DataInputStream(request.getInputStream()); dis.readFully(temp); dis.close();

// Ecriture du fichier image sur le serveur File cibleServeur = new File("/repertoire/nomfichier"); FileOutputStream fos = new FileOutputStream(cibleServeur); fos.write(temp); fos.close();

Comment télécharger un fichier depuis une servlet ?Voici un exemple de code permettant de télécharger un fichier depuis le serveur vers le poste client

response.setContentType("application/download"); response.setHeader("Content-Disposition", "attachment;filename=\"" + filename + "\"");

ServletOutputStream out = response.getOutputStream(); File file = null; BufferedInputStream from = null; try { //dans mon cas le filepath et le path complet après création d'un temp file file = new File(filepath); response.setContentLength((int) file.length()); int bufferSize = 64 * 1024; long time = System.currentTimeMillis(); try { from = new BufferedInputStream(new FileInputStream(file), bufferSize * 2); byte[] bufferFile = new byte[bufferSize]; for (int i = 0; ; i++)

22/122

{ int len = from.read(bufferFile); if (len < 0) break; out.write(bufferFile, 0, len); } out.flush(); } finally { try { from.close(); } catch (Exception e) { } try { out.close(); } catch (Exception e) {} } time = (System.currentTimeMillis() - time) / 1000; // seconds download double kb = (file.length() * 1.0 / 1024); if (file != null) file.delete(); } catch (Exception e) { return; } finally { try { file.delete();} catch (Exception ex) {} }

Comment placer et récupérer un paramètre d'initialisation d'une servlet ?Placer la définition <init-param> dans la description de votre servlet dans le fichier web.xml comme ceci

<servlet> <servlet-name>maServlet</servlet-name> <display-name>Ma Servlet</display-name> <description>Ce que fait ma servlet</description> <servlet-class>com.servlet.MaServlet</servlet-class> <init-param> <param-name>MON_PARAM</param-name> <param-value>Bonjour</param-value> </init-param> </servlet>

Puis dans le code de votre servlet, utilisez ceci pour récupérer la valeur de MON_PARAM getInitParameter("MON_PARAM");

23/122

Si vous désirez mettre plus de paramétres, il suffit d'ajouter des déclarations <init-param> comme ceci <servlet> <servlet-name>maServlet</servlet-name> <display-name>Ma Servlet</display-name> <description>Ma Servlet</description> <servlet-class>com.servlet.MaServlet</servlet-class> <init-param> <param-name>MON_PARAM</param-name> <param-value>Bonjour</param-value> </init-param> <init-param> <param-name>MON_PARAM_2</param-name> <param-value>Bonjour</param-value> </init-param> </servlet>

JSP (Java Server Pages)

Comment mettre un header et un footer a chaque jsp ?(si on est en jsp 2.0 (tomcat 5.0 par exemple))

dans web.xml <jsp-config> <jsp-property-group> <url-pattern>*.jsp</url-pattern> <include-prelude>/includes/header.jsp</include-prelude> <include-coda>/includes/footer.jsp</include-coda> </jsp-property-group> </jsp-config>

Créer sa propre page d'erreur ?Voici la page d'erreur que l'on utilise. Elle n'est utile qu'en phase de développement. Mais elle permet de déterminer rapidement les problèmes qui peuvent surgir.

24/122

<%@ page language="java" isErrorPage="true" %> <!DOCTYPE HTML PUBLIC "-//w3c//dtd html 4.0 transitional//en"> <html> <head> <title>Page d'erreur</title> </head> <body bgcolor="#FFFFFF"> <div>Une erreur s'est produite !</div>

<h1>Attribut de requete</h1> <div class="requestAttributs"> <% java.util.Enumeration en= request.getAttributeNames(); while (en.hasMoreElements()) { String name = (String) en.nextElement(); if(request.getAttribute(name) == null) { %> <div><%=name%>=null</div> <% } else { %> <div><%=name%>=<%=request.getAttribute(name).toString()%></div> <% } } %> </div>

<div class="requestParameters"> <% en= request.getParameterNames(); while (en.hasMoreElements()) { String name = (String) en.nextElement(); if(request.getParameter(name) == null) { %> <div><%=name%>=null</div> <% } else {

25/122

%> <div><%=name%>=<%=request.getParameter(name).toString()%></div> <% } } %> </div>

<h1>Exception</h1> <div> <% Throwable th = pageContext.getException(); if(th != null) { printRecursiveException(out,th); } %> </div>

<%! public void printRecursiveException(JspWriter out, Throwable th) throws java.io.IOException { out.println("<div>" + th.getClass().getName() + ":" + th.getMessage() + "</div>"); StackTraceElement ste; for(int x=0;x < th.getStackTrace().length;x++) { out.println("<div>" + th.getStackTrace()[x].toString() + "</div>"); } Throwable parent = th.getCause(); if(parent != null) { out.println("<div class=\"parentCause\">"); printRecursiveException(out,parent); out.println("</div>"); } } %> </body> </html>

26/122

Comment appliquer ma page d'erreur à toutes mes pages JSP ?<error-page> <exception-type>java.lang.Throwable</exception-type> <location>/error.jsp</location> </error-page>

Note: L'insertion doit se faire entre session-config et ressource-ref mais je ne suis pas sur que ça soit le session-config et ressource-ref qui entourent directement cette balise.

Comment afficher tous les paramêtres d'une requete ?Enumeration en = request.getParameterNames(); while (en.hasMoreElements()) { String pName = (String) en.nextElement();

log.debug(pName + "=" + request.getParameter(pName)); // System.out.println(pName + "=" + request.getParameter(pName)); }

Comment afficher tous les attributs du scope request ?java.util.Enumeration en= request.getAttributeNames(); while (en.hasMoreElements()) { String name = (String) en.nextElement(); if(request.getAttribute(name) == null) { log.debug(name + "=NULL"); } else { log.debug(name + "=" + request.getAttribute(name).toString()); } }

Que sont les objets implicites?Des objets sont dit implicites car il n’est pas nécessaire de les déclarer ou de les initialiserLes objets les plus souvent utilisés sont:

27/122

request: lorsqu'un navigateur envoie une requête vers le serveur, il est possible que celui-ci envoie un certain nombre de paramètres.Il existe deux sortes de paramètres:

o Les paramètres se trouvant dans l'URL comme par exemple http://www.monsite.com/path/de/ma/page?param1=valeur1&param2=valeur2

o Les paramètres de formulaire: ces derniers sont transmis dans le corps de la requête

response: cet objet contient la réponse envoyée au client. La portée de cette instance est la page

out: peut être employé dans les scriptlets pour écrire des données dans la page qui sera envoyée au client. La portée de cette instance est la page

session: cet objet contient, comme son nom l'indique, tous les objets relatifs à la session

Comment utiliser une librairie de tag (taglib) ?Une librairie de tag peut être distribuée sous deux formes :

Le descripteur de fichier est séparé des classes Java...

Le descripteur de fichier est inclut dans le Jar avec les classes et possède le nom suivant : "META-INF/taglib.tld".

Afin de pouvoir utiliser cette taglib dans un fichier JSP, il faut la déclarer avec la directive taglib. Respectivement avec le code suivant :

<%@ taglib uri="/WEB-INF/taglib-v1.0.tld" prefix="tag-prefix" %>ou

<![CDATA[<%@ taglib uri="/WEB-INF/lib/taglib-v1.0.jar" prefix="tag-prefix" %>]]>

Toutefois, il est préférable de ne pas utiliser ces notations sous cette forme.En effet, étant donné que la directive taglib doit être présente sur toutes les pages JSP qui l'utilisent, les modifications du nom du descripteur de taglib pourraient être longues et pénibles.Afin de faciliter la maintenance, il faut déclarer la taglib dans le fichier web.xml :

<![CDATA[<taglib>

28/122

<taglib-uri>taglib-URI</taglib-uri> <taglib-location>/WEB-INF/lib/taglib-v1.0.jar</taglib-location></taglib>]]>

Et utiliser l'URI dans les JSP :<![CDATA[<%@ taglib uri="taglib-URI" prefix="tag-prefix" %>]]>

Ainsi, les changements de fichier de descripteur s'effectuent seulement dans le fichier web.xml...

Enfin, pour utiliser les tags de la librairie, il suffit de les préfixer par le préfixe indiqué dans la directive taglib :<![CDATA[<tag-prefix:nom-du-tag param="valeur"/>]]>

Comment l'interface Tag fonctionne-t-elle ?L'évaluation d'un Tag JSP aboutit aux appels suivants :

Les méthodes setParent(Tag) et setPageContext(PageContext) sont renseignées, ainsi que d'éventuels attributs présents dans le tag.

La méthode doStartTag() est appelée. Son code de retour détermine l'affichage du contenu de la balise. Si le retour vaut Tag.EVAL_BODY_INCLUDE, le corps est évalué et écrit dans le JspWriter de la page, mais il est ignoré si il vaut Tag.SKIP_BODY. Si Tag.EVAL_BODY_INCLUDE est retourné alors que la balise n'a pas de corps, il est ignoré.

La méthode doEndTag() est appelée. Son code de retour détermine si le reste de la page doit être évalué ou pas. Si le retour vaut Tag.EVAL_PAGE, le reste de la page est évalué, mais il est ignoré si le retour vaut Tag.SKIP_PAGE.

Enfin, la méthode release() est appelée avant que l'objet ne soit rendu au garbage collector.Attention toutefois, afin d'éviter trop d'allocation, les tags sont conservés en cache et réutilisés (tout comme les Servlet/JSP)...

La classe javax.servlet.jsp.tagext.TagSupport propose une implémentation par défaut de l'interface Tag (et de son interface fille IterationTag).

Comment l'interface IterationTag fonctionne-t-elle ?L'interface IterationTag étend l'interface Tag. Elle hérite donc de toutes ses propriétés et permet d'effectuer des itérations sur le contenu de la balise :

La méthode doAfterBody() est appelée après chaque affichage du corps du tag. Son code de retour détermine si le corps doit être réévalué ou pas.

29/122

Si le retour vaut IterationTag.EVAL_BODY_AGAIN, le corps sera réévalué, mais si le retour vaut Tag.SKIP_BODY, on passe à la fin du tag (doEndTag()) sans réévaluer le corps. La classe javax.servlet.jsp.tagext.TagSupport propose une implémentation par défaut de l'interface IterationTag.

Comment l'interface BodyTag fonctionne-t-elle ?L'interface BodyTag étend l'interface IterationTag. Elle hérite donc de toutes ses propriétés, mais permet plus de traitement sur le corps de la balise :

La méthode doStartTag() peut désormais retourner BodyTag.EVAL_BODY_BUFFERED.Dans ce cas (et dans ce cas seulement), les méthodes setbodyContent() puis doInitBody() sont appelées avant la première évaluation du corps de la balise.La méthode setBodyContent() permet au serveur d'application d'indiqué un buffer qui sera utilisé pour écrire le contenu du corps.La méthode doInitBody() est appelée avant la première évaluation du corps du message.

La classe javax.servlet.jsp.tagext.BodyTagSupport propose une implémentation par défaut de l'interface BodyTag.

Comment écrire le descripteur de taglib (TLD) ?Le Tag Library Descriptor décrit les différents tag de la librairie.Il s'agit d'un fichier XML qui prend la forme suivante :

<?xml version="1.0" encoding="ISO-8859-1" ?><!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN" "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">

<taglib> <tlibversion>1.0</tlibversion> <jspversion>1.1</jspversion> <shortname>name</shortname> <uri></uri> <info>Description de la taglib</info> <tag>...</tag>*</taglib>

Après l'entête XML et la déclaration du doctype, on a les éléments suivants :

30/122

tlibversion : Numéro de version de la librairie.

jspversion : Version minimum des JSP requise pour pouvoir utiliser la librairie (optionnel, défaut: 1.1).

shortname : Indique le préfixe par défaut de la librairie pour les EDI compatible (ceci n'est qu'à titre indicatif, le préfixe de la directive <%@ taglib %> est utilisé).

uri : Une URI unique qui identifie cette version de la taglib (optionnel).

info : Un texte de description de la taglib (optionnel).

tag : Un ou plusieurs mapping de balise avec les classes Java.

Dans un Jar, ce fichier doit se situer dans le répertoire META-INF avec le nom taglib.tld afin de pouvoir référencer directement le fichier Jar.

Comment faire le mapping entre un nom de balise et une classe Tag ?Dans le fichier TLD, il faut ajouter, pour chaque tag, les balises suivantes :

<tag> <name>name</name> <tagclass>package.NameTag</tagclass> <teiclass>package.NameTEI</teiclass> <bodycontent>JSP</bodycontent> <info>description</info>

<attribute> <name>arg1</name> <required>false</required> <rtexprvalue>true</rtexprvalue> </attribute></tag>

Avec les éléments suivants :

name : Nom de la balise (Utilisation: <taglib-prefix:nom/>).

31/122

tagclass : Nom de la classe Java qui représente cette balise (hérite de Tag).

teiclass : Nom de la classe Java qui fournit des informations complémentaire sur la balise (optionnel).

bodycontent : Type de contenu que peut accepter la balise, peut prendre les valeurs empty (pas de corps), JSP (le contenu est interprété comme du JSP), ou tagdependent (le contenu n'est pas interprété) (optionnel, défaut: JSP).

info : Un texte de description du tag (optionnel).

attribute : Zéro, une, ou plusieurs déclarations d'attribut du tag, décomposé de la manière suivante :

o name : Nom de l'attribut. La classe tagclass doit posséder un mutateur pour cet attribut.

o required : true/false, indique si l'attribut est obligatoire ou pas (optionnel, défaut: false)

o rtexprvalue : true/false, indique si l'attribut peut être le résultat d'une expression (${bean} ou <%=bean%>) ou si il doit être une chaine statique (optionnel, défaut: false/valeur statique)

Comment écrire un Tag ?Exemple simple, un tag vide (sans contenu ni attribut) qui affiche simplement la chaine "Hello World".Le code pourrait se limiter a cela :

public class HelloTag extends TagSupport {

public int doStartTag() throws JspException { try { pageContext.getOut().println ("Hello World !"); } catch (IOException e) { throw new JspException ("I/O Error", e); } return Tag.SKIP_BODY; }}

Explication:

32/122

On étend TagSupport afin de bénéficier des implémentations par défaut des méthodes de Tag.

On surcharge doStartTag(), dans lequel on se contente d'écrire la chaine "Hello World" dans la sortie de la page courante (pageContext est initialisé par l'implémentation par défaut de setPageContext()).

On retourne Tag.SKIP_BODY car on ne veut pas traiter le corps de la balise.

Il est inutile de surcharger doEndTag() car son implémentation par défaut retourne Tag.EVAL_PAGE.

Notre descripteur de fichier complet ressemble à ceci :<?xml version="1.0" encoding="ISO-8859-1" ?><!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN" "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">

<taglib> <tlibversion>1.0</tlibversion> <jspversion>1.1</jspversion> <shortname>tex</shortname> <uri></uri> <info>Taglib d'exemple</info> <tag> <name>hello</name> <tagclass>HelloTag</tagclass> <bodycontent>empty</bodycontent> </tag></taglib>

Le fait de spécifier un bodycontent empty permet de lancer une exception à la compilation si le tag possède un contenu quelconque...

Notre page JSP pourrait ressembler à ceci : <%@ taglib uri="taglib-URI" prefix="p" %><html><body> <b><p:hello/></b></body></html>

donnera l'affichage suivant :

33/122

Hello World !

Comment utiliser des attributs de balise ?Cet exemple se base sur l'exemple précédent.Nous allons améliorer notre tag précédent en lui ajoutant un attribut name.Si name est présent, on devra afficher "Hello " suivi de la valeur de l'attribut name, sinon on affiche "Hello World".

Le code précédent devient : public class HelloTag extends TagSupport { private String name = null; public void setName(String string) { name = string; }

public int doStartTag() throws JspException { if (name==null) name = "World"; try { pageContext.getOut().println ("Hello " + name + " !"); } catch (IOException e) { throw new JspException ("I/O Error", e); } return SKIP_BODY; }}

Explication:

On ajoute une variable name ainsi que son mutateur setName().Le mutateur setName() est obligatoire car il sera utilisé afin d'initialiser l'attribut de classe name avec la valeur de l'attribut du tag, avant d'appeller doStartTag().

Dans doStartTag(), on affiche "Hello " + name + " !"...

enfin, on modifie le TLD de la manière suivante :

34/122

<tag> <name>hello</name> <tagclass>HelloTag</tagclass> <bodycontent>empty</bodycontent> <attribute> <name>name</name> </attribute> </tag>

Ainsi la page JSP :<%@ taglib uri="taglib-URI" prefix="p" %><html><body> <b><p:hello/></b><br/> <b><p:hello name="Fred"/></b><br/></body></html>

donnera l'affichage suivant :Hello World !Hello Fred !

Comment créer un tag conditionnel ?On peut avoir besoin d'exécuter une portion de code seulement si une condition est vérifiée.Par exemple, on va exécuter le corps d'un tag seulement si l'attribut indiqué en paramètre est présent dans la session :

public class IsPresentTag extends TagSupport { private String name = "World"; public void setName(String string) { name = string; }

public int doStartTag() throws JspException { if (name==null) throw new JspException ("name est null !"); if ( pageContext.getAttribute(name,PageContext.SESSION_SCOPE) != null ) return EVAL_BODY_INCLUDE; return SKIP_BODY;

35/122

}}

ainsi le code suivant :<p:isPresent name="infoConnection"> [ Vous êtes en ligne ]</p:isPresent>

remplace le scriplet suivant :<% if ( session.getAttribute("infoConnection") ) { %> [ Vous êtes en ligne ]<% } %>

Comment créer un tag itératif ?Afin de créer un tag itératif, il faut implémenter l'interface IterationTag.Toutefois, TagSupport implémente déjà cette interface, on pourra donc étendre cette classe afin de bénéficier des méthodes par défaut...

Notre tag itératif effectuera un certain nombre de boucle selon un paramètre count.Son mapping serait :

<tag> <name>iterate</name> <tagclass>IterateTag</tagclass> <bodycontent>JSP</bodycontent> <attribute> <name>count</name> <required>true</required> </attribute> </tag>

Et son code source : public class IterateTag extends TagSupport { private int count = 0; private int current;

public void setCount(int i) { count = i; }

public int doStartTag() throws JspException {

36/122

current = 0; if (current < count) return Tag.EVAL_BODY_INCLUDE; return Tag.SKIP_BODY; } public int doAfterBody() throws JspException { current++; if (current < count) return IterationTag.EVAL_BODY_AGAIN; return Tag.SKIP_BODY; }}

Explication :

L'attribut count contiendra la valeur de l'attribut de la balise.Il n'y a pas de conversion String/int à effectuer car elle est automatique puisque le mutateur prend un int en paramètre.En cas de valeur incorrecte, une exception est lancée...

Dans doStartTag(), on initialise current qui contiendra le nombre de ligne déjà affiché. Il est important de l'initialisé dans doStartTag() car la même instance de Tag peut être utilisé plusieurs fois...

Utilisation : <p:iterate count="3">Cette ligne sera affichée trois fois<br/></p:iterate>

Résultat:Cette ligne sera affichée trois foisCette ligne sera affichée trois foisCette ligne sera affichée trois fois

Comment interagir avec le contenu du tag ?Il peut être intéressant d'interagir avec le corps de la balise.Par exemple, dans le cas d'un tag itératif, on peut avoir besoin du numéro de ligne courant dans le body.

Pour cela, il suffit de stocker des éléments dans un des scopes (page, request, session, application)...

On reprend donc le tag précédent et on met le numéro de la ligne dans le scope "page".

37/122

Notre code devient alors :public class IterateTag extends TagSupport { private int count = 0; private int current = 0;

public void setCount(int i) { count = i; }

public int doStartTag() throws JspException { current = 0; if (current < count) { pageContext.setAttribute("line", new Integer(current) ); return Tag.EVAL_BODY_INCLUDE; } return Tag.SKIP_BODY; } public int doAfterBody() throws JspException { current++; if (current < count) { pageContext.setAttribute("line", new Integer(current) ); return IterationTag.EVAL_BODY_AGAIN; } return Tag.SKIP_BODY; } public int doEndTag() throws JspException { pageContext.removeAttribute("line"); return Tag.EVAL_PAGE; }}

Explication:

Avant chaque évaluation du corps, on place dans le scope "page" un attribut "line" contenant un Integer contenant le numéro de ligne courante.

38/122

Dans doEndTag(), on supprime cet attribut afin de ne pas 'polluer' inutilement le reste de la page.

Note : On peut également proposer un attribut supplémentaire afin de changer le nom de l'attribut stocké dans le scope "page", ainsi que le scope à utiliser...

Utilisation :<p:iterate count="3">Ligne numéro <%=pageContext.getAttribute("line")%></p:iterate>

Résultat :Ligne numéro 0Ligne numéro 1Ligne numéro 2

Comment définir/modifier des variables de script dans un Tag ?Il est possible de définir ou de modifier des variables de script via un Tag JSP.Dans l'exemple précédent, l'interaction entre le Tag et la page JSP se fait en récupérant la référence de l'objet avec un getAttribute().Afin de permettre l'utilisation d'une variable de script, nous allons créer une classe qui étend TagExtraInfo :

public class IterateTEI extends TagExtraInfo {

public VariableInfo[] getVariableInfo(TagData data) { VariableInfo[] info = new VariableInfo[1]; info[0] = new VariableInfo ("line", "java.lang.Integer", true, VariableInfo.NESTED); return info; }}

Explication :

La méthode getVariableInfo() permet de définir des variables de script créée ou modifiée par le Tag. Elle retourne un tableau de VariableInfo, qui est constitué de quatre éléments :

Le nom de la variable de script.

Le nom du type de l'objet de la variable.

Un booléen indiquant si il s'agit d'une nouvelle variable ou pas (c'est à dire si elle doit être déclaré).

39/122

Enfin, le dernier argument définit le bloc dans lequel la variable sera accessible, il peut prendre les valeurs suivantes :

o VariableInfo.AT_BEGIN : La variable est définit au début du tag et accessible jusqu'à la fin du bloc qui contient le tag.

o VariableInfo.AT_END : La variable est définit à la fin du tag et accessible jusqu'à la fin du bloc qui contient le tag.

o VariableInfo.NESTED : La variable est définit au début du tag et accessible seulement dans le corps du tag.

Attention, le nom de la variable de script doit correspondre à un élément dans un des scope (dans l'ordre: page, request, session, application).La variable de script est synchronisée avec son équivalent dans le scope, donc il peut y avoir un conflit si le même nom est utilisé dans deux scopes différents.

Pour pouvoir utiliser cette variable, il faut ajouter la balise <tei-class> dans la définition du tag dans le TLD : <tag> <name>iterate</name> <tagclass>IterateTag</tagclass> <teiclass>IterateTEI</teiclass> <bodycontent>JSP</bodycontent> <attribute> <name>count</name> <required>true</required> </attribute> </tag>

Pour pouvoir utiliser le code suivant :<p:iterate count="3">Ligne numéro <%=line%> <br/></p:iterate>

Résultat :Ligne numéro 0Ligne numéro 1Ligne numéro 2

Note :La méthode getVariableInfo() possèdent un TagData qui permet d'accéder aux attributs du tag, afin de pourvoir changer dynamiquement le nom de la scriplet selon un attribut par exemple.

Comment modifier le corps du tag ?On peut donc modifier le corps du Tag avant de l'écrire dans la page JSP.

40/122

Par exemple, on va faire un Tag pour empêcher une partie de code HTML d'être interprété par le navigateur (c'est à dire en remplaçant les caractères < et > par < et >...).

On utilisera pour cela la lecture bufférisé de l'interface BodyTag en héritant de son implémentation BodyTagsupport : public class HtmlCodeTag extends BodyTagSupport { public int doStartTag() throws JspException { return BodyTag.EVAL_BODY_TAG; }

public int doAfterBody() throws JspException { try { String bodyString = getBodyContent().getString(); bodyString = bodyString.replaceAll("<", "<"); bodyString = bodyString.replaceAll(">", ">"); bodyString = bodyString.replaceAll("\t", " "); bodyString = bodyString.replaceAll("\n", "<br/>\n"); getPreviousOut().println(bodyString); } catch (IOException e) { throw new JspException (e); } return SKIP_BODY; }

}Dans le TLD :

<tag> <name>htmlCode</name> <tagclass>HtmlCodeTag</tagclass> </tag>

Explication : La méthode doStartTag() retourne BodyTag.EVAL_BODY_TAG afin d'utiliser l'évaluation bufférisé du corps du Tag. Dans la méthode doAfterBody(), on récupère le corps du tag évalué en String. On modifie ensuite cette String pour remplacer les caractères "<", ">", "\t" et "\n" par du code HTML. Puis on affiche la chaîne ainsi transformé... Note : Avec les JSP 1.2, BodyTag.EVAL_BODY_TAG est déprécié et est remplacé par BodyTag.EVAL_BODY_BUFFERED. A l'utilisation, cela donne :

<p:htmlcode> <h1>Example HTML</h1> <p>Un paragraphe de texte avec des mots en <b>gras</b>,

41/122

et d'autres en <i>italique</i>... </p></p:htmlcode>

Et on obtient :<h1>Example HTML</h1> <p>Un paragraphe de texte avec des mots en <b>gras</b>, et d'autres en <i>italique</i>... </p>

Le fait de pouvoir modifier le corps du Tag apporte un plus indéniable par rapport à l'interface Tag ou IterationTag. En effet, on peut facilement modifier le corps AVANT de l'écrire sur la page JSP. De ce fait, on peut réellement changer le formatage du corps dans on ensemble...

Comment valider les attributs du tag avec TagExtraInfo ?La classe TagExtraInfo permet également de valider les attributs du tag avant de l'exécuter.Il faut pour cela redéfinir la méthode isValid() et utiliser le paramètre TagData pour analyser les paramètres.Si isValid() retourne false une exception sera lancée.

Comment empêcher le compilateur d'interpréter le corps du Tag ?L'exemple précédent permet d'afficher du code HTML, mais on peut également vouloir afficher des scriplets Java ou même des Tag JSP sans qu'ils ne soient interprétés.

En effet, le code suivant :<p:htmlCode> <h1>Example HTML</h1> <p> Code Java <%=new java.util.Date()%> TagLib : <p:hello/> </p></p:htmlCode>

donnera: <h1>Example HTML</h1> <p> Code Java Fri Dec 10 17:45:19 CET 2004 TagLib : Hello World !

42/122

</p>Il faut spécifier que le corps du tag n'est pas du code JSP afin qu'il ne soit pas interprété.Pour cela, on va créer un nouveau Tag htmlJspCode qui utilisera la même classe que htmlCode, mais en spécifiant que le corps est dépendant du tag (il ne sera pas interprété) :

<tag> <name>htmlJspCode</name> <tagclass>HtmlCodeTag</tagclass> <bodycontent>tagdependent</bodycontent> </tag>

Ainsi le code suivant :<p:htmlJspCode> <h1>Example HTML</h1> <p> Code Java <%=new java.util.Date()%> TagLib : <p:hello/> </p></p:htmlJspCode>

donnera:<h1>Example HTML</h1> <p> Code Java <%=new java.util.Date()%> TagLib : <p:hello/> </p>

Ceci peut également permettre d'insérer d'autres langages de scripts (Perl, Php, Shell Script, etc.) au sein d'une page JSP...

Comment gérer les exceptions d'un tag ?L'API des taglibs propose une interface TryCatchFinally afin de gérer les exceptions générées par un Tag.Si un tag implémente l'interface TryCatchFinally, il doit implémenter deux nouvelles méthodes :

doCatch() qui correspondra au bloc catch.

doFinally() qui correspondra au bloc finnaly.

Concrètement, cela signifie que si un tag implémente TryCatchFinally, les appels aux méthodes doXXXX() des interfaces Tag, IterationTag et BodyTag seront exécuté à l'intérieur d'un bloc try/catch de la forme suivante :

43/122

try { ... tag.doStartTag(); ... tag.doInitBody(); ... tag.doAfterBody(); ... tag.doEndTag(); ...} catch (Throwable t) { tag.doCatch(t);} finally { tag.doFinally();}

Comment écrire des tags collaboratifs ?Les tags peuvent communiquer simplement avec le tag parent, c'est à dire le tag qui englobe le tag courant.Par exemple, dans le code suivant:

<p:iterate count="3"> <p:htmlCode> <p:hello/> </p:htmlCode> <p:htmlJspCode></p:htmlJspCode></p:iterate>

Le tag iterate est le parent du tag htmlCode et du tag htmlJspCode.htmlCode est lui même parent du tag hello...Mais il n'existe aucune parenté entre htmlCode et htmlJspCode...

La méthode getParent() permet d'accéder au tag parent, pour éventuellement interagir avec ce dernier.

A Noter également l'existence de la méthode statique TagSupport.findAncestorWithClass(Tag,Class) qui permet de rechercher un parent selon son type dans la hiérarchie des tags..

44/122

Divers

Comment gérer une connexion JDBC avec Tomcat ?Il faut que le jar du JDBC soit dans les lib de Tomcat Puis il y a trois étapes :

dans le server.xml <Context path="/Le_Contexte" reloadable="true" debug="0" docBase="Le_DocBase" workDir="Le_workDir"> <Ressource name="jdbc/Le_Contexte" auth="Container" type="javax.sql.DataSource"/> <ResourceParams name="jdbc/Le_Contexte"> <parameter> <name>user</name><value>Le_Login_SGBD</value> </parameter> <parameter> <name>password</name><value>Le_Password_SGBD</value> </parameter> <parameter> <name>driverClassName</name><value>Le_Driver_SGBD</value> </parameter> <parameter> <name>url</name><value>L_URL_Connection</value> </parameter> </ResourceParams> </Context>

Puis dans le web.xml il faut déclarer la ressource après la section <servlet-mapping>: <resource-ref> <description> reference a la ressource BDD pour le pool </description> <res-ref-name>jdbc/Le_Contexte</res-ref-name> <res-type>javax.sql.DataSource</res-type> <res-auth>Container</res-auth>

45/122

</resource-ref>Enfin dans la méthode init de la servlet, il faut recupèrer la source de données

try { Context initCtx = new InitialContext(); Context envCtx = (Context) initCtx.lookup("java:comp/env"); ds = (DataSource) envCtx.lookup("jdbc/Le_Contexte"); } catch (Exception e) { //Gestion de l'erreur }

sachant que ds est une variable d'instance de type DataSource. Quand on a besoin de l'accès a la base de données, on fait:

Connection conn=ds.getConnection();

ne pas oublier de libérer avec un close après. On peut aussi préciser dans le serveur xml, le nombre de connexions que l'on veut dans le pool (nb max, nb min, nombre en attente)

Comment lire un message d'erreur de Tomcat ?Ces messages sont composés de deux parties. Pour débugger il faut regarder la deuxième partie qui commence après:

root cause

Ou encore le messagecause mere

L'erreur est alors indiquée sous la forme d'une exception.

Comment faire pour appeler dans le constructeur d'une classe fille une méthode de la classe mère avant d'appeler le constructeur super de la classe mère?En déclarant la méthode mère static, et en l’appelant dans l’initialiseur de la classe fille (appelé avant le constructeur)

public class ClasseMere {public ClasseMere() {

System.out.println("Constructeur Mère");}

public static void MaMethode(){System.out.println("Ma méthode mère");

46/122

}

}

public class ClasseFille extends ClasseMere {static {MaMethode();}

public ClasseFille() {System.out.println("Constructeur Fille");

}}

public class MainClass {public static void main(String[] args) {

ClasseFille maClasse = new ClasseFille();}

}

Concepts fondamentaux

Que sont le JRE, le JDK et le SDK ?JRE :Java Runtime Environement, c'est le kit destiné au client pour pouvoir exécuter un programme Java. Il se compose essentiellement d'une machine virtuelle Java (JVM) capable d'exécuter le byte-code et les bibliothèques standards de Java.

SDK :Standard Development Kit, c'est le kit destiné au programmeur. Ce kit est composé d'un JRE, d'un compilateur et de nombreux programmes utiles, des exemples de programmes Java, les sources de toutes les classes de l'api.

JDK :Java Development Kit, c'est l'ancien nom du SDK. Le JDK a été renommé SDK depuis la version 1.2.2.

47/122

Quelles sont les différences entre application, applet et servlet ?Application :Une application Java est un programme utilisant le langage de programmation Java et qui tourne généralement sur la machine où se trouve au départ le code. Il a le même but qu'un programme C ou d'un autre langage.

Applet :L'applet est récupérée à distance à travers un navigateur Web et s'exécute sur celui-ci. En raison de ce téléchargement à distance, les règles de sécurité concernant les applets sont très strictes (pour éviter notamment les virus). Par exemple, une applet (contrairement à une application), ne permet pas forcément l'écriture sur le disque local ou l'impression.

Servlet :Une servlet peut être considérée comme une applet coté serveur. Une servlet est destinée à ajouter des fonctionnalités à un serveur web.

Qu'est-ce que Java Web Start ?JavaWebStart est l'implémentation de référence par Sun de la spécification JNLP (JavaNetworkLaunchingProtocol) qui définit un mécanisme d'installation et de mise à jour supportant des fonctionnalités évoluées grâce à HTTP et XML.

L'idée de JWS est de "mimer" le comportement d'une applet pour une application Java. Un serveur héberge l'application ; le client Web Start se connecte au serveur, télécharge l'application et l'exécute. Les règles de sécurité sont semblables à celles des applets.

L'intérêt principal est la facilité de déploiement des applications. Lors d'une mise à jour, seul le serveur est à modifier, les clients téléchargeront la nouvelle application au prochain démarrage. Ce système est très intéressant pour les grosses entreprises qui ne peuvent pas se permettre d'aller mettre à jour une application sur les milliers de postes de leurs collaborateurs.

Les avantages :

Fonctionnement en mode déconnecté.

Exécution externe au browser -> intégration facile & large support.

48/122

Mise à jour incrémentale et modulaire des applications.

Support d'une exécution sécurisée dans un environnement de type sandbox.

Certains services avancés accessibles sans certificat (ouverture d'un flux fichier, sauvegarde d'un flux fichier, mécanisme de persistance entre sessions, impression, téléchargement de ressources, ...).

Migration facile depuis une application Java standard.

Comment connaître la version de la JVM installée ?Depuis une console :

java -versionDepuis un programme :Lors de l'exécution, la version de la JVM est accessible via les propriétés système (Comment accéder aux valeurs des variables d'environnement ?).

String version = System.getProperty("java.vm.version");Retourne le numéro de version complet de la JVM. Ce numéro peut comporter des informations spécifique. Par exemple : "1.5.0_06-b05"

String version = System.getProperty("java.version");Retourne le numéro de version exacte, y compris les éventuelles updates, mais sans informations spécifiques. Par exemple : "1.5.0_06"

String version = System.getProperty("java.specification.version");Retourne le numéro de version des spécifications, c'est à dire le numéro de version sans les versions de mises à jours. Par exemple : "1.5"

Quelles sont les conventions de nommage en Java ?Les variables :Les noms variables sont écrits en minuscules sauf la première lettre de chaque de mot à partir du deuxième. Il est également recommandé de choisir un nom de variable court mais suffisamment explicite (garder à l'esprit qu'un autre programmeur sera peut-être obligé de comprendre votre code plus tard).

public int maVariableEntiere;

Note : Une variable peut commencer par le caractère '_' ou '$', mais c'est fortement déconseillé par SUN.

49/122

Les constantes :Afin de bien les différencier des variables, les constantes sont écrites en majuscule, les mots sont séparés par le caractère '_'.

public final static int MA_CONSTANTE

Les méthodes :Le nom des méthodes suit les mêmes règles de construction que les variables, mais le premier mot devrait toujours être un verbe à l'infinitif, suivi éventuellement de mots pour qualifier l'action.

Les classes et interfaces :Les noms de classes sont écrits en minuscule, chaque première lettre d'un mot est en majuscule.

public class MaClasse

Les paquets :Les noms de paquet sont intégralement écrits en minuscule, sans caractère de séparation. Afin d'éviter au maximum les risques de conflit de nommage, il est recommandé de placer son travail dans un paquet commençant par un nom de domaine internet (com, edu, gov, mil, en, fr, etc ...) suivit du nom de l'organisation ou du projet.

com.developpez.javaorg.w3c.domorg.xml.sax

Qu'est qu'un obfuscateur ?Qu'est que c'est, quel est le but ?Pour assurer l'indépendance de la plate-forme, les programmes Java sont distribués sous forme de bytecode, cette forme est très proche du code source original. Le bytecode est donc très facile à décompiler ce qui augmente le risque d'une attaque par analyse du code source (reverse engineering). Cette attaque consiste à décompiler une application pour comprendre ce qu'elle fait exactement (dans le cas de la cryptographie) ou pour comprendre comment elle le fait (dans le cas d'espionnage industriel).Pour se protéger de ce type d'attaque, on peut avoir recours à un "obfuscateur". Il s'agit d'un utilitaire qui transforme le bytecode en un bytecode équivalent mais plus difficile à décompiler.

Comment ça marche ?Plusieurs techniques permettent de rendre plus difficile la décompilation du bytecode. La première se base sur les principes d'optimisation du code, en réordonnant les micro-instructions. D'autres techniques, plus radicales, changent l'organisation de la mémoire, le nom des identifiants, ajoute du code parasite ou des "goto" : le bytecode est souvent légèrement moins rapide mais surtout très difficile à comprendre.

50/122

Les mots-clés

Que signifient les mots-clés public, private et protected ?Ces trois mots clefs du langage java définissent la portée d'une variable, d'une méthode ou d'une classe. Il existe en fait quatre modificateurs d'accessibilité. Le quatrième est le modificateur vide (rien, pas de modificateur). Il ne faut pas confondre ce dernier avec public.

Voici les caractéristiques de ces modificateurs, du plus permissif au plus restrictif :

Mot-clé Portée Remarques

publicLes variables, méthodes ou classes publiques sont accessibles par tout objet.

Il ne peut y avoir qu'une seule classe publique par .java et celle-ci doit obligatoirement porter le nom du fichier .java

"rien"Les variables, méthodes ou classes définies sans modificateur sont accessibles par toute classe appartenant au même package.

Attention : les variables sans modificateur ne sont pas accessibles aux classes fille définies dans un autre package.

protectedLes variables, méthodes ou classes définies comme protégées ne sont accessibles que par les classes filles et classes du même package.

 

privateLes variables, méthodes ou classes définies comme privées ne sont accessibles que par la classe dans laquelle elles sont définies.

Il est fortement conseillé de déclarer comme privés tous les attributs d'une classe, et de créer des méthodes de type get/set pour y accéder.

Naturellement, toute méthode, variable ou classe est accessible dans la classe ou elle est définie.

Remarque : il y a deux cas particuliers où l'absence de mot-clé de visibilité ne correspond pas à une visibilité "package-only" :

Tous les membres (attributs et méthodes) d'une interface ou d'une annotation sont obligatoirement public.

Tous les constructeurs d'une enum sont obligatoirement private.

51/122

Que signifie le mot-clé static ?Le mot-clé static est utilisable pour des variables, méthodes, classes internes ou blocs de code.

Devant une variable ou méthode :

Le mot clé static devant une variable (ou méthode) indique que celle-ci n'appartient pas à une instance particulière de la classe. Les variables ou méthodes statiques appartiennent à la classe elle-même. On peut ainsi les utiliser sans avoir une instance créée. De nombreuses classes ont des membres ou méthodes statiques. Par exemple la classe Math :

System.out.println(Math.PI);//affiche la valeur de PISystem.out.println(Math.abs(-1));//affiche la valeur absolue de -1

Voici quelques remarques :

On peut aussi manipuler une variable ou méthode statique à partir d'une instance de la classe.

Pour faire des variables statiques des constantes, il faut combiner le mot-clé static avec le mot-clé final.

Les méthodes statiques, étant indépendantes de toute instance, n'ont pas accès aux variables ou méthodes non statiques.

Devant un bloc de code :

Le mot-clé static devant un bloc de code indique que celui-ci ne sera exécuté qu'une fois. L'exécution se fait lors du chargement de la classe par le ClassLoader. On peut utiliser ces blocs, par exemple, pour initialiser des variables statiques complexes.

public class MaClasse{ public static Map uneVariableStatique = new HashMap(); static{ uneVariableStatique.put("une clef","une valeur"); uneVariableStatique.put("une autre clef","une autre valeur"); //etc . }}

52/122

Que signifie le mot-clé final ?Devant une méthode :On indique que cette méthode ne pourra plus être redéfinie dans une classe fille. Ce qui entraîne une certaine optimisation dans les appels à cette méthode.

Devant une classe : On ne peut pas créer de classe dérivée de celle-ci. Par exemple il est impossible de dériver une classe à partir de la classe String de la bibliothèque de base. La solution consisterait à "encapsuler" String dans une classe de notre conception.

Devant une variable membre ou une variable locale : La variable ne peut plus être modifiée après son initialisation, et doit obligatoirement être initialisée une fois (et une seule fois) :

Pour une variable membre, elle peut être initialisée : private final int i = 5;private final int i;{ i = 5;}private final int i; public Exemple() { i = 5;}

Si la classe possède plusieurs constructeurs, la variable doit être correctement initialisée quel que soit le constructeur utilisé (sinon le compilateur provoquera une erreur).

Pour une variable membre static, elle peut être initialisée : private static final int X = 5;

private static final int X;static { X = 5;}

Pour une variable locale (ou pour un paramètre de la méthode), cela permet également de référencer l'instance dans une classe anonyme.

53/122

Que signifient les mots-clés this et super ?Les mots-clés this et super désignent respectivement des références sur l'instance courante et sur la classe mère. Voici un exemple qui devrais mettre en valeur cette définition plutôt succincte :

public MaClasse extends ClasseMere { private String attribut; /** On peut acceder aux constructeurs de la super-classe*/ public MaClasse(String uneValeur){ super(uneValeur); //on appelle ici le constructeur de la classe mère } /** On peut aussi accéder aux constructeurs de la classe elle-même*/ public MaClasse(String uneValeur){ this("une valeur par défaut"); //on appelle ici le constructeur définis un peu plus haut } /** En général l'appel à this est superflu lors d'appels à une méthode*/ public void uneMethode(){} public void doubleAppel(){ //les deux lignes suivantes sont équivalentes this.uneMethode(); uneMethode(); } /** L'appel à this peut être utile pour bien différencier * les variables de classe des variables de méthodes */ public void uneMethode(String attribut){ this.attribut = attribut; //ici, la variable de classe prend la valeur de la variable //passée en paramètre de la méthode } /** On peut aussi faire appel aux méthodes de la super-classe*/ public void uneAutreMethode(){ //on peux faire quelque chose en plus avant super.uneAutreMethode(); //mais aussi après

54/122

}}

A noter que dans le cas d'une classe interne (non static), le mot clé this permet également de récupérer l'instance de la classe englobante :

public class Englobante {private Object attribut;

public final class Interne {private Object attribut;

private switch() {Englobante.this.attribut = this.attribut;

} }}

Englobante.this fait donc référence à l'instance de la classe englobante et this fait référence à la classe interne.

Que signifie le mot-clé strictfp ?Ce mot clé, qui est une abréviation de Strict floating point, s'applique en tant que modificateur d'accès. Ou plus simplement, on l'utilise de la même manière que les mot-clés public ou synchronized. Avec quelques restrictions : strictfp s'applique en tant que modificateurs de classes, d'interfaces ou de méthodes d'une classe et en aucun cas au constructeur ou aux méthodes d'une interface. L'entité affectée est alors dite "FP-strict".

Les effets :Comme son nom l'indique, strictfp agit sur les opérations en virgule flottante. C'est à dire sur les types primitifs double et float.

Java effectue les calculs en garantissant une priorité de la gauche vers la droite.

/** classe FP-strict */public strictfp class FPDemo { public static void main(String[] args) { double d = 8e+307; /** affiche 4 * d /2 donc 2 * d */ System.out.println(4 * d / 2); /** affiche 2 * d */ System.out.println(2 * d);

55/122

} }

Mathématiquement ces deux expressions sont identiques, mais interprétées dans un langage, il en va autrement. Java impose un parenthésage : (4*d)/2, et dans notre cas (4*d) produit un dépassement de capacité, donc un résultat infini. En revanche, la deuxième expression produit bien un résultat correct.

Notons que le mot-clé oblige l'implémentation de la JVM à évaluer l'expression tel que prévu dans la spécification du langage. Ne pas faire usage de ce mot-clé ne garantit pas que la JVM réalisera ce calcul de la sorte. Une JVM peut en effet avoir le droit, si la méthode n'est pas FP-strict, d'utiliser des types intermédiaires différents pour éviter de provoquer un dépassement de capacité ou pour s'adapter à l'architecture de la machine. Dans ce cas les deux expressions pourraient, en fonction de la JVM, produire des résultats différents.

Conclusion :Le mot-clé strictfp permet de garantir les mêmes calculs quelle que soit la machine virtuelle sur laquelle l'opération est effectuée.

Que signifie le mot-clé transient ?Le mot-clé transient est lié à la sérialisation des classes Java (voir : Qu'est-ce que la sérialisation ?). Il permet d'interdire la sérialisation de certaines variables d'une classe.

// la classe que nous allons sérialiserclass Writeable implements java.io.Serializable { // entier transient public transient int var1 = 4; // entier normal public int var2 = 19;}

Si nous sérialisons une instance de cette classe, la variable 'var1' ne sera pas sauvegardée, lors de la désérialisation elle prendra la valeur 0, malgré la présence de la valeur par défaut 4. L'attribution d'une valeur par défaut se fait lors de l'instanciation de l'objet ! Or, la méthode consistant à lire un objet depuis un fichier ne crée pas cette instance explicitement. Donc demo n'est jamais initialisé avec sa valeur par défaut. De plus, comme cet attribut est transient, il n'est pas écrit dans le fichier. Cela implique que demo ne reçoit aucune valeur et contient donc 0.

Ce mot-clé trouve des applications dès lors qu'une donnée sensible ne doit en aucun cas apparaître dans un fichier. Un mot de passe par exemple. Mais ce mot-clé peut également permettre de "remettre à zéro" certaines valeurs. Dans le cas d'un jeu, on pourra ainsi ne pas sauvegarder le temps de jeu depuis le début de la partie.

56/122

Que signifie le mot-clé volatile ?Le mot-clé volatile est utilisé sur les variables qui peuvent être modifiées de manière asynchrone. C'est à dire que plusieurs threads peuvent y accéder simultanément. Ces accès peuvent être pour la lecture et/ou la modification du contenu.

En indiquant que la variable est volatile, on oblige la JVM à rafraîchir son contenu à chaque fois qu'elle est utilisée. On est ainsi certain que la valeur de la variable n'est pas une valeur mise en cache, mais bel et bien sa valeur exacte. Ainsi chaque thread a accès à la valeur la plus récente de la variable.

Remarque : ce mot-clé est relativement peu utilisé et toutes les JVM ne le prennent pas en compte.

Comment utiliser les mots-clés break et continue ?Comme nous l'avons vu, il n'y a pas de goto en Java, mais il est possible d'associer un label à une instruction de boucle. Ce label, utilisé en conjonction avec l'instruction break, permet de savoir à quel niveau le break sera effectif.

Un label est une chaîne suivie de ":" et qui se place devant l'instruction de boucle.

Voici un exemple : Boucle1: while(true){

System.out.println("Boucle 1");

Boucle2: for(int ind=0; ind < 10; ind++) { System.out.println("Boucle 2");

Boucle3: while(true){ System.out.println("Boucle 3"); break Boucle2;

} }

break; }

A votre avis, qu'affiche l'exécution de ce morceau de code ?

57/122

Remarque : le label peut aussi être utilisé en conjonction avec le mot clé continue. De la même manière, le label indique à quel niveau de boucle le continue s'applique.

Les notions objet

Qu'est-ce que l'héritage ?L'héritage est un des principaux concepts de la programmation orientée objet. L'héritage permet de définir une relation de "filiation" entre classes. Ainsi une classe fille (ou sous-classe) étend une classe mère (ou super-classe). L'héritage permet en général de spécialiser une classe.

Pour indiquer qu'une classe hérite d'une autre, il faut utiliser le mot-clé extends :

public class Fille extends Mere{ //ici le code spécifique de la classe fille}

L'héritage implique plusieurs choses :

La fille hérite du type de la mère :

public class Couleur(){ String nom; public Couleur(String nom){ this.nom = nom; }}public class Rouge extends Couleur{ public Rouge(){ super("rouge"); }}public class AutreClasse(){ public void setCouleur(Couleur uneCouleur){ //etc.

58/122

} public static void main(String[] args){ AutreClasse ac = new AutreClasse(); ac.setCouleur(new Couleur("vert")); ac.setCouleur(new Rouge()); }}

La fille hérite de plusieurs attributs, méthodes et constructeurs de la mère

L'accès à ces attributs ou méthodes se fait avec le mot clef super. Pour plus d'informations, voir Que signifient les mots-clés this et super ?

Voici comment est définie l'accessibilité aux composantes de la super-classe, en fonction des modificateurs :

Mot-clé Accès

public Oui

"rien" Oui, seulement si la classe fille se trouve dans le même package que la super-classe.

protected Oui, quel que soit le package de définition de la classe fille.

private Non.

Regardez les liens ci dessous qui pourront vous éclairer un peu plus sur cette notion.

Qu'est ce qu'une interface ?Définiton :Une interface représente un contrat passé entre plusieurs classes (polymorphisme). En général, l'interface porte un nom de type adjectif, ce qui permet de préciser les aptitudes complémentaires d'une classe. Par exemple :Runnable = capable d'être exécuté Drawable = capable de s'afficher

Utilisation / but :En général, l'interface, spécifie dans son contrat un ensemble de méthodes qui devront être implémentées par les classes qui s'engagent à respecter le contrat. Néanmoins, ceci n'est pas nécessaire et certaines interfaces servent uniquement de marqueur comme par exemple l'interface Serialisable qui permet simplement de préparer une classe à la sérialisation.La notion d'interface permet ainsi-> de découper de manière à la fois élégante et très puissante l'aptitude (contrat) de l'implémentation.Par exemple l'interface Enumeration permet de parcourir une "liste" d'objets d'un bout à l'autre sans se préoccuper de l'implémentation sous-jacente (un tableau, une hashtable, Collection, etc.). En effet il suffit de faire un

59/122

while (Enumeration e = ...; e.hasNextElement(); ) { MonObjet o = (MonObjet)e.next(); // Faire qqc avec o}

-> De bien séparer les activités, et d'améliorer ainsi la lecture du code. En effet, la seule lecture de la déclaration de la classe nous permet de prendre connaissance de l'intégralité des activités de celle-ci. Par exemple une classe, disons "Ensemble" qui implémente l'interface Sortable nous renseigne dès sa déclaration sur la notion d'aptitude au tri qui lui a été attribuée.

En savoir plus :Pour en savoir plus sur la notion d'interface, outre les tutoriels java, il est conseillé de chercher de l'information autour des design patterns.Pour mieux comprendre la notion de séparation des activités, il peut être intéressant de lire les documentations concernant jakarta-avalon.

Qu'est ce qu'une méthode 'deprecated' ?Définition :Deprecated signifie que la méthode existe toujours pour des soucis de compatibilité ascendante, mais qu'elle n'est plus supportée et est amenée à disparaître dans l'avenir.

Pourquoi :Il existe plusieurs raisons pour qu'une méthode soit marquée deprecated.

Le plus généralement il s'agit d'un renommage de la méthode. Certaines méthodes sont héritées des toutes premières versions de JAVA, les conventions de nommage n'étant pas toujours respectées, certaines méthodes ont été renommées par la suite... (Les exemples sont très fréquents dans SWING)

Quelques méthodes sont devenues obsolètes suite à une évolution de l'architecture de l'Api. (La gestion des dates par exemple)

Enfin, certaines méthodes se sont révélées dangereuses et ne doivent plus être utilisées. Les méthodes de la classe java.lang.Thread peuvent conduire a un état incohérant des objets ou un arrêt de l'application (plus d'info)

Marquer ses propres méthodes deprecated :Si vous créez une librairie ou du code destiné a être utilisé par quelqu'un d'autre, vous pourriez être amené à déconseiller l'emploi d'une méthode. Dans ce cas, un simple tag javadoc suffit.

public class MaClass { /** Une méthode dépréciée * @deprecated */ public void maMethodeDepreciee() {

60/122

} }

Qu'est-ce que la sérialisation ?Java, permet de sauvegarder l'état d'un objet à un instant donné dans un flux d'octets. On dirigera généralement ce flux dans un fichier pour effectuer une sauvegarde. Le principal avantage de la sérialisation, c'est d'être complètement intégré à l'api Java et donc de ne nécessiter presque aucun code supplémentaire.

Créer une classe sérialisable :Il suffit simplement que la classe implémente l'interface java.io.Serializable".

public class Writeable implements java.io.SerializableNote : toutes les variables de la classe doivent également être des objets sérialisables (ou des types primitifs).

Sérialisation d'un object.

try { ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("monFichier.sav")); out.writeObject(monObject1); out.writeObject(monObject2); out.close();} catch( IOException e ) { }

Désérialisation d'un object.

try { ObjectInputStream in = new ObjectInputStream(new FileInputStream("monFichier.sav")); MonObject1 monObject1 = (MonObject1)in.readObject(); MonObject2 monObject2 = (MonObject2)in.readObject(); in.close();} catch( ClassNotFoundException e1 ) { } catch( IOException e2 ) { }

Note : Il est possible de ne pas sauvegarder certains attributs de la classe en utilisant le mot clé "transient". Plus d'info ici.

61/122

Qu’est-ce que le polymorphisme ? + En termes simples ? + 1 Exemple concret compris par un passant dans la rue.

Chaines de caractères

Comment comparer des chaînes de caractères ?Pour comparer 2 chaînes, il ne faut pas utiliser l'opérateur == .

La fonction strcmp le permet et si l'on désire effectuer une comparaison sur une longueur donnée de la chaîne, il faut alors utiliser la fonction strncmp. A noter que la comparaison se termine lors de l'apparition de la première différence entre les 2 chaînes, ou que la fin de chaîne est atteinte.

une valeur 0 indique que les chaînes sont identiques

une valeur négative indique que la chaîne 1 contient des caracètres dont la valeur ASCII est inférieure à ceux de la chaîne 2

une valeur positive indique que la chaîne 1 contient des caracètres dont la valeur ASCII est supérieure à ceux de la chaîne 2

const char * chaine1 = "blabla";const char * chaine2 = "blabla";const char * chaine3 = "blablu";

if (strcmp(chaine1, chaine2) == 0){ /* les chaines sont identiques */}

if (strcmp(chaine2, chaine3) != 0){ /* les chaines sont différentes */}

62/122

if (strncmp(chaine2, chaine3, 3) == 0){ /* les chaines sont identiques en se limitant a comparer les 3 premiers caracteres */}

Comment convertir une chaîne en nombre ?Si une chaîne de caractères contient un nombre, il est possible de placer ce nombre dans une variable grâce à la fonction strtol() :

char buf[32] = "15";long n;

n = strtol(buf, NULL, 10);Le troisième paramètre de strtol() correspond à la base utilisée (décimale dans l'exemple). Le deuxième paramètre contiendra après l'éxecution de la fonction l'adresse où la conversion de la chaîne de caractères s'est arrêtée. Si la chaîne a entièrement été traitée, ce paramètre pointe donc sur le caractère '\0' de fin de chaîne :

char buf[32] = "15";long n;char * end

n = strtol(buf, &end, 10);if (*end == '\0'){ /* La chaine a enteirement pu etre convertie */}else{ /* La chaine contenait au moins un caractere ne pouvant pas etre converti en nombre */}

Comment convertir un nombre en chaîne formatée ?Pour convertir un nombre en chaîne de caractères, on utilise la fonction sprintf() (déclarée dans stdio.h). Cette fonction fait partie de la norme ANSI-C, elle peut donc être utilisée sous n'importe quelle plateforme.

Pour placer un nombre entier dans une chaîne de caractères, on procédera donc ainsi : #include <stdio.h>

char buf[32];int n = 10;

sprintf(buf, "%d", n);

63/122

sprintf() admet différents paramètres, comme

%s pour une chaîne de caractères,

%f pour un nombre réel,

%u pour un nombre non signé,

%x pour un nombre hexadécimal.

N.B. :la norme C99 a introduit la fonction snprintf() similaire à sprintf() dans son foncionnement mais prennant en paramètre la taille maximale de la chaîne résultante.

Comment convertir une date en chaîne ?La conversion d'une date en chaîne de caractères est délicate au premier abord. En effet, le format des dates est très différent d'une langue à l'autre. Heureusement, les fonctions d'internationalisation de Java vont faire le travail à notre place...

// IMPORTimport java.util.Locale;import java.text.DateFormat;

// 1. Choix de la langueLocale locale = Locale.getDefault();

/** 2. Construction du DateFormat en choisiant un format : * SHORT = 01/01/2002 * FULL = lundi 1 janvier 2002 */DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.FULL, locale);

// 3. AffichageSystem.out.println(dateFormat.format(maDate));

Si vous souhaitez utiliser un format de sortie plus exotique, vous pouvez accéder directement à la classe java.text.SimpleDateFormat.

DateFormat dateFormat = new SimpleDateFormat("hh'h'mm dd-MM-yy");//résultat : "23h59 31-12-2000"

64/122

Comment convertir une chaîne en Date ?Pour convertir une chaine en date, il faut connaître le format de la date. Par défaut, une seule classe dans l'API gère les formats de date : java.text.SimpleDateFormat. On utilise le parser de date pour effectuer la conversion. Voici une méthode générique :

public static Date stringToDate(String sDate, String sFormat) throws Exception { SimpleDateFormat sdf = new SimpleDateFormat(sFormat); return sdf.parse(sDate);}

Le parser déclenche l'exception ParseException quand la chaine ne respecte pas le format. La documentation sur java.text.SimpleDateFormat décrit le format d'une date, et des lettres à utiliser pour caractériser le jour, le mois, ... etc. Cette méthode est valable à partir du JDK 1.1

Comment convertir des 'char' en ASCII ?Définition du type char :Le type 'char' de Java est un type primitif, codé sur 16 bits, qui contient la valeur unicode du caractère. De plus, le type 'char' est un entier non-signé qui peut contenir des valeurs de 0-65535; Toutes les opérations arithmétiques sont légales ( voir  Les spécifications du langage Java ).

Conversion en ASCII :La manière la plus simple de passer de l'Unicode à l'ASCII est d'utiliser la classe java.lang.String.

try { String chaine = "Ma chaîne à traduire !"; // traduction en tableau de code ASCII : byte[] bytes = chaine.getBytes("ASCII"); // affichage à l'écran : for( int i=0; i<bytes.length; i++ ) { System.out.println( bytes[i] ); } } catch( java.io.UnsupportedEncodingException e ) { // Le codage n'est pas reconnu. e.printStackTrace();}

Conversion dans d'autres formats :Quelques autres formats d'encodage sont gérés par Java en interne : US-ASCII, ISO-8859-X (1 à 7), UTF-8, UTF-16BE, UTF-16LE, UTF-16. (voir la classe

65/122

java.nio.charset.Charset pour plus d'informations)

Comment changer l'encodage d'une chaîne de caractères ?Pour faire cela, on peut utiliser le constructeur de String prenant en paramètre l'encodage.

Voici un exemple permettant de convertir une chaîne codée en UTF-8 en ISO-8859-1 (Latin 1, français)

String stringUTF8 = ... ; String stringISO = new String ( stringUTF8.getBytes(), "ISO-8859-1" );

Quelle est la longueur maximale d'une chaîne de caractères ?Les chaînes de caractères ne sont pas vraiment limitées en java. On notera cependant que les caractères de la chaîne sont indexés par des 'int', ce qui nous fixe une limite à 2^32 caractères (soit une chaîne de plus de 4Go en mémoire).

Note :Attention, si vous manipulez des chaînes (modification, concaténation, etc ...) et à plus forte raison des chaînes de grande taille, vous devez utiliser des java.lang.StringBuffer (en savoir plus).

Les dates

Comment connaître l'heure courante ?Le constructeur par défaut de la classe java.util.Date construit une date initialisée à l'heure courante du système.

Comment mettre à jour l'heure courante du système ?L'API standard ne permet pas de modifier l'heure du système. La seule solution est de passer par une commande externe.

Comment faire des opérations sur des dates ?Tout est prévu, il n'y a qu'à utiliser les classes de Sun tel que :

66/122

java.util.GregorianCalendar

java.util.Calendar

java.util.Date

Tout d'abord il nous faut une instance de GregorianCalendar

GregorianCalendar calendar = new java.util.GregorianCalendar(); // Initialisé à la date et l'heure courrante. calendar.setTime( maDate ); // Initialisé avec une instance de Date.

Voici ensuite quelques exemples d'opération (pour plus d'information lire la doc, évidemment...)- sur le champs "jour" (7 jours plus tôt) :

calendar.add (Calendar.DATE, -7);- sur le champs "mois" (5 mois plus tard) :

calendar.add (Calendar.MONTH, 5);Et pour ce qui est des affichages je vous conseille d'utiliser la solution proposée ici en utilisant la méthode

public Date calendar.getTime ();

Comment convertir une chaîne en Date ?Pour convertir une chaine en date, il faut connaître le format de la date. Par défaut, une seule classe dans l'API gère les formats de date : java.text.SimpleDateFormat. On utilise le parser de date pour effectuer la conversion. Voici une méthode générique :

public static Date stringToDate(String sDate, String sFormat) throws Exception { SimpleDateFormat sdf = new SimpleDateFormat(sFormat); return sdf.parse(sDate);}

Le parser déclenche l'exception ParseException quand la chaine ne respecte pas le format. La documentation sur java.text.SimpleDateFormat décrit le format d'une date, et des lettres à utiliser pour caractériser le jour, le mois, ... etc. Cette méthode est valable à partir du JDK 1.1

Comment connaître la date de création d'un fichier ?Date de création :

67/122

Aucune solution n'est disponible pour connaître la date de création d'un fichier. Certains systèmes comme Linux ne fournissant pas cette information, aucun solution portable n'est possible.

Date de la dernière modification :Là, en revanche, aucun problème, la méthode lastModified() de la classe java.io.File est disponible.

long dateModification = monFichier.lastModified();

Toutefois, le long retourné par la méthode lastModified() peut dépendre du système d'exploitation et donc ne pas être toujours extrêmement précise.

Les threads

Qu'est ce qu'un thread ?Définition :Un thread désigne un point d'exécution dans le programme. En fait, le langage Java est multi-thread, c'est à dire qu'il peut exécuter du code à plusieurs endroits de façon indépendante.

Exemple d'utilisation :L'utilisation des threads est très fréquente dans la programmation réseau. Un client FTP peut télécharger plusieurs fichiers, naviguer sur plusieurs serveurs en même temps, chaque connexion étant gérée par un thread différent. Autre exemple : dans un traitement de texte, un thread s'occupe de ce que tape l'utilisateur, un autre est en charge de souligner les erreurs, un 3ème se charge de faire parler le trombone ! :-)

Comment créer un thread ?Créer un thread est très simple en Java. Deux solutions s'offrent à vous :

Dériver de la class Thread :Vous pouvez créer une nouvelle classe qui dérive de la classe java.lang.Thread. Il suffit ensuite de redéfinir la méthode run(). C'est cette méthode que le thread va exécuter.

68/122

Implémenter java.lang.Runnable :Si vous ne souhaitez pas faire une classe dédiée à la gestion du processus, vous pouvez simplement implémenter l'interface java.lang.Runnable et définir la méthode run(). Ensuite il suffit de créer un objet java.lang.Thread en lui passant la classe en paramètre.

Dans tous les cas :Pour lancer l'exécution d'un thread vous devez exécuter la méthode start() et en aucun cas exécuter vous-même la méthode run() (L'exécution se déroulerait alors dans le processus courant !).

Pourquoi toutes les méthodes de la classe Thread sont marquées "deprecated" ?Pour ceux qui maîtrisent l'anglais, un petit tour sur le site de Sun : http://java.sun.com/j2se/1.4/docs/guide/misc/threadPrimitiveDeprecation.html.

Pour les autres, toutes ces méthodes ont été marquées deprecated car, sous certaines conditions et sans qu'il y ait d'erreur de conception, l'application peut se bloquer. Typiquement, lorsqu'un thread est tué, il n'est pas possible de savoir ce qu'il était en train de faire, il est donc possible qu'il soit arrêté au milieu d'une modification d'un objet; cet objet est donc laissé dans un état incohérent. Des problèmes similaires peuvent se produire avec les méthodes suspend() et resume().

Comment terminer un thread sans la méthode stop() ?La méthode stop() de la classe java.lang.Thread étant dépréciée, il est nécessaire de prévoir soit-même la possibilité d'arrêter le processus.

Squelette standard d'un ThreadCe squelette permet de facilement arrêter le processus sans utiliser la méthode dépréciée stop().

/** Ce boolean sera utilisé pour signaler au * processus s'il doit continuer ou s'arrêter. */private boolean stopThread = false;

public void run() { boolean fin = false; while( !fin ) { try { // traitement

69/122

synchronized(this) { Thead.yield(); // lecture du boolean fin = this.stopThread; } } catch( InterruptedException e ) { } } }

public synchronized void stop() { this.stopThread = true;}

2ème squelette standardLa solution précédente est adaptée aux threads qui effectuent régulièrement le même traitement. Si le traitement est très long, il peut être nécessaire de tester la requête de fin en cours de traitement. Le plus simple est alors de lever une exception en cours de traitement.

private boolean stopThread = false;

public synchronized void testFin() throws InterruptedException { if( stopThread ) { throw new InterruptedException(); } } public void run() { try { // traitement avec un appel régulier à testFin(); } catch( InterruptedException e ) { } } public synchronized void stop() { this.stopThread = true;}

Attention : les appels à la méthode testFin() doivent être effectués uniquement lorsque tous les objets sont dans un état cohérent. (voir :Pourquoi toutes les méthodes de la classe Thread sont marquées 'deprecated' ?).

70/122

Comment faire un minuteur (timer) facilement ?On peut utiliser la classe java.lang.Thread ou implémenter l'interface java.lang.Runnable, mais suivant les cas de figure cela représente beaucoup de code et de contraintes. En effet, les instructions qui affectent ou dépendent d'un composant graphique Swing doivent être effectuées par le processus d'évènement (the event-dispatching thread). Par conséquent si l'on utilise la classe Thread ou l'interface Runnable il est nécessaire d'utiliser les méthodes : invokeLater(java.lang.Runnable) ou invokeAndWait(java.lang.Runnable)" javax.swing.SwingUtilities.

La classe Timer :La classe javax.swing.Timer remplace avantageusement l'utilisation directe de thread. Elle génère un évènement à intervalles réguliers (à la milli-seconde). C'est le "event-dispatching thread" qui exécute l'évènement, donc on peut directement modifier des objets graphiques.

Méthodes importantes :le constructeur de javax.swing.Timer :

public Timer (int delay, ActionListener listener);/** delay = l'intervalle de temps entre chaque évènement. * listener = l'objetécouteur de ces evènements. */

méthode permettant de lancer le processus :public void start();

méthode permettant de stopper le processus :public void stop();

Note :Cette méthode est à utiliser uniquement si le traitement à faire est court en temps d'exécution sinon on aura une interface non réactive pendant le traitement ....

Comment faire une "pause" dans mon application ?On peut simuler une "pause" dans l'exécution d'une application en utilisant la méthode sleep() de la classe Thread. Cette méthode force le Thread courant à cesser son exécution pendant le temps passé en paramètres.

Par exemple :

71/122

long milliSecondes = 500L; int nanosSecondes = 6000; Thread.sleep(milliSecondes, nanosSecondes);// ouThread.sleep(milliSecondes);

Ces deux méthodes sont susceptibles de lever une InterruptedException.

Quand instancier un thread directement, et quand se contenter d'implémenter l'Interface Runnable, pourquoi et dans quel cas, quelle est la différence ?

Les structures de données

Quelle est la différence entre HashSet, TreeSet et LinkedHashSet ?L'API propose trois implémentations concrètes pour les ensembles (java.util.Set). Un ensemble est un groupe d'élément uniques.

java.util.HashSet :Le java.util.HashSet est la plus utile des implémentations.Note : L'ordre d'itération des éléments est aléatoire.Complexité : Les opérations add, remove, contains and size sont exécutées en un temps constant.

java.util.TreeSet :Le java.util.TreeSet contient un ensemble d'éléments ordonnés (il implémente également l'interface java.util.SortedSet). Les éléments sont ordonnés en fonction de leur ordre naturel (voir java.util.Comparable), ou en fonction d'un java.util.Comparator précisé à la construction du TreeSet.Complexité : Les opérations add, remove, contains and size sont exécutées en un temps log(n).

java.util.LinkedHashSet :Un java.util.LinkedHashSet est identique au HashSet sauf qu'il conserve l'ordre d'insertion des éléments dans une liste doublement chainée.Note : L'ordre d'itération des éléments correspond à l'ordre d'insertion, l'ordre reste inchangé si l'on ajoute un élément déjà présent.

72/122

Complexité : Les opérations add, remove, contains and size sont exécutées en un temps constant (mais supérieur au temps du HashSet car il faut également gérer la liste chainée).

Quelles différences entre ArrayList, LinkedList et Vector ?L'API propose deux implémentations concrètes pour les listes (java.util.List). Une liste est une suite ordonnée d'éléments (les éléments peuvent être ajoutés à plusieurs endroits de la liste).

java.util.ArrayList :Un java.util.ArrayList utilise un tableau en interne pour ranger les données. Un ArrayList fournit un accès aux éléments par leur indice très performant et est optimisé pour des opérations d'ajout/suppression d'éléments en fin de liste.Complexité : Les opérations size, isEmpty, get, set, iterator sont exécutées en temps constant.Les opérations d'ajout/suppression sont exécutées en temps constant amorti (les ajouts/suppressions en fin de liste sont plus rapides).

java.util.LinkedList :Un java.util.LinkedList utilise une liste chainée pour ranger les données. L'ajout et la suppression d'éléments est aussi rapide quelle que soit la position, mais l'accès aux valeurs par leur indice est très lente.Complexité : Les opérations size, isEmpty, add, remove, set, get sont exécutées en temps constant. Toutes les méthodes qui font référence à un indice sont exécutées en temps O(n).

java.util.Vector :La classe java.util.Vector est une classe héritée de Java 1. Elle n'est conservée dans l'API actuelle que pour des raisons de compatiblité ascendante et elle ne devrait pas être utilisée dans les nouveaux programmes. Dans tous les cas, il est préférable d'utiliser un ArrayList.Note : Cette classe est "thread-safe", c'est-à-dire que plusieurs processus peuvent l'utiliser en même temps sans risque.Complexité : idem que pour ArrayList, plus le temps de synchronisation des méthodes.

Quels sont les différents types de Map ?L'API propose cinq implémentations concrètes pour les 'Map' (java.util.Map). Une map permet de créer un ensemble de couples clé/valeur (On parle aussi de tableaux associatifs), la clé permettant de retrouver rapidement la valeur qui lui a été associée. Les clés sont des objets uniques pouvant être NULL; Les valeurs peuvent être multiples et NULL.

java.util.HashMap :

73/122

La classe java.util.HashMap est l'implémentation concrète la plus standard, elle est adaptée à la plupart des situations.

java.util.TreeMap :La classe java.util.TreeMap ajoute une fonction de tri des clés de la Map. L'ordre des clés peut être choisi en donnant une instance de java.util.Comparator sinon c'est l'ordre naturel des clés qui sera utilisé (elles doivent donc implémenter java.lang.Comparable). Si vous avez une grande quantité de données à ajouter dans la collection et que l'ordre clés n'est utile qu'après l'ajout, il est plus efficace de créer un HashMap pour ajouter les éléments et de construire la TreeMap à partir de la HasMap :

Map map = new HashMap();// Toutes les operations pour ajouter les éléments... map.put(....);

// ... puis on construit la TreeMap. map = new TreeMap(map);

java.util.LinkedHashMap :La classe java.util.LinkedHashMap conserve l'ordre d'ajout des clés (même principe que java.util.LinkedHashSet avec un set). Si la clé ajoutée est déjà présente, l'ordre ne change pas.

java.util.IdentityHashMap :La classe java.util.IdentityHashMap, contrairement aux autres implémentations concrètes, utilise l'opérateur '==' pour savoir si deux clés sont identiques (les autres utilisent le résultat de la méthode equals(java.lang.Object)).

java.util.WeakHashMap :La classe java.util.WeakHashMap conserve les couples en utilisant des références faibles, donc si la clé n'est plus référencée ailleurs dans le programme, le couple est automatiquement supprimé de la collection (voir java.lang.ref.WeakReference).

java.util.Hashtable :La classe java.util.Hashtable est une classe héritée de Java 1. Elle n'est conservée dans l'API actuelle que pour des raisons de compatiblité ascendante et elle ne devrait pas être utilisée dans les nouveaux programmes. Dans tous les cas, il est préférable d'utiliser un HashMap.

Comment créer une pile (LIFO) ?La classe StackLa classe java.util.Stack pourrait correspondre à nos besoins, mais elle hérite de Vector, ces méthodes sont synchronisées et donc plus lentes que si l'on créait une pile en se basant sur une collection de l'API java 2 ( voir : Comment bien utiliser les collections ?).

La classe LinkedListLa classe java.util.LinkedList contient toutes les méthodes nécessaires à la création d'un pile : addFirst(Object o), getFirst() et removeFirst(). On peut donc très bien utiliser cette classe comme une pile.

74/122

Créer sa propre classeLe but n'est pas de réinventer la roue, mais juste d'utiliser une classe qui porte le nom 'Stack' ou 'Pile' pour plus de clarté dans le code source sans plomber les performances avec la classe Stack de Java 1. L'implémentation proposée ici est basée sur le modèle des collections de Java2, elle utilise une interface Stack et une classe concrète LinkedStack.

Comment augmenter la taille d'un tableau ?La taille d'un tableau est fixée lors de sa construction et ne peut plus être modifiée. La seule solution consiste à créer un nouveau tableau plus grand et à copier les anciennes valeurs dans le nouveau tableau. Pour effectuer la copie de tableau, on utilise la méthode arraycopy(java.lang.Object, int, java.lang.Object, int, int) de la classe java.lang.System bien plus performante qu'une itération.

/** la méthode simple */int[] nouveau = new int[longueur];System.arraycopy(vieuxTableau,0,nouveau,0,vieuxTableau.length);/** Note : On place ici les anciennes valeurs au début du nouveau tableau. */

Note :La création d'un nouveau tableau est une opération coûteuse en terme de performances, si vous devez utiliser une structure de données dont la taille change souvent, il est fortement conseillé d'utiliser une liste (Quelles différences entre ArrayList, LinkedList et Vector ?).

Comment fonctionne un ArrayList ?Bien utiliser une structure de données implique d'en comprendre le fonctionnement. Les classes java.util.Vector et java.util.ArrayList fonctionnent de la même manière ( Quel différance ?).

Structure interne :Les données de la liste sont rangées dans un tableau d'objets. Le principal intérêt d'un ArrayList ou d'un Vector étant de pouvoir facilement ajouter un élément à la liste, le tableau utilisé en interne est surdimensionné par rapport au besoin. Exemple : Un ArrayList de 5 éléments pourrait utiliser un tableau de 10 éléments, lorsque qu'on ajoute un nouvel élément, on le place dans la 1ère case libre du tableau interne, on n'est pas obligé d'instancier un nouveau tableau. Evidemment, à force d'ajouter des éléments, le tableau interne peut se trouver saturé, dans ce cas un nouveau tableau est créé et les anciennes valeurs sont recopiées dedans.

Optimisation :La gestion automatique de la taille du tableau interne ne nous empêche pas de donner un coup de main pour améliorer les performances. Lors de la création d'une liste, il est important d'utiliser un constructeur précisant la capacité (taille du tableau interne), il est en général facile d'estimer la taille moyenne de sa structure de données, on évite ainsi de passer par plusieurs dizaines de réallocation du tableau interne. De même, avant d'insérer une grande quantité d'information, il est possible de demander de garantir une capacité minimale. Ces précautions sont d'autant plus importantes si la liste contient beaucoup d'éléments.

75/122

Comment trier une List (ArrayList, Vector, ...) ou un tableau?La classe java.util.Collections apporte la solution :

List ma_liste = new ArrayList();Collections.sort(ma_liste);

ma_liste est ainsi triée par ordre croissant. Pour trier dans l'ordre décroissant, il suffit de faire ceci : Collections.sort(ma_liste, Collections.reverseOrder());

Attention cependant, cet exemple fonctionne que si les éléments dans la liste sont de type Comparable, comme int, String, Date, ... (voir l'interface java.lang.Comparable). Si ce n'est pas le cas (les éléments sont des objets que vous avez défini), il faut que votre classe implémente l'interface java.lang.Comparable, donc en fait il faut définir la méthode int compareTo(Object o). Prenons un exemple simple :

class Voiture { String marque = ""; int nbCheveau = 0;

public Voiture(String s, int i) { marque = s; nbCheveau = i; }

public int getNbCheveau() { return nbCheveau; }

public String toString() { return marque + "\t" + nbCheveau; }}

On veut pouvoir trier une liste de Voiture suivant leur nombre de chevaux. Voilà alors les modifications à apporter à la classe :

class Voiture implements java.lang.Comparable { // méthode à implémenter /** * @param other other doit être de type Voiture ! */ public int compareTo(Object other) { int nombre1 = ((Voiture) other).getNbCheveau(); int nombre2 = this.getNbCheveau(); if (nombre1 > nombre2) return -1; else if(nombre1 == nombre2) return 0; else return 1; }

76/122

} Maintenant, vous pouvez trier facilement une liste de voitures :

Collections.sort(liste_voitures);

Le code est identique pour un tableau. Il faut seulement utiliser la classe Arrays. Arrays.sort(unTableauDeVoitures);

Vous avez aussi la possibilité de facilement mélanger une liste grâce à la méthode shuffle de Collections.

Comment déterminer si un objet est un tableau ?Tout simplement en faisant :

boolean estUnTableau = monObjet.getClass().isArray();

Comment déterminer le nombre de dimensions d'un tableau ?Cette propriété n'est pas directement accessible, mais une petite fonction permet de la calculer rapidement. On se base sur le fait qu'un tableau à plusieurs dimensions est en fait un tableau de tableaux.

public static int getNbDimension( Object monTableau ) { int dim=0; Class cls = monTableau.getClass(); while( cls.isArray() ) { cls = cls.getComponentType(); dim++; } return( dim );}

Comment agrandir un tableau ?En Java, les tableaux ne sont pas extensibles. On doit donc procéder en 2 étapes, créer un nouveau tableau plus grand, puis copier toutes les valeurs de l'ancien tableau dans le nouveau.

Object nouveauTableau = Array.newInstance( ancienTableau.getClass().getComponentType(), nouvelleTaille );System.arraycopy( ancienTableau, 0, nouveauTableau, Array.getLength(ancienTableau);

Note :Avant de vous embarquer dans cette solution, réfléchissez bien si un .ArrayList ou un Vector ne seraient pas plus appropriés à votre problème.

77/122

L'API de reflection

A quoi sert l'introspection ou la réflexivité, et comment l'utiliser ?L'introspection consiste en la découverte dynamique des informations propres à une classe Java ou à un objet. Ce mécanisme est notamment utilisé au niveau de la machine virtuelle Java lors de l'exécution de votre programme, et donne lieu à une API.

Le paquetage java.lang.reflect permet l'introspection en rendant possible l'accès aux classes, à leurs champs, méthodes ou encore constructeurs, et à toutes les informations les caractérisant, même celles qu'on pensaient inaccessibles Elle est également très utile pour instancier des classes de manière dynamique, dans le processus de sérialisation d'un bean Java, ainsi que dans la génération de code.

Les méta données présentes dans les fichiers binaires renseignent sur le contenu de chaque classe répertoriée et permettent à la jvm de procéder à des vérifications lors de l'exécution d'un programme (pensez à l'exception java.lang.NoSuchMethodError).La jvm utilise également ces informations pour vous proposer la complétion de code dans les environnements de développement Java, ce qui se fait en temps réel (pas de génération à faire au préalable).

Des détails sur le format des méta données dans un fichier binaire sont disponibles dans les documents de spécification de la machine virtuelle Java. Sachez seulement que les champs et méthodes sont identifiés par leur nom, le type (identifiants spécifiques à la jvm) pour les champs, et la signature pour les méthodes. A partir de ces informations, la jvm sait directement localiser la portion de byte code correspondant à l'implémentation d'une méthode.

Comment connaître l'ensemble des classes dont hérite une classe ?Il existe dans la classe Class une méthode nommée getSuperClass(), c'est cette méthode que nous allons utiliser.

Class c = Class.forName("maClasse");while((c=c.getSuperclass()) != null){ System.out.println(c.getName());

78/122

}

Comment connaître l'ensemble des interfaces qu'implémente une classe ?Il existe dans la classe Class une méthode nommée getInterfaces() qui renvoie un tableau des interfaces implémentées par la classe.

Class c = Class.forName("maClasse");Class[] interfaces = c.getInterfaces();for(int i=0;i<interfaces.length;++i){ System.out.println(interfaces[i].getName());}

Comment connaître le nom du paquetage dans lequel se situe une classe ?Il existe dans la classe Class une méthode nommée getPackage() qui renvoie un objet de type java.lang.Package.

Class c = Class.forName("monPackage.maClasse");Package p = c.getPackage();System.out.println(p.getName());

Comment récupérer la liste des méthodes d'une classe ?La liste des méthodes publiques (même celles héritées) est disponible grâce à la méthode getMethods().

Class c = Class.forName("maClasse");java.lang.reflect.Method[] m = c.getMethods();

Il est également possible de récupérer une méthode par son nom et sa signature en utilisant la méthode :getMethod(String name, Class[] parameterTypes)

Comment connaître la signature d'une méthode ?La classe java.lang.reflect.Method dispose d'un certain nombre de méthodes permettant de reconstituer la signature d'une méthode. Voici un exemple de deux d'entre elles :

// m est un objet de type MethodClass r = m.getReturnType();Class[] params = m.getParameterTypes();

79/122

Comment récupérer la liste des champs d'une classe ?Il existe dans la classe Class une méthode nommée getFields(), c'est cette méthode que nous allons utiliser.

Class c = Class.forName("maClasse");java.lang.reflect.Field[] f = c.getFields();

Il est également possible de récupérer un champ par son nom en utilisant la méthode getField(String name).

Comment savoir si une méthode ou un champ est de classe ?Il existe une classe dans java.lang.reflect appelée Modifier.Cette classe gère l'ensemble des informations définies pour un champ ou une méthode, à savoir : la visibilité, l'attribut "constante" ainsi que le caractère statique. Ce sont essentiellement des méthodes de classe qui permettent de consulter ces caractéristiques à partir d'un entier.

// m est un objet de type Methodint mod = m.getModifiers();if(java.lang.reflect.Modifier.isStatic(mod)){ System.out.println("méthode statique");}

Comment déterminer l'ensemble des informations concernant un champ ?Il existe bien entendu les méthodes getName() et getType() qui renvoie des le nom et le type du champ. Une dernière méthode permet d'obtenir les informations complémentaires : getModifiers(). Nous nous retrouvons avec un entier qu'il faut analyser à l'aide de la classe java.lang.reflect.Modifier. Nous allons ici utiliser la méthode statique toString() pour obtenir ces informations sous la forme d'une chaîne de caractères.

// f est un objet de type Fieldint mod = f.getModifiers();System.out.println(java.lang.reflect.Modifier.toString(mod));

Avec les infos de la méthode getModifiers(), vous pouvez aussi définir via la classe Modifier si les informations contiennent quelque chose de spécifique, via les méthodes isXXX, par exemple :

// f est un objet de type Fieldint mod = f.getModifiers();System.out.println("f est static = " + Modifier.isStatic(mod));System.out.println("f est transient = " + Modifier.isTransient(mod));System.out.println("f est volatile = " + Modifier.isVolatile(mod));...

80/122

Comment accéder dynamiquement à la valeur d'un champ donné d'un objet ?Pour consulter ou modifier un champ donné d'un objet de façon dynamique, il faut commencer par récupérer l'objet de type Field correspondant au champ en question. Il suffit ensuite d'appeler la méthode correspondante avec pour premier paramètre l'objet cible.Prenons l'exemple suivant où nous modifions le contenu du champ défini par la variable nomChamp de l'objet obj en lui donnant la valeur définie par la variable val.

void changeValeur(Object obj, String nomChamp, Object val) throws Exception{ java.lang.reflect.Field f = obj.getClass().getField(nomChamp); f.set(obj,val);}

Un exemple de consultation de la valeur d'un champ donné :

void afficheValeur(Object obj, String nomChamp) throws Exception{ Field f = obj.getClass().getField(nomChamp); System.out.println(f.get(obj));}

Remarque : les methodes set et get sont des méthodes générales mais il existe aussi des équivalents pour les types classiques : setDouble(Object obj, double d) ou setBoolean(Object obj, boolean z).

Comment lancer dynamiquement une méthode donnée d'un objet ?Nous allons utiliser la méthode invoke définie dans la classe Method :

Object invoke(Object obj, Object[] args)Voici un exemple générique de lancement dynamique d'une méthode donnée sur un objet :

Object lancerMethode(Object obj, Object[] args, String nomMethode) throws Exception{ Class[] paramTypes = null; if(args != null) { paramTypes = new Class[args.length]; for(int i=0;i<args.length;++i) {

81/122

paramTypes[i] = args[i].getClass(); } } Method m = obj.getClass().getMethod(nomMethode,paramTypes); return m.invoke(obj,args);}

A noter que cette méthode ne fonctionne que pour les types exacts de classe pour les paramètres. C'est-à-dire qu'on ne pourra pas utiliser une classe fille comme argument de paramètre.

Comment passer les types primitifs en paramètre lors de l'utilisation de la réflexivité ?Les types primitifs (byte, char, short, int, long, float, double, boolean) ont tous des wrapper dans le package java.lang. Respectivement: Byte, Character, Short, Integer, Long, Float, Double, Boolean.

Chacune de ces classes contient une variable static TYPE de type Class. C'est cette classe qu'il faut utiliser pour spécifier le type du paramètre; la valeur quand a elle sera contenue dans un objet du type du wrapper.

Exemple: Appel d'une méthode prenant un int en paramètre.

Dans cet exemple nous allons appeler la méthode statique abs(int) de la classe java.lang.Math Class types[] = { Integer.TYPE }; Method method = Math.class.getMethod("abs", types); Object parametres[] = { new Integer(-1) }; Integer iWrap = (Integer) method.invoke(null, parametres); System.out.println("Valeur absolue de -1 = " + iWrap);

Comment lancer dynamiquement une méthode de classe donnée ?Pour lancer dynamiquement une méthode de classe, le principe est le même que pour une méthode sur un objet (voir lien). La signature de la méthode (classe Method) à utiliser étant :

Object invoke(Object obj, Object[] args)

Lorsque la méthode est de classe, le paramètre obj n'est pas évalué. Vous pouvez mettre n'importe quel objet ou tout simplement null.

82/122

Y a-t-il un moyen de consulter et/ou de modifier la valeur d'un champ privé ?Après avoir récupéré un objet sur un champ privé (voir lien), vous pouvez tenter de désactiver la protection en utilisant la méthode setAccessible(boolean b). Si l'utilisation de cette méthode ne provoque pas le déclenchement d'une exception par un SecurityManager, vous allez pouvoir modifier la valeur du champ.

Exemple : prenons une classe Secret avec un champ privé priv de type String.

void modifierChamp(Secret s, String val){ Field f = s.getClass().getDeclaredField("priv"); f.setAccessible(true); f.set(s,val);}

Est-il possible d'avoir la liste des champs/méthodes privés et protégés d'une classe ?Les moyens mis à disposition par l'API Reflection permettent de passer outre les règles de l'encapsulation. Vous pourrez consulter les champs et méthodes privés/protégés de la même manière que les champs et méthodes publiques, mais en utilisant les méthodes getDeclaredFields et getDeclaredMethods (ainsi que leurs variantes) au lieu de getFields et getMethods.

Exemple :

Class c = Class.forName("maClasse");java.lang.reflect.Field[] f = c.getDeclaredFields();

Remarque : contrairement aux méthodes getFields et getMethods, getDeclaredFields et getDeclaredMethods ne renvoient pas les informations héritées. Dans ce cas, il est nécessaire d'aller interroger la classe mère.

Les fichiers

83/122

Comment connaître les racines des arborescences de fichiers ?La classe java.io.File fournit la méthode statique listRoots(). Sous Windows, le résultat est la liste des lecteurs logiques ( a:/, c:/, d:/ ), sous Unix, le résultat se limite à la seule racine système.

File[] listeRacine = File.listRoots();

Comment parcourir une arborescence de fichiers ?Pour obtenir la liste des fichiers d'un répertoire :

/** Class : java.io.File */public File [] listFiles ();

Pour connaître le type d'un fichier :

/** Class : java.io.File */public boolean isDirectory ();public boolean isFile ();

Exemple :Cet exemple effectue un parcours récursif d'une arborescence de fichiers et affiche (sur la sortie standard) la liste de tous les fichiers contenus dans le répertoire et ses sous-répertoires.

public static void listeRepertoire ( File repertoire ) { System.out.println ( repertoire.getAbsolutePath()); if ( repertoire.isDirectory ( ) ) { File[] list = repertoire.listFiles(); if (list != null){

for ( int i = 0; i < list.length; i++) { // Appel récursif sur les sous-répertoires listeRepertoire( list[i]); }

} else { System.err.println(repertoire + " : Erreur de lecture."); } } }

Attention : cet algorithme ne fonctionne pas correctement avec une arborescence cyclique sous Unix !

84/122

Comment copier ou déplacer un fichier ?Copie de fichier :L'Api ne fournissant pas de solution clé en main pour la copie de fichier, voila un bout de code qui devrait fonctionner.

/** copie le fichier source dans le fichier resultat * retourne vrai si cela réussit */public static boolean copyFile( File source, File dest ) {

try {// Création du fichier :dest.createNewFile();

// Declaration et ouverture des fluxjava.io.FileInputStream sourceFile = new java.io.FileInputStream(source);

try {java.io.FileOutputStream destinationFile = null;

try {// Lecture par segment de 0.5Mo byte buffer[]=new byte[512*1024];int nbLecture;

while( (nbLecture = sourceFile.read(buffer)) != -1 ) {destinationFile.write(buffer, 0, nbLecture);

} } finally { destinationFile.close(); }

} finally { sourceFile.close(); }} catch (IOException e) {

e.printStackTrace(); return false; // Erreur }

return true; // Résultat OK }

Depuis Java 1.4, l'Api de Java a été enrichie de nio. Voici le code à utiliser pour une copie plus rapide de fichier en utilisant nio :

85/122

FileChannel in = null; // canal d'entréeFileChannel out = null; // canal de sortie try { // Init in = new FileInputStream("toto.txt").getChannel(); out = new FileOutputStream("tutu.txt").getChannel(); // Copie depuis le in vers le out in.transferTo(0, in.size(), out);} catch (Exception e) { e.printStackTrace(); // n'importe quelle exception} finally { // finalement on ferme if(in != null) { try {

in.close();} catch (IOException e) {}

} if(out != null) { try {

out.close();} catch (IOException e) {}

}}

Déplacer un fichierOn n'a vu que le déplacement d'un fichier pouvait être fait grâce à la méthode renameTo(java.io.File) de la classe java.io.File ( voir ici ) Mais cette solution n'est valable que pour des déplacements à l'intérieur d'un disque physique... On va donc utilisé l'algorithme de copie lorsque le renommage ne suffit pas :

public static boolean deplacer(File source,File destination) { if( !destination.exists() ) { // On essaye avec renameTo boolean result = source.renameTo(destination); if( !result ) { // On essaye de copier result = true; result &= copier(source,destination); if(result) result &= source.delete();

86/122

} return(result); } else { // Si le fichier destination existe, on annule ... return(false); } }

Comment supprimer un fichier ou un répertoire ?Supprimer un fichier ou un répertoire vide :La suppression des fichiers et des répertoires vides est effectuée grâce à la méthode delete() de la classe java.io.File. Un booléen en résultat indique si la suppression a réussi (cause d'échec : Fichier inexistant; Fichier en lecture seule; Le fichier est ouvert par une application ou par le système; Flux ouvert sur le fichier; etc...).

Supprimer un répertoire non-vide :L'Api de base ne permet pas de supprimer un répertoire contenant des fichiers, il faut donc supprimer à la main tous les fichiers du répertoire avant !

static public boolean deleteDirectory(File path) { boolean resultat = true; if( path.exists() ) { File[] files = path.listFiles(); for(int i=0; i<files.length; i++) { if(files[i].isDirectory()) { resultat &= deleteDirectory(files[i]); } else { resultat &= files[i].delete(); } } } resultat &= path.delete(); return( resultat ); }

87/122

Comment renommer/déplacer un fichier ?La méthode renameTo(java.io.File) de la classe java.io.File permet très facilement de renommer un fichier. De plus, si le répertoire destination est différent du répertoire source, le fichier sera déplacé. (ATTENTION : le déplacement n'est effectué que si la source et la destination sont sur le même disque physique, sinon une copie de fichier est nécessaire)

File source = new File("mon fichier");File destination = new File("mon fichier renommé");source.renameTo(destination);

Comment créer un fichier temporaire ?Un fichier temporaire est un fichier qui sera créé dans le répertoire temporaire du système et qui sera automatiquement supprimé à la fin de l'application (si la JVM quitte correctement).

File temp = File.createTempFile("nom",".tmp");temp.deleteOnExit();

Comment écrire à la fin d'un fichier ?Pour écrire à la fin d'un fichier il faut utiliser la classe java.io.FileWriter.Cette classe possède des constructeurs acceptant parmi leurs arguments un booléen nommé append.Si cet argument est positionné à true, les données écrites dans ce fichier seront mises à la fin de celui-ci.

Voici un exemple d'utilisation:

FileWriter writer = null;String texte = "texte à insérer à la fin du fichier";try{ writer = new FileWriter("fichier.txt", true); writer.write(texte,0,texte.length());}catch(IOException ex){ ex.printStackTrace();}finally{ if(writer != null){ writer.close(); }}

88/122

Comment connaître le type MIME d'un fichier ?Cette information peut être accessible grâce à la classe URLConnection du package java.net Par exemple :

public static String getMIMEType(File file){ if(file.isDirectory()){return "repertoire";} if(!file.exists()){return "fichier inexistant";} try{ URL url = file.toURL(); URLConnection connection = url.openConnection(); return connection.getContentType(); }catch(MalformedURLException mue){ return mue.getMessage(); }catch(IOException ioe){ return ioe.getMessage(); }}

Pour plus de "sécurité", vous pouvez utiliser la méthode statique guessContentTypeFromStream. A la différence de getContentType (ou guessContentTypeFromName) cette méthode essaye de déterminer le type MIME en lisant directement les premiers bytes de l'InputStream.

Comment connaître la date de création d'un fichier ?Date de création :Aucune solution n'est disponible pour connaître la date de création d'un fichier. Certains systèmes comme Linux ne fournissant pas cette information, aucun solution portable n'est possible.

Date de la dernière modification :Là, en revanche, aucun problème, la méthode lastModified() de la classe java.io.File est disponible.

long dateModification = monFichier.lastModified();

Toutefois, le long retourné par la méthode lastModified() peut dépendre du système d'exploitation et donc ne pas être toujours extrêmement précise.

Comment connaître l'espace libre d'un disque ?Aucune solution n'est pleinement portable, donc aucune solution pure Java.

JConfig

89/122

est une bibliothèque supplémentaire qui est lié à du code natif disponible pour plusieurs plateformes. Elle permet d'accéder à cette information, ainsi que beaucoup d'autre choses. http://www.tolstoy.com/samizdat/jconfig.html

Dans Java 6, il est désormais possible de connaître simplement l'espace libre, l'espace utilisable et l'espace totale grâce à trois nouvelles méthodes de la classe File.

public long getTotalSpace();public long getFreeSpace();public long getUsableSpace();

Comment indiquer la position d'un fichier en conservant la portabilité ?Les différents systèmes d'exploitation ne gèrent pas les arborescences de fichier de la même façon. Le monde Windows associe les périphériques physiques à des lettres de lecteur, le monde Unix utilise un seul répertoire racine. De plus, les séparateurs de fichier ne sont pas les mêmes (respectivement '\' et '/'). Tout ceci doit être analysé afin d'assurer la portabilité de l'application. Heureusement Java fournit tous les outils pour localiser efficacement les fichiers en gardant toute l'indépendance vis à vis du système d'exploitation.

Le plus important est de ne jamais utiliser directement de séparateur de fichier mais d'utiliser la constante définie en fonction du système dans la classe java.io.File.

/** Class : java.io.File */public static final char separatorChar;

Si vous désirez exprimer une liste de fichiers, il convient également d'utiliser la constante prévue à cet effet.

/** Class : java.io.File */public static final char pathSeparatorChar;

Comment lire des informations sur l'entrée standard ?L'entrée standard est accessible au programmeur grâce au flux 'in' de la classe java.lang.System. Si vous exécutez votre application dans une console, l'entrée standard contiendra tous les caractères entrés au clavier dans la console. La manipulation directe du flux n'étant pas très aisée, une petite conversion en java.io.BufferedReader s'impose.

/** Convertion du flux en BufferedReader */BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));

try { /** Lecture d'une ligne : */entree.readLine();} catch( IOException e ) { e.printStackTrace();

90/122

} Note : La lecture d'une ligne est une méthode dite 'blocante', tant que l'utilisateur n'a pas fait 'entrée', le processus attends.

Depuis J2SE 5.0 (Tiger) vous pouvez aussi utiliser un Scanner pour parser la sortie standard. Par exemple : Scanner scanner = new Scanner(System.in);// traitementscanner.close();

Le Scanner a l'avantage de possèder un ensemble de méthodes permettant de lire "directement" les types primitifs. Vous pouvez aussi l'utiliser pour faire des recherches dans les flux scannés avec des expressions régulières.

Depuis JAVA SE 6, il est possible de lire sur l'entrée standard via la classe http://java.sun.com/javase/6/docs/api/java/io/Console.html.

Par exemple : Console console=System.console();String ligneLue=console.readLine();

La classe Console propose également la méthode printf (si chère aux programmeurs C), ainsi qu'une méthode readPassword() qui n'affiche pas les carctères sur la console.

Comment charger une ressource présente dans le CLASSPATH (répertoire ou jar) ?Pour faire cela, il faut utiliser les méthodes getResource et getResourceAsStream de la classe Class. Le chemin à passer en argument est celui commençant dans le répertoire du CLASSPATH ou a la racine d'un fichier jar. Attention si le chemin ne commence pas par "/" alors le package courant est ajouté au début du chemin. Exemple:

package com.developpez;

public class Test {

public Test() { InputStream is1 = getClass().getResourceAsStream("fichier.txt");

InputStream is2 = getClass().getResourceAsStream("/fichier.txt"); } }

91/122

Dans le code de l'exemple is1 sera un InputStream ouvert sur un fichier "com/developpez/fichier.txt" présent dans un des répertoires du CLASSPATH ou dans la même arborescence à partir de la racine d'un fichier jar du CLASSPATH. is2 sera un InputStream ouvert sur un fichier "fichier.txt" présent directement dans un répertoire du CLASSPATH ou a la racine d'un fichier jar.

Comment changer l'encodage d'un fichier texte ?On peut spécifier l'encodage utilisé pour lire un flux. Voici un exemple qui lis un fichier en UTF-8 et écris celui-ci en ISO-8859-1 :

public static void toISO(String source, String destination){ BufferedReader br = null; PrintWriter pw = null; try{ //flux de lecture en UTF-8 br = new BufferedReader( new InputStreamReader( new FileInputStream(source),"UTF-8")); //flux d'écriture en ISO (valeur par défaut) pw = new PrintWriter(new FileOutputStream(destination)); String ligne; while((ligne = br.readLine())!=null){ pw.println(ligne); } }catch(Exception e){e.printStackTrace();} finally{ try { pw.close(); } catch( Throwable e ) {} try { br.close(); } catch( Throwable e ) {} } }

Comment connaître les Charset disponibles et leurs alias ?La classe java.nio.Charset nous permet de facilement accèder à ces informations.

Voici un exemple listant l'ensemble des charsets disponibles :

SortedMap<String,Charset> charsets = Charset.availableCharsets();for(String nom : charsets.keySet()){ System.out.println("Charset "+nom);

92/122

Charset charset = charsets.get(nom); for(String alias : charset.aliases()){ System.out.print(" "+alias+","); } System.out.println();}

Peut-on modifier l'encodage de la sortie standard ?Oui, cela est possible. Ceci peut être utile par exemple pour afficher corectement les caractères accentués.

Voici un exemple permettant d'écrire correctement les caractères accentués sur la console windows (DOS) :

PrintStream ps = new PrintStream(System.out,true,"IBM850");// on commence par changer l'encodage en IBM850 (connu aussi sous l'alias Cp850)System.setOut(ps);// ensuite l'utilisation de la sortie standard reste la mêmeSystem.out.println("àâäÂÄéèêëîïÎÏÊËôöÔÖûüùÛÜÿç");

Réseaux

Comment puis-je faire un 'ping' en Java ?Depuis J2SE 5.0 (Tiger)Vous pouvez utiliser la méthode isReachable(int timeout) de la classe InnetAdress qui indique si l'adresse est accessible. Les implémentation de cette méthode utilisent en général ICMP. En cas de problèmes d'accès ICMP, la méthode tente une connexion TCP sur le port 7 (echo).

Avant : aucune solution portable !La commande ping nécessite des paquets ICMP (Internet Control Message Protocol : voir  http://www.faqs.org/rfcs/rfc792.html).Les bibliothèques standards de Java ne supportent pas ICMP. Il n'est donc pas possible d'effectuer de ping en Java sans avoir recours à du code natif ou un programme externe.

Comment connaître l'adresse IP de sa machine ?Si vous avez Windows et une seule carte réseau, l'information n'est pas trop difficile à obtenir, ce petit code suffit :

String ip = InetAddress.getLocalHost ().getHostAddress ();

93/122

Sinon, cela va se compliquer. Il faut parcourir les interfaces réseaux et filter les bonnes addresses :

/** * Retourne toutes les adresses ips des carte réseau de la machine. Retourne seulement les addresses IPV4 * * @return Une liste des addresses ip */public List<String> getIps(){

List<String> ips = new ArrayList<String>();

try{Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();

while (interfaces.hasMoreElements()) { // carte reseau trouvee NetworkInterface interfaceN = (NetworkInterface)interfaces.nextElement(); Enumeration<InetAddress> ienum = interfaceN.getInetAddresses(); while (ienum.hasMoreElements()) { // retourne l adresse IPv4 et IPv6 InetAddress ia = ienum.nextElement(); String adress = ia.getHostAddress().toString(); if( adress.length() < 16){ //On s'assure ainsi que l'adresse IP est bien IPv4 if(adress.startsWith("127")){ //Ce n'est pas l'adresse IP Local' System.out.println(ia.getHostAddress()); } else if(adress.indexOf(":") > 0){ System.out.println(ia.getHostAddress()); // les ":" indique que c'est une IPv6" } } ips.add(adress); } } } catch(Exception e){ System.out.println("pas de carte reseau"); e.printStackTrace(); } return ips;

94/122

}

Comment spécifier un proxy pour se connecter à un serveur ?Au lancement de la JVM :

La première solution consiste à préciser le proxy au démarrage de la JVM, idéale si une application ne gère pas cette option...java -DproxySet=true -DproxyHost=nomproxy -DproxyPort=numport test

Depuis le programme :ces options peuvent également être initialisées par le programme en modifiant les propriétés systèmes.

Properties prop = System.getProperties();prop.put("http.proxyHost","172.28.48.1");prop.put("http.proxyPort","8080");

Si vous avez besoin de vous authentifier sur le proxy avec un user/mot de passe, il faut utiliser la classe Authenticator pour indiquer ces informations. Il suffit pour d'utiliser la méthode setDefault(Authenticator a) avec un Authenticator personnel :

Authenticator.setDefault(new Authenticator(){protected PasswordAuthentication getPasswordAuthentication() {

return new PasswordAuthentication("user", "password".toCharArray()); }});

Comment envoyer une requête de type POST en utilisant une URL ?Pour faire cela, on doit récuperer l'URLConnection correspondant à l'URL. Par exemple :

public void doPost(String adresse){ OutputStreamWriter writer = null; BufferedReader reader = null; try { //encodage des paramètres de la requête String donnees = URLEncoder.encode("clef", "UTF-8")+ "="+URLEncoder.encode("valeur", "UTF-8"); donnees += "&"+URLEncoder.encode("autreClef", "UTF-8")+ "=" + URLEncoder.encode("autreValeur", "UTF-8");

//création de la connection

95/122

URL url = new URL(adresse); URLConnection conn = url.openConnection(); conn.setDoOutput(true); //envoi de la requête writer = new OutputStreamWriter(conn.getOutputStream()); writer.write(donnees); writer.flush();

//lecture de la réponse reader = new BufferedReader(new InputStreamReader(conn.getInputStream())); String ligne; while ((ligne = reader.readLine()) != null) { System.out.println(ligne); } }catch (Exception e) { e.printStackTrace(); }finally{ try{writer.close();}catch(Exception e){} try{reader.close();}catch(Exception e){} }}

Comment établir une communication entre une applet et une servlet ?Il existe différentes façons pour établir une communication entre une applet et une servlet. Les deux méthodes suivantes ne sont pas propres aux servlets, et peuvent être aussi utilisées entre 2 applications quelconques.

RMI : permet de manipuler des objets distants (plus d'infos ici)

Socket : création d'un flux point à point (plus d'infos ici)

La méthode la plus proche du mode de fonctionnement d'une httpServlet est une communication HTTP; elle a l'avantage d'utiliser (en général) le port 80, et donc de franchir plus facilement les firewalls. La requête HTTP de l'applet peut se faire soit par GET, soit par POST (multipart).

/** Envoi de données par GET */URL url = new URL("http://localhost/servlet?cle1=valeur1&cle2=valeur2");URLConnection conn = url.openConnection();

96/122

/** Envoi de données par POST */URL url = new URL("http://localhost/servlet");String data = "cle1=valeur1&cle2=valeur2");URLConnection conn = url.openConnection();conn.setDoOutput(true);OutputStreamWriter osw = new OutputStreamWriter(conn.getOutputStream());osw.write(data);osw.flush();osw.close();

/** Récupération de la réponse de la servlet */BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));String line;while ((line = br.readLine()) != null) { /** traitement des lignes */} br.close();

Pour envoyer la réponse à partir de la servlet, il suffit d'utiliser l'OutputStream de l'HttpServletResponse.

/** Réponse de la servlet */String texte = "...";PrintStream out = new PrintStream(response.getOutputStream());out.println(texte);out.close();

Remarque: pour le passage des données (clés ou valeurs), si des caractères spéciaux sont employés, utiliser URLEncoder :

cle1 = URLEncoder.encode(cle1, "UTF-8")

97/122

L’exécution

Comment créer un programme Java exécutable ?Il y a différentes façons de comprendre "exécutable" :

Une machine virtuelle est installéeEcrire un script dans un fichier de commande (.bat, ...) pour lancer l'application Créer une application .jar exécutable (plus d'infos)

points positif : on simplifie le lancement de l'application.

points négatif : la machine virtuelle installée n'est peut-être pas assez récente.

Installation automatique d'une machine virtuelle

Packager son application avec une machine virtuelle associée (exemple : InstallAnyWhere de ZeroG).

points positif : L'utilisateur n'a pas à installer une machine virtuelle lui-même et on est sûr de la compatibilité JVM / application.

points négatif : L'application est plus lourde de quelques Mo supplémentaires et il faut réaliser un exécutable par plateforme.

Plus de machine virtuelle

Utilisation d'un compilateur natif.

points positif : L'application est plus légère qu'avec une JVM associée et on gagne en performance (Le gain est nettement moins significatif maintenant que la JVM utilise un compilateur à la volée (Just In Time)).

points négatif : L'application n'est plus portable et le logiciel, pour rendre le code natif, se limite souvent aux classes les plus courantes de l'API.

Comment créer un jar exécutable ?Tout d'abord, il convient de créer un fichier Manifest. Ce fichier contiendra le nom de la classe à exécuter ainsi que les archives à mettre dans le CLASSPATH.

Manifest-Version: 1.0 Created-By: 1.4.1_01 (Sun Microsystems Inc.)

98/122

Main-Class: Start Class-Path: .\archive1.jar .\archive2.jar

Attention : il est nécessaire de terminer le fichier manifest par un saut de ligne.

Nous appellerons le fichier MANIFEST.MF et il sera placé dans un répertoire META-INF en racine de l'application (par exemple). Les archives jar du classpath ne seront pas inclues dans ce jar mais seront situées par la suite dans le même répertoire que nous allons créer (ou dans un path bien défini). Si l'on veut qu'elles soient rangées dans un répertoire il suffira de donner le path:

Class-Path: path1\archive1.jar path2\archive2.jar A noter que de puis Java SE 6, on peut utiliser le caractère étoile (*) pour prendre tous les librairies d'un dossier :

Class-Path: path/*

Pour créer le jar il faut déjà supprimer tous les .java L'idéal étant de copier tous les .class (avec leur arborescence s'ils sont packagés) dans un répertoire temporaire pour créer le jar dans ce répertoire. On peut aussi copier les fichiers qui seront accessibles dans le jar (images) s'il y en a.

La commande permettant de créer un fichier .jar est la suivante : jar cvfm fichier-jar fichier-manifeste fichiers...

Voilà la signification des différents paramètres :

fichier-jar : est le nom du jar à créer

fichier-manifeste : fichier MANIFEST.MF

fichiers : fichiers à ajouter à l'archive. Si un des fichiers est un répertoire, celui-ci est traité récursivement.

Dans le répertoire des .class, on exécutera donc la commande suivante : jar cvfm monappli.jar META-INF/MANIFEST.MF .

Cela va nous créer un .jar éxécutable nommé monappli.jar avec le fichier MANIFEST.MF présent dans le répertoire META/INF. Ce jar se voit ajouter les fichiers du répertoire courant (spécifié par le caractère '.').

99/122

Le programme jar reconstruira le fichier Manifest et affichera sur la sortie standard les résultats (ça permet de vérifier qu'il est codé correctement). On exécute ensuite le jar de la façon suivante :

java -jar monappli.jar

Les archives indiquées dans le Class-Path du Manifest seront recherchées selon leurs chemin relatif par rapport au fichier Jar principal.

Comment signer un JAR ?Il faut d'abord générer un certificat :

keytool -genkey -alias signature -keystore monStore

Il faut alors répondre aux différentes questions (nom, prénom, société, adresse,....) Cela génère un certificat "signature' qui est stocké dans un dépot "monStore"

Ensuite pour signer le jar :

jarsigner -keystore monStore -signedjar sMonJar.jar monJar.jar signature

Cela génère le jar "sMonJar.jar" qui est la version signée avec le certificat "signature" du jar "monJar.jar".

Comment obtenir la pile d'exécution d'une méthode ?Avant le SDK 1.4

Throwable t = new Throwable(); StringWriter sw = new StringWriter(); t.printStackTrace(new PrintWriter(sw, true)); String stackTrace = sw.toString();

La chaîne ainsi obtenue correspond a l'affichage d'un printStackTrace() d'une exception.

A partir du SDK 1.4 Throwable t = new Throwable(); StackTraceElement traces[] = t.getStackTrace();

100/122

Le tableau traces contient la pile d'exécution au moment de la création du Throwable. Le premier élément du tableau correspond a la création du Throwable, le dernier élément du tableau représente le bas de la pile.

Comment avoir une seule instance de mon application qui tourne ?Une astuce possible est d'utiliser une ServerSocket, du package java.net. On peut lancer un tel type de socket (sur un port précis) lors de l'exécution du main. Si une Exception est levée, cela indique qu'une instance de l'application est déjà en train de tourner. Voici un exemple :

private static int PORT = 12345; public static void main(String[] args) { try { new ServerSocket(PORT); System.out.println("Instance du programme unique"); }catch(Exception e){ System.out.println("Il y a deja une instance du programme active"); System.exit(0); } }

La seule difficulté sera de déterminer un port libre (non utilisé par une quelconque application de la machine).

Lorsque l'application est déployé via Java Web Start, il est possible d'utiliser un service conçu spécialement pour cela :

// Utilisation du service :SingleInstanceService singleInstanceService =

(SingleInstanceService)ServiceManager.lookup("javax.jnlp.SingleInstanceService"); // Ajout d'un listener qui sera appelé pour chaque nouvelle instance :singleInstanceService.addSingleInstanceListener( new SingleInstanceListener() {

public void newActivation(String[] params) {// 'params' contient les paramètres passé à la nouvelle instance

}});

101/122

Système

Comment connaître le système d'exploitation depuis le programme ?Bien que Java soit conçu pour fonctionner indépendament du système, il est parfoit utile de savoir lequel exécute notre programme. Cela permet, par exemple, de choisir si l'on doit exécuter Mozilla, Safari ou plutot Internet Explorer.

Pour cela, il suffit de consulter les variables d'environnement initialisées par la JVM :

String name = System.getProperty ( "os.name" );String version = System.getProperty ( "os.version" );

Comment accéder aux valeurs des variables d'environnement ?Variable d'environnement du système :L'accès aux variables d'environnement se fait par l'intermédiaire de la classe java.lang.System et plus précisément par la méthode getProperty(java.lang.String clé). Cette méthode donne accès à toutes les variables définies par le système. Des variables peuvent facilement être initialisées lors du lancement du programme en les ajoutant à la ligne de commande :

java -DTEST="test" nom_programme// Création d'une variable : TEST = "test"

Variable d'environnement de Java :Se baser sur les variables du système n'étant pas très portable, Java définit un certain nombre de variables de façon indépendante de la plateforme d'exécution.Exemple :

System.getProperty("user.dir");System.getProperty("java.home");System.getProperty("os.name");

Connaître la liste des variables d'environnement :La liste des variables d'environnement est disponible par la méthode getProperties() de la classe java.lang.System.Programme affichant la liste de toutes les variables :

java.util.Enumeration liste = System.getProperties().propertyNames();String cle;while( liste.hasMoreElements() ) { cle = (String)liste.nextElement(); System.out.println( cle + " = " + System.getProperty(cle) );

102/122

}

Comment exécuter une application externe ?Execution : L'exécution d'un programme externe se fait grâce à la méthode exec(java.lang.String commande) de la classe java.lang.Runtime.

try { Process proc = Runtime.getRuntime().exec("commande paramétrée");} catch (IOException e) { }

Communication : Il est possible de communiquer avec l'application grâce à l'objet java.lang.Process :

destroy() pour tuer l'application fille.

waitFor() pour attendre la fin de l'application fille (Attention à ne pas bloquer l'exécution du processus d'évènement awt).

getErrorStream(), getInputStream() et getOutputStream() pour communiquer avec l'application.

exitValue() pour connaître l'état de sortie de l'application.

Comment lancer une application sans le terminal (Windows uniquement) ?Lorsque l'on exécute une application Java sous windows, un terminal de commande permet d'afficher les entrées/sorties de l'application. Si vous souhaitez exécuter votre application sans le terminal, il suffit d'utiliser javaw.exe à la place de java.exe

javaw -CLASSPATH ... monAppliUne deuxième solution consiste à créer une archive Jar contenant tous les fichiers de l'application et un fichier 'manifest'. De cette manière, il suffit alors de double-clicker sur le fichier jar pour l'exécuter. Pour plus d'informations, lire : Comment créer un jar exécutable ?

Comment trouver le répertoire contenant le jar où est ma classe ?Le bout de code suivant permet de retrouver le répertoire contenant le fichier jar où est la classe courante.

103/122

Si la classe n'est pas dans un jar, le répertoire sera celui présent dans le CLASSPATH.Par exemple si la classe est:C:\sources\java\lang\Object.classLe répertoire trouvé sera:C:\sources

Voici le code pour réaliser ça:

String path = "/" + TestLocation.class.getName().replace('.', '/') + ".class"; URL url = getClass().getResource(path); path = URLDecoder.decode(url.toString(), "UTF-8"); // suppression de la classe ou du jar du path de l'url int index = path.lastIndexOf("/"); path = path.substring(0, index);

if (path.startsWith("jar:file:")) { // suppression de jar:file: de l'url d'un jar // ainsi que du path de la classe dans le jar index = path.indexOf("!"); path = path.substring(9, index); } else { // suppresion du file: de l'url si c'est une classe en dehors d'un jar // et suppression du path du package si il est présent. path = path.substring(5, path.length()); Package pack = getClass().getPackage(); if (null != pack) { String packPath = pack.toString().replace('.', '/'); if (path.endsWith(packPath)) { path = path.substring(0, (path.length() - packPath.length())); } }

104/122

} System.out.println("Répertoire contenant la classe: " + path);

NB : Pour un JDK inférieur au 1.4 il faut utiliser URLDecoder.decode(String uneURL).

NB2 : Pour appeler ce code depuis un bloc static il faut remplacer getClass() par NomDeLaClasse.class.

Comment faire en sorte que le paramètre int de ma méthode soit modifié en retour ?En Java les types de base sont passés aux méthodes par valeur, ils ne peuvent pas être modifiés. Il va falloir utiliser une instance de classe "encapsulant" un entier pour effectuer la modification. Attention la classe fournie Integer ne permet pas la modification et est donc inutile dans ce cas.

Exemple :

class MonEntier { /** champ privé : */ private int value; /** mise à jour de la valeur */ public void setValue(int newValue) { value = newValue; } /** Acces à la valeur */ public int getValue() { return( value); } }

Dans la méthode maMethode faire :

public void maMethode (MonEntier i) { i.setValue(maNouvelleValeur);}

105/122

Comment gérer les fermetures accidentelles ( Contrôle-C et kill -9 ) ?Contrôle-C, kill -2, kill -15 et autres sont des méthodes permettant d'arrêter l'exécution du programme sans lui demander son avis. Pourtant, il est parfois nécessaire de faire au moins quelques instructions capitales telles que la fermeture de flux de fichier, d'une connexion réseaux ou une sauvegarde rapide. Pour se faire il est possible de définir un 'ShutdownHook' ce qui se traduit par un thread exécuté à la réception du signal de fin d'exécution.

Attention : Ce traitement final sera également éxécuté lors de l'arrêt normal de l'application.

Cette astuce ne marche malheureusement pas pour le code kill -9.

Comment forcer le passage du 'Garbage collector' ?Le garbage Collector (rammasse miette) est la partie de la JVM qui s'occupe de la récupération des zones mémoires. Les phases de libération de la mémoire sont gérées de façon autonome, il est inutile de lui dire quand passer.

Il existe néanmoins la fonction gc de la classe java.lang.System qui permet de faire un appel explicite au garbage collector. Cet appel ne garantit pas que tous les objets inutiles seront supprimés de la mémoire.

System.gc ();//Appel explicite au Garbage collector

Néanmoins, cette méthode ne garantit par le passage du GC. Elle permet seulement d'augmenter la propabilité que le GC se déclenche. Il est préférable de mieux gérer ses objets plutôt que d'utiliser cette méthode.

Comment faire une énumération en Java ?Voici trois solutions :

1ère solution :

public class MonEnum { public final static int Val1=0; public final static int Val2=1; public final static int Val3=2;

106/122

}

On peut ensuite utiliser MonEnum.Val1, MonEnum.Val2 etc, ou mieux on peut faire une interface plutôt qu'une classe afin que les classes l'implémentant puissent directement appeler Val1, Val2...

Le problème reste le typage des éléments, rien n'empêche de passer un objet d'une énumération à la place d'une autre.

2ème solution :Cette deuxième catégorie de solutions, plus complexes, permet d'éviter ce problème. On peut par exemple penser à utiliser des instances de classes :

public final class MonEnum1 { private MonEnum1() { /** Rien à faire */ } /** liste des valeurs */ public final static MonEnum1 Val1 = new MonEnum1(); public final static MonEnum1 Val2 = new MonEnum1(); public final static MonEnum1 Val3 = new MonEnum1();}

Ainsi un éventuel objet de type MonEnum2 ne pourra jamais être utilisé à la place d'un objet de type Enum1 (Enum1.Val1 Enum1.Val2 ...).

2ème bis solution :La 2ème solution pose un autre problème, il reste possible d'utiliser la valeur 'null' alors que celle-ci n'appartient pas au domaine de notre énumération. Pour ce faire, rien de plus simple, si on considère val1 comme la valeur par défaut, on la déclare de la manière suivante :

public final static Enum1 val1 = null;

De cette manière il devient totalement impossible de passé un Enum1 non reconnu !

3ème solution :Depuis Java 5.0, vous pouvez utiliser le mot-clé enum pour créer des énumérations. Voilà comment vous pouvez procéder pour créer un énumération :

enum Align{ LEFT,RIGHT, CENTER,JUSTIFIED

};

107/122

Vous pouvez accéder aux valeurs ainsi :

Align.LEFT;Align.RIGHT;

Conclusion :Si vous avez Java 5.0 ou une version plus récente, il vous faut utiliser la solution 3.

Comment recharger dynamiquement une classe ?En utilisant la méthode:

Class c = Class.forName("com.developpez.MaClasse");

On utilise le ClassLoader du système. Ce ClassLoader cache l'information et ne rechargera pas la classe lors d'un nouvel appel a forName, et ce même si le fichier ".class" a changé depuis le dernier chargement.

Il y a deux solutions :

1 - La classe n'est pas présente dans le CLASSPATH C'est le cas le plus simple, il suffit d'utiliser un nouveau URLClassLoader a chaque fois pour recharger une nouvelle version de la classe.

// le chemin ou trouver la classe a recharger URL chemins[] = { new URL("file:/C:/MesClasses/") }; URLClassLoader loader = new URLClassLoader(chemins); Class c = loader.loadClass("com.developpez.MaClasse");

Attention, il faut créer a chaque fois un nouvel URLClassLoader, sinon la classe est cachée par le loader.

Si la classe est présente dans le CLASSPATH c'est le ClassLoader du système qui la charge (et la met dans son cache).

2 - La classe est présente dans le CLASSPATH

Dans ce cas, on ne peut pas utiliser l'URLClassLoader. Il faut créer son propre ClassLoader qui hérite de la classe ClassLoader

import java.io.InputStream;

public class MonLoader extends ClassLoader {

108/122

public Class loadNewClass(String aName) throws Exception { InputStream is = getClass().getResourceAsStream("/" + aName); if (null == is) { return null; }

byte buffer[] = new byte[is.available()]; is.read(buffer); Class c = defineClass(aName, buffer, 0, buffer.length); resolveClass(c); return c; } }

Dans ce code, nous avons créé une nouvelle méthode "loadNewClass" qui recharge le fichier ".class" a chaque fois.

Le fait de ne pas avoir redéfini la méthode loadClass permet a ce nouveau ClassLoader d'utiliser le ClassLoader du système pour charger d'eventuelles classes mères ou interfaces.

Si la méthode loadClass est redéfinie il faut qu'elle puisse aussi trouver les super classes et interfaces des classes qui seront chargées, et ce sans recharger celles déjà présentes dans le système.

Design patterns

Qu'est ce que le pattern Transfer Object?Le pattern transfer Object précédemment appelé Value Object est une classe implémentant l'interface Serializable.Ce pattern est essentiellement utilisé pour échanger des données entre une application cliente et des EJB de type Entity (EntityBean).

Pourquoi me direz-vous?

109/122

Tout simplement parce que, comme vous le savez, les EntityBean comme tous les EJB sont des objets distants, ce qui induit, pour chaque accès à celui-ci, un aller-retour à travers le réseau, avec en plus démarrage/validation de transactions.Par exemple, pour lire un objet Personne avec 5 attributs, il vous faudra 6 allers-retours pour récupérer vos informations (1 findByPrimaryKey + 5 lectures d'attribut).

C'est pour cette raison que les Transfer Object sont là.les EntityBean ne sont là que pour être utilisé sur le serveur EJB (dans les EJB 2.0, ils sont maintenant "local", ils ne peuvent pas être accessible de l'exterieur). L'idée est de fournir un service avec des EJB stateless qui vont vous fournir les service qui vous intéressent (Lecture/création/modification/suppression ... d'un objet). Cet EJB utilise des Entity en interne pour faire les opérations, et créer des classes de transport (avec uniquement les attributs + get/set), cette classe doit implémenter Serializable pour pouvoir passer sur RMI/IIOP. C'est cette classe que l'on appelle Transfer Object

L'avantage de ce modèle, c'est avoir une programmation distante (N tiers) avec le transit de veritables objets que vous allez pouvoir manipuler puis renvoyer au serveur pour modification... .

Quels sont les design patterns que vous connaissez ?3 familles sont identifiées par le GoF (Gang of Four)

CréationFabrique abstraire (abstract factory)Monteur (builder)Fabrique (factory method)Prototype (prototype)Singleton (singleton)

StructureAdapteur (adapter)Pont (bridge)Objet composite (composite)Décorateur (decorator)Façade (facade)Poids-Mouche (Flyweight)Proxy (proxy)

ComportementChaîne de responsabilité (chain of responsability)Commande (command)Interpréteur (interpretor)Itérateur (iterator)Médiateur (mediator)

110/122

Memento (memento)Observateur (observer)Etat (state)Stratégie (strategy)Patron de méthode (Template method)Visiteur (visitor)

Citer les DP des Gang of 4, Etat, singleton, façade.

Questionnaire 2

Que permet la classe ThreadLocal ?Cette classe permet à chaque thread de posséder sa propre copie initialisée indépendamment d’une variable statique privée, par exemple, un ID d’utilisateur ou de transaction.On peut ainsi associer un état à un thread.

Qu’est ce qu’un template ?

Qu’est ce que la surcharge des opérateurs ?C'est une technique qui permet de réaliser des opérations mathématiques intelligentes entre des objets en utilisant des symboles comme +, -, *, etc.

Une classe abstraite peut-elle étendre une classe concrète ? oui

C’est quoi un JSP ? Voir Que sont les JSP ?Les JSP (Java Server Pages) sont un standard permettant de développer des applications Web interactives, c'est-à-dire dont le contenu est dynamique. C'est-à-dire qu'une page web JSP (repérable par l'extension .jsp) aura un contenu pouvant être différent selon certains paramètres (des informations stockées dans une base de données, les préférences de l'utilisateur,...) tandis que page web "classique" (dont l'extension est .htm ou .html) affichera continuellement la même information.

111/122

Ca se présente sous quelle forme   ? Il s'agit en réalité d'un langage de script puissant (un langage interprété) exécuté du côté du serveur (au même titre que les scripts CGI,PHP,ASP,...) et non du côté client (les scripts écrits en JavaScript ou les applets Java s'exécutent dans le navigateur de la personne connectée à un site).Les JSP sont intégrables au sein d'une page Web en HTML à l'aide de balises spéciales permettant au serveur Web de savoir que le code compris à l'intérieur de ces balises doit être interprété afin de renvoyer du code HTML au navigateur du client.

Qu’y a-t-il dedans   ? Comment on fait du Java dedans   ?

Le Javascript s’exécute côté client ou côté serveur ?Côté serveurCa sert à quoi   ? Intégration de code dans les pages web : enrichissement de l’interface utilisateur, manipulation de données…b) Nom de la méthode Javascript.c) Comment fait-on pour récupérer une sous-classe dans une chaîne de caractère   ?

Par défaut, les Servlets sont multithreadés ou par instance ?Multithreadés

Citez 2 classes emblématiques de Struts.

C’est quoi les EJB ?

Quelles catégories connaissez-vous   ? Cf Que sont les EJB ?

Avez-vous utilisé les EJB entités   ? Quelle est la différence entre EJB 1.1 et 2.0   ? Nouveau modèle cmp : basé sur un nouveau contrat appelé « abstract persistence schema » permettant au container de gérer la persistance automatiquement à l’exécutionEJB Query language : langage basé sur le sql pour le requêtage d’ejbInterfaces locales : des beans peuvent dorénavant être appelés localement, par la même machine virtuelle et aisni ne nécessite pas d’être wrappés comme des beans distants, les arguements entre les interfaces passant directementEJB Home method : les beans entité peuvent déclarer des méthodes ejbhome propre à ces beans mais non spécifique à une instance particulièreMessage Driven Bean (MDB): nouveau EJB conçu spécialement pour gérer les messages JMS.

Qu’est ce qu’une classe anonyme ?Ce sont des classes locales directement déclarées et instanciées au sein d'une même expression de code. Elles peuvent directement étendre une classe ou implémenter une interface. Elles peuvent spécifier les arguments d'un des constructeurs de la super-classe mais ne peuvent pas en définir.

112/122

Dans quels cas, peut-on attribuer des attributs private ?

Quelle est le gros inconvénient du « garbage collector » ?Pas adapté pour les programmes temps réel car non prédictif.

String, c’est quoi ? C’est une classe qui représente une chaine de caractères.

Transiant, c’est quoi ?C’est un mot clé qui permet de spécifier qu’un variable ne peut être sérialisée.

Comment stopper le dérivé d’une classe ?En utilisant le mot clé final à la déclaration de la classe.public final class MyFinalClass {...}

Quelle est la méthode interne de la classe string ?

Comment interdire la méthode ?

C’est quoi synchronized ?C’est un mot clé qui permet d’obtenir un accès exclusif à un objet, une méthode…

La réflexivité, c’est quoi ?La réflexivité consiste é découvrir dynamiquement des informations propres à une classe ou à un objet.

Connaissez-vous les proxy class ? C’est quoi ?Elles permettent d’interagir avec des objets distants de façon transparente. Le processus redirige les appels aux méthodes du proxy vers le processus distant.

Quels DP avez-vous utilisés ?

113/122

A faire le Composite en UML ? Quel est l’intérêt de ce patern ?

Ce pattern permet de manipuler des objets et des groupe d’objets de la même façon.

L’Abstract Factory, à quoi ça sert ? comment le modéliser ? Pourquoi ce nom Abstract Factory par rapport à Abstract ?Le but de ce pattern est de pouvoir créer des objets regroupés en familles sans avoir à connaître les classes concrètes destinées à la création de ces objets.

114/122

Visiteur : comment ajouter des fonctionnements à une classe sans toucher à la classe ? En ajoutant les fonctionnalités au visiteur dédié.

Inconvénient de ce pattern Si la structure de données change, il faut changer tous les visiteurs.

Quand la méthode « Finalize » d’un objet est-elle appelée ?Cette méthode est appelée par le garbage collector lorsque l’instance n’est plus nécessaire.

115/122

On met quoi dans le Finalize ? Libérer des ressources mémoire.

Si une classe comporte un bloc déclaré « static »{}, est-il exécuté à chaque instanciation de celle-ci ? Static, ça sert à quoi ?Le bloc d’initialisation est dans ce cas appelé à la première instanciation seulement.Static sert à déclarer une méthode, une variable, un bloc… comme n’appartenant pas à une instance particulière de la classe. Il est donc exécuté une seule fois pour un bloc ; les méthodes et variables étant partagées par toutes les instances.

Une méthode statique d’une classe peut-elle manipuler les variables non statiques de cette classe ?non

Les membres protected d’une classe sont-elles accessibles depuis des classes du même package n’ayant aucune relation d’héritage avec elle ?Oui

2 instances d’une même classe ne peuvent pas accéder mutuellement à leurs membres privés. Vrai ou faux ?

Dans quel cas peut-on manipuler des attributs private ?

Lequel de ces gestionnaires récupère toutes les exceptions ?a) Finally {}b) Catch (…){}c) Catch (){}d) Catch (Trowable t) {}

Des classes anonymes sont :a) Des classes dont on ne connaît pas le nom

b) Des classes ayant implémenté partiellement une interfacec) Des classes que l’on peut manipuler par réflexiond) Des classes que l’on déclare localement à une méthode, lors de leur instanciation

Existent-ils des héritages entre tableaux ?

116/122

Une classe A peut-elle hériter d’une classe B et d’une classe abstraite C ?

La visibilité par défaut d’un attribut ou d’une fonction est-il protected, private ou public ?Entre protected et private. L’accès est possible aux classes du package mais pas aux classes dérivées (hors du package), contrairement au protected.

Dans une relation d’héritage, certains membres de la classe mère sont inaccessibles à la classe fille. Lesquels sont-ils  ? Les membres protected, private ou les 2Les private sont inaccessibles. 

Qu’est-ce qu’un constructeur C’est une méthode spéciale appelée à l’instanciation d’une classe.

Pouvez-vous me citer les 3 notions de l’objet ?EncapsulationHéritagePolymorphisme

Définir l'encapsulation L’encapsulation est l’idée de protéger l’information contenue dans un objet et de ne proposer que des méthodes de manipulation de cet objet.

Expliquez le fonctionnement du BorderLayout (Java Swing)C’est un gestionnaire de mise en forme qui décompose le conteneur en 5 zones : Centre, Nord, Sud, Est, Ouest. Par défaut les composants sont placés au centre.

Peut-on mettre un Jpanel dans un Jpanel ? Pourquoi? Quelle utilité ?

Que fait la méthode run () d'un Thread (en détail) ?

Comment fonctionne un environnement multi-threadé ?

Comment le gère-t-on? Quelles classes /mécanismes ?

Comment fonctionne le mode cluster en JBOSS? Détaillez. Expliquer le paramétrage.

Que contient un Jar? et si le jar contient des javabeans ?

117/122

Citez quelques mots clés de la gestion d'exceptionTry, catch, finally, throw

Si on a un return () dans le try avant le catch et le finally est-ce que l'on passe dans le finally ?Oui

Une variable déclarée de type « long » est codée sur : a- 8 bits

b- 16 bitsc- 32 bitsd- 64 bits

A quoi sert la méthode run() d’un thread ?Permet le lancement d’un thread en mode séquentielle ; le programme attend la fin de l’exécution pour poursuivre.

Différence entre Collection et Collections ?Collection est une interface et Collections une classe

C’est quoi un DBLink ?C’est un objet d’une base de données qui permet d’exécuter des requêtes sur une autre base de données.

Questions personnelles

1) Qu’est ce qu’un projet réussi pour vous ?

2) Qu’est-ce qui est le plus important pour vous dans le cadre d’un projet ?

3) Où vous voyez-vous à Court Terme / d’ici 2 ans ? A Moyen Terme / Dans 4-5 ans ?Long Terme / dans 8-10 ans ?

4) Le projet idéal ?

5) Quel est le projet qui vous a le plus intéressé tout au long de votre carrière ?

118/122

6) Pourquoi avez-vous choisi des études d’informatique ?

7) Vos passions ?

8) Qualités ?

9) Défauts ? (il est préférable d'énoncer des défauts qui sont en fait des qualités un peu trop exacerbées : trop exigeant, etc

10) Que préférez-vous ?

- Un cahier des charges détaillé- Un cahier des charges pas rédigé

11) Sur votre mission, si vous avez un problème, que faites-vous ?

- Vous allez tout de suite voir votre CDP- Vous vous débrouillez tout seul

12) Comment gérez-vous vos priorités ?

13) Trouvez les points positifs de chacune des missions que vous avez effectuées

14) Qu’est ce qui vous intéresse sur ce projet ?

15) Qu’est ce que vous allez nous apporter ? (rester modeste)

16) Qu’est ce que le projet va vous apporter ?

17) Pourquoi on vous choisirait plutôt qu’un autre candidat ?

18) Préférez-vous travailler en équipe ou de manière autonome ?

19) Avez-vous déjà été sous pression sur un projet ?

20) Quelle est votre résistance au stress ?

21) Avez-vous connu l’échec sur certains projets ?

22) Quels ont été vos principaux succès ?

119/122

Avez-vous eu des situations de conflit sur certains projets ?

23) Avez-vous connu des difficultés sur certains projets ? Si oui, comment les avez-vous résolu ?

24) Quel est votre niveau d’anglais ?

25) Présentez-vous en anglais

26) Vous démarrez demain le projet, vous commencez par quoi ?

27) Pourquoi ce projet vous intéresse-t-il ?

28) Qu’est ce que vous connaissez du client ?

29) Qu’est ce qui vous a amené à passer d’une mission à l’autre ?

30) Qu’avez-vous retenu du projet (pour le second entretien) ?

31) Avez-vous des relations dans l’environnement de la finance (ou télécom : car les impacts sont assez proches) ? Si oui, que vous ont-ils dit à ce sujet ?

32) Comment vous noteriez-vous (de 1 à 10) sur les technologies proposées ?

33) Aimez-vous faire des doc ?

34) Parlez-nous d’une expérience similaire à notre projet

35) Est-ce que les astreintes vous dérangent ?

36) Avez-vous déjà été force de proposition sur certains projets ? Si oui, lesquels ?

37) Quel type de poste recherchez-vous aujourd’hui ?

38) Préférez-vous les projets courts ou les projets longs ?

39) Sur la mission décrite, qu’est ce qui vous semble le plus complexe ?

40) Qu’est ce qui vous plaît le plus dans votre poste ?

120/122

41) Quel est le comportement que vous n’appréciez pas d’un collègue de travail ?

42) Vous préférez quoi une petite ou une grosse équipe ?

43) Quels ont été les cours que vous préféré ?

44) Qu’est ce qui a le plus satisfait / intéressé au sein de chacun de vos stages ?

45) Qu’est ce qui a motivé vos études ?

46) Quel a été l’algorithme le plus compliqué que vous ayez eu à écrire ?

47) Depuis quand êtes-vous chez ADNEOM TECHNOLOGIES ?

48) A partir de quand êtes-vous disponible ?

49) Qu’est ce qui vous plaît le moins dans le poste que l’on vous propose ?

50) Pouvez-vous, SVP, nous dire ce que chaque mission vous apportée ?

51) Qu’avez-vous fait avant votre école ?

52) Comment avez-vous choisi votre première mission ?

53) Vous vous attendez à faire quoi chez nous ?

54) Le projet est-il clair ?

55) Avez-vous des questions ? (il faut toujours avoir des questions, les préparer éventuellement avant l'entretien, et poser celles auxquelles le client n'a pas répondu par lui meme au préalable)

56) Vous pouvez alors résumer ce que vous en avez compris.

57) Quel rôle avez-vous eu au sein des équipes de chaque client où vous avez travaillé ?

58) Cela ne vous fera dégrader socialement d’assumer ce nouveau poste ?

59) Quels sont les moyens que vous allez vous donner pour acquérir ce nouveau

121/122

fonctionnel ? (sites internet, bouquins...)

61) Que connaissez-vous en finance ? (rester tres modeste)

122/122