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

Dans cet exercice, on part du principe que vous avez terminé l'exercice 1.1 : Importation des ressources requises. Cet exercice contient un scénario utilisateur que vous devez lire en premier. Assumez ensuite le rôle de développeur de logiciels qui est décrit dans le scénario utilisateur.



Scénario utilisateur

Un grand groupe de développeurs de logiciels dispersés géographiquement codifie une nouvelle application logicielle. Il est important que les développeurs exécutent régulièrement des révisions de code pour vérifier si le code comporte des incidents.

Un des développeurs souhaite exécuter une révision de code pour déterminer l'état général du code. Pour réviser un nouveau code afin de déterminer si celui-ci est conforme aux valeurs recommandées dans plusieurs domaines, le développeur exécute une révision de code rapide automatisée. Cette révision applique au code plusieurs catégories de règles fournies. Chaque catégorie de règles vérifie la qualité du code dans un domaine particulier, par exemple, les performances.

Une fois la révision de code terminée, une liste d'anomalies apparaît. Chaque anomalie représente une chaîne de code qui n'est pas rigoureusement conforme à une règle appliquée. Lorsqu'un correctif rapide est disponible pour une des anomalies, le développeur applique la solution automatisée et corrige l'incident immédiatement.

Dans la première partie de l'exercice, vous pouvez procéder comme suit pour exécuter une révision de code :

  1. Sélectionnez une révision de code à exécuter.
  2. Visualisez les règles appliquées dans la révision de code.
  3. Choisissez le code pour lequel exécuter la révision.
  4. Exécutez la révision de code.
  5. Visualisez les anomalies constatées par la révision de code.
  6. Sélectionnez une anomalie pour afficher les informations correspondants suivantes :

Pour appliquer ensuite un correctif rapide à une anomalie constatée dans la révision de code, procédez comme suit :

  1. Déterminez si un correctif rapide est disponible pour une anomalie.
  2. Consultez la liste des modifications que le correctif rapide apporte au code.
  3. Avant d'appliquer le correctif rapide, prévisualisez le code d'origine et restructuré.
  4. Appliquez le correctif rapide pour restructurer le code.
  5. Obtenez une confirmation une fois le correctif rapide appliqué.


Exercice

Sélection d'une révision de code

Pour sélectionner une révision de code rapide, procédez comme suit :

  1. Dans 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 des règles de la révision de code sélectionnée s'affichent, comme illustré dans la capture d'écran suivante :
  4. Fenêtre Préférences, Révision de code rapide sélectionnée

  5. Pour visualiser une des règles appliquées à la révision de code, développez le dossier Pratiques recommandées dans J2SE puis le sous-dossier Valeur NULL. Le dossier Valeur NULL affiche une règle dont le niveau de gravité est Problème, comme illustré dans la capture d'écran suivante :
  6. Fenêtre Préférences, catégorie Pratiques recommandées dans J2SE, dossier Comparaison développé

    A titre d'information, les icônes de niveau de gravité sont illustrées dans la figure suivante :

    text

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


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

Pour sélectionner le projet comme base de code à réviser, procédez comme suit :



Exécution de la révision de code

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



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

Une fois la révision de code terminée, les anomalies s'affichent dans la vue Révision de code, comme illustré dans la capture d'écran suivante :

Anomalies constatées par la révision de code, réduites

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



Informations complémentaires relatives à une anomalie constatée par la révision de code

Pour obtenir des informations complémentaires sur une anomalie constatée par la révision de code, procédez comme suit :

  1. Dans la vue Révision de code, accédez au dossier Pratiques recommandées dans J2SE : Comparaison. Développez ensuite le dossier de sorte que les anomalies qu'il contient s'affichent, comme illustré dans la capture d'écran suivante :
  2. Anomalies constatées par la révision de code, catégorie Pratiques recommandées dans J2SE, dossier Comparaison développé

  3. La première anomalie commence par EqualsHashCode_Example.java. Elle est suivie de la règle qui lui est appliquée :
  4. Remplacez toujours java.lang.Object.equals() et java.lang.Object.hashCode()

  5. Cliquez deux fois sur la première anomalie. Les détails correspondants apparaissent dans deux emplacements, comme décrit dans les points et la capture d'écran suivants :
  6. Détails de l'anomalie de révision de code sélectionnée.



Sélection d'une anomalie pour laquelle un correctif rapide est disponible

Les anomalies du dossier Pratiques recommandées : Comparaison pour lesquelles un correctif rapide est disponible sont signalées à l'aide de leur icône. A titre d'information, les icônes de correctif rapide sont illustrées dans la figure suivante :

text

  1. Cliquez à l'aide du bouton droit de la souris sur la première anomalie de la liste, comme illustré dans la capture d'écran qui suit.
  2. L'option de menu en incrustation Correctif rapide varie selon la solution. Pour l'anomalie sélectionnée, le correctif consiste à implémenter hashCode et equals.
  3. Menu en incrustation Correctif rapide

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


Application du correctif rapide

Le correctif rapide de l'anomalie sélectionnée consiste à implémenter hashCode et equals.

Pour réviser et appliquer le correctif rapide à l'anomalie, procédez comme suit :

  1. Une vue juxtaposée s'affiche, comme illustré dans la capture d'écran ci-dessous. Le code source d'origine est situé à gauche et le code source restructuré qui va être créé par le correctif rapide est situé à droite. Si vous choisissez d'appliquer le correctif rapide, celui-ci ajoute les lignes de code manquantes qui sont mises en évidence.
  2. Liste réduite des modifications du correctif rapide, contenant le code d'origine et le code restructuré

  3. Dans la section des modifications à effectuer, développez la liste pour déterminer exactement les modifications apportées par le correctif rapide et l'impact de celles-ci, comme illustré dans la capture d'écran suivante :
  4. Liste développée des modifications apportées par le correctif rapide

  5. Vérifiez les modifications de la liste. Cliquez ensuite sur OK pour appliquer le correctif rapide à toutes les modifications sélectionnées dans la liste.
  6. Une fois le correctif rapide appliqué, une marque de sélection apparaît en regard de l'anomalie que vous avez résolue.
  7. Anomalies de révision de code cochées

    Les informations suivantes apparaissent en regard de la marque de sélection :

Vous avez terminé l'exercice suivant : Exécution d'une révision de code et application d'un correctif rapide.



Récapitulatif de l'exercice

Vous avez effectué toutes les tâches de l'exercice suivant : Exécution d'une révision de code et application d'un correctif rapide.

Tâches relatives à l'exécution d'une révision de code

Lors de l'exécution de la révision de code :

  1. Vous avez sélectionné une révision de code à exécuter.
  2. Vous avez visualisé les règles appliquées dans la révision de code.
  3. Vous avez choisi un corps de code pour lequel exécuter la révision.
  4. Vous avez exécuté la révision de code.
  5. Vous avez visualisé les anomalies constatées par la révision de code.
  6. Vous avez sélectionné une anomalie pour afficher les informations correspondants suivantes :


Tâches relatives à l'application d'un correctif rapide

Lorsque vous avez appliqué le correctif rapide :

  1. Vous avez déterminé si un correctif rapide est disponible pour une anomalie.
  2. Vous avez consulté la liste des modifications que le correctif rapide apporte au code.
  3. Vous avez prévisualisé le code d'origine et le code restructuré.
  4. Vous avez appliqué le correctif rapide pour restructurer le code.
  5. Vous avez obtenu une confirmation selon laquelle le correctif rapide a été appliqué.


Avantages d'une révision de code

En exécutant des révisions de code de façon proactive, vous êtes en mesure d'analyser les anomalies rapidement. Cela signifie que vous pouvez les traiter avant qu'elles entraînent les problèmes suivants :



Avantages d'un correctif rapide

En appliquant un correctif rapide fourni, vous disposez d'une méthode automatisée permettant de résoudre une anomalie courante. Les correctifs rapides vous aident :

Terminez le tutoriel en révisant les objectifs d'apprentissage dans la section Récapitulatif : Exécution d'une révision de code.



Commentaires
(C) Copyright IBM Corporation 2000, 2005. All Rights Reserved.