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 :
- Sélectionner une révision de code à exécuter.
- Visualiser les règles appliquées dans la révision de code.
- Choisir sur quel code exécuter la révision.
- Exécuter la révision de code.
- Visualiser les anomalies constatées par l'exécution de la révision de code.
- Sélectionner une anomalie pour afficher les informations suivantes la concernant :
- Code source.
- Description, exemples et solutions.
Ensuite, pour appliquer une correction rapide à l'une des anomalies constatées dans la révision de code,
vous accomplissez les tâches suivantes :
- Déterminer si une correction rapide est disponible pour une anomalie.
- Visualiser la liste des modifications qui seront apportées au code par la correction rapide.
- Prévisualiser la version initiale et la version restructurée du code avant d'appliquer la correction rapide.
- Appliquer la correction rapide pour restructurer le code.
- 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 :
- Sur la barre d'outils de la vue Révision de code,
cliquez sur l'icône Gérer les règles,
.

- 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 :

- 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).

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

- 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 :
- Sur la barre d'outils de la vue Révision de code,
cliquez sur l'icône Révision (
) > Projets > Révision de CodeReview_Examples.
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 :

La vue Révision de code fournit les informations suivantes :
- Statistiques : la ligne située au-dessus des anomalies constatées donne des détails sur la révision de code
la plus récente : type, portée, nombre de règles et de fichiers inclus, nombre et gravité des anomalies constatées.
- Anomalies constatées : les anomalies constatées par la révision de code sont répertoriées sous forme de dossiers
dans la vue Révision de code. Chaque nom de dossier mentionne la catégorie de règles appliquées ainsi que le nombre
d'anomalies.
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 :
- 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 :

- La première anomalie constatée commence par EqualsHashCode_Example.java. La règle appliquée figure après :
Remplacez toujours java.lang.Object.equals() et java.lang.Object.hashCode()
- 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 :
- Code source : affiche le code dans lequel l'anomalie est constatée et met en évidence l'endroit précis où
elle se situe.
- Vue Détails de la révision du code : décrit l'anomalie plus en détail et fournit des exemples et des solutions pour la corriger.

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 :

- Cliquez avec le bouton doit sur la première anomalie répertoriée
dans la liste (voir l'illustration suivante).
- 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.

- 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 :
- 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.

- 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) :

- Examinez les modifications dans la liste. Cliquez ensuite sur OK pour
appliquer la correction rapide à toutes les modifications sélectionnées dans la liste.
- 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.

A côté de cette marque de sélection figurent les informations suivantes :
- La correction rapide appliquée
- Le numéro de ligne où se situe l'anomalie dans le code source
- La règle qui était spécifiée dans la révision de code et qui n'était pas respectée
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 :
- Sélectionner une révision de code à exécuter.
- Visualiser les règles appliquées dans la révision de code.
- Choisir sur quel corps de code exécuter la révision.
- Exécuter la révision de code.
- Visualiser les anomalies constatées par l'exécution de la révision de code.
- Sélectionner une anomalie pour afficher les informations suivantes la concernant :
- Code source.
- Description, exemples et solutions.
Tâches à accomplir pour appliquer une correction rapide
Pour appliquer la correction rapide, vous avez accompli les tâches suivantes :
- Déterminer si une correction rapide est disponible pour une anomalie.
- Visualiser la liste des modifications qui seraient apportées au code par la correction rapide.
- Prévisualiser le code d'origine et le code restructuré.
- Appliquer la correction rapide pour restructurer le code.
- 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 :
- Affectation des performances, de la maintenabilité et de l'extensibilité de votre application.
- Augmentation du temps et des ressources nécessaires au développement, et donc du coût pour votre entreprise.
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 :
- Elles corrigent les problèmes de manière cohérente et identique chaque fois qu'ils surviennent.
- Elles vous soulagent d'une part du codage et vous permettent de passer moins de temps à corriger les bogues.
Terminez ce tutoriel en passant en revue les objectifs de formation, dans la
section Résumé : Exécution d'une révision de code.