Paggalugad ng mga tanong at sagot mula sa isang job interview para sa isang Java developer position. Bahagi 6

Kumusta, Mundo! Mahalaga para sa sinumang developer na hindi kailanman tumigil sa paglaki. Pagkatapos ng lahat, kung huminto ka, nanganganib kang mawalan ng demand at tuluyang mawalan ng trabaho. Ang mundo ng IT ay patuloy na umuunlad at sumusulong — kailangan mong makisabay dito. Ngunit sa parehong oras, hindi ka maaaring palaging umiikot sa pinakabagong mga teknolohiya upang hindi mo makalimutan ang "mga klasiko" (mga klasikong paksa ng pagbuo ng software). Ngayon gusto kong ipagpatuloy ang aking pagtalakay sa "mga klasikong paksa" para sa mga developer ng Java. Ipapakita ko na ang aking mga sagot ay hindi ang huling salita. Ang mga ito ay pananaw ko lamang sa mga tamang sagot — maaaring hindi ka sumasang-ayon sa ilan sa kanila. Ayos lang iyon, kaya huwag mag-atubiling ibahagi ang iyong opinyon sa mga komento. Makakakita ka ng mga link sa mga nakaraang bahagi ng pagsusuri sa dulo ng artikulo.

Mga aklatan at pamantayan

52. Ano ang Hibernate? Ano ang pagkakaiba ng JPA at Hibernate?

Upang masagot ang tanong na ito, sa tingin ko kailangan muna nating maunawaan kung ano ang JPA. Ito ay isang detalye na naglalarawan ng isang object-relational na pagmamapa ng mga simpleng Java object at nagbibigay ng API para sa pag-iimbak, pagbawi, at pagmamanipula ng mga naturang bagay. Iyon ay, ang mga relational database (DB) ay kinakatawan bilang isang hanay ng mga magkakaugnay na talahanayan. At ang JPA ay isang malawak na pinagtibay na pamantayan na naglalarawan kung paano maaaring makipag-ugnayan ang mga bagay sa mga relational na database. Tulad ng nakikita mo, ang JPA ay isang bagay na abstract at hindi madaling unawain. Parang yung idea mismo, yung approach. Ngunit ang Hibernate ay isang partikular na library na nagpapatupad ng mga paradigma ng JPA. Sa pagkakasunud-sunod ng mga salita, maaari mong gamitin ang library na ito upang gumana sa isang relational database sa pamamagitan ng mga bagay na kumakatawan sa data sa database (Entity). Ang aklatang ito ay sinasabing napakalapit sa mga ideyal ng JPA. Iyon ang dahilan kung bakit ito naging sikat. Tulad ng maiisip mo, ang katanyagan nito ay nagbigay-katwiran sa karagdagang pag-unlad at pagpapabuti. Bukod pa rito, ang malawakang paggamit ay nagmumula sa isang malawak na komunidad na na-explore na ang bawat posible at imposibleng tanong na nauugnay sa tool na ito. Ang hibernate ay lubusang pinag-aralan, at, bilang ito ay lumalabas, ito ay maaasahan. May magandang dahilan kung bakit kahit na ang perpektong pagpapatupad ng JPA sa Spring ay karaniwang gumagamit ng Hibernate sa ilalim ng hood.

53. Ano ang cascading? Paano ito ginagamit sa Hibernate?

Tulad ng sinabi ko kanina, ang komunikasyon sa Hibernate ay nangyayari sa pamamagitan ng mga data object na tinatawag na entity. Ang mga entity na ito ay kumakatawan sa mga partikular na talahanayan sa database, at bilang maaalala mo, ang mga klase ng Java ay maaaring maglaman ng mga sanggunian sa iba pang mga klase. Ang mga ugnayang ito ay makikita rin sa database. Bilang panuntunan, ang mga ito ay alinman sa mga dayuhang key (para sa OneToOne, OneToMany, ManyToOne na relasyon) o mga intermediate na talahanayan (para sa ManyToMany na relasyon). Kapag may mga reference ang iyong entity sa iba pang nauugnay na entity, inilalagay ang mga anotasyon sa itaas ng mga reference na ito upang isaad ang uri ng relasyon: @OneToOne, @OneToMany, @ManyToOne, @ManyToMany. Maaari mong tukuyin ang uri ng cascade para sa kaugnayang ito sa cascade property ng mga anotasyon. Ang JPA ay may mga partikular na pamamaraan para sa pakikipag-ugnayan sa mga entity (pumilit, i-save, pagsamahin ...). Ginagamit ang mga uri ng cascade upang ipakita kung paano dapat kumilos ang nauugnay na data; ang mga pamamaraang ito ay ginagamit sa isang target na entity. Kaya ano ang mga diskarte sa cascading (mga uri ng cascade)? Ang pamantayan ng JPA ay nagbibigay para sa paggamit ng anim na uri ng cascade:

• PERSIST — nagaganap ang mga operasyon sa pag-save sa isang kaskad (para sa mga pamamaraan ng save() at persist() ). Sa madaling salita, kung magse-save kami ng isang entity na nauugnay sa iba pang mga entity, ang mga entity na iyon ay nai-save din sa database (kung wala pa sila doon)

• MERGE - ang mga pagpapatakbo ng pag-update ay nangyayari sa isang kaskad (para sa paraan ng pagsasanib() )

• REMOVE — ang pagtanggal ng mga operasyon ay nangyayari sa isang cascade ( remove() method)

• LAHAT — naglalaman ng tatlong cascading operation nang sabay-sabay — PERSIST — MERGE — REMOVE

Ang JPA ay may konsepto ng isang persistent entity — isang entity na nauugnay sa data nito sa database at kinokontrol ng kasalukuyang session (koneksyon). Kung babaguhin mo ito nang hindi sine-save ang mga pagbabago sa database, babaguhin pa rin ang data ng entity sa database.

• DETACH — ang mga kaugnay na entity ay hindi pinamamahalaan ng session ( detach() method). Iyon ay, kapag ang data ng mga kaugnay na entity ay binago, ang data sa database ay hindi awtomatikong na-update — ang mga ito ay na-convert mula sa persistent sa detached (ibig sabihin, ang entity ay hindi pinamamahalaan ng JPA)

• REFRESH — sa tuwing ang isang entity ay nire-refresh gamit ang data mula sa database ( refresh() — nagre-refresh ng mga hiwalay na bagay), ang mga nauugnay na entity nito ay nire-refresh din. Halimbawa, binago mo kahit papaano ang data na kinuha mula sa database, at gusto mong ibalik ang mga orihinal na halaga. Sa kasong ito, makikita mong kapaki-pakinabang ang operasyong ito.

Sinusuportahan ng hibernate ang lahat ng mga karaniwang pagpapatakbo ng cascading na ito at nagpapakilala rin ng tatlo sa sarili nitong:

• REPLICATE — ginagamit kapag mayroon kaming higit sa isang pinagmumulan ng data at gusto naming ma-synchronize ang data (paraan ng pagtitiklop ng Hibernate). Ang lahat ng entity ay dapat may mga identifier (id) upang matiyak na magagawa ang mga ito nang walang problema (upang matiyak na ang parehong entity ay walang magkakaibang mga id para sa iba't ibang mga database)

• SAVE_UPDATE — cascading save/delete (para sa paraan ng saveOrUpdate ng Hibernate)

• LOCK — ang kabaligtaran ng DETACHED na operasyon: nagko-convert ng isang hiwalay na entity pabalik sa patuloy na estado, ibig sabihin, susubaybayan muli ng kasalukuyang session ang entity

Kung walang napiling uri ng cascade, hindi makakaapekto ang isang operasyon sa entity sa iba pang entity na nauugnay dito.

54. Maaari bang abstract ang klase ng Entity?

Ayon sa 2.1 The Entity Class ng JPA specification , " Ang parehong abstract at concrete classes ay maaaring maging entity. " Kaya, ang sagot ay oo, ang abstract class ay maaaring isang entity at maaaring markahan ng @Entity annotation.

55. Ano ang isang entity manager? Ano ang pananagutan nito?

Una sa lahat, gusto kong tandaan na ang EntityManager ay isang mahalagang bahagi ng JPA . Ginagamit ito para sa pakikipag-ugnayan ng mga entity sa database. Sa pangkalahatan, ang mga pamamaraan para sa pakikipag-ugnayan ng entity sa database ay tinatawag sa entity (pumuloy, pagsamahin, tanggalin, tanggalin)... Ngunit tandaan ko rin na ang bahaging ito ay karaniwang hindi singleton para sa buong aplikasyon. Madalas itong magaan, ang isa ay tinanggal, at ang isang bago ay nilikha gamit ang EntityManagerFactory . Kung gumuhit tayo ng parallel sa JDBC , kung saan ang EntityManagerFactory ay kahalintulad sa DataSource , kung gayon ang EntityManager ay kahalintulad sa Connection . Mas maaga, binanggit ko na ang isang persistent entity ay isang entity na pinamamahalaan ng kasalukuyang koneksyon. Ang entity na ito ay pinamamahalaan ng EntityManager , na malapit na nauugnay sa kasalukuyang koneksyon, at ng TransactionManager , na responsable para sa pagbubukas/pagsasara ng mga transaksyon. Sa figure sa ibaba, makikita mo ang cycle ng buhay ng entity: Pinamamahalaan ng EntityManager ang entity kapag ito ay nasa Managed stage (kapag ito ay paulit-ulit, dahil ito ay may koneksyon sa EntityManager ). Ibig sabihin, hindi na ito bago at hindi rin natatanggal. Kapag ang isang entity ay bago o inalis, maaari nating sabihin na ito ay hiwalay din, dahil hindi ito pinamamahalaan ng EntityManager . Mayroong iba't ibang mga diskarte para sa EntityManager . Maaari kang magkaroon ng singleton ng EntityManager para sa buong application o lumikha ng bago sa bawat oras para sa bawat koneksyon. Kung gumagamit ka ng Spring, ang paggawa/pagtanggal ng EntityManager ay awtomatikong pinamamahalaan sa ilalim ng hood (ngunit hindi iyon nangangahulugan na hindi mo ito mako-customize para sa iyong sarili ^^). Kailangan kong banggitin na ang isa o higit pang EntityManagers ay bumubuo ng konteksto ng pagtitiyaga . Ang konteksto ng pagtitiyaga ay isang kapaligiran kung saan ang mga pagkakataon ng mga entity ay naka-synchronize sa mga katulad na entity sa database (tulad ng sinabi ko, ito ay gumagana lamang para sa mga persistent entity). Kung mas malalalim mo ang JPA (na lubos kong inirerekumenda), madalas mong mahaharap ang konseptong ito.

56. Ano ang klase ng Assert? Bakit ito ginagamit?

Wala akong narinig na ganoong klase sa JPA , kaya ipagpalagay ko na ang tanong na ito ay tumutukoy sa isang klase na matatagpuan sa JUnit library na ginagamit para sa mga unit test. Sa library na ito, ang Assert class ay ginagamit upang suriin ang mga resulta ng code execution (dito ang assert ay nangangahulugang isang assertion na mayroon kang partikular na estado/data sa isang partikular na lokasyon sa code). Halimbawa, sabihin nating sinusubukan mo ang isang paraan na dapat na lumikha ng isang pusa. Pinapatakbo mo ang pamamaraan at nakakakuha ka ng ilang resulta:

Cat resultOfTest = createCat();

Ngunit kailangan mong tiyakin na ito ay nilikha nang tama, tama? Kaya manu-mano kang lumikha ng isang partikular na pusa ( expectedCat ) na may eksaktong mga parameter na inaasahan mong makita sa pusa na nakuha mula sa createCat() na paraan. Pagkatapos ay gagamitin mo ang klase ng Assert upang i-verify ang mga resulta:

Assert.assertEquals(resultOfTest, expectedCat);

Kung magkaiba ang mga pusa, may itatapon na AssertionError , na nagsasabi sa amin na hindi namin nakuha ang inaasahang resulta. Ang klase ng Assert ay may maraming iba't ibang mga pamamaraan na sumasaklaw sa iba't ibang mga operasyon na nakakatulong sa pag-verify ng mga inaasahang resulta. Narito ang ilan sa kanila:

• assertTrue(<boolean>) — ang value na ipinasa bilang argumento ay inaasahang totoo

• assertFalse(<boolean>) — ang value na ipinasa bilang argumento ay inaasahang mali

• assertNotEquals(<object1>, <object2>) — ang mga bagay na ipinasa bilang mga argumento ay dapat na iba kapag inihambing gamit ang equals ( false )

• assertThrows(<ClassNameOfException>.class, <exceptionObject>) — ang pangalawang argumento ay inaasahang magiging exception na ibinabato ng unang argumento (ibig sabihin, ang pangalawang argumento ay karaniwang isang method call na dapat maghagis ng exception ng kinakailangang uri)

String

57. Ilarawan ang klase ng String ng Java

Ang String ay isang karaniwang klase ng Java na responsable para sa pag-iimbak at pagmamanipula ng mga halaga ng string (mga pagkakasunud-sunod ng mga character). Ito ay isang hindi nababagong klase (isinulat ko ang tungkol sa hindi nababago dati dito ), ibig sabihin, ang data ng mga bagay ng klase na ito ay hindi mababago pagkatapos na malikha ang mga ito. Gusto kong tandaan kaagad na ang mga klase ng StringBuilder at StringBuffer ay mahalagang magkapareho — ang pagkakaiba lamang ay ang isa sa mga ito ay inilaan para gamitin sa isang multithreaded na kapaligiran ( StringBuffer ). Ang mga klase ay tulad ng String , ngunit naiiba sa na sila ay nababago . Kahit na matapos ang mga ito, hinahayaan ka nilang baguhin ang mga string na kinakatawan nila, nang hindi gumagawa ng bagong bagay. Ang kanilang mga pamamaraan ay naiiba sa mga karaniwang pamamaraan ng String at idinisenyo para sa pagmamanipula ng string (may dahilan kung bakit tinawag nila itong isang tagabuo).

58. Ano ang mga paraan upang lumikha ng isang String object? Saan ito nilikha?

Ang pinakakaraniwang paraan upang lumikha ng isang string ay ang tukuyin ang halaga na gusto namin sa dobleng mga panipi:

String str = "Hello World!";

Maaari mo ring gawin ito nang tahasan gamit ang bago :

String str = new String("Hello World!");

Maaari ka ring lumikha ng isang string mula sa isang hanay ng mga character:

char[] charArr = {'H','e','l','l','o',' ', 'W','o','r','l','d','!'};
String str = new String(charArr);

Magagawa natin ito sa pamamagitan ng pagtawag sa toString method sa ilang bagay:

String str = someObject.toString();

Magagawa natin ito sa pamamagitan ng pagtawag sa anumang paraan na nagbabalik ng string. Halimbawa:

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String str = reader.readLine();

Nauunawaan mo na maaaring mayroong maraming, maraming paraan upang lumikha ng isang string. Kapag nalikha ang isang String object, ito ay nakaimbak sa isang string pool , na tatalakayin natin nang mas detalyado sa isa sa mga tanong sa ibaba.

59. Paano mo ihahambing ang dalawang string ng Java, at paano mo pinag-uuri ang mga ito?

Gumagamit ang Java ng double equal sign ( == ) upang magsagawa ng mga paghahambing. Kung kailangan nating ihambing ang mga simpleng halaga tulad ng ints, gagamitin natin ito. Ngunit ang pamamaraang ito ay hindi angkop para sa paghahambing ng mga ganap na bagay. Ito ay maghahambing lamang ng mga sanggunian, ibig sabihin, kung ang mga sanggunian ay tumuturo sa parehong bagay o hindi. Nangangahulugan ito na kung ihahambing natin ang dalawang bagay na may parehong mga halaga ng field gamit ang == , makakakuha tayo ng false . Ang mga patlang ay may parehong mga halaga, ngunit ang mga bagay mismo ay sumasakop sa iba't ibang mga lokasyon sa memorya. Ang mga string na bagay, sa kabila ng kanilang mapanlinlang na pagiging simple, ay mga bagay pa rin. Ang paghahambing sa kanila gamit ang == ay hindi rin angkop (sa kabila ng pagkakaroon ng isang string pool). Ang wastong solusyon ay ang standard equals method ng Object class , na kailangang ma-override para gumana nang tama (bilang default, gumagamit ito ng == para sa mga paghahambing). Ino-override ito ng String class, kaya ginagamit lang namin ang pagpapatupad nito:

String firstStr = "Hello World!";
String secondStr = "Hello World!";
boolean isEquals = firstStr.equals(secondStr);

Napag-usapan na natin ang mga paghahambing para sa pagkakapantay-pantay. Ngayon ay aalamin natin ang mga paghahambing para sa pag-uuri. Kung tutuusin, kung pag-uuri-uriin natin ang isang bagay, kailangan nating malaman kung anong prinsipyo ang ating gagamitin sa pag-uuri. Upang gawin ito, maaari mong gamitin ang TreeSet , isang karaniwang pinagsunod-sunod na hanay. Ang istraktura ng data na ito ay umaasa sa red-black tree algorithm at pinag-uuri-uri ang set ayon sa isang tinukoy na prinsipyo ng pag-uuri. Tulad ng sinabi ko kanina, kailangan mong maunawaan kung paano pag-uri-uriin ang mga bagay ng isang tiyak na uri. Upang italaga ang paraan ng paghahambing para sa pag-uuri, gumamit ng mga comparator . Karaniwang kailangan mong ipatupad ang mga ito para sa mga klase na gusto mong pag-uri-uriin, ngunit sa kaso ng String , ipinatupad na ang mga ito. Alinsunod dito, idinaragdag lang namin ang aming mga string sa TreeSet , at pag-uuri-uriin nito ang mga ito para sa amin:

TreeSet<String> sortedSet = new TreeSet<>();
sortedSet.add("B");
sortedSet.add("C");
sortedSet.add("A");
sortedSet.forEach(System.out::println);

Output ng console:

60. Magbigay ng algorithm para sa pag-convert ng string sa mga character. Isulat ang kaukulang code

Tulad ng sinabi ko kanina, ang mga String object ay may maraming iba't ibang mga kapaki-pakinabang na pamamaraan. Isa sa mga ito ay toCharArray . Ang pamamaraang ito ay nagko-convert ng isang string sa isang array ng character:

String str = "Hello world";
char[] charArr = str.toCharArray();

Susunod, mayroon kaming hanay ng mga character na maaari naming sanggunian sa pamamagitan ng index:

char firstChar = charArr[0]; // H

61. Paano mo iko-convert ang isang string sa isang byte array at pabalik? Isulat ang kaukulang code

Ang String class ay may getBytes method, na katulad ng toCharArray method at ibinabalik ang string bilang byte array:

String str = "Hello world";
byte[] byteArr = str.getBytes();
byte firstChar = byteArr[6]; // 119

Nakarating na kami sa lohikal na konklusyon ng aming pagsusuri ngayon. Salamat sa pagbabasa!