Meneroka soalan dan jawapan daripada temu duga kerja untuk jawatan pembangun Java. Bahagian 6

Hai dunia! Adalah penting bagi mana-mana pembangun untuk tidak berhenti berkembang. Lagipun, jika anda berhenti, anda berisiko kehilangan permintaan dan terkeluar sepenuhnya daripada pasaran kerja. Dunia IT sentiasa berkembang dan bergerak ke hadapan — anda perlu bergerak bersamanya. Tetapi pada masa yang sama, anda tidak boleh sentiasa berputar dalam teknologi terkini supaya anda tidak melupakan "klasik" (topik pembangunan perisian klasik). Hari ini saya ingin meneruskan perbincangan saya tentang "topik klasik" untuk pembangun Java. Saya akan menegaskan bahawa jawapan saya bukanlah kata akhir. Itu hanyalah pandangan saya tentang jawapan yang betul — anda mungkin tidak bersetuju dengan sebahagian daripada mereka. Itu tidak mengapa, jadi jangan ragu untuk berkongsi pendapat anda dalam ulasan. Anda boleh mendapatkan pautan ke bahagian ulasan sebelumnya di penghujung artikel.

Perpustakaan dan piawaian

52. Apakah Hibernate? Apakah perbezaan antara JPA dan Hibernate?

Untuk menjawab soalan ini, saya rasa kita perlu memahami dahulu apa itu JPA. Ia ialah spesifikasi yang menerangkan pemetaan hubungan objek bagi objek Java mudah dan menyediakan API untuk menyimpan, mendapatkan semula dan memanipulasi objek tersebut. Iaitu, pangkalan data hubungan (DB) diwakili sebagai satu set jadual yang saling berkaitan. Dan JPA ialah piawaian yang diterima pakai secara meluas yang menerangkan cara objek boleh berinteraksi dengan pangkalan data hubungan. Seperti yang anda lihat, JPA adalah sesuatu yang abstrak dan tidak ketara. Ia seperti idea itu sendiri, pendekatannya. Tetapi Hibernate ialah perpustakaan khusus yang melaksanakan paradigma JPA. Dalam susunan perkataan, anda boleh menggunakan perpustakaan ini untuk bekerja dengan pangkalan data hubungan melalui objek yang mewakili data dalam pangkalan data (Entiti). Perpustakaan ini dikatakan sangat dekat dengan cita-cita JPA. Mungkin itulah sebabnya ia menjadi popular. Seperti yang anda boleh bayangkan, popularitinya mewajarkan pembangunan dan penambahbaikan selanjutnya. Selain itu, penggunaan meluas berpunca daripada komuniti yang luas yang telah meneroka setiap soalan yang mungkin dan mustahil yang berkaitan dengan alat ini. Hibernate telah dikaji dengan teliti, dan, ternyata, ia boleh dipercayai. Terdapat sebab yang baik mengapa walaupun pelaksanaan JPA yang ideal dalam Spring umumnya menggunakan Hibernate di bawah hud.

53. Apakah itu lata? Bagaimanakah ia digunakan dalam Hibernate?

Seperti yang saya katakan sebelum ini, komunikasi dalam Hibernate berlaku melalui objek data yang dipanggil entiti. Entiti ini mewakili jadual tertentu dalam pangkalan data, dan seperti yang anda ingat, kelas Java boleh mengandungi rujukan kepada kelas lain. Hubungan ini juga ditunjukkan dalam pangkalan data. Sebagai peraturan, ia sama ada kunci asing (untuk perhubungan OneToOne, OneToMany, ManyToOne) atau jadual perantaraan (untuk perhubungan ManyToMany). Apabila entiti anda mempunyai rujukan kepada entiti lain yang berkaitan, anotasi diletakkan di atas rujukan ini untuk menunjukkan jenis perhubungan: @OneToOne, @OneToMany, @ManyToOne, @ManyToMany. Anda boleh menentukan jenis lata untuk perhubungan ini dalam sifat lata anotasi. JPA mempunyai kaedah khusus untuk berinteraksi dengan entiti (berterusan, simpan, gabung ...). Jenis lata digunakan untuk menunjukkan cara data yang berkaitan harus berkelakuan; kaedah ini digunakan pada entiti sasaran. Jadi apakah strategi lata (jenis lata)? Piawaian JPA memperuntukkan penggunaan enam jenis lata:

• PERSIST — operasi simpan berlaku dalam lata (untuk kaedah save() dan persist() ). Dalam erti kata lain, jika kita menyimpan entiti yang dikaitkan dengan entiti lain, maka entiti tersebut juga disimpan dalam pangkalan data (jika mereka belum ada)

• MERGE - operasi kemas kini berlaku dalam lata (untuk kaedah merge() )

• REMOVE - operasi padam berlaku dalam lata ( kaedah remove() )

• SEMUA — mengandungi tiga operasi berlatarkan sekali gus — BERTAHAN — BERGABUNG — KELUARKAN

JPA mempunyai konsep entiti berterusan — entiti yang dikaitkan dengan datanya dalam pangkalan data dan dikawal oleh sesi semasa (sambungan). Jika anda menukarnya tanpa menyimpan perubahan pada pangkalan data, data entiti dalam pangkalan data masih akan diubah.

• DETACH — entiti berkaitan tidak diuruskan oleh sesi ( kaedah detach() ). Iaitu, apabila data entiti berkaitan ditukar, data dalam pangkalan data tidak dikemas kini secara automatik — ia ditukar daripada berterusan kepada tertanggal (iaitu entiti tidak diuruskan oleh JPA)

• REFRESH — setiap kali entiti dimuat semula dengan data daripada pangkalan data ( refresh() — menyegarkan objek yang terpisah), entiti berkaitannya turut dimuat semula. Sebagai contoh, anda entah bagaimana menukar data yang diambil daripada pangkalan data, dan anda mahu memulihkan nilai asal. Dalam kes ini, anda akan mendapati operasi ini berguna.

Hibernate menyokong semua operasi lata standard ini dan juga memperkenalkan tiga operasinya sendiri:

• REPLICATE — digunakan apabila kami mempunyai lebih daripada satu sumber data dan kami mahu data itu disegerakkan (kaedah replika Hibernate). Semua entiti mesti mempunyai pengecam (id) untuk memastikan ia boleh dibuat tanpa masalah (untuk memastikan entiti yang sama tidak mempunyai id yang berbeza untuk pangkalan data yang berbeza)

• SAVE_UPDATE — melantun simpan/padam (untuk kaedah saveOrUpdate Hibernate )

• LOCK — bertentangan dengan operasi DETACHED : menukarkan entiti tertanggal kembali kepada keadaan berterusan, iaitu, sesi semasa akan menjejaki entiti itu sekali lagi

Jika tiada jenis lata dipilih, maka operasi pada entiti tidak akan menjejaskan entiti lain yang dikaitkan dengannya.

54. Bolehkah kelas Entiti menjadi abstrak?

Menurut 2.1 Kelas Entiti spesifikasi JPA , " Kedua-dua kelas abstrak dan konkrit boleh menjadi entiti. " Jadi, jawapannya ialah ya, kelas abstrak boleh menjadi entiti dan boleh ditandakan dengan anotasi @Entity.

55. Apakah pengurus entiti? Apakah tanggungjawabnya?

Pertama sekali, saya ingin ambil perhatian bahawa EntityManager ialah komponen penting JPA . Ia digunakan untuk interaksi entiti dengan pangkalan data. Secara umum, kaedah untuk interaksi entiti dengan pangkalan data dipanggil pada entiti (berterusan, bergabung, keluarkan, tanggalkan)... Tetapi saya juga ambil perhatian bahawa komponen ini biasanya bukan satu untuk keseluruhan aplikasi. Ia selalunya ringan, satu dipadamkan dan yang baharu dibuat menggunakan EntityManagerFactory . Jika kita melukis selari dengan JDBC , di mana EntityManagerFactory adalah analog dengan DataSource , maka EntityManager adalah analog dengan Connection . Terdahulu, saya menyebut bahawa entiti berterusan ialah entiti yang diuruskan oleh sambungan semasa. Entiti ini diuruskan oleh EntityManager , yang berkait rapat dengan sambungan semasa dan TransactionManager , yang bertanggungjawab untuk membuka/menutup transaksi. Dalam rajah di bawah, anda boleh melihat kitaran hayat entiti: EntityManager mengurus entiti apabila ia berada dalam peringkat Terurus (apabila ia berterusan, kerana ia mempunyai sambungan dengan EntityManager ) . Iaitu, ia bukan baru dan juga tidak dikeluarkan. Apabila entiti baharu atau dialih keluar, kita boleh mengatakan bahawa entiti itu juga terpisah, kerana EntityManager tidak mengurusnya. Terdapat strategi yang berbeza untuk EntityManager . Anda boleh mempunyai singleton EntityManager untuk keseluruhan aplikasi atau mencipta yang baharu setiap kali untuk setiap sambungan. Jika anda menggunakan Spring, penciptaan/pemadaman EntityManager diuruskan secara automatik di bawah hud (tetapi itu tidak bermakna anda tidak boleh menyesuaikannya untuk diri sendiri ^^). Saya perlu menyebut bahawa satu atau lebih EntityManagers membentuk konteks kegigihan . Konteks kegigihan ialah persekitaran di mana kejadian entiti disegerakkan dengan entiti serupa dalam pangkalan data (seperti yang saya katakan, ini hanya berfungsi untuk entiti berterusan). Jika anda mendalami JPA (yang saya sangat mengesyorkan), anda akan menghadapi konsep ini dengan kerap.

56. Apakah kelas Assert? Mengapa ia digunakan?

Saya tidak pernah mendengar tentang kelas sedemikian dalam JPA , jadi saya akan menganggap bahawa soalan ini merujuk kepada kelas yang terdapat dalam perpustakaan JUnit yang digunakan untuk ujian unit. Dalam perpustakaan ini, kelas Assert digunakan untuk menyemak keputusan pelaksanaan kod (di sini menegaskan bermaksud penegasan bahawa anda mempunyai keadaan/data tertentu di lokasi tertentu dalam kod). Sebagai contoh, katakan anda sedang menguji kaedah yang sepatutnya mencipta kucing. Anda menjalankan kaedah dan anda mendapat beberapa hasil:

Cat resultOfTest = createCat();

Tetapi anda perlu memastikan ia dicipta dengan betul, bukan? Jadi anda secara manual mencipta kucing tertentu ( expectedCat ) dengan tepat parameter yang anda jangkakan untuk melihat dalam kucing yang diperoleh daripada kaedah createCat() . Kemudian anda menggunakan kelas Assert untuk mengesahkan keputusan:

Assert.assertEquals(resultOfTest, expectedCat);

Jika kucing berbeza, maka AssertionError akan dilemparkan, yang memberitahu kami bahawa kami tidak mendapat hasil yang diharapkan. Kelas Assert mempunyai banyak kaedah berbeza yang merangkumi pelbagai operasi yang membantu dalam mengesahkan hasil yang dijangkakan . Berikut adalah beberapa daripada mereka:

• assertTrue(<boolean>) — nilai yang dihantar sebagai hujah dijangka benar

• assertFalse(<boolean>) — nilai yang dihantar sebagai hujah dijangka palsu

• assertNotEquals(<object1>, <object2>) — objek yang diluluskan sebagai hujah mestilah berbeza apabila dibandingkan menggunakan equals ( false )

• assertThrows(<ClassNameOfException>.class, <exceptionObject>) — hujah kedua dijangka menjadi pengecualian yang dilemparkan oleh hujah pertama (iaitu hujah kedua biasanya merupakan panggilan kaedah yang harus membuang pengecualian jenis yang diperlukan)

Tali

57. Terangkan kelas String Java

String ialah kelas Java standard yang bertanggungjawab untuk menyimpan dan memanipulasi nilai rentetan (urutan aksara). Ia adalah kelas tidak berubah (saya menulis tentang tidak berubah sebelum ini di sini ), iaitu, data objek kelas ini tidak boleh diubah selepas ia dicipta. Saya ingin ambil perhatian segera bahawa kelas StringBuilder dan StringBuffer pada asasnya adalah sama — satu-satunya perbezaan ialah salah satu daripadanya bertujuan untuk digunakan dalam persekitaran berbilang benang ( StringBuffer ). Kelas ini adalah seperti String , tetapi berbeza kerana ia boleh berubah . Walaupun selepas ia dibuat, mereka membenarkan anda mengubah suai rentetan yang mereka wakili, tanpa membuat objek baharu. Kaedah mereka berbeza daripada kaedah String standard dan direka untuk manipulasi rentetan (ada sebab mereka memanggilnya pembina).

58. Apakah cara untuk mencipta objek String? Di manakah ia dicipta?

Cara yang paling biasa untuk mencipta rentetan adalah untuk menentukan nilai yang kita inginkan dalam tanda petikan berganda dengan mudah:

String str = "Hello World!";

Anda juga boleh melakukannya secara eksplisit menggunakan new :

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

Anda juga boleh membuat rentetan daripada pelbagai aksara:

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

Kita boleh melakukannya dengan memanggil kaedah toString pada beberapa objek:

String str = someObject.toString();

Kita boleh melakukannya dengan memanggil mana-mana kaedah lain yang mengembalikan rentetan. Contoh:

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

Anda faham bahawa terdapat banyak, banyak cara untuk mencipta rentetan. Apabila objek String dicipta, ia disimpan dalam string pool , yang akan kita bincangkan dengan lebih terperinci dalam salah satu soalan di bawah.

59. Bagaimanakah anda membandingkan dua rentetan Java, dan bagaimana anda menyusunnya?

Java menggunakan tanda sama berganda ( == ) untuk melakukan perbandingan. Jika kita perlu membandingkan nilai mudah seperti ints, kita akan menggunakannya. Tetapi kaedah ini tidak sesuai untuk membandingkan objek penuh. Ia hanya akan membandingkan rujukan, iaitu sama ada rujukan menghala ke objek yang sama atau tidak. Ini bermakna jika kita membandingkan dua objek dengan nilai medan yang sama menggunakan == , kita akan mendapat false . Medan mempunyai nilai yang sama, tetapi objek itu sendiri menduduki lokasi yang berbeza dalam ingatan. Objek rentetan , walaupun kesederhanaan menipu mereka, masih objek. Membandingkannya menggunakan == juga tidak sesuai (walaupun terdapat kolam rentetan). Penyelesaian yang betul ialah kaedah sama standard kelas Objek , yang perlu ditindih untuk berfungsi dengan betul (secara lalai, ia menggunakan == untuk perbandingan). Kelas String mengatasinya, jadi kami hanya menggunakan pelaksanaannya:

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

Kami telah bercakap tentang perbandingan untuk kesaksamaan. Sekarang kita akan memikirkan perbandingan untuk menyusun. Lagipun, jika kita akan menyusun sesuatu, kita perlu tahu prinsip apa yang akan kita gunakan untuk mengisih. Untuk melakukan ini, anda boleh menggunakan TreeSet , set diisih standard. Struktur data ini bergantung pada algoritma pokok merah-hitam dan mengisih set mengikut prinsip pengisihan yang ditentukan. Seperti yang saya katakan sebelum ini, anda perlu memahami cara mengisih objek dari jenis tertentu. Untuk menetapkan kaedah perbandingan bagi pengisihan, gunakan pembanding . Anda biasanya perlu melaksanakannya untuk kelas yang ingin anda isi, tetapi dalam kes String , ia sudah dilaksanakan. Sehubungan itu, kami hanya menambah rentetan kami ke TreeSet , dan ia akan menyusunnya untuk kami:

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

Output konsol:

60. Sediakan algoritma untuk menukar rentetan kepada aksara. Tulis kod yang sepadan

Seperti yang saya katakan sebelum ini, objek String mempunyai banyak kaedah berguna yang berbeza. Salah satunya ialah toCharArray . Kaedah ini menukar rentetan kepada tatasusunan aksara:

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

Seterusnya, kami mempunyai pelbagai aksara yang boleh kami rujuk mengikut indeks:

char firstChar = charArr[0]; // H

61. Bagaimanakah anda menukar rentetan kepada tatasusunan bait dan belakang? Tulis kod yang sepadan

Kelas String mempunyai kaedah getBytes , yang serupa dengan kaedah toCharArray dan mengembalikan rentetan sebagai tatasusunan bait:

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

Kami telah sampai pada kesimpulan logik ulasan kami hari ini. Terima kasih untuk membaca!