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 :
- Sélectionnez une révision de code à exécuter.
- Visualisez les règles appliquées dans la révision de code.
- Choisissez le code pour lequel exécuter la révision.
- Exécutez la révision de code.
- Visualisez les anomalies constatées par la révision de code.
- Sélectionnez une anomalie pour afficher les informations correspondants suivantes :
- Code source
- Description, exemples et solutions
Pour appliquer ensuite un correctif rapide à une anomalie constatée dans la révision de code, procédez comme suit :
- Déterminez si un correctif rapide est disponible pour une anomalie.
- Consultez la liste des modifications que le correctif rapide apporte au code.
- Avant d'appliquer le correctif rapide, prévisualisez le code d'origine et restructuré.
- Appliquez le correctif rapide pour restructurer le code.
- 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 :
- Dans 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 des règles de la révision de code sélectionnée s'affichent, comme illustré dans la capture d'écran suivante :

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

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

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

La vue Révision de code contient les informations suivantes :
- Statistiques de la révision de code : la ligne située au-dessus des anomalies affiche des informations relatives à la révision de code la plus récente : type, portée, nombre de règles et fichiers inclus, et nombre et gravité des anomalies.
- Anomalies constatées par la révision de code : les anomalies issues de la révision de code sont répertoriées dans des dossiers de la vue Révision de code. Chaque nom de dossier indique la catégorie des règles appliquées et le nombre d'anomalies.
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 :
- 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 :

- La première anomalie commence par EqualsHashCode_Example.java. Elle est suivie de la règle qui lui est appliquée :
Remplacez toujours java.lang.Object.equals() et java.lang.Object.hashCode()
- 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 :
- Code source : affiche le code dans lequel l'anomalie se produit et met en évidence son emplacement exact.
- Vue Détails de la révision du code : décrit l'anomalie plus en détail et fournit des exemples et solutions permettant de la corriger.

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 :

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

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

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

- 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.
- Une fois le correctif rapide appliqué, une marque de sélection apparaît en regard de l'anomalie que vous avez résolue.

Les informations suivantes apparaissent en regard de la marque de sélection :
- Le correctif rapide appliqué
- Le numéro de ligne du code source qui contient l'anomalie
- La règle de révision de code qui n'a pas été respectée
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 :
- Vous avez sélectionné une révision de code à exécuter.
- Vous avez visualisé les règles appliquées dans la révision de code.
- Vous avez choisi un corps de code pour lequel exécuter la révision.
- Vous avez exécuté la révision de code.
- Vous avez visualisé les anomalies constatées par la révision de code.
- Vous avez sélectionné une anomalie pour afficher les informations correspondants suivantes :
- Code source
- Description, exemples et solutions
Tâches relatives à l'application d'un correctif rapide
Lorsque vous avez appliqué le correctif rapide :
- Vous avez déterminé si un correctif rapide est disponible pour une anomalie.
- Vous avez consulté la liste des modifications que le correctif rapide apporte au code.
- Vous avez prévisualisé le code d'origine et le code restructuré.
- Vous avez appliqué le correctif rapide pour restructurer le code.
- 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 :
- Impact sur les performances, la maintenance ou l'extensibilité de votre application
- Augmentation des coûts, du temps et des ressources utilisés par votre société
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 :
- à corriger un incident de façon cohérente chaque fois qu'il se produit,
- à vous libérer pour la codification et à passer moins de temps à corriger les bogues.
Terminez le tutoriel en révisant les objectifs d'apprentissage dans la section Récapitulatif : Exécution d'une révision de code.