Pag-debug sa IntelliJ IDEA: gabay ng baguhan

Kumusta sa lahat sa komunidad ng CodeGym! Ngayon, pag-usapan natin ang tungkol sa pag-debug — ano ito at kung paano mag-debug sa IntelliJ IDEA. Ang artikulong ito ay inilaan para sa mga taong mayroon nang minimum na kaalaman sa Java Core. Hindi magkakaroon ng anumang mga balangkas o kumplikadong pamamaraan upang mag-publish ng mga aklatan. Isang masayang lakad. Kaya gawing komportable ang iyong sarili at magsimula tayo!

Bakit kailangan mo ng Debug mode

Agad nating linawin ang isang bagay para sa ating sarili: walang code na walang mga bug... Ito ay kung paano gumagana ang buhay. Kaya, hindi tayo dapat magkapira-piraso at sumuko kung ang ating code ay hindi gagana gaya ng ating inaasahan. Ngunit ano ang dapat nating gawin? Kaya, maaari kaming maglagay System.out.printlnng mga pahayag sa lahat ng dako at pagkatapos ay magsuklay sa output ng console sa pag-asang makahanap ng isang error. Iyon ay sinabi, maaari mong (at ginagawa ng mga tao) ang pag-debug gamit ang maingat na pag-log. Ngunit kung maaari mong patakbuhin ang iyong code sa isang lokal na makina, mas mainam na gumamit ng Debug mode. Gusto kong tandaan kaagad na sa artikulong ito isasaalang-alang namin ang pag-debug ng isang proyekto gamit ang IntelliJ IDEA.

Ano ang Debug mode?

Ang debug mode ay para sa pag-debug (pagsusuri) ng running code. Ginagawa nitong posible para sa iyo na ihinto ang pagpapatupad sa mga itinalagang lugar at tingnan kung paano umuusad ang mga bagay. Hinahayaan ka nitong maunawaan ang estado ng programa sa isang partikular na lugar sa code. Ito ay tulad ng magagawang ihinto ang orasan at tingnan ang lahat mula sa gilid. Astig diba? Ang aming layunin ay mabilis at madaling matutunan kung paano mag-debug ng mga application gamit ang aming minamahal na kapaligiran sa pagbuo ng IntelliJ IDEA.

Ano ang kailangan mo upang simulan ang pag-debug

Narito ang ilang libreng payo: habang binabasa ang artikulong ito, gawin ang lahat ng ilalarawan dito — mayroon kang lahat ng kailangan mong gawin sundin. Ang iyong kailangan:

1. IntelliJ IDEA bersyon 2019.3.1 o mas mataas. Kung sakaling walang ganito ang isang tao, narito ang isang link kung saan maaari mong i-download ito . I-download ang Community Edition — iyon ang bersyon na gagamitin ko.
2. I-clone ang proyektong GitHub na ito at i-import ito sa pamamagitan ng IDEA.

Buksan ang IDEA: Piliin ang debug-presentation project at pindutin ang OK . Pagkatapos ay makikita mo ang sumusunod na window: Iwanan ang mga napiling opsyon: Mag-import ng proyekto mula sa mga panlabas na mapagkukunan at Maven . I-click ang Tapos na . Ngayong na-import na namin ang proyekto, maaari naming ilarawan ang natitirang bahagi ng proseso gamit ang isang buhay na halimbawa.

Medyo theory lang... promise :D

Upang simulan ang pag-debug kahit kaunti, kailangan mong maunawaan kung ano ang breakpoint at maging pamilyar sa ilang mga hot key. Ang breakpoint ay isang espesyal na marker na nagsasaad kung saan mo gustong ihinto ang pagpapatupad ng application, posibleng batay sa estado ng aplikasyon. Maaari kang magtakda ng breakpoint alinman sa pamamagitan ng pag-left-click sa kaliwang bahagi ng panel, o sa pamamagitan ng pag-click sa lokasyon ng code at pagpindot sa Ctrl+F8 . Tingnan natin ang tatlong uri ng mga breakpoint: line breakpoints, field watchpoints, at at method breakpoints. Ganito ang hitsura nito:

• Sa isang linya:

  Kung may lambda expression ang isang statement, ipo-prompt ka ng IDEA na piliin kung ilalagay ang breakpoint sa buong statement o partikular sa lambda expression:

• Sa isang pamamaraan:

• Sa isang klase:

Maaaring alisin ang mga breakpoint sa pamamagitan ng pagsunod sa parehong mga hakbang na ginamit upang idagdag ang mga ito. May mga sitwasyon kung kailan mo gustong i-inactivate (i-mute) ang mga ito. Upang gawin ito, hanapin ang icon sa seksyong Debug. Imu-mute nito ang lahat ng breakpoints. Upang makita kung anong mga breakpoint ang naitakda, maaari kang pumunta sa seksyong Debug sa ibabang kaliwang sulok at hanapin ang icon, o pindutin ang Ctrl+Shift+F8 : Paglipat sa listahan ng mga breakpoint, makikita natin ang sumusunod: Mayroong dalawang breakpoints dito:

• Bee.java:24 — sa klase ng Bee sa linya 24
• Main.java:14 — sa Pangunahing klase sa linya 14

Pakitandaan na ang mga breakpoint na ito ay hindi awtomatikong itatakda kung na-clone mo ang proyekto: kakailanganin mong itakda ang mga ito sa iyong sarili! Mayroon ding seksyon ng Java Exception Breakpoints . Ito ay lubhang kapaki-pakinabang. Dito maaari kang magdagdag ng isang implicit na breakpoint upang ang programa ay huminto bago maghagis ng anumang exception o isang partikular na exception. Magdaragdag kami ng implicit na breakpoint para sa RuntimeException. Ito ay madaling gawin. Hanapin ang icon na "+" sa kaliwang sulok sa itaas. Mag-click dito at piliin ang Java Exception Breakpoints : Sa lalabas na window, isulat ang pangalan ng exception na gusto mong idagdag, pumili mula sa listahan at i-click ang OK : Iyon ay nagtatapos sa aming panimulang aklat sa kung paano i-set up ang mga bagay, kaya ngayon ay ' Magpatuloy sa ilang pagsasanay.

Gawin natin itong tinatawag na debugging!

Nagmula ako sa mahabang hanay ng mga beekeepers ng pamilya, kaya ang proyektong ginawa ko upang ilarawan ang pag-debug ay naglalarawan ng mga modelo ng proseso ng pagkolekta ng mga bubuyog ng nektar, pagproseso ng nektar upang maging pulot, at pagkatapos ay pagkuha ng pulot mula sa beehive. Ayon sa dokumentasyong README file, na makikita sa root directory ng proyekto, ang inaasahang pag-uugali ng lahat ng mga bulaklak kung saan kinokolekta ang nektar ay para sa dami ng nakolektang pulot (na may anyo ng double ) na katumbas ng kalahati ng ang nakolektang nektar. Ang proyekto ay may mga sumusunod na klase:

• Pukyutan — isang ordinaryong manggagawang pukyutan
• BeeQueen - ang queen bee
• BeeHive — ang bahay-pukyutan
• HoneyPlant — isang halaman ng pulot (pinagmulan ng nektar) kung saan kinokolekta ang nektar
• Pangunahin — dito natin makikita public static void main(), ang paraan kung saan magsisimula ang pagpapatupad.

Kung patakbuhin namin ang main()pamamaraan, pagkatapos ay nalaman namin na hindi lamang ang aming programa ay hindi kinakalkula ang dami ng pulot, ito rin ay nagtatapon ng isang pagbubukod ... Kailangan nating mag-imbestiga at matukoy kung ano ang problema. Mula sa trace stack sa kanang sulok sa ibaba, makikita natin na sa isang RuntimeException ay itinapon sa HoneyPlant.java:20: Iyon lang ang pinag-uusapan natin sa itaas. Panoorin natin ang RuntimeException na ito sa pamamagitan ng pagpapatakbo ng main()pamamaraan sa debug mode. Upang gawin ito, mag-click sa berdeng tatsulok na arrow sa IntelliJ IDEA sa tabi ng main()pamamaraan. Bilang resulta, ipapahinto natin ang programa sa sandaling ito bago itapon ang exception at makikita natin ang icon na ito: Upang makuha ang lahat ng magagamit na impormasyon, kailangan nating tumingin sa seksyong Debug. Mayroon itong mga Variablepane na nagpapakita ng lahat ng mga variable na magagamit sa bahaging ito ng application:

• nektar = 1.0;
• nectarCapacity = -1.0.

Makatuwirang itapon ang pagbubukod, dahil hindi maaaring magkaroon ng negatibong dami ng nektar ang isang halaman ng pulot. Ngunit bakit ito nangyayari? Pagkatapos ng lahat, sa mga linya 15-17, sinusuri namin kung naubos na ang suplay ng nektar at nagbabalik ng zero kung ito ay:

if (nectar == 0) {
   	     return 0;
}

Ngunit ang problema ay sinusuri namin ang maling variable. Ito ay isang error sa code. Sa halip na suriin ang dami ng nektar na makukuha sa bulaklak (na nakaimbak sa nectarCapacity variable), sinusuri ng program ang halaga ng parameter ng nectar ng pamamaraan , na kung saan ay ang dami ng nektar na gusto naming kunin mula sa bulaklak. Heto na! Ang aming unang bug! Pagkatapos ayusin ito, nakukuha namin ang sumusunod na code:

if (nectarCapacity == 0) {
   	     return 0;
}

Ngayon patakbuhin ang main()pamamaraan sa normal na paraan (Run 'Main.main()'). Walang itinapon na pagbubukod, at gumagana ang programa: Ang application ay tumatakbo hanggang sa pagkumpleto at nagbibigay ng sumusunod na sagot:

"33.0 honey was produced by 7 bees from 2 honey plants"

Magiging maayos ang lahat ngayon, ngunit ang sagot na ito ay hindi tama... Ayon sa dokumentasyong README file, ang nektar ay na-convert sa pulot sa ratio na 2 hanggang 1:

## Documentation
Presentation based on honey production.

**Note**: 2 units of nectar = 1 unit of honey

Ang pangunahing pamamaraan ay malinaw na mayroong dalawang halaman ng pulot na may 30 at 40 na yunit ng nektar, ayon sa pagkakabanggit. Kaya't sa huli, dapat tayong magkaroon ng 35 yunit ng pulot. Ngunit sinasabi ng programa na makakakuha tayo ng 33. Saan napunta ang dalawa pang unit? Alamin Natin! Upang gawin ito, magtakda ng breakpoint sa Main.main()pamamaraan sa linya 28, kung saan beeHive.populateHoney()tinatawag at patakbuhin ang main()pamamaraan sa Debug mode: Isasaalang-alang namin ang puntong ito nang mas detalyado. Ang programa ay huminto sa pagpapatupad bago isagawa ang linya 28. Sa ibabang bahagi, makikita natin ang seksyong Debug, na nagpapakita ng lahat ng magagamit na impormasyon tungkol sa tumatakbong application. Tulad ng nabanggit na, ang pane ng Variable ay naglalaman ng lahat ng mga variable at bagay na magagamit mula sa bahaging ito ng application. Ipinapakita ng Frames pane ang mga hakbang na pinagdadaanan ng application — maaari mong tingnan ang mga nakaraang hakbang (mga frame) at makita ang lahat ng lokal na data. Upang patuloy na patakbuhin ang programa, maaari mong pindutin ang F9 o ang berdeng icon, tulad ng ipinapakita sa ibaba: Upang ihinto ang programa, mag-click sa pulang parisukat: Upang i-restart ang application sa debug mode, mag-click sa arrow: Dagdag pa, maaari kang magpatuloy sa pamamagitan ng hakbang-hakbang na aplikasyon gamit ang dalawang key:

• F8 — Hakbang sa code nang hindi pumapasok sa mga pamamaraan;
• F7 — Hakbang sa code at hakbang sa mga pamamaraan.

Sa aming kaso, kailangan naming pindutin ang F7, upang makapasok sa beeHive.populateHoney()pamamaraan. Sa pagpasok dito, makukuha natin: Ngayon ay gagamit tayo ng F8 para lampasan ang pamamaraang ito at ilarawan kung ano ang nangyayari dito:

• Linya 25 — Ang Stream API ay ginagamit upang mangolekta ng nektar mula sa lahat ng mga bubuyog
• Linya 26 — Ang bagong likhang pulot ay idinaragdag sa umiiral na pulot;
• Line 27 — 2 units of honey ang inilalaan para sa reyna
• Linya 28 — Ang dalawang yunit na ito ay tinanggal mula sa kabuuang halaga ng pulot
• Linya 29 — Kinakain ng reyna ang pulot na ito.

Kaya doon napunta ang dalawang nawawalang unit! Hurray! Pagkatapos makipag-usap sa isang business analyst, napagpasyahan namin na ang dokumentasyong README file ay naglalaman ng isang error at kailangang i-update. I-update natin ang README file:

## Documentation
Presentation based on honey production.

**Note**:
* 2 units of nectar = 1 unit of honey
* The queen bee eats 2 units of honey every time when beehive is replenished with honey.

Tapos na. Naayos na namin ang lahat ng mga bug na nakita namin. Maaari naming kalmado na magpatuloy sa isang mapagmataas na hitsura, humigop ng kape, at magbasa ng mga artikulo sa Stack Overflow CodeGym :)

I-summarize natin

Sa artikulong ito, natutunan namin:

• ang trabaho ng lahat ay may mga error at ang pag-debug ay isang mahusay na paraan upang ayusin ang mga ito
• kung ano ang isang breakpoint at kung anong mga uri ng breakpoint ang mayroon
• paano magtakda ng exception breakpoint
• kung paano humakbang sa code sa debug mode

Basahin ang artikulo

• Ang proyektong ginamit sa artikulong ito
• Paano Ka Magagawa ng Pag-debug na Mas Mabuting Developer
• Opisyal na dokumentasyon
• Mga uri ng breakpoints. Opisyal na dokumentasyon