Ang pagsulat ng code ay kalahati ng labanan. Kailangan pa itong gawin upang gumana nang tama. Malaki ang tulong sa amin ng mga IDE at mga tool sa pag-debug dito.
Gamit ang IntelliJ IDEA bilang isang halimbawa, ipinapanukala kong kilalanin kung paano natin malalaman kung ano ang mangyayari sa ating code kapag tumatakbo ito. Ang pag-debug ay isang malawak na paksa, kaya ang pagsusuri na ito ay hindi nag-aalok ng malalim na pagsisid, tulad ng isang maninisid. Pero sana mag snorkeling ako for sure)
Panimula
Bahagi ng pagsusulat ng code ang pagde-debug nito. At kung ang iyong mga gawain ay may kasamang suporta sa code, magkakaroon ng higit pang pag-debug. Well, bilang karagdagan, sa tulong ng pag-debug, maaari mong suriin ang gawain ng mga aklatan at mga framework na ginamit nang malalim hangga't maaari mong isawsaw ang iyong sarili sa gubat ng code ng ibang tao. Para sa aming dive kakailanganin namin:
Una, i-unpack ang na-download na archive gamit ang Quick Start Source Code. Ilunsad ang IntelliJ Idea at lumikha ng " Bagong Proyekto mula sa Mga Umiiral na Pinagmumulan ". Piliin ang pom.xml file sa hibernate4 subdirectory . Kapag nag-i-import, tukuyin ang " Awtomatikong Mag-import ng mga proyekto ng Maven " at kumpletuhin ang paggawa ng proyekto, na iniiwan ang iba pang mga setting na hindi nagbabago. Habang ini-import ang proyekto, i-unzip ang na-download na server ng application ng WildFly sa ilang direktoryo. Sinisimulan namin ang server gamit ang file (o standalone.sh para sa *nix system). (!) Mahalagang magsimula sa --debug parameter . Hinihintay namin na magsimula ang server. Susulatan nila kami na nagsimula ito at ipahiwatig ang oras. Magiging ganito ang hitsura nito: bin\standalone.bat
Susunod, kailangan nating patakbuhin ang proyektong napili natin sa server. Ang prosesong ito ay inilarawan sa isang maliit na dokumentasyon na makikita sa mismong proyekto: \hibernate4\README.adoc Gaya ng ipinahiwatig sa dokumentasyong ito, kailangan nating patakbuhin ang utos sa hibernate4 na direktoryo: mvn clean package wildfly:deploy Naghihintay kami ng mensahe na matagumpay na nakumpleto ang pagbuo:
Pagkatapos nito, sa log ng server makikita natin kung paano "na-deploy" ang bagong proyekto:
Pagkatapos nito, pumunta kami sa pahina http://localhost:8080/wildfly-hibernate4at dapat naming ipakita ang isang pahina na may form na " Pagpaparehistro ng Miyembro ". Kaya, ang aming paghahanda para sa mga eksperimento ay kumpleto at maaari na tayong magsimula)) Maraming mga larawan sa unahan para sa kalinawan, kaya maghanda)
Remote Debug
Kaya, kailangan naming i-configure ang Debug mode upang kontrolin ng aming IDE ang pagpapatupad ng code sa server ng application. Ang IntelliJ Idea ay may dalawang bersyon: libre (Community) at bayad (Ultimate). Ang huli ay maaaring opisyal na subukan sa anyo ng EAP. Sa Ultimate na bersyon, ang lahat ay simple - ang application server ay maaaring direktang ilunsad mula sa IDE sa debug mode. Ngunit sa bersyon ng Komunidad kailangan mong gumawa ng ilang bagay nang manu-mano. Samakatuwid, isaalang-alang natin ang isang mas kumplikadong kaso, i.e. setting sa bersyon ng Komunidad. Ang bersyon ng Komunidad ay may ilang mga limitasyon. Sa partikular, hindi ka maaaring magpatakbo ng isang server ng application mula dito. Ngunit maaari kang mag-set up ng malayuang pag-debug (Remote Debug), kapag sa isang lugar na hiwalay ay mayroong tumatakbong server na may application na kailangan namin. Gamitin natin ang paglalarawan ng setup mula rito: Remote debug Wildfly sa IntelliJ Idea community edition (pagse-set up ng Remote Run Configuration para sa port 8787). Pagkatapos ng configuration, inilunsad namin ang aming bagong configuration sa Debug mode:
Kung maayos ang lahat, makakakita tayo ng mensahe tungkol dito sa ibaba:
Proseso ng pag-debug
I-debug natin ang pag-save ng record. Para magawa ito, kailangan muna nating magpasya kung saan tayo tutuklasin. Sa paghusga sa window, kailangan namin ng "Register" na buton. Hanapin natin ito sa code. Kaya, kailangan namin ng isang elemento, dapat itong mayroong teksto: "Magrehistro". O dapat may kinalaman siya dito. I-click Ctrl+Shift+Fat hanapin ang Register in quotes. Nakita namin na mayroong isa sa index.xhtml.
Pindutin ang Enter upang pumunta sa nahanap na pinagmulan:
Kaya, nakikita namin na kapag nagrerehistro, memberController.register ay tinatawag na. Tila, ito ay dapat na isang uri ng java class. Mag-click Ctrl+Nat maghanap para sa:
May klase talaga. Pasukin natin ito. Tila, dapat mayroong isang paraan ng pagrehistro. I-click Ctrl+F12at hanapin ang paraan ng pagrehistro
Sa katunayan, natagpuan namin ito. Tila, ang pagpaparehistro ay nangyayari dito, sa memberRegistration.register . Pindutin ang Ctrl at mag-click sa paraan upang "mahulog" dito:
Magtakda tayo ngayon ng "break point" o Break Point. Ito ay isang marker na nagsasabi kung saan dapat i-pause ang code execution. Sa sandaling ito magkakaroon tayo ng pagkakataong matuto ng maraming kawili-wiling bagay. Upang ilagay ito, kailangan mong mag-click sa lugar sa kanan ng numero ng linya.
Sa pahinang http://localhost:8080/wildfly-hibernate4 punan ang mga field at i-click ang Register button. Ang icon ng ideya sa panel ay magbi-blink:
Pagpunta sa Idea, makikita mo na maraming kawili-wiling impormasyon sa debug panel:
Dito makikita mo ang halaga ng mga field ng object. Halimbawa, ano ang binubuo ng isang rehistradong Miyembro:
Malaki. Ano pa ang magagawa natin? Maaari naming buksan ang menu ng konteksto at piliin ang Suriin ang Expression doon (o sa pamamagitan ng menu Run -> Suriin ang Expression). Mas mabuti pa, sa debugger control panel:
Ito ay isang napakahusay na kakayahan sa isang breakpoint, pagkakaroon ng access sa lahat ng bagay na may access sa code point na iyon, upang maisagawa ang anumang code na maaaring isagawa sa puntong iyon. Halimbawa:
Mayroon ding mga control button sa debugger control panel na responsable para sa kung saan mo gustong ilipat ang program flow control. Hindi ba magic?) Sa pamamagitan ng pagpindot sa F8 (Step Out) na buton, tinatahak namin ang code nang hindi naglalagay ng mga pamamaraan. Sa pamamagitan ng pagpindot sa F9, huminto kami sa paglalakad sa mga linya ng code gamit ang debugger, at binibigyan ang debugger ng kontrol sa pagpapatupad ng programa. Kung pinindot natin ang F7 (Step Into), pagkatapos ay dadaan tayo sa code, na ilalagay ang bawat pamamaraan na ating nakikilala sa daan. Sa pamamagitan ng paraan, bigyang-pansin ang block ng impormasyon na ito:
Ipinapakita nito ang thread na kinaroroonan natin at ang mga pamamaraan sa stack ng kasalukuyang thread. Ngunit hindi lang iyon. Para sa kaginhawahan, maaari mong buksan ang tab na mga frame. Upang gawin ito, dapat itong paganahin:
Ngayon sa tab na mga frame nakikita namin ang impormasyon tungkol sa paglipat mula sa paraan patungo sa pamamaraan, dahil nagsimulang maglakad sa code gamit ang Step Into.
Tulad ng nakikita natin, hindi tayo palaging maililipat sa kung saan kasalukuyang isinasagawa ang programa. Kami ay nasa "getDelegate:469, AbstractEntityManager(org.jboss.as.jpa.container)". Ngunit sa katunayan, tayo ay nasa pagpapatupad. Ito ay pinatunayan ng klase na tinukoy nito:
Tingnan natin ito. Tulad ng alam natin, tumuturo ito sa kasalukuyang bagay. Kami ay nasa TransactionScopedEntityManager. Bakit hindi maipakita sa amin ng Idea ang code? Ang katotohanan ay kasalukuyang hindi alam ng IntelliJ Idea ang tungkol sa anumang TransactionScopedEntityManager, dahil hindi ito konektado sa aming proyekto (wala ito sa mga dependency ng proyekto). Kapag ang isang application server ay tumatakbo, mayroong maraming, maraming iba't ibang mga aklatan na tumatakbo sa loob nito. Pero kakaunti lang ang alam natin tungkol sa kanila, dahil... sa pangkalahatan, hindi natin kailangang mag-deve sa internals, kailangan lang natin itong gumana. Ngunit kung minsan ang trabaho o interes sa palakasan ay nangangailangan nito. Pagkatapos, kailangan mong ipaalam sa Idea ang tungkol sa library na ito para malaman nito kung saan kukunin ang class code.
Pagkonekta ng mga third-party na library para sa pag-debug
Una, kailangan nating maunawaan kung anong uri ng silid-aklatan ito na kailangang konektado. Ang unang paraan ay ang pinakamahirap - maghanap sa Internet. Ang bilis at resulta ng paghahanap ng resulta ay lubos na nakadepende sa kung gaano kahusay pinamamahalaan ang proyekto. Halimbawa, ang WildFly ay may bukas na imbakan. Kaya kapag nag-Google kami ng "TransactionScopedEntityManager" pupunta kami sa https://github.com/wildfly/wildfly/tree/master/jpa/subsystem at malalaman na kailangan namin ng wildfly-jpa. Ang pangalawang paraan ay tama. Kung nasaan ang server, tumingin doon. Makakatulong dito ang iba't ibang paraan. Halimbawa, sa Windows ito ay maaaring Far Manager . Nasa ibaba ang isang halimbawa ng algorithm ng paghahanap. Kapag na-install at nailunsad ito, gamitin ang Tab upang lumipat sa isa sa mga tab, gamit Alt+F1ang kaliwang tab o Alt+F2ang kanan, at piliin ang partition na kailangan namin sa hard drive. Posible na ang direktoryo ng Far Manager mismo ay bukas sa Far Manager pagkatapos ng pag-install. Upang pumunta sa ugat ng disk, pindutin ang Ctrl + \. Gamit, Alt+Fbuksan ang window ng paghahanap, simulan ang pag-type ng pangalan ng direktoryo at pindutin ang Enter pagkatapos mahanap ang direktoryo. Ang paghahanap na ito ay matalino at hina-highlight ang mga direktoryo na tumutugma sa teksto ng paghahanap. Kung nagpasok ka ng mga character kung saan walang mga folder, kung gayon ang mga naturang character ay hindi maipasok. Sa ganitong paraan pumunta tayo sa direktoryo ng server ng application. Sabihin nating hindi natin alam kung saan matatagpuan ang mga module sa server. Marahil ito ang unang pagkakataon sa iyong buhay na makarinig ka tungkol sa isang uri ng WildFly. Samakatuwid, mag-click kaagad dito Alt+F7upang maghanap ng mga file. Kaya, ang lohika ay nagdidikta: kailangan namin ng isang file na may library. Ibig sabihin, kailangan natin ng garapon. Dapat mayroong klase ng TransactionScopedEntityManager sa loob. kasi class = file, pagkatapos ay hanapin ang "naglalaman". Iyon ay, isang bagay na tulad nito:
Ngayon, hintayin natin ang resulta. Hindi ka niya hihintayin)
Ngayon, kailangan nating hanapin ang source code para dito sa isang lugar. At mayroong 2 pagpipilian:
Gamitin natin, marahil, ang pangalawa. Hanapin natin doon:
Ngayon ay magpatuloy tayo sa paglalarawan ng dependency. Sa pahinang ito maaari mong i-download ang source code. Mahusay, na-download na namin ngayon ang code. Ang natitira na lang ay ikonekta ang library. Kumokonekta ito nang napakasimple. Kailangan nating buksan ang mga setting ng proyekto:
Doon ay pinili namin ang "Mga Aklatan" at idagdag ang mga natanggap na source code sa seksyong "Mga Pinagmulan", at sa seksyong "Mga Klase" ipinapahiwatig namin ang file ng jar ng library mismo mula sa direktoryo ng WildFly, na natagpuan namin gamit ang Far Manager. Pagkatapos nito, kapag nag-navigate kami sa F7, makikita namin ang mga nilalaman ng AbstractEntityManager at TransactionScopedEntityManager na klase, at magiging available din sa pamamagitan ng paghahanap ayon sa klase gamit ang Ctrl+N.
Mga Break Point na may mga kundisyon
Bumalik tayo ngayon sa Break Points. Minsan, hindi natin laging nais na huminto, ngunit sa ilalim lamang ng ilang kondisyon. Anong gagawin? At dito matutulungan din tayo ng ating IDE. Sa pamamagitan ng paglalagay ng Break Point, maaari tayong magtalaga ng kundisyon dito. Halimbawa, maglagay ng punto at mag-right click dito:
Ngayon ang breakpoint ay magpapaputok lamang kapag ang pangalan ay Maximilian. Sa pamamagitan ng pag-click sa button na Higit Pa, isang pinalawak na hanay ng mga setting para sa Mga Break Point ay magiging available sa iyo.
Mga Break Point sa mga exception
Minsan maaari kaming makatanggap ng isang error at gusto naming subaybayan kung saan ito nanggaling. Pagkatapos ay maaari tayong magdagdag ng breakpoint hindi sa isang partikular na linya ng code, ngunit sa lugar kung saan itatapon ang exception. Upang gawin ito, kailangan mong palawakin ang listahan ng lahat ng mga breakpoint:
At lumikha ng bagong panuntunan para sa napiling uri ng pagbubukod:
Halimbawa, para sa NPE:
Mga klase sa HotSwap
Ang debugger ay isang kamangha-manghang bagay. Bilang karagdagan sa pag-debug, pinapayagan ka nitong magpalit ng mga klase! Oo, ang mga mapagkukunan (tulad ng mga pahina ng xhtml, halimbawa) ay hindi madaling baguhin. Ngunit ang code ng mga klase ng java ay maaaring mapalitan sa mabilisang (ito ay tinatawag na Hot Swap). Upang gawin ito, baguhin lamang ang klase na may nakalakip na debugger at isagawa ang Run -> I-reload ang Mga Binagong Klase. Kapaki-pakinabang na pagsusuri sa paksang ito: 4 na libreng paraan ng hot-swap code sa JVM
Konklusyon
Ang debugger ay isang makapangyarihang tool na nagbibigay-daan sa isang developer na tumagos sa pinakalalim ng executing code at pag-aralan ito sa bawat detalye. Ito ay nagbibigay-daan sa iyo upang iwasto ang pinaka nakakalito na mga error. Nagbibigay-daan din ito sa iyo na mas maunawaan kung paano gumagana ang ilang library. Kahit na ang isang maikling pagsusuri ay naging kahanga-hanga, ngunit inaasahan kong magiging kapaki-pakinabang at kawili-wili ito. Kung sinuman ang interesado sa materyal na ito, maaari mong ipagpatuloy ang pagsisid gamit ang mga sumusunod na link:
GO TO FULL VERSION