Explorer les questions et réponses d'un entretien d'embauche pour un poste de développeur Java. Partie 6

Bonjour le monde! Il est essentiel pour tout développeur de ne jamais cesser de croître. Après tout, si vous arrêtez, vous risquez de ne plus répondre à la demande et de vous exclure complètement du marché du travail. Le monde informatique évolue et avance constamment : vous devez évoluer avec lui. Mais en même temps, vous ne pouvez pas toujours utiliser les dernières technologies, de peur d'oublier les « classiques » (sujets classiques de développement de logiciels). Aujourd'hui, je souhaite poursuivre ma discussion sur les « sujets classiques » pour les développeurs Java. Je soulignerai que mes réponses ne sont pas le dernier mot. Ce ne sont que mes opinions sur les bonnes réponses – vous pourriez être en désaccord avec certaines d’entre elles. C'est très bien, alors n'hésitez pas à partager votre opinion dans les commentaires. Vous pouvez trouver des liens vers les parties précédentes de la revue à la fin de l’article.

Bibliothèques et normes

52. Qu'est-ce que la mise en veille prolongée ? Quelle est la différence entre JPA et Hibernate ?

Pour répondre à cette question, je pense que nous devons d’abord comprendre ce qu’est JPA. Il s'agit d'une spécification qui décrit un mappage objet-relationnel d'objets Java simples et fournit une API pour stocker, récupérer et manipuler ces objets. Autrement dit, les bases de données relationnelles (DB) sont représentées comme un ensemble de tables interconnectées. Et JPA est une norme largement adoptée qui décrit comment les objets peuvent interagir avec les bases de données relationnelles. Comme vous pouvez le constater, JPA est quelque chose d’abstrait et d’intangible. C'est comme l'idée elle-même, l'approche. Mais Hibernate est une bibliothèque spécifique qui implémente les paradigmes JPA. En d'autres termes, vous pouvez utiliser cette bibliothèque pour travailler avec une base de données relationnelle via des objets qui représentent les données de la base de données (Entité). On dit que cette bibliothèque est très proche des idéaux du JPA. C’est peut-être pour cela qu’il est devenu populaire. Comme vous pouvez l’imaginer, sa popularité a justifié de nouveaux développements et améliorations. De plus, l'utilisation répandue provient d'une vaste communauté qui a déjà exploré toutes les questions possibles et impossibles liées à cet outil. Hibernate a été étudié de manière approfondie et, en fin de compte, il est fiable. Il y a une bonne raison pour laquelle même l'implémentation idéale de JPA au printemps utilise généralement Hibernate sous le capot.

53. Qu'est-ce que la cascade ? Comment est-il utilisé dans Hibernate ?

Comme je l'ai dit plus tôt, la communication dans Hibernate s'effectue via des objets de données appelés entités. Ces entités représentent des tables spécifiques dans la base de données et, comme vous vous en souviendrez, les classes Java peuvent contenir des références à d'autres classes. Ces relations sont également reflétées dans la base de données. En règle générale, il s'agit soit de clés étrangères (pour les relations OneToOne, OneToMany, ManyToOne), soit de tables intermédiaires (pour les relations ManyToMany). Lorsque votre entité a des références à d'autres entités liées, des annotations sont placées au-dessus de ces références pour indiquer le type de relation : @OneToOne, @OneToMany, @ManyToOne, @ManyToMany. Vous pouvez spécifier le type de cascade pour cette relation dans la propriété cascade des annotations. JPA dispose de méthodes spécifiques pour interagir avec les entités (persister, sauvegarder, fusionner...). Les types en cascade sont utilisés pour montrer comment les données associées doivent se comporter ; ces méthodes sont utilisées sur une entité cible. Alors, quelles sont les stratégies en cascade (types en cascade) ? La norme JPA prévoit l'utilisation de six types de cascade :

• PERSIST — les opérations de sauvegarde se produisent en cascade (pour les méthodes save() et persist() ). En d’autres termes, si nous enregistrons une entité associée à d’autres entités, alors ces entités sont également enregistrées dans la base de données (si elles n’y sont pas déjà)

• MERGE — les opérations de mise à jour se produisent en cascade (pour la méthode merge() )

• REMOVE - les opérations de suppression se produisent en cascade ( méthode Remove() )

• ALL - contient trois opérations en cascade en même temps - PERSIST - MERGE - SUPPRIMER

JPA a le concept d'entité persistante — une entité associée à ses données dans la base de données et contrôlée par la session en cours (connexion). Si vous le modifiez sans enregistrer les modifications dans la base de données, les données de l'entité dans la base de données seront quand même modifiées.

• DETACH — les entités liées ne sont pas gérées par la session ( méthode detach() ). Autrement dit, lorsque les données des entités associées sont modifiées, les données de la base de données ne sont pas automatiquement mises à jour : elles sont converties de persistantes en détachées (c'est-à-dire que l'entité n'est pas gérée par JPA).

• REFRESH — chaque fois qu'une entité est actualisée avec les données de la base de données ( refresh() — actualise les objets détachés), ses entités associées sont également actualisées. Par exemple, vous avez modifié d'une manière ou d'une autre les données extraites de la base de données et vous souhaitez restaurer les valeurs d'origine. Dans ce cas, cette opération vous sera utile.

Hibernate prend en charge toutes ces opérations en cascade standard et en introduit également trois :

• REPLICATE - utilisé lorsque nous avons plusieurs sources de données et que nous souhaitons que les données soient synchronisées (méthode de réplication d'Hibernate). Toutes les entités doivent avoir des identifiants (id) pour garantir qu'elles peuvent être créées sans problème (pour garantir que la même entité n'a pas d'identifiant différent pour différentes bases de données)

• SAVE_UPDATE — sauvegarde/suppression en cascade (pour la méthode saveOrUpdate d'Hibernate )

• LOCK — l'opposé de l' opération DETACHED : reconvertit une entité détachée à l'état persistant, c'est-à-dire que la session en cours suivra à nouveau l'entité

Si aucun type de cascade n'est sélectionné, alors une opération sur l'entité n'affectera pas les autres entités qui lui sont associées.

54. Une classe Entity peut-elle être abstraite ?

Selon 2.1 The Entity Class de la spécification JPA , « Les classes abstraites et concrètes peuvent être des entités. » La réponse est donc oui, une classe abstraite peut être une entité et peut être marquée avec l'annotation @Entity.

55. Qu'est-ce qu'un gestionnaire d'entité ? De quoi est-il responsable ?

Tout d'abord, je voudrais souligner qu'EntityManager est un composant crucial de JPA . Il est utilisé pour l'interaction des entités avec la base de données. En général, les méthodes d'interaction de l'entité avec la base de données sont appelées sur l'entité (persister, fusionner, supprimer, détacher)... Mais je note également que ce composant n'est généralement pas un singleton pour l'ensemble de l'application. Il est souvent léger, un est supprimé et un nouveau est créé à l'aide de EntityManagerFactory . Si nous faisons un parallèle avec JDBC , où EntityManagerFactory est analogue à DataSource , alors EntityManager est analogue à Connection . Plus tôt, j'ai mentionné qu'une entité persistante est une entité gérée par la connexion actuelle. Cette entité est gérée par le EntityManager , qui est étroitement lié à la connexion actuelle, et par le TransactionManager , qui est responsable de l'ouverture/fermeture des transactions. Dans la figure ci-dessous, vous pouvez voir le cycle de vie de l'entité : Le EntityManager gère l'entité lorsqu'elle est à l'étape Managed (quand elle est persistante, puisqu'elle a une connexion avec le EntityManager ). C'est-à-dire qu'il n'est ni nouveau ni supprimé. Lorsqu'une entité est nouvelle ou supprimée, on peut dire qu'elle est également détachée, car l' EntityManager ne la gère pas. Il existe différentes stratégies pour le EntityManager . Vous pouvez avoir un singleton EntityManager pour l'ensemble de l'application ou en créer un nouveau à chaque fois pour chaque connexion. Si vous utilisez Spring, la création/suppression d'EntityManager est gérée automatiquement en coulisse (mais cela ne veut pas dire que vous ne pouvez pas le personnaliser vous-même ^^). Je dois mentionner qu'un ou plusieurs EntityManagers forment un contexte de persistance . Un contexte de persistance est un environnement dans lequel les instances d'entités sont synchronisées avec des entités similaires dans la base de données (comme je l'ai dit, cela ne fonctionne que pour les entités persistantes). Si vous approfondissez JPA (ce que je recommande vivement), vous rencontrerez très souvent ce concept.

56. Qu'est-ce que la classe Assert ? Pourquoi est-il utilisé ?

Je n'ai pas entendu parler d'une telle classe dans JPA , je suppose donc que cette question fait référence à une classe trouvée dans la bibliothèque JUnit qui est utilisée pour les tests unitaires. Dans cette bibliothèque, la classe Assert est utilisée pour vérifier les résultats de l'exécution du code (ici assert signifie une assertion selon laquelle vous avez un état/des données spécifiques à un emplacement spécifique dans le code). Par exemple, disons que vous testez une méthode censée créer un chat. Vous exécutez la méthode et vous obtenez un résultat :

Cat resultOfTest = createCat();

Mais vous devez vous assurer qu’il a été créé correctement, n’est-ce pas ? Vous créez donc manuellement un chat spécifique ( ExpectCat ) avec exactement les paramètres que vous vous attendez à voir dans le chat obtenu à partir de la méthode createCat() . Ensuite, vous utilisez la classe Assert pour vérifier les résultats :

Assert.assertEquals(resultOfTest, expectedCat);

Si les chats sont différents, alors une AssertionError sera levée, ce qui nous indiquera que nous n'avons pas obtenu les résultats attendus. La classe Assert dispose de nombreuses méthodes différentes qui couvrent diverses opérations utiles pour vérifier les résultats attendus. En voici quelques-uns :

• assertTrue(<boolean>) — la valeur transmise en argument devrait être vraie

• assertFalse(<boolean>) — la valeur transmise en argument devrait être fausse

• assertNotEquals(<object1>, <object2>) — les objets passés en arguments doivent être différents lorsqu'ils sont comparés à l'aide de equals ( false )

• assertThrows(<ClassNameOfException>.class, <exceptionObject>) — le deuxième argument est censé être une exception levée par le premier argument (c'est-à-dire que le deuxième argument est généralement un appel de méthode qui doit lever une exception du type requis)

Chaîne

57. Décrire la classe String de Java

String est une classe Java standard chargée de stocker et de manipuler les valeurs de chaîne (séquences de caractères). C'est une classe immuable (j'ai déjà parlé d'immuable ici ), c'est-à-dire que les données des objets de cette classe ne peuvent pas être modifiées après leur création. Je voudrais tout de suite noter que les classes StringBuilder et StringBuffer sont essentiellement identiques — la seule différence est que l'une d'elles est destinée à être utilisée dans un environnement multithread ( StringBuffer ). Ces classes sont comme String , mais diffèrent en ce qu'elles sont mutables . Même après leur création, ils vous permettent de modifier les chaînes qu'ils représentent, sans créer de nouvel objet. Leurs méthodes diffèrent des méthodes String standard et sont conçues pour la manipulation de chaînes (il y a une raison pour laquelle elles l'appellent un constructeur).

58. Quelles sont les manières de créer un objet String ? Où est-il créé ?

La manière la plus courante de créer une chaîne consiste à spécifier simplement la valeur souhaitée entre guillemets doubles :

String str = "Hello World!";

Vous pouvez également le faire explicitement en utilisant new :

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

Vous pouvez également créer une chaîne à partir d'un tableau de caractères :

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

Nous pouvons le faire en appelant la méthode toString sur un objet :

String str = someObject.toString();

Nous pouvons le faire en appelant n’importe quelle autre méthode qui renvoie une chaîne. Exemple:

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

Vous comprenez qu’il peut y avoir de très nombreuses façons de créer une chaîne. Lorsqu'un objet String est créé, il est stocké dans un pool de chaînes , dont nous discuterons plus en détail dans l'une des questions ci-dessous.

59. Comment comparer deux chaînes Java et comment les trier ?

Java utilise un double signe égal ( == ) pour effectuer des comparaisons. Si nous devons comparer des valeurs simples comme des entiers, nous l'utiliserons. Mais cette méthode ne convient pas pour comparer des objets à part entière. Il comparera uniquement les références, c'est-à-dire si les références pointent vers le même objet ou non. Cela signifie que si nous comparons deux objets avec les mêmes valeurs de champ en utilisant == , nous obtiendrons false . Les champs ont les mêmes valeurs, mais les objets eux-mêmes occupent des emplacements différents en mémoire. Les objets String , malgré leur simplicité trompeuse, restent des objets. Les comparer en utilisant == n'est pas non plus approprié (malgré la présence d'un pool de chaînes). La solution appropriée est la méthode égale standard de la classe Object , qui doit être remplacée pour fonctionner correctement (par défaut, elle utilise == pour les comparaisons). La classe String la remplace, nous utilisons donc simplement son implémentation :

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

Nous avons parlé de comparaisons pour l'égalité. Nous allons maintenant trouver des comparaisons pour le tri. Après tout, si nous voulons trier quelque chose, nous devons savoir quel principe nous utiliserons pour trier. Pour ce faire, vous pouvez utiliser TreeSet , un ensemble trié standard. Cette structure de données s'appuie sur l'algorithme de l'arbre rouge-noir et trie l'ensemble selon un principe de tri spécifié. Comme je l'ai dit plus tôt, vous devez comprendre comment trier les objets d'un certain type. Pour attribuer la méthode de comparaison pour le tri, utilisez comparators . Vous devez généralement les implémenter pour les classes que vous souhaitez trier, mais dans le cas de String , elles sont déjà implémentées. En conséquence, nous ajoutons simplement nos chaînes au TreeSet , et il les triera pour nous :

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

Sortie de la console :

60. Fournir un algorithme pour convertir une chaîne en caractères. Écrivez le code correspondant

Comme je l'ai dit plus tôt, les objets String ont de nombreuses méthodes utiles différentes. L'un d'eux est toCharArray . Cette méthode convertit une chaîne en tableau de caractères :

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

Ensuite, nous avons un tableau de caractères que nous pouvons référencer par index :

char firstChar = charArr[0]; // H

61. Comment convertir une chaîne en un tableau d'octets et inversement ? Écrivez le code correspondant

La classe String possède une méthode getBytes , qui est similaire à la méthode toCharArray et renvoie la chaîne sous forme de tableau d'octets :

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

Nous sommes arrivés à la conclusion logique de notre examen aujourd’hui. Merci d'avoir lu!