Analisi di domande e risposte da interviste per sviluppatori Java. Parte 6

Ciao mondo! Continuare a sviluppare è molto importante per qualsiasi sviluppatore. Dopotutto, se ti fermi, c'è il rischio di non essere reclamato e di volare completamente fuori dal mercato: il mondo IT è in costante sviluppo e progresso, e devi muoverti con esso. Ma anche allo stesso tempo non ci si può concentrare solo sulle nuove e fresche tecnologie, per non dimenticare, per così dire, i classici (argomenti classici). Oggi voglio continuare la mia analisi delle domande su argomenti “classici” per uno sviluppatore Java. Prendo atto che le mie risposte non sono l'autorità finale: questo è proprio il modo in cui vedo le risposte corrette a queste domande e potresti non essere d'accordo con alcune di esse. Questo sarà abbastanza normale, quindi sentiti libero di condividere la tua opinione nei commenti. I collegamenti a parti dell'analisi si trovano alla fine dell'articolo.

Librerie e standard

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

Penso che per rispondere a questa domanda dobbiamo prima capire cos’è l’APP . JPA è una specifica che descrive la mappatura relazionale degli oggetti di semplici oggetti Java e fornisce un'API per archiviare, recuperare e manipolare tali oggetti. Cioè, come ricordiamo, i database relazionali (DB) si presentano sotto forma di numerose tabelle interconnesse. E JPA è uno standard ampiamente accettato 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. Allo stesso tempo, Hibernate è una libreria specifica che implementa i paradigmi JPA . Cioè, con l'aiuto di questa libreria puoi lavorare con un database relazionale attraverso oggetti che rappresentano i dati dal database (Entità). Come si suol dire, questa biblioteca è molto vicina agli ideali dell'APP e forse è per questo che è diventata popolare. E come capisci, la popolarità di utilizzo è un buon argomento per ulteriori sviluppi e miglioramenti. Inoltre, dietro il suo utilizzo frequente si nasconde un'enorme community che ha già risolto tutte le domande possibili e impossibili legate a questo strumento. Ecco un esempio di libro che esamina nel dettaglio tutti gli angoli oscuri di questa tecnologia. Cioè, Hibernate è stato studiato il più possibile e, risulta, è affidabile. In realtà, non è per niente che anche l'implementazione ideale di JPA sul lato Spring di solito utilizza Hibernate sotto il cofano.

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

Come ho detto prima, in Hibernate la comunicazione avviene tramite oggetti dati chiamati entità . Queste entità rappresentano alcune tabelle specifiche nel database e, come ricorderete, in Java le classi possono contenere riferimenti ad altre classi. Queste relazioni si riflettono nel database. In un database, di norma, si tratta di chiavi esterne (per OneToOne, OneToMany, ManyToOne) o di tabelle intermedie (per ManyToMany). Puoi leggere di più sulla relazione tra le entità in questo articolo . Quando la tua entità ha collegamenti ad altre entità correlate, le annotazioni vengono posizionate sopra questi collegamenti per indicare il tipo di connessione: @OneToOne, @OneToMany, @ManyToOne, @ManyToMane, nei cui parametri puoi specificare il valore della proprietà - cascade - il tipo di cascata per questo collegamento. JPA dispone di metodi specifici per interagire con le entità (persistere, salvare, unire...) . I tipi a cascata vengono utilizzati proprio per mostrare come dovrebbero comportarsi i dati associati quando questi metodi vengono utilizzati sull'entità di destinazione. Quindi, quali sono le strategie a cascata (tipi di cascata)? Lo standard JPA implica l'uso di sei tipi di cascata:

• PERSIST - le operazioni di salvataggio avverranno in cascata (per i metodi save() e persist() ). Cioè, se salviamo un'entità associata ad altre entità, anche queste verranno salvate nel database (se non ci sono già)

• MERGE - le operazioni di aggiornamento avverranno in cascata (per il metodo merge() )

• REMOVE - le operazioni di rimozione avvengono in cascata ( metodo Remove() )

• ALL - contiene tre operazioni a cascata contemporaneamente: PERSIST - MERGE - REMOVE

JPA ha il concetto di entità persistente : un'entità associata ai suoi dati nel database, che è controllata dalla sessione corrente (connessione) . Se lo modifichi, ma non salvi le modifiche nel database, i suoi dati nel database verranno comunque modificati.

• Le entità correlate a DETACH non saranno gestite dalla sessione ( metodo detach() ). Cioè, quando cambiano, non ci sarà alcun cambiamento automatico nei loro dati nel database: vengono trasferiti dallo stato di persistenza a quello distaccato (un'entità non gestita da JPA)

• AGGIORNA - ogni volta che un'entità viene aggiornata con i dati dal database ( refresh() - aggiorna gli oggetti staccati), le entità correlate vengono aggiornate nello stesso modo. Ad esempio, in qualche modo hai modificato i dati presi dal database e desideri restituirne i valori originali. In questo caso questa operazione ti sarà utile.

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

• REPLICA - Utilizzato quando disponiamo di più di un'origine dati e desideriamo che i dati siano sincronizzati (metodo Hibernate - replica). Tutte le entità devono avere identificatori (id) in modo che non ci siano problemi con la loro generazione (in modo che la stessa entità non abbia ID diversi per database diversi)

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

• LOCK è l'operazione inversa di DETACHED : trasferisce nuovamente l' entità distaccata allo stato di persistenza , cioè l'entità verrà nuovamente tracciata dalla sessione corrente

Se il tipo a cascata non è selezionato, nessuna operazione su un'entità avrà alcun effetto sulle altre entità ad essa associate.

54. Una classe Entità può essere astratta?

Nella specifica JPA nel paragrafo 2.1 La classe di entità c'è una riga: " Sia le classi astratte che quelle concrete possono essere entità ". Quindi la risposta è sì, una classe astratta può essere un'entità e può essere annotata con @Entity.

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

Innanzitutto vorrei sottolineare che EntityManager è uno dei componenti chiave di JPA , che viene utilizzato per far interagire le entità con il database. In generale, chiama i metodi di interazione tra l'entità e il database (persisti, unisci, rimuovi, stacca)... Ma vorrei anche notare che questo componente, di regola, non è uno per l'intera applicazione: molto spesso è leggero e viene spesso rimosso e ne viene creato uno nuovo utilizzando EntityManagerFactory . Se tracciamo un parallelo con JDBC , dove EntityManagerFactory sarà un analogo di DataSource , allora EntityManager, a sua volta, sarà un analogo di Connection . In precedenza ho menzionato un'entità di persistenza , come un'entità controllata dalla connessione corrente. Quindi: questa entità è gestita proprio dall'EntityManager , che è strettamente correlato alla connessione corrente e dal TransactionManager , che è responsabile dell'apertura/chiusura delle transazioni. Più avanti nella figura seguente puoi vedere il ciclo di vita di un'entità: EntityManager gestisce l'entità quando è nella fase Gestita (in questo momento è persistente, perché ha una connessione con EntityManager). Cioè, non è più nuovo e non è stato ancora rimosso. Possiamo dire che quando un'entità è nuova o rimossa, è anche distaccata, perché non è gestito dall'EntityManager. Esistono diverse strategie per EntityManager. Cioè, può esserci un EntityManager singleton per l'intera applicazione, oppure può esserne creato uno nuovo ogni volta, per ogni connessione. Se usi Spring, la creazione/eliminazione di EntityManager viene controllata automaticamente di nascosto (ma questo non significa che non puoi personalizzarlo ^^). Vale la pena dire che uno o più EntityManager formano il contesto di persistenza . Il 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), ti imbatterai in questi concetti molto, molto spesso.

56. Cos'è la classe Assert? Perché usarlo?

Non ho sentito parlare di una classe del genere in JPA , quindi suppongo che si riferisca alla classe JUnit della libreria, che viene utilizzata per il test unitario del codice. La classe di questa libreria, Assert , viene utilizzata per verificare i risultati dell'esecuzione del codice ( assert è un'affermazione che hai un determinato stato/dati in un determinato posto). Ad esempio, stai testando un metodo che dovrebbe creare un gatto. Esegui un metodo e ottieni qualche risultato:

Cat resultOfTest = createCat();

Ma devi assicurarti che sia stato creato correttamente, giusto? Pertanto, in precedenza hai creato manualmente un determinato gatto - awareCat - con esattamente i parametri che ti aspetti dal gatto ottenuto dal metodo createCat() . Successivamente, utilizzerai la classe Assert per verificare i risultati:

Assert.assertEquals(resultOfTest, expectedCat);

Se i gatti sono diversi verrà lanciata un'eccezione AssertionError , che ci dice che i risultati attesi non convergono. La classe Assert dispone di numerosi metodi diversi che coprono molte delle attività di verifica dei risultati attesi. Ecco qui alcuni di loro:

• assertTrue(<booleano>) - il valore atteso ricevuto come argomento deve essere vero

• assertFalse(<boolean>) - il valore atteso ricevuto come argomento dovrebbe essere falso

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

• assertThrows(<ClassNameOfException>.class, <exceptionObject>) - si prevede che il secondo argomento sia un'eccezione della classe specificata dal primo argomento (vale a dire, di regola, al posto del secondo argomento, viene chiamato un metodo che dovrebbe lancia un'eccezione del tipo richiesto)

Corda

57. Caratterizzare la stringa in Java

String è una classe standard in Java, responsabile della memorizzazione e della manipolazione dei valori di stringa (sequenze di caratteri), è una classe immutabile ( ho scritto prima di immutabile ), ad es. I dati degli oggetti di questa classe non possono essere modificati dopo la creazione. Vorrei subito notare che le classi StringBuilder e StringBuffer sono due classi praticamente identiche con l'unica differenza che una di esse è destinata all'utilizzo in un ambiente multi-thread (StringBuffer). Queste classi sono analoghe a String , ma a differenza di essa sono mutabili . Cioè gli oggetti, una volta creati, consentono la modifica della stringa che rappresentano senza creare un nuovo oggetto. In realtà i metodi differiscono dai metodi String standard e mirano a soddisfare le esigenze di modifica della stringa (non per niente si chiamano builder). Maggiori informazioni su String , StringBuffer e StringBuilder in questo articolo .

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

Il modo più comune per creare una stringa è semplicemente specificare il valore di cui abbiamo bisogno tra parentesi doppie:

String str = "Hello World!";

Puoi anche farlo direttamente tramite new :

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

Puoi creare una stringa partendo da un array di caratteri:

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

Come risultato del metodo toString in esecuzione su alcuni oggetti:

String str = someObject.toString();

Come il risultato di qualsiasi altro metodo, restituisce una rappresentazione di stringa. Per esempio:

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

Come hai capito, possono esserci moltissimi modi per creare una stringa. Quando viene creato un oggetto String , viene memorizzato nello string pool , di cui parleremo più in dettaglio in una delle domande seguenti.

59. Come confrontare due stringhe in Java e come ordinarle?

Per confrontare i valori in Java, viene utilizzato il doppio segno di uguale == . Se avessimo bisogno di confrontare alcuni valori semplici come int , lo useremmo. Ma questo metodo non è applicabile per confrontare oggetti a tutti gli effetti. In questo caso si tratterà solo di un confronto di riferimenti, indipendentemente dal fatto che puntino o meno allo stesso oggetto. Cioè, quando si confrontano due oggetti con esattamente gli stessi valori dei campi interni, il confronto tramite == darà come risultato falso : nonostante i campi identici degli oggetti, gli oggetti stessi occupano celle di memoria diverse. E gli oggetti della classe String , nonostante la loro ingannevole semplicità, sono pur sempre oggetti. E anche per loro il confronto tramite == non è applicabile (anche nonostante la presenza di uno string pool). Qui entra in gioco il metodo standard della classe Object - equals , che deve essere sovrascritto nella classe affinché funzioni correttamente (altrimenti, per impostazione predefinita, confronta utilizzando == ). Viene sovrascritto nella classe String , quindi lo prendiamo e lo usiamo:

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

Abbiamo parlato dei confronti corrispondenti, ora esaminiamo l'ordinamento dei confronti. Dopotutto, per ordinare qualcosa dobbiamo sapere in base a quale principio ordinare. Per fare ciò, puoi utilizzare un set ordinato standard - TreeSet . Puoi leggere ulteriori informazioni sulle varie raccolte in Java in questo articolo . Questo elenco funziona in base all'algoritmo dell'albero rosso-nero e ordina l'insieme secondo il principio di ordinamento specificato. Come ho detto prima, devi capire come ordinare gli oggetti di un certo tipo. I comparatori vengono utilizzati per impostare il metodo di confronto per l'ordinamento . In genere questi devono essere implementati per le classi che si desidera ordinare, ma nel caso di String sono già implementati. Pertanto, aggiungiamo semplicemente le righe di cui abbiamo bisogno a TreeSet e le ordinerà:

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

Uscita console:

60. Fornisci un algoritmo per convertire una stringa in un carattere. Scrivi il codice appropriato

Come ho detto prima, gli oggetti della classe 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 un array di caratteri che possiamo chiamare per indice:

char firstChar = charArr[0]; // H

61. Come convertire una stringa in un array di byte e viceversa? Scrivi il codice appropriato

Similmente al metodo toCharArray , la classe String ha un metodo getBytes che restituisce un array di byte della stringa:

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

La parte odierna dell'analisi è giunta alla sua logica conclusione. Grazie per l'attenzione!