JavaRush /Blog Java /Random-FR /IntelliJ IDEA et Debug : pas de plongée, mais du snorkeli...
Viacheslav
Niveau 3

IntelliJ IDEA et Debug : pas de plongée, mais du snorkeling

Publié dans le groupe Random-FR
Écrire du code représente la moitié de la bataille. Encore faut-il le faire fonctionner correctement. Les IDE et les outils de débogage nous aident beaucoup dans ce domaine.
IntelliJ IDEA et Debug : Pas de plongée, mais de plongée en apnée - 1
En utilisant IntelliJ IDEA comme exemple, je propose de vous familiariser avec la façon dont nous pouvons découvrir ce qui arrive à notre code lors de son exécution. Le débogage est un vaste sujet, cette revue ne propose donc pas de plongée profonde, comme un plongeur. Mais j'espère que la plongée en apnée est sûre)

Introduction

Une partie de l’écriture du code consiste à le déboguer. Et si vos tâches incluent la prise en charge du code, il y aura encore plus de débogage. Eh bien, de plus, avec l'aide du débogage, vous pouvez examiner le travail des bibliothèques et des frameworks utilisés aussi profondément que vous pouvez vous immerger dans la jungle du code de quelqu'un d'autre. Pour notre plongée nous aurons besoin de : Tout d’abord, décompressez l’archive téléchargée avec le code source de démarrage rapide. Lancez IntelliJ Idea et créez un « nouveau projet à partir de sources existantes ». Sélectionnez le fichier pom.xml dans le sous-répertoire hibernate4 . Lors de l'importation, spécifiez « Importer les projets Maven automatiquement » et terminez la création du projet, en laissant les autres paramètres inchangés. Pendant l'importation du projet, décompressez le serveur d'applications WildFly téléchargé dans un répertoire. Nous démarrons le serveur en utilisant le fichier (ou standalone.sh pour les systèmes *nix). (!) Il est important de commencer par le paramètre --debug , on attend que le serveur démarre. Ils nous écriront que cela a commencé et nous indiqueront l'heure. Cela ressemblera à ceci : bin\standalone.bat
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 2
Ensuite, nous devons exécuter le projet que nous avons choisi sur le serveur. Ce processus est décrit dans une petite documentation qui se trouve dans le projet lui-même : \hibernate4\README.adoc Comme indiqué dans cette documentation, nous devons exécuter la commande dans le répertoire hibernate4 : mvn clean package wildfly:deploy Nous attendons un message indiquant que la construction s'est terminée avec succès :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 3
Après cela, dans le journal du serveur, nous pouvons voir comment le nouveau projet a été « déployé » :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 4
Après cela, nous allons sur la page http://localhost:8080/wildfly-hibernate4et nous devrions afficher une page avec le formulaire « Inscription des membres ». Notre préparation pour les expériences est donc terminée et nous pouvons commencer)) Il y aura beaucoup de photos à venir pour plus de clarté, alors préparez-vous)

Débogage à distance

Nous devons donc configurer le mode Debug pour que notre IDE contrôle l'exécution du code sur le serveur d'applications. IntelliJ Idea est disponible en deux versions : gratuite (Community) et payante (Ultimate). Ces derniers peuvent être officiellement jugés sous forme d'EAP. Dans la version Ultimate, tout est simple : le serveur d'applications peut être lancé directement depuis l'IDE en mode débogage. Mais dans la version Community, vous devez effectuer certaines opérations manuellement. Considérons donc un cas plus compliqué, à savoir paramètre dans la version communautaire. La version communautaire présente certaines limitations. En particulier, vous ne pouvez pas exécuter un serveur d'applications à partir de celui-ci. Mais vous pouvez configurer le débogage à distance (Remote Debug), lorsqu'il existe quelque part séparément un serveur en cours d'exécution avec l'application dont nous avons besoin. Utilisons la description de la configuration à partir d'ici : Débogage à distance de Wildfly dans l'édition communautaire IntelliJ Idea (configuration de la configuration d'exécution à distance pour le port 8787). Après configuration, nous lançons notre nouvelle configuration en mode Debug :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 5
Si tout va bien, nous verrons un message à ce sujet ci-dessous :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 6

Processus de débogage

Déboguons en sauvegardant l'enregistrement. Pour ce faire, nous devons d’abord décider du lieu où nous allons explorer. À en juger par la fenêtre, nous avons besoin d'un bouton « S'inscrire ». Trouvons-le dans le code. Nous avons donc besoin d'un élément, il doit avoir le texte : "S'inscrire". Ou alors, elle devrait avoir quelque chose à voir avec ça. Cliquez Ctrl+Shift+Fet recherchez S'inscrire entre guillemets. On voit qu'il y en a un sur index.xhtml.
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 7
Appuyez sur Entrée pour accéder à la source trouvée :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 8
Ainsi, nous voyons que lors de l'enregistrement, memberController.register est appelé. Apparemment, cela doit être une sorte de classe Java. Cliquez Ctrl+Net recherchez :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 9
En effet, une telle classe existe. Allons-y. Apparemment, il devrait y avoir une méthode d'enregistrement. Cliquez Ctrl+F12et recherchez la méthode d'enregistrement
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 10
En effet, nous l'avons trouvé. Apparemment, l'inscription a lieu ici, dans memberRegistration.register . Appuyez sur Ctrl et cliquez sur la méthode pour y accéder :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 11
Définissons maintenant un « point d'arrêt » ou Break Point. Il s'agit d'un marqueur qui indique où l'exécution du code doit s'arrêter. À ce moment-là, nous aurons l’occasion d’apprendre beaucoup de choses intéressantes. Pour le mettre, vous devez cliquer à l'endroit situé à droite du numéro de ligne.
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 12
Sur la page http://localhost:8080/wildfly-hibernate4 remplissez les champs et cliquez sur le bouton S'inscrire. L'icône d'idée sur le panneau clignote :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 13
En allant sur Idea, vous pouvez voir qu'il y a beaucoup d'informations intéressantes dans le panneau de débogage :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 14
Ici vous pouvez voir la valeur des champs de l'objet. Par exemple, en quoi consiste un membre inscrit :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 15
Super. Que pouvons-nous faire d'autre? Nous pouvons ouvrir le menu contextuel et y sélectionner Évaluer l'expression (ou via le menu Exécuter -> Évaluer l'expression). Mieux encore, sur le panneau de configuration du débogueur :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 16
C'est une capacité super intéressante à un point d'arrêt, avoir accès à tout ce à quoi ce point de code a accès, pour exécuter n'importe quel code qui pourrait être exécuté à ce stade. Par exemple:
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 17
Il existe également des boutons de contrôle sur le panneau de configuration du débogueur qui déterminent où vous souhaitez déplacer le contrôle de flux du programme. N'est-ce pas magique ?) En appuyant sur le bouton F8 (Step Out), on parcourt le code sans saisir de méthodes. En appuyant sur F9, nous arrêtons de parcourir les lignes de code avec le débogueur et donnons au débogueur le contrôle de l'exécution du programme. Si nous appuyons sur F7 (Step Into), nous parcourrons le code en entrant chaque méthode que nous rencontrerons en cours de route. D'ailleurs, portez une attention particulière à ce bloc d'informations :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 18
Cela montre le thread dans lequel nous nous trouvons et les méthodes sur la pile du thread actuel. Mais ce n'est pas tout. Pour plus de commodité, vous pouvez ouvrir l'onglet Cadres. Pour ce faire, il doit être activé :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 19
Maintenant, dans l'onglet frames, nous voyons des informations sur la transition d'une méthode à l'autre, car a commencé à parcourir le code en utilisant Step Into.
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 20
Comme nous le voyons, nous ne pouvons pas toujours être transférés là où le programme est actuellement en cours d'exécution. Nous sommes maintenant à "getDelegate:469, AbstractEntityManager(org.jboss.as.jpa.container)". Mais en fait, nous sommes en phase de mise en œuvre. Ceci est démontré par la classe spécifiée par ceci :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 21
Regardons ça. Comme nous le savons, il pointe vers l'objet actuel. Nous sommes chez TransactionScopedEntityManager. Pourquoi Idea ne peut-il pas nous montrer le code ? Le fait est qu'IntelliJ Idea ne connaît actuellement aucun TransactionScopedEntityManager, car il n'est pas connecté à notre projet (il n'est pas dans les dépendances du projet). Lorsqu'un serveur d'applications est en cours d'exécution, de très nombreuses bibliothèques différentes s'y exécutent. Mais nous en savons très peu sur eux, car... en général, nous n'avons pas besoin de nous plonger dans les composants internes, nous avons juste besoin que cela fonctionne. Mais parfois, le travail ou l’intérêt sportif l’exigent. Ensuite, vous devez informer Idea sur cette bibliothèque afin qu'elle sache où trouver le code de la classe.

Connexion de bibliothèques tierces pour le débogage

Premièrement, nous devons nous-mêmes comprendre quel type de bibliothèque doit être connecté. La première méthode est la plus difficile : effectuer une recherche sur Internet. La rapidité et le résultat de l'obtention d'un résultat dépendent grandement de la qualité de la gestion du projet. Par exemple, WildFly dispose d'un référentiel ouvert. Ainsi, lorsque nous recherchons « TransactionScopedEntityManager » sur Google, nous irons sur https://github.com/wildfly/wildfly/tree/master/jpa/subsystem et constaterons que nous avons besoin de wildfly-jpa. La deuxième méthode est correcte. Où se trouve le serveur, regardez là-bas. Divers moyens peuvent y contribuer. Par exemple, sous Windows, il pourrait s'agir de Far Manager . Vous trouverez ci-dessous un exemple d'algorithme de recherche. Après l'avoir installé et lancé, utilisez Tab pour passer à l'un des onglets, en utilisant Alt+F1l'onglet de gauche ou Alt+F2celui de droite, et sélectionnez la partition dont nous avons besoin sur le disque dur. Il est fort possible que le répertoire Far Manager lui-même soit ouvert dans Far Manager après l'installation. Pour accéder à la racine du disque, appuyez sur Ctrl + \. À l'aide de, Alt+Fouvrez la fenêtre de recherche, commencez à taper le nom du répertoire et appuyez sur Entrée une fois le répertoire trouvé. Cette recherche est intelligente et met en évidence les répertoires qui correspondent au texte recherché. Si vous saisissez des caractères pour lesquels il n'existe aucun dossier, ces caractères ne peuvent pas être saisis. De cette façon, nous allons dans le répertoire du serveur d'applications. Disons que nous ne savons pas où se trouvent les modules sur le serveur. C'est peut-être la première fois de votre vie que vous entendez parler d'une sorte de WildFly. Par conséquent, cliquez immédiatement ici Alt+F7pour rechercher des fichiers. Donc, la logique veut : nous avons besoin d'un fichier avec la bibliothèque. Autrement dit, nous avons besoin d'un pot. Il devrait y avoir une classe TransactionScopedEntityManager à l’intérieur. Parce que class = file, puis recherchez « contient ». Autrement dit, quelque chose comme ceci :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 22
Maintenant, attendons le résultat. Il ne te fera pas attendre)
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 23
Maintenant, nous devons trouver le code source quelque part. Et il y a 2 options : Utilisons peut-être le deuxième. Retrouvons-y :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 24
Passons maintenant à la description de la dépendance. Sur cette page, vous pouvez télécharger le code source. Super, maintenant nous avons le code téléchargé. Il ne reste plus qu'à connecter la bibliothèque. Cela se connecte extrêmement simplement. Nous devons ouvrir les paramètres du projet :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 25
Là, nous sélectionnons « Bibliothèques » et ajoutons les codes sources reçus à la section « Sources », et dans la section « Classes », nous indiquons le fichier jar de la bibliothèque lui-même à partir du répertoire WildFly, que nous avons trouvé à l'aide de Far Manager. Après cela, lorsque nous naviguons dans F7, nous verrons le contenu des classes AbstractEntityManager et TransactionScopedEntityManager, et deviendrons également disponibles via une recherche par classe en utilisant Ctrl+N.

Points d'arrêt avec conditions

Revenons maintenant aux points de rupture. Parfois, nous ne voulons pas toujours nous arrêter, mais seulement sous certaines conditions. Ce qu'il faut faire? Et ici, notre IDE nous aidera également. En plaçant un point d'arrêt, nous pouvons lui attribuer une condition. Par exemple, placez un point et faites un clic droit dessus :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 26
Désormais, le point d'arrêt ne se déclenchera que lorsque le nom est Maximilian. En cliquant sur le bouton Plus, un ensemble étendu de paramètres pour les points d'arrêt sera disponible.

Points d'arrêt sur les exceptions

Parfois, nous pouvons recevoir une erreur et nous souhaitons déterminer d'où elle vient. Ensuite, nous pouvons ajouter un point d'arrêt non pas sur une ligne de code spécifique, mais à l'endroit où l'exception sera levée. Pour ce faire, vous devez développer la liste de tous les points d'arrêt :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 27
Et créez une nouvelle règle pour le type d'exception sélectionné :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 28
Par exemple, pour les NPE :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 29

Cours HotSwap

Le débogueur est une chose étonnante. En plus du débogage, il permet de changer de classe ! Oui, les ressources (telles que les pages xhtml, par exemple) ne peuvent pas être modifiées aussi facilement. Mais le code des classes Java peut être remplacé à la volée (c'est ce qu'on appelle le Hot Swap). Pour ce faire, changez simplement la classe avec le débogueur attaché et exécutez Run -> Reload Changed Classes. Revue utile sur ce sujet : 4 méthodes gratuites pour échanger du code à chaud sur la JVM

Conclusion

Un débogueur est un outil puissant qui permet à un développeur de pénétrer dans les profondeurs du code en cours d'exécution et de l'étudier dans les moindres détails. Cela vous permet de corriger les erreurs les plus déroutantes. Cela permet également de mieux comprendre le fonctionnement de certaines bibliothèques. Même une revue aussi brève s'est avérée assez impressionnante, mais j'espère qu'elle sera utile et intéressante. Si quelqu'un est intéressé par ce matériel, vous pouvez continuer la plongée en utilisant les liens suivants :
IntelliJ IDEA et Debug : Pas de plongée, mais de snorkeling - 30
#Viacheslav
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION