Analisis soalan dan jawapan daripada temu bual untuk pembangun Java. Bahagian 6

Hai dunia! Meneruskan pembangunan adalah sangat penting bagi mana-mana pembangun. Lagipun, jika anda berhenti, terdapat risiko untuk menjadi tidak dituntut dan hilang sepenuhnya daripada pasaran: dunia IT sentiasa membangun dan bergerak ke hadapan, dan anda perlu bergerak dengannya. Tetapi walaupun pada masa yang sama, seseorang tidak boleh hanya menumpukan pada teknologi baru dan segar, supaya tidak lupa, boleh dikatakan, tentang klasik (topik klasik). Hari ini saya ingin meneruskan analisis soalan saya tentang topik "klasik" untuk pembangun Java. Saya perhatikan bahawa jawapan saya bukanlah kuasa muktamad - ini adalah cara saya melihat jawapan yang betul untuk soalan ini, dan anda mungkin tidak bersetuju dengan sebahagian daripada mereka. Ini adalah perkara biasa, jadi jangan ragu untuk berkongsi pendapat anda dalam ulasan. Pautan ke bahagian analisis ada di penghujung artikel.

Perpustakaan dan piawaian

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

Saya fikir untuk menjawab soalan ini, kita perlu memahami dahulu apa itu JPA . JPA ialah spesifikasi yang menerangkan pemetaan hubungan objek objek Java mudah dan menyediakan API untuk menyimpan, mendapatkan semula dan memanipulasi objek tersebut. Iaitu, seperti yang kita ingat, pangkalan data hubungan (DB) dibentangkan dalam bentuk banyak jadual yang saling berkaitan. Dan JPA ialah piawaian yang diterima 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. Pada masa yang sama, Hibernate ialah perpustakaan khusus yang melaksanakan paradigma JPA . Iaitu, dengan bantuan perpustakaan ini anda boleh bekerja dengan pangkalan data hubungan melalui objek yang mewakili data daripada pangkalan data (Entiti). Seperti yang mereka katakan, perpustakaan ini sangat dekat dengan cita-cita JPA dan mungkin itulah sebabnya ia menjadi popular. Dan seperti yang anda fahami, populariti penggunaan adalah hujah yang baik untuk pembangunan dan penambahbaikan selanjutnya. Di samping itu, di sebalik penggunaannya yang kerap terdapat komuniti besar yang telah menyelesaikan semua soalan yang mungkin dan mustahil yang berkaitan dengan alat ini. Berikut adalah contoh buku yang mengkaji secara terperinci semua sudut gelap teknologi ini. Iaitu, Hibernate telah dikaji sebanyak mungkin dan, ternyata, boleh dipercayai. Sebenarnya, bukan tanpa alasan walaupun pelaksanaan JPA yang ideal di bahagian Spring biasanya menggunakan Hibernate di bawah hud.

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

Seperti yang saya katakan sebelum ini, dalam komunikasi Hibernate dijalankan melalui objek data yang dipanggil entiti . Entiti ini mewakili beberapa jadual tertentu dalam pangkalan data, dan seperti yang anda ingat, dalam kelas Java boleh mengandungi rujukan kepada kelas lain. Hubungan ini ditunjukkan dalam pangkalan data. Dalam pangkalan data, sebagai peraturan, ini sama ada kunci asing (untuk OneToOne, OneToMany, ManyToOne) atau jadual perantaraan (untuk ManyToMany). Anda boleh membaca lebih lanjut tentang hubungan antara entiti dalam artikel ini . Apabila entiti anda mempunyai pautan kepada entiti lain yang berkaitan, anotasi diletakkan di atas pautan ini untuk menunjukkan jenis sambungan: @OneToOne, @OneToMany, @ManyToOne, @ManyToMane, di mana parameter anda boleh menentukan nilai harta - lata - yang jenis lata untuk sambungan ini. JPA mempunyai kaedah khusus untuk berinteraksi dengan entiti (berterusan, simpan, gabung...) . Jenis Lata digunakan dengan tepat untuk menunjukkan cara data yang berkaitan harus bertindak apabila kaedah ini digunakan pada entiti sasaran. Jadi, apakah strategi lata (jenis lata)? Piawaian JPA membayangkan penggunaan enam jenis lata:

• PERSIST - operasi simpan akan berlaku dalam lata (untuk kaedah save() dan persist() ). Iaitu, jika kita menyimpan entiti yang dikaitkan dengan entiti lain, mereka juga disimpan dalam pangkalan data (jika mereka belum ada)

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

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

• SEMUA - mengandungi tiga operasi lata sekali gus - PERSIST - MERGE - REMOVE

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

• DETACH - entiti berkaitan tidak akan diuruskan oleh sesi ( kaedah detach() ). Iaitu, apabila mereka berubah, tidak akan ada perubahan automatik dalam data mereka dalam pangkalan data - mereka dipindahkan dari keadaan kegigihan kepada tertanggal (entiti yang tidak diuruskan oleh JPA)

• REFRESH - setiap kali entiti dikemas kini dengan data daripada pangkalan data ( refresh() - mengemas kini objek tertanggal), entiti berkaitan dikemas kini dengan cara yang sama. Sebagai contoh, anda entah bagaimana menukar data yang diambil daripada pangkalan data dan ingin mengembalikan nilai asalnya. Dalam kes ini, operasi ini akan berguna kepada anda.

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

• REPLICATE - Digunakan apabila kami mempunyai lebih daripada satu sumber data dan kami mahu data itu disegerakkan (Kaedah Hibernate - replika). Semua entiti mesti mempunyai pengecam (id) supaya tiada masalah dengan penjanaan mereka (supaya entiti yang sama tidak mempunyai id yang berbeza untuk pangkalan data yang berbeza)

• SAVE_UPDATE - lata simpan/padam (untuk kaedah Hibernate - saveOrUpdate )

• LOCK ialah operasi songsang kepada DETACHED : ia memindahkan entiti tertanggal kembali ke keadaan kegigihan , i.e. entiti akan dijejaki semula oleh sesi semasa

Jika jenis lata tidak dipilih, tiada operasi pada entiti akan mempunyai sebarang kesan ke atas entiti lain yang dikaitkan dengannya.

54. Bolehkah kelas Entiti menjadi abstrak?

Dalam spesifikasi JPA dalam perenggan 2.1 Kelas Entiti terdapat baris: " Kedua-dua kelas abstrak dan konkrit boleh menjadi entiti ." Jadi jawapannya ialah ya, kelas abstrak boleh menjadi entiti dan boleh dianotasi dengan @Entity.

55. Apakah pengurus entiti? Apa yang dia bertanggungjawab?

Pertama sekali, saya ingin ambil perhatian bahawa EntityManager ialah salah satu komponen utama JPA , yang digunakan untuk berinteraksi dengan entiti dengan pangkalan data. Secara umum, ia memanggil kaedah interaksi antara entiti dan pangkalan data (berterusan, bergabung, mengalih keluar, menanggalkan)... Tetapi saya juga akan ambil perhatian bahawa komponen ini, sebagai peraturan, bukan satu untuk keseluruhan aplikasi: selalunya ia ringan dan sering dialih keluar dan yang baharu dibuat menggunakan EntityManagerFactory . Jika kita membuat persamaan dengan JDBC , di mana EntityManagerFactory akan menjadi analog DataSource , maka EntityManager pula akan menjadi analog Connection . Terdahulu saya menyebut entiti kegigihan , sebagai entiti yang dikawal oleh sambungan semasa. Jadi: entiti ini diuruskan dengan tepat oleh EntityManager , yang berkait rapat dengan sambungan semasa dan TransactionManager , yang bertanggungjawab untuk membuka/menutup transaksi. Selanjutnya dalam rajah di bawah anda boleh melihat kitaran hayat entiti: EntityManager mengurus entiti apabila ia berada di peringkat Terurus (pada masa ini ia berterusan, kerana ia mempunyai hubungan dengan EntityManager). Iaitu, ia bukan lagi baru dan belum lagi dialih keluar. Kita boleh mengatakan bahawa apabila entiti baharu atau dialih keluar, ia juga terpisah, kerana ia tidak diuruskan oleh EntityManager. Terdapat strategi yang berbeza untuk EntityManager. Iaitu, boleh ada satu EntityManager tunggal untuk keseluruhan aplikasi, atau yang baharu boleh dibuat setiap kali, untuk setiap sambungan. Jika anda menggunakan Spring, maka penciptaan/pemadaman EntityManager dikawal secara automatik di bawah hud (tetapi ini tidak bermakna anda tidak boleh menyesuaikannya ^^). Perlu dikatakan 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 yang berterusan). Jika anda mendalami JPA (yang saya sangat syorkan), anda akan menemui konsep ini dengan sangat kerap.

56. Apakah kelas Assert? Mengapa menggunakannya?

Saya tidak pernah mendengar tentang kelas sedemikian dalam JPA , jadi saya akan menganggap bahawa ini merujuk kepada kelas JUnit perpustakaan, yang digunakan untuk ujian unit kod. Kelas perpustakaan ini, Assert , digunakan untuk menyemak hasil pelaksanaan kod ( assert ialah pernyataan bahawa anda mempunyai keadaan/data tertentu di tempat tertentu). Sebagai contoh, anda sedang menguji kaedah yang sepatutnya mencipta kucing. Anda menjalankan kaedah dan mendapat beberapa hasil:

Cat resultOfTest = createCat();

Tetapi anda perlu memastikan ia dicipta dengan betul, bukan? Oleh itu, anda sebelum ini mencipta kucing tertentu - expectedCat - secara manual dengan tepat parameter yang anda jangkakan daripada kucing yang diperoleh daripada kaedah createCat() . Seterusnya, anda menggunakan kelas Assert untuk mengesahkan keputusan:

Assert.assertEquals(resultOfTest, expectedCat);

Jika kucing berbeza, pengecualian AssertionError akan dilemparkan , yang memberitahu kami bahawa hasil yang dijangkakan tidak menumpu. Kelas Assert mempunyai banyak kaedah berbeza yang merangkumi banyak tugas untuk mengesahkan hasil yang dijangkakan. Berikut adalah sebahagian daripada mereka:

• assertTrue(<boolean>) - nilai jangkaan yang diterima sebagai argumen mestilah benar

• assertFalse(<boolean>) - nilai jangkaan yang diterima sebagai hujah mestilah palsu

• assertNotEquals(<object1>, <object2>) - objek yang diterima sebagai argumen mesti berbeza apabila dibandingkan menggunakan equals ( false )

• assertThrows(<ClassNameOfException>.class, <exceptionObject>) - argumen kedua dijangka menjadi pengecualian kelas yang ditentukan oleh argumen pertama (iaitu, sebagai peraturan, sebagai ganti argumen kedua, kaedah dipanggil yang sepatutnya buang pengecualian jenis yang diperlukan)

Tali

57. Mencirikan String dalam Java

String ialah kelas standard di Jawa, bertanggungjawab untuk menyimpan dan memanipulasi nilai rentetan (urutan aksara), ialah kelas tidak berubah ( saya menulis tentang tidak berubah tadi ), i.e. Data objek kelas ini tidak boleh ditukar selepas penciptaan. Saya ingin segera ambil perhatian bahawa kelas StringBuilder dan StringBuffer adalah dua kelas yang hampir sama dengan satu-satunya perbezaan ialah salah satu daripadanya bertujuan untuk digunakan dalam persekitaran berbilang benang (StringBuffer). Kelas ini adalah serupa dengan String , tetapi tidak seperti itu, ia boleh berubah . Iaitu, objek, setelah dibuat, membenarkan pengubahsuaian rentetan yang diwakilinya tanpa mencipta objek baharu. Sebenarnya, kaedah berbeza daripada kaedah String standard dan bertujuan untuk memenuhi keperluan menukar rentetan (ia bukan untuk apa-apa yang mereka dipanggil pembina). Baca lebih lanjut mengenai String , StringBuffer dan StringBuilder dalam artikel ini .

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

Cara paling biasa untuk mencipta rentetan adalah dengan hanya menentukan nilai yang kita perlukan dalam kurungan berganda:

String str = "Hello World!";

Anda juga boleh melakukan ini secara langsung melalui baru :

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

Anda boleh membuat rentetan bermula daripada pelbagai aksara:

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

Hasil daripada kaedah toString yang dijalankan pada beberapa objek:

String str = someObject.toString();

Seperti hasil kaedah lain, ia mengembalikan perwakilan rentetan. Sebagai contoh:

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

Seperti yang anda fahami, terdapat 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. Bagaimana untuk membandingkan dua rentetan dalam Java dan bagaimana untuk menyusunnya?

Untuk membandingkan nilai dalam Java, tanda ganda sama == digunakan . Jika kami perlu membandingkan beberapa nilai mudah seperti int , kami akan menggunakannya. Tetapi kaedah ini tidak boleh digunakan untuk membandingkan objek lengkap. Dalam kes ini, ia hanya akan menjadi perbandingan rujukan - sama ada merujuk kepada objek yang sama atau tidak. Iaitu, apabila membandingkan dua objek dengan nilai medan dalaman yang sama, perbandingan melalui == akan memberikan hasil palsu : walaupun medan objek yang sama, objek itu sendiri menduduki sel memori yang berbeza. Dan objek kelas String , walaupun kesederhanaan menipu mereka, masih objek. Dan perbandingan melalui == juga tidak terpakai untuk mereka (walaupun terdapat kolam rentetan). Di sini kaedah standard kelas Objek dimainkan - equals , yang mesti ditindih dalam kelas agar ia berfungsi dengan betul (jika tidak, secara lalai ia membandingkan menggunakan == ). Ia diganti dalam kelas String , jadi kami hanya mengambilnya dan menggunakannya:

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

Kami bercakap tentang perbandingan padanan, sekarang mari kita lihat perbandingan pengisihan. Lagipun, untuk menyusun sesuatu kita perlu tahu dengan prinsip apa yang hendak diisih. Untuk melakukan ini, anda boleh menggunakan set diisih standard - TreeSet . Anda boleh membaca lebih lanjut mengenai pelbagai koleksi di Jawa dalam artikel ini . Senarai ini berfungsi berdasarkan 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. Pembanding digunakan untuk menetapkan kaedah perbandingan untuk menyusun . Biasanya ini perlu dilaksanakan untuk kelas yang anda ingin isikan, tetapi dalam kes String mereka sudah dilaksanakan. Oleh itu, kami hanya menambah baris yang kami perlukan pada TreeSet , dan ia akan menyusunnya:

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

Output konsol:

60. Berikan algoritma untuk menukar rentetan kepada aksara. Tulis kod yang sesuai

Seperti yang saya katakan sebelum ini, objek kelas 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 kita mempunyai pelbagai aksara yang boleh kita panggil mengikut indeks:

char firstChar = charArr[0]; // H

61. Bagaimana untuk menukar rentetan kepada tatasusunan bait dan belakang? Tulis kod yang sesuai

Sama seperti kaedah toCharArray , kelas String mempunyai kaedah getBytes yang mengembalikan tatasusunan bait rentetan:

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

Bahagian analisis hari ini telah sampai ke penghujung logiknya. Terima kasih kerana memberi perhatian!