

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.
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
-
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.

-
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
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
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);

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!
GO TO FULL VERSION