Coffee break #158. 10 Mga Tip para sa Paghawak ng mga Pagbubukod sa Java

Source: Medium Tutulungan ka ng post na ito na mas maunawaan kung paano epektibong pangasiwaan ang mga exception sa Java. Ang paghawak sa mga eksepsiyon sa Java ay maaaring maging mahirap. Maaaring mahirap matukoy kung aling mga eksepsiyon sa Java ang hahawakan, aling mga eksepsiyon ang ire-rethrow, at alin ang basta na lang babalewalain. Gayunpaman, mayroong ilang mga kapaki-pakinabang na alituntunin na epektibong makakatulong sa iyong pangasiwaan ang mga pagbubukod at lumikha ng mga bagong application. Kilalanin natin sila.

1. Mag-ingat kung ano ang iyong i-log.
2. Huwag pansinin ang mga itinapon na pagbubukod.
3. Gumamit ng global exception handler.
4. Huwag isara nang manu-mano ang mga mapagkukunan.
5. Magtapon ng maaga at pangasiwaan ang mga pagbubukod sa ibang pagkakataon.
6. Hindi dapat i-log at i-rethrow ang mga exception sa Java.
7. Suriin ang mga pinigilan na pagbubukod.
8. Sa throw statement, ideklara ang mga exception nang tumpak.
9. Pangasiwaan muna ang pinaka-halatang exception.
10. Gumamit ng modernong exception sa paghawak ng semantics.

1. Mag-ingat kung ano ang iyong ni-log

Dapat palaging alam ng mga developer ng software ang mga karapatan ng kanilang mga kliyente sa seguridad at privacy.

• Ang isang Java program ay maaaring maglipat ng data sa iba pang mga system, at isang malaking bilang ng mga developer at administrator ang maaaring gumana dito (kabilang ang pag-aayos ng mga bug).
• Kung ang anumang sensitibong data ay naitala sa mga log file, hindi susunod ang iyong kumpanya sa mga kinakailangan sa seguridad at maaari kang mawalan ng trabaho.

2. Huwag pansinin ang mga itinapon na eksepsiyon

Huwag mahuli ang isang pagbubukod at pagkatapos ay huwag pansinin ito. Ang pagtatago ng mga pagbubukod ay hindi isang magandang paraan upang mahawakan ang mga ito sa Java. Sa pinakamababa, isulat ang pangalan ng exception at ang nauugnay na mensahe. Sa ganitong paraan, makikita ang impormasyon tungkol sa problema sa iyong entry. Ang pag-debug sa mga application ng Java dahil sa mga nakatagong pagbubukod ay napakahirap.

3. Gumamit ng global exception handler

Sa panahon ng pagpapatupad ng programa ay palaging may ilang mga pagbubukod na hindi nahuli sa iyong code. Samakatuwid, palaging magdagdag ng pandaigdigang tagapangasiwa ng pagbubukod upang mahawakan ang mga hindi nahuhuling pagbubukod. Hindi lamang nito papayagan ang pagbubukod na mai-log at mapangasiwaan, ngunit pipigilan din ang pag-crash ng application kung ang isang pagbubukod ay itinapon sa runtime.

4. Huwag isara nang manu-mano ang mga mapagkukunan

Ang isa pang mahalagang rekomendasyon kapag pinangangasiwaan ang mga eksepsiyon sa Java ay ang payagan ang JVM na tawagan ang close() na pamamaraan sa mga mapagkukunang isinasara. Huwag subukang isara ang mga ito sa iyong sarili. Madali itong makakamit sa pamamagitan ng pagsisimula ng mga mapagkukunan sa loob ng try-resources module . Semantics:

public class TryWithResourcesExample {

public static void main(String[] args) throws Exception {

try (Door door = new Door()) {

door.swing();

} catch (Exception e) { ..... }

} finally { .....}

}

}

Gaya ng nakikita mo, pagkatapos makumpleto ang pagsubok...catch block, isinasara ng JVM ang mapagkukunan para sa iyo, na inaalis ang posibilidad ng kumplikado at mahirap ayusin na mga paglabas ng mapagkukunan.

5. Magtapon ng maaga at hawakan ang mga pagbubukod mamaya

Magtapon ng exception sa tuwing magkakaroon ng exception condition sa iyong code. Huwag maghintay para sa anumang mga linya ng code na isagawa bago lumabas sa paraang nasa iyo. Kapag nakakuha ng mga pagbubukod, ang function ay dapat ilagay sa dulo ng pamamaraan. Binabawasan nito ang bilang ng mga catch block sa iyong mga pamamaraan, na ginagawang mas madaling basahin at mapanatili ang iyong code.

6. Hindi dapat i-log at i-rethrow ang mga exception sa Java

Kung may nangyaring pagbubukod, gawin ang isa sa mga sumusunod:

• Magpatuloy sa pagtatrabaho sa iyong programa habang nagla-log ka sa exception.
• Itapon muli ang exception at payagan ang ibang paraan ng pag-log ng data.

Huwag pagsamahin ang dalawang yugto. Huwag kailanman mag-log at pagkatapos ay i-rethrow ang parehong exception, tulad ng ipinapakita sa halimbawa sa ibaba:

try {

Class.forName("com.min.Example");

} catch (ClassNotFoundException ex) {

log.warning("Class was not found.");

throw ex;

}

Nagreresulta ito sa pagdoble ng code at mga log file na nagiging barado ng mga duplicate na entry, na ginagawang mas mahirap na i-diagnose ang code.

7. Suriin ang mga pinigilan na pagbubukod

Ang suppressed exception ay isang bagong feature ng wika na hindi alam ng lahat ng developer. Sa pamamagitan ng pagpapatupad ng isang napatunayang pamamaraan na may mga mapagkukunan, dalawang eksepsiyon ang maaaring ihagis nang sabay. Ang kundisyong ito ay madaling masuri sa pamamagitan ng pagtatanong para sa pagkakaroon ng pinigilan na pagbubukod. Ang tanging paraan upang matukoy kung ang kundisyong ito ay naganap ay upang makita kung ang target na pagbubukod ay naglalaman din ng isang pinigilan na pagbubukod.

8. Kapag ginagamit ang throw statement, tukuyin ang eksaktong mga exception

Sa pamamagitan ng paggamit ng throw statement sa loob ng method body, ang isang pabaya na developer ay gagamit ng generic exception class. Ngunit hindi ito ang pinakamahusay na paraan upang mahawakan ang mga pagbubukod sa Java. Sa halip, palaging tukuyin ang eksaktong mga pagbubukod na maaaring itapon ng pamamaraan. Tinutulungan nito ang iba pang mga developer na malaman ang tungkol sa iba't ibang mga diskarte sa paghawak ng error na maaaring gamitin kapag ang isang partikular na paraan ay hindi gumagana gaya ng inaasahan.

9. Pangasiwaan muna ang pinaka-halatang exception

Ito ay higit pa sa isang compiler na kinakailangan kaysa sa isang tip para sa Java exception handling practices, ngunit ang isang developer ay dapat palaging pangasiwaan ang pinaka-halatang exception muna at ang hindi bababa sa ilang exception ang huli. Kung hindi masusunod ang panuntunang ito, magbabalik ang JVM ng isang error sa oras ng pag-compile na may napakalihim at mahirap maunawaan na mensahe ng error. Gawing mas madali ang iyong buhay bilang isang software developer sa pamamagitan ng palaging paghawak ng ilang partikular na exception sa iyong code.

10. Gumamit ng modernong exception sa paghawak ng mga semantika

Nagbibigay ang Java ng maraming error at exception handling feature na nagpapasimple sa pag-develop at makabuluhang binabawasan ang dami ng Java code. Gamitin ang kakayahang pangasiwaan ang maraming pagbubukod sa iisang catch block at awtomatikong isara ang mga mapagkukunan gamit ang try block . Gumamit ng Runtime Exceptions para hindi na kailangang pangasiwaan ng ibang mga developer ang mga exception na ibinabato mo.