Formation IQ JAVA · – Permet aux développeurs de générer dynamiquement du code HTML, XML ou tout autre type de page Web. La technologie permet au code Java et à certaines actions

Formation IQ JAVA V1.1 1

Formation IQ JAVA


PROGRAMME DE LA FORMATION

• Introduction

• Les règles de codage

• Les bonnes pratiques

• Les environnements de développement Java

• ECLIPSE

• PMD

• Les tests de taux de couverture

• Si on a du temps : survoler les bases du langage Java


Introduction


Introduction

Les difficultés de l'IQ dans les nouvelles technologies

• Connaître les éléments de programmation– le langage JAVA – l'influence des ses nombreuses classes– les architectures complexes N-tiers

• Faire les choix des règles de codage dans un environnement hétérogène (java, xml, jsp, j2ee, javascript, php, perl, …)

• L'homogénéité dans une architecture CORBA utilisant différents langages (Java, C++,Ada, …)

• Faire le choix des environnements de développement (IDE)• Faire le choix des outils complémentaires• La mise en œuvre des moyens de contrôle de code et de test

nécessite une connaissance des outils comme ant


Introduction

JAVA

• JAVA est un langage orientée objet

• Sa syntaxe est proche du C++

• Beaucoup de règle du C++ s'applique à Java

• Règles spécifiques au langage Java

• Règles spécifiques aux architectures Java– J2EE, JSP, Javascript

– XML

– CORBA

– …


Introduction•Qu'est-ce que Java ?

Principes de fonctionnement

Développement Exécution

CompilateurJava -> Bytecode

Code source Java

maClasse.java

Machine virtuelle JavaIntégré dans un browser (Applet)

Exécute le Bytecode(et le transforme en code natif)

Machine virtuelle JavaAutonome (Application)


Machine virtuelle JavaIntégré dans un « container » (Servlet)


Bytecode Java

maClasse.classBytecode Java

maClasse.classBytecode Java

maClasse.class

Ce n ’est pas du code machine

natif

Présentation de Java

javac.exe (Sun)jikes.exe (IBM)

java.exe (Sun)java.exe (IBM)

appletviewer.exe (Sun)HotJava (Sun)IE (Microsoft)Netscape Nav. (Netscape)Java Plug-in (Sun)

Tomcat (Apache, [SUN])WebSphere (IBM)IPlanet (Netscape)Resin (Caucho)...


IntroductionPrésentation de Java

• Les applets éliminent la nécessité d ’assurer la maintenance ou la mise à jour des logiciels sur les postes clients

– le code est chargé dynamiquement sur le client selon les besoins

Client

browser Web

JVM intégrée

Serveur

Serveur HTTP

Fichiers Bytecode

Fichiers Bytecode

Chargement des fichiers de Bytecode depuis un serveur dans le navigateur via un serveur HTTP

•Qu'est-ce que Java ?

Principes de fonctionnement : Applet


Introduction•Qu'est-ce que Java ?

Principes de fonctionnement : Bytecode

Serveur d ’applicationServeur d ’application

MonAppli.war•WEB-INF\classes\A.class•WEB-INF\classes\B.class•WEB-INF\classes\C.class•WEB-INF\web.xml•jsp\D.jsp•img.gif•meta-inf\manifest.mf

MonAppli.war•WEB-INF\classes\A.class•WEB-INF\classes\B.class•WEB-INF\classes\C.class•WEB-INF\web.xml•jsp\D.jsp•img.gif•meta-inf\manifest.mf

Présentation de Java

JVMJVM

MonAppli.jar•A.class•B.class•C.class•img.gif•meta-inf\manifest.mf

MonAppli.jar•A.class•B.class•C.class•img.gif•meta-inf\manifest.mf

A.classA.class

C.classC.class

B.classB.class

img.gifimg.gif

• Les fichiers de bytecode peuvent être indépendants dans des fichiers « *.class » ou regroupé dans des fichiers « *.jar » ou « *.war » (type de fichier ZIP)


Introduction

L'INFLUENCE DES SPÉCIFICITÉS DE JAVA (1/3)

• Les architectures des répertoires– l'organisation en package (signature)– les web archives– …

• La gestion de la mémoire– le garbage collector– les collections, les itérateurs, les énumétaeurs

• Les classes prédéfinies– très nombreuses– évolutions constantes : dépricated– "best-pratices"

• Les interfaces– propre à Java : très importantes

• La réflèxivité du langage– le nommage des méthodes– la lisibilité du code– les outils de vérification ne sont pas complètement utilisables sur ce type de code– cela reste une exception– on le rencontre dans des API (ex: Hibernate)

Exemple ��


Introduction

Exemple de réflexivité


Introduction


• Les extensions: .java, .class & .jar .war

• Les fichiers de configuration: .properties– paramétrage des outils prédéfinis et de son propre code

– hiérarchie des propriétés, API de lecture/écriture de ces fichiers

– basés sur une syntaxe mot clef = valeur

• Les répertoires spécifiques de génération– le répertoire generatedcomme par exemple pour les architecture

CORBA

– le répertoire docspour la génération javadoc

– le répertoire idl (Corba)

– le répertoire configpour les fichiers de configuration

• La déclaration des variables, des paramètres et des membres


Introduction


• Les traces : les loggueurs� log4j

• La gestion des exceptions

• …


Introduction

LA COMPARAISON AVEC LE C++ (1/3)

• Pas de structures ni d’unions

• Pas de types énumérés

• Pas de typedef

• Pas de préprocesseur

• Pas de variables ni de fonctions en dehors des classes

• Pas de fonctions à nombre variable d’arguments (sauf depuis la version 1.5)

• Pas d'héritage multiple de classes

• Pas de "template" (sauf depuis la 1.5)

• Pas de surcharge d’opérateurs

• Pas de passage par référence des paramètres

• Pas de pointeurs, seulement des références


Introduction


• Exceptions : plus formels et plus étendues

• Garbage-collector intégré: inutile de détruire les objets créés

• Pas de « makefile »

• Packages = répertoires

• Archivages (.jar)

• Les tableaux sont des objets

• Les chaînes de caractères sont toutes des constantes

• La syntaxe est celle du C++ simplifiée

• Pas de .h

• L'interface

• Les commentaires sont ceux du C++ (// /*..*/)

• Commentaires de documentation (/**..*/)


Introduction


• Pas de "dynamic-cast" : un cast unique

• Java est un langage objet à liaison dynamique

• A partir de la version 1.5 :– "auto-boxing" des types primitifs

– implémentation de la structure de contrôle "pour chaque" de base dans le langage (for(e:conteneur){e.toDo();) quelque soit le conteneur y compris le tableau de base.

– l'énumération est connu du langage

– …


Introduction

DEFINITIONS (1/7) : JDK, SDK, J2SE

• Difficile d'être exhaustif sur un tel langage– en évolution constante : une nouvelle version tous les ans– périmètre "flou" : confusion entre le langage et son environnement– confusion entre les termes utilisés (JDK, SDK, J2SE, J2EE, Java 2)

• Le JDK (Java Development Kit) est l'environnement dans lequel le code Java est compilé pour être transformé en bytecode afin que la JVM(Machine virtuelle de java) puisse l'interpréter

• Le SDK (Software Development Kitou Servlet Development Kit) représente le passage du JDK à un framework. Le même terme est utilisépour l'extension aux servlets !!

• Le J2SE(Java 2 Standard Edition) : framework contenant– toutes les API de base– toutes les API spécialisées (JFC et donc Swing, AWTet Java2D)– ainsi que des API d'usage général comme JAXP (pour le parsing XML) et

JDBC (pour la gestion des bases de données).– (Récemment renommé "Java SE par Sun")

Java Foundation Classes : framework graphique composé de AWT, Swing et Java2D


Introduction

DEFINITIONS (2/7) : J2EE• J2EE (Java 2 Platform, Enterprise Edition)

– est une spécificationpour le langage de programmation Java de Sun plus particulièrement destinée aux applications d'entreprise.

– de nombreux éditeurs proposent leurs implémentations au sein de leurs Frameworks.

– dans ce but, toute implémentation de cette spécification contient un ensemble d'extension au framework Java standard (J2SE, Java 2 standard edition) afin de faciliter la création d'applications réparties.

– Ci-dessous, une liste des API pouvant être contenues dans une implémentation J2EE :

• Servlets : Conteneur Web • JSP : Framework Web (http://fr.wikipedia.org/wiki/JavaServer_Pages) (en local)• JSF : Java Server Face, Framework Web, extension des JSP (http://www.jsftutorials.net/)

– Le but de JSF est de fournir au développeur d'applications de type Web, une interface de programmation lui permettant de manipuler l'interface Web dans un environnement J2EE sans avoir à recourir à du code HTML ou JavaScript.

• EJB : Composants distribués transactionnels • JNDI : API de connexion à des annuaires, notamment des annuaires LDAP • JDBC : API de connexion à des bases de données • JMS : API de communication asynchrone • JCA : API de connexion, notamment à des ERP • JavaMail : API de gestion des mails


Introduction

DEFINITIONS (3/7) : J2EE (suite)

• JMX : Extension d'administration des applications

• JTA : API de gestion des transactions

• JAXP : API d'analyse XML

• JAXM: API de communication asynchrone par XML

• JAX-RPC: API de communication synchrone par XML, par exemple à l'aide du protocole SOAP

• JAXB : API de sérialisation par XML

• JAXR: API de gestion des registres XML, permettant d'enregistrer des Web Servicesen ebXML

• RMI : API de communication distante entre des objets java

• Java IDL: API de communication entre objets Java et objets non-Java, via le protocole CORBA


Introduction

DEFINITIONS (4/7) : Servlet

• L'API Java Servletest une application Java qui permet de générer dynamiquement des données au sein d'un serveur HTTP. Ces données sont le plus généralement présentées au format HTML , mais elles peuvent également l'être au format XML ou tout autre format destiné aux navigateurs Web.

• Ce programme Java s'exécute dynamiquement sur le serveur Web et permet l'extension des fonctions de ce dernier, typiquement : accès à des bases de données, transactions d'e-commerce, etc. Une servlet peut être chargée automatiquement lors du démarrage du serveur Web ou lors de la première requête du client. Une fois chargées, les servlets restent actives dans l'attente d'autres requêtes du client.

• L'utilisation de servlets se fait par le biais d'un conteneur de servlets (framework) côté serveur (ex: tomcat). Celui-ci constitue l'environnement d'exécution de la servletet lui permet de persisterentre les requêtes des clients. L'API définit les relations entre le conteneur et le servlet. Le conteneur reçoit la requête du client, et sélectionne la servlet qui aura à la traiter. Le conteneur fournit également tout un ensemble de services standard pour simplifier la gestion des requêtes et des sessions

• Une ou plusieurs servlets constituent les web applicationsJava

• La version actuelle des spécifications servlet est la 2.5.


Introduction

DEFINITIONS (5/7) : JAVA 2

• Java 2est le Framework standard Java proposé par Sun Microsystems. Il regroupe un ensemble de spécifications et d'API consolidant la plateforme Java Sun première génération. Il en existe trois éditions.

– J2SE : Java 2 Standard Editioncomprenant les API et bibliothèques de bases, ainsi que les API destinés au poste client (comme par exemple JFC (Java Foundation Classes (JFC) est un framework graphique pour Java composé de AWT, Swing et Java2D. )

– J2EE : Java 2 Enterprise Editiondestinée aux développements des applications d'entreprises. Sun propose en plus des spécifications, des implémentationsillustratives. De nombreux éditeurs proposent leurs implémentations au sein de leurs Frameworks.

– J2ME : Java 2 Micro Editiondestinée aux systèmes mobiles tel que par exemple, les assistants personnels ou les téléphones portables.


Introduction

DEFINITIONS (6/7) : JSP

• Le JavaServer Pagesou JSP

– Permet aux développeurs de générer dynamiquement du code HTML, XML ou tout autre type de page Web. La technologie permet au code Java et à certaines actions prédéfinies d'êtres ajoutés dans un contenu statique.

– La syntaxe du JSP ajoute des balises XML, appelées actions JSP, qui peuvent être utilisées pour appeler des fonctions. De plus, la technologie permet lacréation de bibliothèques de balises JSP (taglib) qui agissent comme des extensions au HTML ou au XML. Les bibliothèques de balises offrent une méthode indépendante de la plate-forme pour étendre les fonctionnalités d'un serveur HTTP.

– Les JSP sont compilées par un compilateur JSP pour devenir des servlets Java. Un compilateur JSP peut générer un servlet Java en code source Java qui peut àson tour être compilé par le compilateur Java, ou peut générer le pseudo-codeJava interprétable directement.


Introduction

DEFINITIONS (7/7) : EJB

• La technologie Enterprise JavaBeans(EJB) est une architecture de composants logiciels côté serveur pour la plateforme de développement J2EE.

• Cette architecture propose un cadre pour créer des composants distribués(c'est àdire déployé sur des serveurs distants) écrit en langage de programmation Java hébergés au sein d'un serveur applicatif permettant de représenter des données (EJB dit entité), de proposer des services avec ou sans conservation d'état entre les appels (EJB session), ou encore d'accomplir des taches de manière asynchrone (EJB dit message). Tous les EJB peuvent évoluer dans un contexte transactionnel.

• Un EJB est accompagné d'un ou plusieurs fichiers de déploiement écrit en XML qui va permettre au serveur applicatif de déployer correctement cet objet au sein d'un conteneur. C'est notamment dans ces fichiers de déploiement que le développeur va pouvoir préciser le cadre transactionnel dans lequel l'objet va être exécuté.

• C'est le serveur applicatif qui a en charge la création, la destruction, la passivation ou l'activation de ses composants en fonction des besoins. Le client via un appel RMI(ou une de ses dérivées) va rechercher un EJB par son nom logique JNDI et appeler une/des méthodes de cet objet.


Les règles de codage



Présentation

• Les règles dit "de codage" se décomposent en différentes catégories :– les règles de rédaction du code en lui-même :

• la syntaxe proprement dit du code (syntaxe du langage)

• les règles de l'architecture du code liées aux dépendances entre les classes (programmation objet)

• les règles de la mise en forme et des commentaires

• les règles de nommage des composants

– les règles de structuration de l'architecture de développement liées au déploiement des composants "exécutables"

– les règles de développement liées à l'environnement de développement

– les règles de codage et de nommage liées à l'architecture du logiciel (N-tiers, Corba, web-services, web, …)



LES RÈGLES DE NOMMAGE

• Le nom d'un fichier .java est le nom de la classe publique• Le nom d'un package est toujours en minuscule

– désigne un chemin ou signature d'arborescence

• Le nom d'une classe est composé de mots commençant par une majuscule (ex: MyFavoriteClasse)

• Les membres commencent toujours par une minuscule• La reconnaissance des membres et non-membres

– Le préfixage des non-membres ou le préfixage des attributs par this– La réflexivité ne permet pas de préfixer ou suffixer les attributs par "_"

• Les constantes sont en majuscule• Les règles de nommage se simplifie car il n'y a pas de notion de

pointeur



LA LANGUE FRANÇAISE

• Si la langue française doit être utilisée alors– l'anglais reste quand même incontournable

– l'influence des "qualifieurs" (soit en préfixe ou suffixe)• setet getpour les assesseurs et les accesseurs,suivi du nom de

l'attribut

• les is

• les Helper, Holder, Tie, Factory, Impl, Int, …

• Faire une liste des mots anglais autorisés– ex: insert, add, update, merge, …

– les développeurs sont de niveaux d'anglais différent



LES MOTS RÉSERVÉS DU LANGAGE JAVA

• abstract, boolean, break, byte, case, catch, char, class, continue, default, do, double, else, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, super, switch, synchronized, this, throw, throws, transient, true, try, void, volatile, while

• ne pas utiliser comme identificateur



LES COMMENTAIRES DE DOCUMENTATION

• L'outil javadoc– de base dans le langage

– ces mots réservés : @author, @deprecated, @exception, @param, @return, @see, @serial,@serialData, @serialField, @since,@throws, @version, {@docroot}, …

• Eclipse insère automatiquement ce type de commentaire mais dérive lors des mises à jours

• L'outil DOxygen– efficace

– remonte les diagrammes UML

– paramétrage : peut se paramétrer en fonction de la syntaxe de javadoc



LES COMMENTAIRES DE DOCUMENTATION

• Exemple de commentaire javadoc :



L'ORGANISATION DES SOURCES (1/3)

• l'arborescence des répertoires

• architecture modulaire classique peut s'appliquer

• mais chacun des répertoires est la racine de l'arborescence des packages des modules

• chaque composant peut rassembler les packages d'un composant en un ficher .jar




• Exemple dans le projet SySBIVC

• IACL/src/fr/capgemini/sysbivc/iacl/trt/ui




dev

SOCLE IHM APP

COM

fr

capgemini

sysbivc

com

utilio tcp

fr

capgemini

sysbivc

iacl

fr

capgemini

sysbivc

ignr

IACL IGNR

utilecrans

commun ihm commun

fr

capgemini

sysbivc

srv1

SRV1 SRV2

commun

commun communihm

commun chemin d'accès aux packages

du projet

package commun àtout le projet,

distribué dans tous les composants

packages commun àtoutes les ihm

distribué dans toutes les ihms



L'ORGANISATION DES SOURCES DANS UNE APPLICATION WEB (1/2)

• Une application Web :– est une application contenant des objets spéciaux, capables

de recevoir des requêtes web (HTTP) et de renvoyer des réponses à ces requêtes. Ces objets s'appellent en Java des servlets.

• La webapp (non compactée) est une structure de fichier

• Le WAR est une archive d'une webapp déployée dans un serveur HTTP



L'ORGANISATION DES SOURCES DANS UNE APPLICATION WEB (2/2)

<web-app>/ la racine est le docRoot de l'application

web.xml descripteur de déploiement (description des servlets, paramètres d'initialisation, …)

WEB-INF/

classes/ contient les classes et les arborescences de packages

lib/ contient les .jar externesutilisés par l'application web

src/ contient les sources de l'application web (optionnel)

fichiers divers dont les pages .jsp

• Cette arborescence peut être créée par la compilation : usage de l'outil ant.



LA GESTION DES EXCEPTIONS (1/2)

• une exception = une classe

• La hiérarchie des classes

• La capture des exceptions

• La confiance dans les exceptions : toutes erreurs de code se traduit par une exception

• Journaliser avec log4j, en niveau DEBUG, systématique toutes les exceptions

• Le plus haut niveau de capture d'une exception dépend de l'architecture et la nature du programme Java



LA GESTION DES EXCEPTIONS (2/2)

• Utiliser log4j afin de profiter du niveau DEBUG pour tracer toutes les exceptions

• Pourquoi prévoir de tracer toutes les exceptions ?– une exception est déclenchée qui ne devrait pas être

déclenchée

– elle est récupérée et "absorbée" plus haut

– cette exception n'est donc pas perçue par le programmeur àmoins de les tracer en mode debug systématiquement

• Logguer en niveau ERROR, l'exception capturée par l'appelant qui est considérée comme une erreur



EXEMPLE METHODE / EXCEPTIONpublic Resultat methode(Parametre aParam)

throws PremiereException,MyException,Exception // Si difficile d'être exhaustif

{try {

// … code de la méthode// …//

} catch (PremiereException lEx){// On retourne la même exceptionLOGGER.debug(lEx.toString());throw lEx;

} catch (DeuxiemeException lEx){// On ne retourne pas d'exception (cas nominal)// … code …LOGGER.debug(lEx.toString());

} catch (TroisiemeException lEx){// On déclenche une autre Exceptionthrow new MyException(…);

} catch (Exception lEx){// Cas d'une exception non attendueLOGGER.error(lEx.toString());

}}



LOG4J (1/4)

• log4j est un framework extensible • permet de logger et débugger vos applications Java.• indispensable, pratique • 3 type des composants :

– Logger• envoi de message, gestion hiérarchique

– Appender• filtrer les messages• détermine le mode de sortie (console, fichier, socket, mails, et plus …)

– Layout

• 5 niveaux :– DEBUG INFO WARN ERROR FATAL– configuration par priorité



LOG4J (2/4)

• Exemples :import org.apache.log4j.Logger; //// …

try {LOGGER.debug("DEBUT DU TRAITEMENT");

if (…) LOGGER.error("Erreur dans …");

} catch(IllegalArgumentException lEx) {LOGGER.fatal("Erreur dans les parametres", lEx);

//…

• Configuration : log4j.xml



LOG4J (3/4)

• Configuration : log4j.xml<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"><log4j:configuration>

<appender name="dailyRollFile" class="org.apache.log4j.DailyRollingFileAppender">

<param name="DatePattern" value="'.'yyyy-MM-dd"/><param name="File" value="/ logs/SCOH.log "/>

<layout class="org.apache.log4j.PatternLayout"><param name="ConversionPattern" value="%d{ABSOLUTE} -

%5p - [%c{1}:%L] %m%n"/></layout>

</appender>

<logger name="fr.capgemini.sysbivc" additivity="fals e"><level value="info"/><appender-ref ref="dailyRollFile" />

</logger>

<root><priority value ="error" /><appender-ref ref="dailyRollFile" />

</root></log4j:configuration>



LOG4J (4/4)

• le site officiel• http://logging.apache.org/log4j/docs/index.html

• L'IQ d'un projet Java doit imposer l'utilisation de log4j dans tout développement Java (ou un logger similaire)



LA GESTION DE LA MÉMOIRE

• plus d'écrasement mémoire

• plus de pointeurs

• plus de destruction explicites des objets

• le revers de la médaille : prolifération d'objets inutilement créés en mémoire � baisse des performances (déjà que Java est moins performant que le C++…)

• rendre Java performant est un effort de "best-practices" continue dans le développement



MODELE DE QUALIMETRIE (1/9)

• Les mesures de complexité– nombre d'instructions exécutables dans une méthode(ex: 30)– nombre de variables locales dans une méthode(ex: 7)

• on part du principe que toutes les variables locales sont déclarées en début de la méthode et avant le début du try/catch

– nombre maximum d'imbrications (ex: 3)• le try/catch englobant de la méthode ne compte pas

– nombre cyclomatique (ex: 10)• nombre de branches conditionnelles dans l'organigramme de la méthode :

représentatif de l'effort de test– nombre de paramètres (ex: 5)

• ce seuil peut être différent pour les constructeurs• dans la version 2.5, on peut traiter des listes variables d'argument

– nombre de bloc try imbriqué (ex: 2)• 1 si on ne compte pas l'englobant de la méthode




• Mesure de la présentation– nombre d'attributs hérités (ex: 7)

• dans le cas des "protected" car normalement les attributs sont déclarées privées

– profondeur de classe dans l'arbre d'héritage (ex: 4)

– somme pondérée des complexités des méthodes d'une classe• complexité interne d'une classe = nombre de méthodes qui peuvent être

appelées lors de la réception d'un message

– couplage entre classe (ex: 5 à 20)• utiliser les interfacepermet de diminuer le couplage entre classe

• un couplage en terme d'appel de méthode, d'accès aux attributs, d'héritage, de type de retour, d'exceptions traitées, …

• ne pas faire d'héritage multiple permet de diminuer le couplage (c'est le cas de Java)




– nombre de descendants immédiats de la classe dans la hiérarchie de classe• arborescence des liens d'agrégation des attributs d'une classe• ne doit compter que les attributs qui ne sont pas transient :

– différence entre le lien d'agrégation et le lien de référence– un attribut en "référence" n'est pas alloué par le constructeur

– proportion d'attributs non privés (ex: 0.3)• les attributs final staticne comptent pas• on peut trouver cette proportion = 0• les attributs public static sont dangereux, ils sont équivalents aux variables globales

des langages non OO– les variables locales doivent être déclarées en début de bloc

• pas nécessairement en début de méthode– pas de ligne trop longue (ex: > 132)

• avec les nouveaux édites et les IDE la limite standard de 80 n'est plus d'actualité– une instruction par ligne

• améliore la lisibilité et la maintenabilité du code• permet une meilleur lisibilité des rapports des outils d'analyse de couverture de code

– chaque bloc logique d'instructions doit être entouré d'accolades




• Mesure de la structuration du flot de contrôle– l'instruction continue est déconseillée

– l'instruction break est déconseillée pour sortie de boucle• l'exception classique des algorithme de recherche itératif

– une méthode doit avoir une sortie nominale et une seule• qu'un seul return

• dans le cas où une méthode doit retourner une valeur (non void):




public Resultat methode(Parametre aParam) throws Premi ereException{

// Par defautResultat lRes = new Resultat(…);//ou// Resultat lRes = null; // Si type de retour n'est pas un type primitif

//try{

// … code de la méthode// … fait une affectation du résultat// lRes = …………;//

}catch(PremiereException lEx){// On retourne la même exceptionLOGGER.debug(lEx.toString());throw lEx;}

catch(DeuxiemeException lEx){// On ne retourne pas d'exception, on retourne le c as par défautLOGGER.debug(lEx.toString());

catch(Exception lEx){// Cas d'une exception non attendueLOGGER.error(lEx.toString());

}return(lRes )

}




– une instruction break ou un commentaire dans chaque instruction case

– un cas défaut pour chaque instruction switch

– éviter les blocs ou les instructions vides

– éviter de définir des méthodes avec un corps vide• dans une conception objet, on crée des adaptateursdont les

méthodes sont par définition du code vide. Pour éviter cela, on peut y insérer une instruction de log (LOGGER.debug("…"))

• un adaptateur est une classe qui implémente par défaut toutes les méthodes d'une interface




• Mesure de l'utilisation des ressources– variable inutilisée– paramètre inutilisée– les constantes numériques doivent être représentées par des attributs final static

• il existe le cas de valeurs numériques littérales uniques. Dans ce cas, on put ne pas être obligé de créé une constante

– il est interdit d'utiliser la redéfinition des méthodes statiques• il est difficile de déterminer quelle méthode sera appelée dans certains cas de

généricité• donc préfixer toutes les méthodes statiques par final (en plus cela optimise)

– éviter d'attribuer le même nom à une variable locale et à un attribut• avec une bonne règle de nommage cela est interdit)

– les attributs privés constants devraient être final– en cas de redéfinition de la méthode finalize()on doit appeler super.finalize()– éviter les attributs de portée public ou package



class c1 {

public int A;protected int B;

int C;private int D;

}

class c3{

...}

class c5{

...}

A B C DAccessible par c1 oui oui oui ouiAccessible par c2 oui oui oui -Accessible par c3 oui oui oui -Accessible par c4 oui oui - -Accessible par c5 oui - - -

Package P1 Package P2

class c4 extends c1

{...

}

class c2 extends c1

{...

}

Pour rappel : le scope des membres




• Mesure de complexité des expressions– assignation multiple interdite

– l'opérateur d'alternative est interdit (ex: (x==y)?...)

– une condition de plus de 4 opérateurs logiques ne doit pas contenir plusieurs opérateurs distincts

– pas d'opérateur d'affectation dans une condition

– pas d'affectation dans les paramètres d'appel de fonction




• Mesure de l'utilisation des constructions à risque– pas de test d'égalité entre 2 valeurs à virgule flottante

– pas de modification de l'indice d'une boucle for dans le corps de celle-ci

– éviter d'accéder aux membres statiques au travers d'une classe descendante

– éviter d'accéder aux membres statiques au travers d'un objet

– pas de substitution (overriding) d'une méthode non abstraite par une méthode abstraite

– ne pas surcharger une méthode privée

– pas de bloc vide pour une instruction catch

– utiliser la méthode equals à la place de l'opérateur == pour comparer les chaîne de caractères

– éviter d'assigner une valeur à un paramètre d'entrée


Les bonnes pratiques



PASSAGE PAR VALEUR

• Java ne fait pas de passage par référence � obligé de passer un Holder : un objet qui contient l'objet que l'on veut retourner.– Cette pratique n'est pas conseillé mais peut être incontournable comme

cela est le cas dans l'implémentation des paramètres out des interfaces idl des architectures CORBA.

• Cet Holder doit définir les setteursdes attributs pouvant être modifiés

• La seul manière en Java de définir des objets constants est de définir les attributs privés et de ne pas définir de setteursur ces attributs

• A ne pas confondre avec les attributs préfixés par final qui permet de définir des constantes



LES CONTENEURS (1/3)

• les conteneurs sont en constante évolution

• le vecteur (Vector) est moins optimisé que ArrayListmais plus pratique

• le tableau est par définition performant

• la performances des conteneurs dépend de leurs utilisations (suppression d'un des premier élément est coûteux pour certains)

• Homogénéité entre les développeurs de l'usage des conteneurs.


Les bonnes pratiquesLes API

Groupe d ’objets uniques

Groupe d ’objets ordonnés

Groupe d ’objets

Groupe d ’objetsClés �� Valeurs

LES CONTENEURS (2/3)• Diagramme de classe



LES CONTENEURS (3/3)

• toutes ces "structures de données" sont protégés par les exceptions prédéfinies

• il est impossible de "déborder" d'un tableau sans que cela ne déclenche pas d'exception



FINAL

• final protège un attribut en écriture

• permet de déclarer des constantes

• attention si final porte sur un objet: seul la référence est protégée, pas le contenu de l'objet

class Test{static final int someInt = 10;//…

}//. . . someInt = 2: // INCORRECT

class Circle{private double rad;public Circle(double r){rad=r;}public void setRad(double r){rad=r;}public double getRad(){return rad;}

}

public class FinalTest{private static final Circle wheel = new

Circle(5.0);private statc void main(String args[]){

wheel.setRadius(7.4): // CORRECT !!!}

}



INSTANCEOF

• Préférer le polymorphisme à l'usage de instanceof

• Cela doit donc rester un exception– Cela est le cas quand on utilise la réflexivité du langage

– Cela est le cas quand on ne maîtrise pas le stockage des objets dans les conteneurs (ex: Vector)

• Tous les objets Java hérite de java.lang.Object

• Tous les conteneurs contiennent des Object– � utiliser un try/catch sur l'exception ClassCastException

– � utiliser instanceof



NULL

• Quand assigner la valeur null à des références d'objet?

• Le "garbage collector" ne ramasse pas tous les objets au premier coup

• L'aider consiste à affecter ànull tous les objets devenus inutiles dans la suite du programme

• Rappels: – par défaut tous les objets sont null

– les objets sont des références: il n'y a plus d'allocation implicite des objets



OBJETS ET TEST D'EGALITE (1/3)

• les types primitifs et les types références ne réagissent pas de la même manière lors des affectations

int a = 1;int b = 2;Point x = new point(0,0);Point y = new Point(1,1);//…a = b;a++; // a vaut 3, et b vaut 2x=y;x.setLocation(5,5); // x et y vaut (5,5) !!!

• == teste l'égalité des primitifs et des références

• equalsteste l'égalité du contenu des objetsobj1.equals(obj2)




• == ne marche pas pour les objets � l'IQ doit traquer son usage autres que sur les types primitifs

• le equals par défaut est celui de Objectqui réalise un == !!! � la méthode equals doit être implémentée.

• Attention: toutes les classes prédéfinies n'implémentent pas la méthode equals. – Exemples: Integeret String implémentent equals, mais

StringBuffern'implémente pas.– Donc une méthode equals ne marcherait plus sur une

évolution d'un de ses attributs de Stringen StringBuffer

• Utiliser toStringdans le code de equals




• utiliser getClasspour tester en 1er que les 2 objets sont de même classe

• utiliser super.equalspour tester l'égalité des attributs hérités

• le problème se corse quand on accepte le test d'égalitéentre des classes de base et ses classes dérivées



GESTION DES EXCEPTIONS (1/4)

• il y a beaucoup à dire sur le sujet (trop)

• les exceptions est une fonctionnalité puissante, complexe, mais doit être maîtrisée sinon effet inverse de qualité du code

• coupler au mécanisme d'exception un mécanisme de trace (logueur) est un garant de qualité

• le mécanisme d'exception est un "goto" vers :– le bloc catch

– le bloc finally

– la méthode appelante




• Ne jamais ignorer une exception :– récupérer l'exception et la gérer de telle sorte qu'elle ne se

propage pas plus avant

– récupérer l'exception et la rejeter afin qu'elle se propage dans la méthode appelante ou sous une autre exception

– ne pas récupérer l'exception et la laisser se propager vers la méthode appelante




• Ne jamais masquer une exception– seule la dernière exception générée est propagée vers la

méthode appelante

public void foo() throws Exception{

try{throw new Exception("Première exception");

}catch(Exception e) {

throw new Exception("Deuxième exception"); }finally {

throw new Exception("Troisième exception"); }}//// seul la troisième remonte à l'appelant//




• utilisez la clause throwsde manière explicite et exhaustive (une exception héritante peut cacher les dérivées)

• utiliser la clause finally avec modération• un returndans un bloc try n'évite pas la clause finally• placer les blocs try/catchen dehors des boucles (sinon

baisse de la performance d'exécution)

• ne pas utiliser les exceptions pour les contrôles de flux d'information

• utiliser les exceptions dans les constructeurs• tracer systématiquement en mode DEBUG toutes les

exceptions



PERFORMANCES (1/2)

• améliorer ou ne pas dégrader les performances d'un programme Java est un exercice difficile etdifficilement vérifiable par un IQ

• son rôle est donc limité mais sa démarche peut être aidé par l'utilisation d'un profiler (analyseur) de performance afin de générer des information d'analyse– JProbe Profiler– NetBeans Profiler

• optimiser le code source par le compilateur (option –O) : n'est pas très utilisécar peu probante

• utiliser StringBuffer plutôt que String pour la concaténation• minimiser le coût de la création d'objet• ne pas créer d'objets inutiles (vérifier les algorithmes)• éviter la synchronisation• utilisez les variables de pile (locales) plutôt que les membres de la classe



PERFORMANCES (2/2)

• employer les méthodes static, final, et private– méthode candidate à l'inlining (incorporation dans le coprs de la

méthode appelante)– sont résolues statiquement au moment de la compilation (donc pas de

résolution dynamique)

• afin d'améliorer le constructeur ne pas affecter les attributs avec les valeurs par défaut de Java

• préférer l'usage des types primitifs• itérer un Vectoravec une boucle for et getplutôt l'usage de

Enumerationou Iterator• utiliser System.arraycopypour copier des tableaux• préférer un objet tableau à un objet Vectorou ArrayList• réutiliser les objets


Les environnements de développement

JAVA



DÉFINITIONS

• IDE : Integrated Environment Development

• Un IDE est composé au minum– un éditeur de texte

– un compilateur

– un debogueur



LES IDE DU MARCHÉ

• Eclipse(à part :plug-in) logiciel libre

• JBuilder de Borland

• JavaWorkShop (JWS)

• VisualJ++

• Visual Age for Java d'IBM

• Java Development Envronment for Emacs (JDEE)

• VisualStudio de Microsoft

• NetBeansde SUN

• JCreator de XINOX



LES CRITÈRES DE CHOIX (1/2)

• la navigation dans le code• le debug du code• CVS• l'aide en ligne• les modes de complétion• la documentation• la création des composants

– JavaBeans, web-archive, html, XML,

• la prise en compte des environnement– J2EE, Tomcat, UML, AppServer



LES CRITÈRES DE CHOIX (2/2)

• le prix

• la gratuité des environnement de développement

• la complexité de leur utilisation

• une interface graphique

• une gestion des versions


ECLIPSE

On peut remarquer la facétie d'IBM dans le choix du nom de son logiciel, sachant que le créateur de Java est Sun (en anglais : « soleil »), concurrent qu'IBM semble vouloir « éclipser ».


ECLIPSE

CE QUE APPORTE L'USAGE DE ECLIPSE

• L'organisation du projet• Le formatage du code source• Une vérification du code en temps réel• Une structuration d'accueil des composants• De nombreux plug-in pour vérifier son code, générer

du code, …• Des outils de génération et de déploiement• Un environnement de développement complet• Améliore la qualité du code développé car généré,

guidé, …• La génération de la documentation (javadoc)


ECLIPSE

DE QUOI EST COMPOSÉ ECLIPSE À LA BASE

• Platform Runtime démarrant la plateforme et gérant les plug-ins

• SWT la bibliothèque graphique de base de l'EDI

• JFace une bibliothèque graphique de plus haut niveau basée sur SWT

• Eclipse Workbench qui est la dernière couche graphique permettant de manipuler des composants tels que des vues, des éditeurs, des perspectives...


ECLIPSE

LES PROJETS D'ECLIPSE

• Eclipse est un projet open-source :– Eclipse Project le projet fondateur comprenant Eclipse Platform,

Eclipse Rich Client Platform (RCP) et le Java Development Tools (JDT)

• Il rassemble de très nombreux autres projets qui peuvent devenir des standards et de nouveaux plug-in

• Par exemple :– Web Tools Platform project (WTP) propose de nombreux outils pour

le développement d'applications web en Java. – C/C++ Development Tools Project(CDT) est un environnement

complet de développement pour les langages C et C++ pour Eclipse.– De nombreux projets autour du modèle MVC très utilisés dans les

architectures Web (Eclipse Modeling Framework, Graphical EditingFramework, Graphical Modeling Framework )

– Des projets pour la conception UML (UML2 )– Autour des dernières technologies comme AJAX et RUBY


ECLIPSE

LES PLUG-IN DE ECLIPSE• des centaines de plug-in

– http://eclipse-plugins.info/eclipse/plugin_statistics.jsp?pager.offset=0&firstItem=1


ECLIPSE

LES PLUG-IN DE ECLIPSE

• Pour connaître les plug-in contenus dans votre Eclipse– Menu Help/About Eclipse Platform� Plug-in Details

• Pour installer les plug-in à partir d'un site– Menu Help/Software Updates/Find and Install


ECLIPSE

L'USAGE DE ECLIPSE

• package, interface, classe


ECLIPSE

UN EXEMPLE DE CADRAGE

• créer une interface

• créer une classe qui doit implémenter l'interface– le code est généré

– implémentation par défaut des méthodes

– génération des blocs commentaires

• De l'UML aux classes (plug-in UML)


ECLIPSE

LE FORMATAGE

• Windows�Preferences

• Le fichier format.sysbivc.xml

• Un formatage du source paramétrables


ECLIPSE

LE FICHIER DE FORMATAGE


ECLIPSE

L'EDITION SOUS ECLIPSE

• coller automatiquement les imports des packages des classes utilisées (Shift-Ctrl O)

• l'aide en ligne sur les éléments (F2), la navigation (F3)

• le JDK en ligne

• la génération des getteurs et setteurs

• la génération des commentaires sur les éléments du langage suivant la syntaxe javadoc

• utilisation des raccourcis clavier 'emacs'


PMD


PMD

ROLES DE PMD

• PMD est disponible à http://pmd.sourceforge.net/

• PMD peut être utiliser en dehors de Eclipse

• permet de contrôler le code source (Java, C++, …)

• permet d'adapter les règles de contrôle, les niveaux d'alerte

• permet de faire des bilans des contrôles sous différents formats

• les rapports doivent être mis à la disposition de l'IQ


PMD

VÉRIFIER LE CODE AVEC PMD

Menu contextuel


PMD


• Zone de la liste de toutes les alertes

• Niveaux d'alerte différents

• Code de couleur correspondant aux différents niveaux d'alerte


PMD


• Windows� Préférences � PMD– Adaptation des règles, changer les niveaux d'alerte

– Importer des règles d'un autre projet


PMD

RAPPORTS PMD

• Rapports au format HTML, CSV

• Rappel des règles

• Navigation sur le net


PMD

LES REGLES DE PMD

• accessible sur le site de – http://pmd.sourceforge.net/rules/index.html

• de nombreux ensemble de règles (ruleset)

• ruleset propre à certains développements– J2EE, JSP, JSF, …


Les tests de couverture



Introduction

• permet de répondre à des critères de SDF• les taux peuvent aller de 70% à 100%• 100% est le cas pire : nécessite des ateliers complets

d'automatisation de test• calcul du taux de couverture avec les tests unitaires

– prévoir la plupart des cas d'erreur même les plus improbables– difficultés de créer des user-case permettant de passer dans toutes les

branches– permet de vérifier si les TU sont suffisants– identifier la nature des branches non couvertes (exceptions)

• calcul du taux de couverture en validation– permet de calculer une valeur acceptable de taux de couverture– est un indicateur de la couverture des exigences



Les logiciels du marché

• EMMA

• JProbe Coverage (de QuestSoftware)– appartient à un pack (JProbe Profiler, JProbe Memory

Debugger, JProbe Threadalyzer)

• TOBIAS– outil de test combinatoire à partir d'un schéma de test

• Rational Test RealTime– très complet, chère



EMMA : présentation

• gratuit, beaucoup utilisé pour Java• http://emma.sourceforge.net• mesure de couverture à la volée• facilité de la mise en œuvre (avec ou sans ant)• rapport au format HTML permettant de naviguer dans

les résultats de l'analyse de couverture• 2 modes d'utilisation:

– "on-the-fly" : adapté à des programmes monolithique– "offline" : séparé l'instrumentation et l'exécution, adapté à

des applicatifs contenant plusieurs composants exécutables



EMMA : utilisation sur un exemple (1/4)

• Un programme : des classes de gestion d'un composant logiciel (ici une liste générique d'élément)

• Le test unitaire : un programme Java à menu

• Une commande d'exécution classique

• L'objectif : exécuter le programme en l'instrumentant avec Emma




• La commande d'exécution :– java -classpath ".;..\packages" ListeP

• La même commande instrumentée avec Emma :– java -classpath "C:\emma-2.0.5312\lib\emma.jar" emmarun -r html -cp

.;..\packages -sp .;..\packages ListeP

• Le principe :– emmarun est une classe appartenant au jar emma.jarqui prend en charge

l'exécution de ListeP

JVMemmarun

ListeP




• On exécute le TU comme si il n'y avait pas Emma• Une fois le programme terminé :

– soit nominalement– soit en exceptionEmma crée un rapport textuel ou html (répertoire coverage)

• Un code de couleur permet d'interpréter la couverture de chacun des lignes

• Importance de faire une instruction par ligne• Code de couleur :

– blanc : ne correspond pas à du P-code exécutée par la JVM– vert : code couvert– jaune : ligne contenant plusieurs instructions partiellement couverte– rouge : code non couvert




code non couvert : passer dans les exceptions

niveaux de couvertures : classe, méthode, bloque et

ligne de code

résumé

navigation dans les sources



CONCLUSIONS


Conclusion sur Java

• Le monde Java est complexe

• Avec lui, il embarque une bonne partie des nouvelles technologies dans le développement des applications logicielles

• C# de Microsoft est un concurrent sérieux de Java


Conclusion sur le rôle de l'IQ

• La façon de développer a évoluée : – intégration de logiciel

– développement web

– utilisation des IDE

• Le rôle de l'IQ a donc lui aussi évolué– il ne peut plus connaître d'une manière précise tous les langages (C++,

java, jsp, javascript, scripts, C#, php, perl, …)

– il doit s'appuyer sur des outils lui permettant d'assurer ses contrôles

– il ne contrôle plus la même chose :• la génération de code se contrôle peu

• de plus en plus : conception assistée

– savoir s'entourer, s'appuyer sur les experts techniques, les architectes


Conclusion sur le besoin de formation

• Il faut que l'IQ soit capable d'exprimer son besoin de formation

• Exemples de besoin de formation :– les base du langage Java

– les règles du contrôle qualité dans les architectures WEB

– les bases de C#

– les règles qualité applicables dans le développement de Microsoft

Documents

Formation IQ JAVA · – Permet aux développeurs de générer dynamiquement du code HTML, XML ou tout autre type de page Web. La technologie permet au code Java et à certaines actions