Esplorazione di domande e risposte da un colloquio di lavoro per una posizione di sviluppatore Java. Parte 6

Ciao mondo! È essenziale per qualsiasi sviluppatore non smettere mai di crescere. Dopotutto, se ti fermi, rischi di rimanere fuori dalla domanda e completamente fuori dal mercato del lavoro. Il mondo IT è in continua evoluzione e va avanti: devi stare al passo con esso. Ma allo stesso tempo, non puoi sempre inserire le tecnologie più recenti per non dimenticare i "classici" (argomenti classici sullo sviluppo del software). Oggi voglio continuare la mia discussione sugli "argomenti classici" per gli sviluppatori Java. Sottolineerò che le mie risposte non sono l’ultima parola. Sono solo il mio punto di vista sulle risposte corrette: potresti non essere d'accordo con alcune di esse. Va bene, quindi sentiti libero di condividere la tua opinione nei commenti. Puoi trovare i collegamenti alle parti precedenti della recensione alla fine dell'articolo.

Librerie e standard

52. Cos'è l'ibernazione? Qual è la differenza tra JPA e Hibernate?

Per rispondere a questa domanda, penso che dobbiamo prima capire cos’è l’APP. È una specifica che descrive una mappatura relazionale tra oggetti di semplici oggetti Java e fornisce un'API per archiviare, recuperare e manipolare tali oggetti. Cioè, i database relazionali (DB) sono rappresentati come un insieme di tabelle interconnesse. E JPA è uno standard ampiamente adottato che descrive come gli oggetti possono interagire con i database relazionali. Come puoi vedere, l’APP è qualcosa di astratto e intangibile. È come l'idea stessa, l'approccio. Ma Hibernate è una libreria specifica che implementa i paradigmi JPA. In parole povere, puoi utilizzare questa libreria per lavorare con un database relazionale attraverso oggetti che rappresentano i dati nel database (Entità). Si dice che questa biblioteca sia molto vicina agli ideali dell'APP. Forse è per questo che è diventato popolare. Come puoi immaginare, la sua popolarità ha giustificato ulteriori sviluppi e miglioramenti. Inoltre, l'uso diffuso deriva da una vasta comunità che ha già esplorato ogni domanda possibile e impossibile relativa a questo strumento. Hibernate è stato studiato a fondo e, a quanto pare, è affidabile. C'è una buona ragione per cui anche l'implementazione ideale dell'APP in primavera generalmente utilizza Hibernate sotto il cofano.

53. Cos'è il cascata? Come viene utilizzato in Ibernazione?

Come ho detto prima, la comunicazione in Hibernate avviene attraverso oggetti dati chiamati entità. Queste entità rappresentano tabelle specifiche nel database e, come ricorderete, le classi Java possono contenere riferimenti ad altre classi. Queste relazioni si riflettono anche nel database. Di norma si tratta di chiavi esterne (per le relazioni OneToOne, OneToMany, ManyToOne) o di tabelle intermedie (per le relazioni ManyToMany). Quando la tua entità ha riferimenti ad altre entità correlate, le annotazioni vengono posizionate sopra questi riferimenti per indicare il tipo di relazione: @OneToOne, @OneToMany, @ManyToOne, @ManyToMany. È possibile specificare il tipo di cascata per questa relazione nella proprietà cascade delle annotazioni. JPA dispone di metodi specifici per interagire con le entità (persistere, salvare, unire...). I tipi a cascata vengono utilizzati per mostrare come dovrebbero comportarsi i dati correlati; questi metodi vengono utilizzati su un'entità di destinazione. Allora quali sono le strategie a cascata (tipi a cascata)? Lo standard JPA prevede l'utilizzo di sei tipologie di cascata:

• PERSIST — le operazioni di salvataggio avvengono in cascata (per i metodi save() e persist() ). In altre parole, se salviamo un'entità associata ad altre entità, anche quelle entità verranno salvate nel database (se non sono già presenti)

• MERGE : le operazioni di aggiornamento avvengono in cascata (per il metodo merge() )

• REMOVE : le operazioni di eliminazione si verificano a cascata ( metodo Remove() )

• ALL - contiene tre operazioni a cascata tutte in una volta: PERSIST - MERGE - REMOVE

JPA ha il concetto di entità persistente: un'entità associata ai suoi dati nel database e controllata dalla sessione corrente (connessione). Se lo modifichi senza salvare le modifiche nel database, i dati dell'entità nel database verranno comunque modificati.

• DETACH : le entità correlate non sono gestite dalla sessione ( metodo detach() ). Cioè, quando i dati delle entità correlate vengono modificati, i dati nel database non vengono aggiornati automaticamente: vengono convertiti da persistenti a distaccati (ovvero l'entità non è gestita da JPA)

• AGGIORNA : ogni volta che un'entità viene aggiornata con i dati dal database ( refresh() : aggiorna gli oggetti scollegati), vengono aggiornate anche le sue entità correlate. Ad esempio, hai in qualche modo modificato i dati presi dal database e desideri ripristinare i valori originali. In questo caso troverete utile questa operazione.

Hibernate supporta tutte queste operazioni a cascata standard e ne introduce anche tre proprie:

• REPLICATE — utilizzato quando abbiamo più di una fonte di dati e vogliamo che i dati siano sincronizzati (metodo di replica di Hibernate). Tutte le entità devono avere identificatori (id) per garantire che possano essere create senza problemi (per garantire che la stessa entità non abbia ID diversi per database diversi)

• SAVE_UPDATE : salvataggio/eliminazione a cascata (per il metodo saveOrUpdate di Hibernate )

• LOCK — l'opposto dell'operazione DETACHED : riconverte un'entità distaccata allo stato persistente, ovvero la sessione corrente traccerà nuovamente l'entità

Se non viene selezionato alcun tipo di cascata, un'operazione sull'entità non influenzerà le altre entità ad essa associate.

54. Una classe Entità può essere astratta?

Secondo 2.1 The Entity Class della specifica JPA , " Sia le classi astratte che quelle concrete possono essere entità ". Quindi, la risposta è sì, una classe astratta può essere un'entità e può essere contrassegnata con l'annotazione @Entity.

55. Cos'è un gestore di entità? Di cosa è responsabile?

Innanzitutto vorrei sottolineare che EntityManager è una componente cruciale di JPA . Viene utilizzato per l'interazione delle entità con il database. In generale, i metodi per l'interazione dell'entità con il database vengono chiamati sull'entità (persisti, unisci, rimuovi, stacca)... Ma noto anche che questo componente di solito non è un singleton per l'intera applicazione. Spesso è leggero, uno viene eliminato e ne viene creato uno nuovo utilizzando EntityManagerFactory . Se tracciamo un parallelo con JDBC , dove EntityManagerFactory è analogo a DataSource , allora EntityManager è analogo a Connection . In precedenza, ho menzionato che un'entità persistente è un'entità gestita dalla connessione corrente. Questa entità è gestita da EntityManager , che è strettamente correlato alla connessione corrente, e da TransactionManager , che è responsabile dell'apertura/chiusura delle transazioni. Nella figura seguente puoi vedere il ciclo di vita dell'entità: L' EntityManager gestisce l'entità quando è nella fase Gestita (quando è persistente, poiché ha una connessione con l' EntityManager ). Cioè, non è nuovo e inoltre non è stato rimosso. Quando un'entità è nuova o rimossa, possiamo dire che è anche distaccata, perché l' EntityManager non la gestisce. Esistono diverse strategie per EntityManager . Puoi avere un singleton EntityManager per l'intera applicazione o crearne uno nuovo ogni volta per ogni connessione. Se utilizzi Spring, la creazione/eliminazione di EntityManager viene gestita automaticamente (ma ciò non significa che non puoi personalizzarlo ^^). Devo menzionare che uno o più EntityManager formano un contesto di persistenza . Un contesto di persistenza è un ambiente in cui le istanze di entità sono sincronizzate con entità simili nel database (come ho detto, funziona solo per entità persistenti). Se approfondisci l'APP (cosa che consiglio vivamente), incontrerai questo concetto molto spesso.

56. Cos'è la classe Assert? Perché viene utilizzato?

Non ho sentito parlare di una classe del genere in JPA , quindi presumo che questa domanda si riferisca a una classe trovata nella libreria JUnit che viene utilizzata per i test unitari. In questa libreria, la classe Assert viene utilizzata per verificare i risultati dell'esecuzione del codice (qui assert significa un'asserzione secondo cui si dispone di uno stato/dati specifici in una posizione specifica nel codice). Ad esempio, supponiamo che tu stia testando un metodo che dovrebbe creare un gatto. Esegui il metodo e ottieni qualche risultato:

Cat resultOfTest = createCat();

Ma devi assicurarti che sia stato creato correttamente, giusto? Quindi crei manualmente un gatto specifico ( awareCat ) con esattamente i parametri che ti aspetti di vedere nel gatto ottenuto dal metodo createCat() . Quindi utilizzi la classe Assert per verificare i risultati:

Assert.assertEquals(resultOfTest, expectedCat);

Se i gatti sono diversi, verrà lanciato un AssertionError , che ci dice che non abbiamo ottenuto i risultati attesi. La classe Assert dispone di numerosi metodi diversi che coprono una varietà di operazioni utili per verificare i risultati attesi. Eccone alcuni:

• assertTrue(<boolean>) — si prevede che il valore passato come argomento sia vero

• assertFalse(<boolean>) — si prevede che il valore passato come argomento sia falso

• assertNotEquals(<object1>, <object2>) — gli oggetti passati come argomenti devono essere diversi se confrontati utilizzando equals ( false )

• assertThrows(<ClassNameOfException>.class, <exceptionObject>) — si prevede che il secondo argomento sia un'eccezione lanciata dal primo argomento (ovvero il secondo argomento è solitamente una chiamata al metodo che dovrebbe lanciare un'eccezione del tipo richiesto)

Corda

57. Descrivi la classe String di Java

String è una classe Java standard responsabile della memorizzazione e della manipolazione dei valori stringa (sequenze di caratteri). È una classe immutabile (ho già scritto di immutabile qui ), ovvero i dati degli oggetti di questa classe non possono essere modificati dopo la loro creazione. Vorrei sottolineare subito che le classi StringBuilder e StringBuffer sono essenzialmente identiche: l'unica differenza è che una di esse è destinata all'uso in un ambiente multithread ( StringBuffer ). Queste classi sono come String , ma differiscono in quanto sono mutabili . Anche dopo la loro creazione consentono di modificare le stringhe che rappresentano, senza creare un nuovo oggetto. I loro metodi differiscono dai metodi String standard e sono progettati per la manipolazione delle stringhe (c'è una ragione per cui lo chiamano builder).

58. Quali sono i modi per creare un oggetto String? Dove viene creato?

Il modo più comune per creare una stringa è specificare semplicemente il valore che vogliamo tra virgolette doppie:

String str = "Hello World!";

Puoi anche farlo esplicitamente usando new :

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

Puoi anche creare una stringa da un array di caratteri:

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

Possiamo farlo chiamando il metodo toString su qualche oggetto:

String str = someObject.toString();

Possiamo farlo chiamando qualsiasi altro metodo che restituisca una stringa. Esempio:

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

Comprendi che possono esserci molti, molti modi per creare una stringa. Quando viene creato un oggetto String , viene archiviato in un pool di stringhe , di cui parleremo più dettagliatamente in una delle domande seguenti.

59. Come si confrontano due stringhe Java e come le si ordina?

Java utilizza un doppio segno di uguale ( == ) per eseguire i confronti. Se dobbiamo confrontare valori semplici come int, lo useremo. Ma questo metodo non è adatto per confrontare oggetti a tutti gli effetti. Confronterà solo i riferimenti, cioè se i riferimenti puntano allo stesso oggetto oppure no. Ciò significa che se confrontiamo due oggetti con gli stessi valori di campo utilizzando == , otterremo false . I campi hanno gli stessi valori, ma gli oggetti stessi occupano posizioni diverse nella memoria. Gli oggetti stringa , nonostante la loro ingannevole semplicità, sono pur sempre oggetti. Anche confrontarli utilizzando == non è appropriato (nonostante la presenza di uno string pool). La soluzione corretta è il metodo equals standard della classe Object , che deve essere sovrascritto per funzionare correttamente (per impostazione predefinita, utilizza == per i confronti). La classe String la sovrascrive, quindi utilizziamo semplicemente la sua implementazione:

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

Abbiamo parlato di confronti per l'uguaglianza. Ora scopriremo i confronti per l'ordinamento. Dopotutto, se vogliamo ordinare qualcosa, dobbiamo sapere quale principio utilizzeremo per ordinare. Per fare ciò, puoi utilizzare TreeSet , un set ordinato standard. Questa struttura dati si basa sull'algoritmo dell'albero rosso-nero e ordina l'insieme secondo un principio di ordinamento specificato. Come ho detto prima, devi capire come ordinare gli oggetti di un certo tipo. Per assegnare il metodo di confronto per l'ordinamento, utilizzare i comparatori . In genere è necessario implementarli per le classi che si desidera ordinare, ma nel caso di String sono già implementati. Di conseguenza, aggiungiamo semplicemente le nostre stringhe a TreeSet e lui le ordinerà per noi:

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

Uscita console:

60. Fornire un algoritmo per convertire una stringa in caratteri. Scrivi il codice corrispondente

Come ho detto prima, gli oggetti String hanno molti metodi utili diversi. Uno di questi è toCharArray . Questo metodo converte una stringa in un array di caratteri:

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

Successivamente, abbiamo una serie di caratteri a cui possiamo fare riferimento tramite indice:

char firstChar = charArr[0]; // H

61. Come si converte una stringa in un array di byte e viceversa? Scrivi il codice corrispondente

La classe String ha un metodo getBytes , che è simile al metodo toCharArray e restituisce la stringa come array di byte:

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

Oggi siamo giunti alla logica conclusione della nostra recensione. Grazie per aver letto!