Exercice 1.2 : Exécution d'une révision de code et application d'une correction rapide

On suppose ici que vous avez effectué les étapes de l'Exercice 1.1 : Importation des ressources requises. Dans le présent exercice, vous commencez par lire un scénario mettant en jeu plusieurs utilisateurs. Puis vous prenez le rôle du développeur de logiciels décrit dans ce scénario.



Scénario utilisateurs

Une grande équipe de développeurs dispersés géographiquement travaille à l'écriture d'une nouvelle application logicielle. Il est important que les développeurs exécutent régulièrement des révisions de code afin de détecter les problèmes dans leur code.

L'un des développeurs souhaite exécuter une révision de code pour avoir un aperçu général de son travail. Pour passer en revue le code qu'il vient d'écrire et évaluer sa conformité aux pratiques recommandées dans plusieurs domaines, il exécute une procédure automatisée appelée Révision de code rapide. Cette révision applique au code plusieurs catégories de règles fournies en standard avec le produit. Chaque catégorie de règles contrôle la qualité du code dans un domaine spécifique tel que les performances.

Une fois la révision de code terminée, une liste de constatations, ou "anomalies", s'affiche à l'écran. Chaque anomalie représente une chaîne de code qui ne respecte pas strictement une règle appliquée. Pour l'une des anomalies constatées, une correction rapide est disponible. Le développeur applique donc la solution automatisée et corrige immédiatement le problème constaté.

Dans la première partie de l'exercice, vous accomplissez les tâches suivantes en vue d'exécuter une révision de code :

  1. Sélectionner une révision de code à exécuter.
  2. Visualiser les règles appliquées dans la révision de code.
  3. Choisir sur quel code exécuter la révision.
  4. Exécuter la révision de code.
  5. Visualiser les anomalies constatées par l'exécution de la révision de code.
  6. Sélectionner une anomalie pour afficher les informations suivantes la concernant :

Ensuite, pour appliquer une correction rapide à l'une des anomalies constatées dans la révision de code, vous accomplissez les tâches suivantes :

  1. Déterminer si une correction rapide est disponible pour une anomalie.
  2. Visualiser la liste des modifications qui seront apportées au code par la correction rapide.
  3. Prévisualiser la version initiale et la version restructurée du code avant d'appliquer la correction rapide.
  4. Appliquer la correction rapide pour restructurer le code.
  5. Obtenir une confirmation de l'application de la correction.


Exercice

Sélection d'une révision de code

Pour sélectionner une révision de code rapide :

  1. Sur la barre d'outils de la vue Révision de code, cliquez sur l'icône Gérer les règles, text.
  2. Vue Révision de code

  3. Dans la liste Sélectionnez la révision de code, cliquez sur Révision de code rapide. Les dossiers de règles de la révision de code sélectionnée s'affichent, comme l'illustre la capture d'écran suivante :
  4. Fenêtre Préférences, Révision de code rapide sélectionnée

  5. Pour voir l'une des règles qui sera appliquée dans la révision de code, développez la branche du dossier Pratiques recommandées dans J2SE, puis celle du sous-dossier Valeur NULL. Ce sous-dossier contient une seule règle, dont la gravité est de niveau Problème (voir l'illustration ci-dessous).
  6. Fenêtre Préférences, catégorie Pratiques recommandées dans J2SE, dossier Comparaison développé

    Pour mémoire, les icônes symbolisant les différents niveaux de gravités sont les suivantes :

    texte

  7. Cliquez sur OK pour choisir la Révision de code rapide.


Sélection d'une base de code à réviser

Procédez comme suit pour sélectionner le projet de la base de code à réviser :



Exécution de la révision de code

Une fois que vous avez sélectionné la base de code à réviser, la révision de code s'exécute. Vous pouvez suivre son état en observant la barre de progression, dans l'angle inférieur droit de la vue.



Visualisation des anomalies constatées par la révision de code

Une fois la révision de code terminée, les anomalies constatées sont présentées dans la vue Révision de code, comme le montre l'illustration ci-après :

Anomalies constatées dans la vue Révision de code (branches réduites)

La vue Révision de code fournit les informations suivantes :



Obtention d'informations complémentaires sur une anomalie constatée

Procédez comme suit pour obtenir plus d'informations sur une anomalie constatée dans la révision de code :

  1. Faites défiler la vue Révision de code pour atteindre le dossier Pratiques recommandées dans J2SE : Comparaison. Développez la branche de ce dossier pour révéler les anomalies qu'il contient, comme illustré ci-après :
  2. Anomalies constatées dans la révision de code, catégorie Pratiques recommandées dans J2SE, dossier Comparaison développé

  3. La première anomalie constatée commence par EqualsHashCode_Example.java. La règle appliquée figure après :
  4. Remplacez toujours java.lang.Object.equals() et java.lang.Object.hashCode()

  5. Cliquez deux fois sur la première anomalie. Les détails la concernant apparaissent en deux endroits, comme décrit et illustré ci-après :
  6. Détails de l'anomalie sélectionnée dans la révision de code.



Sélection d'une anomalie pour laquelle il existe une correction rapide

Les icônes symbolisant les deux anomalies dans le dossier Pratiques recommandées dans J2SE : Comparaison montrent qu'il existe une correction rapide pour celles-ci. Pour mémoire, les icônes symbolisant les corrections rapides sont les suivantes :

texte

  1. Cliquez avec le bouton doit sur la première anomalie répertoriée dans la liste (voir l'illustration suivante).
  2. Les choix proposés dans le menu contextuel Correction rapide varient en fonction de la solution. Pour l'anomalie sélectionnée ici, la correction consiste à implémenter hashCode et equals.
  3. Menu contextuel Correction rapide

  4. Cliquez sur Correction rapide : Implémentez hashCode et equals.


Application de la correction rapide

Pour l'anomalie que vous avez sélectionnée, la correction rapide consiste à implémenter hashCode et equals.

Pour examiner la correction rapide et l'appliquer à l'anomalie :

  1. La vue affichée, illustrée ci-après, présente deux sous-fenêtres de code placées l'une à côté de l'autre. Le code source d'origine se trouve à gauche, tandis que le code restructuré qui serait créé par la correction rapide se trouve à droite. Si vous décidez d'appliquer la correction rapide, les lignes mises en évidence dans la sous-fenêtre de droite seront ajoutées au code d'origine.
  2. Correction rapide : liste condensée des modifications avec codes d'origine et restructuré

  3. Dans la section Modifications à apporter, développez la liste pour voir précisément ce que la correction rapide changera dans le code et de quelle manière elle le fera (voir l'illustration suivante) :
  4. Correction rapide : liste étendue des modifications

  5. Examinez les modifications dans la liste. Cliquez ensuite sur OK pour appliquer la correction rapide à toutes les modifications sélectionnées dans la liste.
  6. Une fois la correction rapide appliquée, une marque de sélection (coche) figure en regard de l'anomalie que vous venez de résoudre.
  7. Révision de code : anomalie avec marque de sélection

    A côté de cette marque de sélection figurent les informations suivantes :

L'exercice "Exécution d'une révision de code et application d'une correction rapide" est terminé.



Conclusion de l'exercice

Vous avez accompli toutes les tâches de l'exercice "Exécution d'une révision de code et application d'une correction rapide".

Tâches à accomplir pour exécuter une révision de code

Pour exécuter cette révision de code, vous avez accompli les tâches suivantes :

  1. Sélectionner une révision de code à exécuter.
  2. Visualiser les règles appliquées dans la révision de code.
  3. Choisir sur quel corps de code exécuter la révision.
  4. Exécuter la révision de code.
  5. Visualiser les anomalies constatées par l'exécution de la révision de code.
  6. Sélectionner une anomalie pour afficher les informations suivantes la concernant :


Tâches à accomplir pour appliquer une correction rapide

Pour appliquer la correction rapide, vous avez accompli les tâches suivantes :

  1. Déterminer si une correction rapide est disponible pour une anomalie.
  2. Visualiser la liste des modifications qui seraient apportées au code par la correction rapide.
  3. Prévisualiser le code d'origine et le code restructuré.
  4. Appliquer la correction rapide pour restructurer le code.
  5. Obtenir une confirmation de l'application de la correction.


Mettre à profit la puissance d'une révision de code

En exécutant régulièrement des révisions de code, vous êtes en mesure d'identifier très tôt les anomalies. Cela signifie que vous pouvez aussi les traiter immédiatement, avant qu'elles ne conduisent aux problèmes suivants :



Mettre à profit la puissance d'une correction rapide

En appliquant une correction rapide fournie, vous disposez d'un moyen automatisé de résoudre une anomalie courante. Les corrections rapides présentent les avantages suivants :

Terminez ce tutoriel en passant en revue les objectifs de formation, dans la section Résumé : Exécution d'une révision de code.



Conditions d'utilisation | Appréciations en retour
(C) Copyright IBM Corporation 2000, 2004. All Rights Reserved.