Top 45+ des questions et réponses des entretiens de printemps

Préparez-vous à réussir votre prochain entretien de printemps avec ces 45+ questions et réponses essentielles. Ce didacticiel discutera des 45 questions et réponses des entretiens de printemps avec des explications et des exemples appropriés.

Envisagez-vous de poursuivre votre carrière dans Spring Framework? Êtes-vous à la recherche d'un ensemble QnA approprié pour préparer vos entretiens ? Voici un blog sur Spring Interview Questions qui traite de plus de 45 questions avec des explications et des exemples appropriés. Cela vous aidera certainement à réussir les entretiens. Mais avant de commencer avec les questions d'entrevue de Spring, jetons un coup d'œil sur la demande et le statut de Spring Framework sur le marché.

Depuis sa sortie, Spring Framework n'a cessé de fleurir sur le marché. La communauté Spring propose continuellement de nouvelles choses et s'est propagée dans un vaste écosystème. Aujourd'hui, il occupe la première place sur le marché des cadres. Consultez le graphique ci-dessous qui montre les frameworks les plus fréquemment utilisés sur le marché en janvier 2018. 

Avant d'aller plus loin, jetons un coup d'œil à certaines des questions d'entrevue de printemps les plus fréquemment posées,

Q1. Quelles sont les principales fonctionnalités des différentes versions de Spring Framework ?
Q2. Qu'est-ce qu'un framework Spring ?
Q3. Énumérez les avantages de Spring Framework
Q4. Quelles sont les différentes fonctionnalités de Spring Framework ?
Q5. Combien y a-t-il de modules dans Spring Framework et quels sont-ils ?
Q6. Qu'est-ce qu'un fichier de configuration Spring ?
Q7. Quels sont les différents composants d'une application Spring ?
Q8. Quelles sont les différentes manières d'utiliser Spring Framework ?
Q9. Qu'est-ce que le conteneur Spring IOC ?
Q10. Qu'entendez-vous par injection de dépendance ?

Questions d'entretien de printemps

Alors, voici les 45+ questions d'entrevue de printemps les plus susceptibles d'être posées par l'intervieweur. Si vous cherchez un avenir dans ce domaine, ces questions vous aideront sûrement à réussir l'entretien. Pour votre facilité d'accès, j'ai classé les questions sous quelques sujets, à savoir :

• Questions générales
• Injection de dépendance/ IoC
• Haricots de printemps
• Annotations de printemps
• Accès aux données de printemps
• AOP de printemps
• MVC de printemps

Commençons par la première section des questions d'entrevue de printemps qui sont les questions générales.

Questions générales - Questions d'entrevue de printemps

1. Quelles sont les principales fonctionnalités des différentes versions de Spring Framework ?

Version	Logo	Fonctionnalité
Printemps 2.5		Cette version est sortie en 2007. C'était la première version qui prenait en charge les annotations.
Printemps 3.0		Cette version est sortie en 2009. Elle  utilisait pleinement les améliorations de Java5 et fournissait également un support pour JEE6.
Printemps 4.0		Cette version a été publiée en 2013. Il s'agissait de la première version à fournir une prise en charge complète de Java 8.

2. Qu'est-ce qu'un framework Spring ?

• Spring est un puissant framework d'applications open source créé pour réduire la complexité du développement d'applications d'entreprise.
• Il est léger et faiblement couplé.
• Il a une architecture en couches, qui vous permet de sélectionner les composants à utiliser, tout en fournissant un cadre cohérent pour le développement d'applications J2EE.
• Le framework Spring est également appelé le framework des frameworks car il prend en charge divers autres frameworks tels que Struts, Hibernate, Tapestry, EJB, JSF, etc.

3. Énumérez les avantages de Spring Framework.

• Grâce à l'architecture en couches de Spring Frameworks, vous pouvez utiliser ce dont vous avez besoin et laisser ce dont vous n'avez pas besoin.
• Spring Framework permet la programmation POJO (Plain Old Java Object) qui à son tour permet une intégration et une testabilité continues.
• JDBC est simplifié grâce à l'injection de dépendance et à l'inversion de contrôle.
• Il est open-source et n'a pas de verrouillage du fournisseur.

4. Quelles sont les différentes fonctionnalités de Spring Framework ?

Voici quelques-unes des principales fonctionnalités de Spring Framework :

• Léger : Spring est léger en termes de taille et de transparence. 
• Inversion de contrôle (IOC) :  les objets donnent leurs dépendances au lieu de créer ou de rechercher des objets dépendants. C'est ce qu'on appelle l'inversion de contrôle.
• Programmation orientée aspect (AOP) :  la programmation orientée aspect dans Spring prend en charge le développement cohérent en séparant la logique métier de l'application des services système.
• Conteneur :  Spring Framework crée et gère le cycle de vie et la configuration des objets d'application.
• MVC Framework :  le framework d'application Web MVC de Spring Framework est hautement configurable. D'autres frameworks peuvent également être utilisés facilement à la place de Spring MVC Framework.
• Gestion des transactions : la couche d'abstraction générique pour la gestion des transactions est fournie par Spring Framework. La prise en charge des transactions de Spring peut également être utilisée dans des environnements sans conteneur.
• Gestion des exceptions JDBC : la couche d'abstraction JDBC de Spring offre une hiérarchie des exceptions, ce qui simplifie la stratégie de gestion des erreurs.

5. Combien de modules y a-t-il dans Spring Framework et quels sont-ils ?

Il y a environ 20 modules qui sont généralisés en Core Container, Data Access/Integration, Web, AOP (Aspect Oriented Programming), Instrumentation et Test.

• Spring Core Container - Cette couche est essentiellement le cœur de Spring Framework.  Il contient les modules suivants :

1. Noyau de ressort
2. Haricot de printemps
3. SpEL (langage d'expression printanier)
4. Contexte printanier 

• Accès aux données/intégration - Cette couche fournit un support pour interagir avec la base de données. Il contient les modules suivants :

1. JDBC (connectivité de base de données Java)
2. ORM (mappage relationnel objet)
3. OXM (mappeurs XML d'objets)
4. JMS (service de messagerie Java)
5. Transaction

• Web -  Cette couche fournit un support pour créer une application Web. Il contient les modules suivants :

1. la toile
2. Web – MVC
3. Web – Prise
4. Web – Portlet

• Programmation orientée aspect (AOP) - Dans cette couche, vous pouvez utiliser des conseils, des coupes de points, etc., pour découpler le code.
• Instrumentation -  Cette couche prend en charge les implémentations d'instrumentation de classe et de chargeur de classe.
• Test –  Cette couche prend en charge les tests avec JUnit et TestNG.

Quelques modules divers sont donnés ci-dessous :

• Messagerie –  Ce module prend en charge STOMP. Il prend également en charge un modèle de programmation d'annotations utilisé pour acheminer et traiter les messages STOMP des clients WebSocket.
• Aspects –  Ce module prend en charge l'intégration avec AspectJ.

6. Qu'est-ce qu'un fichier de configuration Spring ?

Un fichier de configuration Spring est un fichier XML. Ce fichier contient principalement les informations sur les classes. Il décrit comment ces classes sont configurées et présentées les unes aux autres. Les fichiers de configuration XML, cependant, sont verbeux et plus propres. Si ce n'est pas planifié et écrit correctement, cela devient très difficile à gérer dans les grands projets.

7. Quels sont les différents composants d'une application Spring ?

Une application Spring se compose généralement des composants suivants :

• Interface : Elle définit les fonctions.
• Classe Bean : elle contient des propriétés, ses méthodes setter et getter, des fonctions, etc.
• Spring Aspect Oriented Programming (AOP): Fournit la fonctionnalité des préoccupations transversales.
• Fichier de configuration du bean : Contient les informations sur les classes et comment les configurer.
• Programme utilisateur : Il utilise la fonction.

8. Quelles sont les différentes manières d'utiliser Spring Framework ?

Spring Framework peut être utilisé de différentes manières. Ils sont répertoriés comme suit :

1.  En tant qu'application Web Spring à part entière.
2. En tant que framework Web tiers, utilisant le niveau intermédiaire de Spring Frameworks.
3.  Pour une utilisation à distance. 
4. En tant qu'Enterprise Java Bean qui peut encapsuler des POJO existants (Plain Old Java Objects).

Injection de dépendance / Conteneur IoC - Questions d'entretien de printemps

9. Qu'est-ce que le conteneur Spring IOC ?

Au cœur de Spring Framework se trouve le conteneur Spring. Le conteneur crée l'objet, les relie, les configure et gère leur cycle de vie complet. Le conteneur Spring utilise Dependency Injection pour gérer les composants qui composent une application. Le conteneur reçoit des instructions pour les objets à instancier, configurer et assembler en lisant les métadonnées de configuration fournies. Ces métadonnées peuvent être fournies soit par XML, soit par des annotations Java, soit par du code Java.

10. Qu'entendez-vous par injection de dépendance ? 

Dans Dependency Injection, vous n'avez pas à créer vos objets mais devez décrire comment ils doivent être créés. Vous ne connectez pas directement vos composants et services ensemble dans le code, mais décrivez quels services sont requis par quels composants dans le fichier de configuration. Le conteneur IoC les connectera ensemble.

11. De combien de manières l'injection de dépendance peut-elle être effectuée ?

De manière générale, l'injection de dépendances peut se faire de trois manières, à savoir :

• Injection de constructeur
• Injection de poseur
• Injection d'interface

Dans Spring Framework, seules les injections de constructeur et de setter sont utilisées.

12. Différencier l'injection constructeur et l'injection setter.

Injection de constructeur vs injection de setter

13. Combien de types de conteneurs IOC existe-t-il au printemps ?

1. BeanFactory : BeanFactory est comme une classe d'usine qui contient une collection de beans. Il instancie le bean chaque fois que les clients le demandent.
2. ApplicationContext : L'interface ApplicationContext est construite au-dessus de l'interface BeanFactory. Il fournit des fonctionnalités supplémentaires sur BeanFactory.

14. Faites la différence entre BeanFactory et ApplicationContext.

BeanFactory contre ApplicationContext

15. Énumérez quelques-uns des avantages de l'IoC.

Certains des avantages de l'IoC sont :

• Cela minimisera la quantité de code dans votre application.
• Cela rendra votre application facile à tester car elle ne nécessite aucun singleton ou mécanisme de recherche JNDI dans vos cas de test unitaire.
• Il favorise un couplage lâche avec un minimum d'effort et un mécanisme le moins intrusif.
• Il prend en charge l'instanciation hâtive et le chargement paresseux des services.

16. Dans quel scénario utiliserez-vous la portée singleton et prototype ?

Utilisez Singleton Scope lorsque vous souhaitez n'avoir qu'une seule instance partagée sur l'ensemble de l'application.

Utilisez Prototype Scope lorsque vous souhaitez qu'une nouvelle instance soit créée à chaque fois qu'elle est demandée, offrant une indépendance pour chaque partie de l'application.

17. A quoi sert l'annotation @Controller ?

L'annotation @Controller est utilisée dans Spring Framework pour Java pour marquer une classe en tant que composant de contrôleur. Il fait partie de l'architecture Spring MVC (Model-View-Controller), qui est utilisée pour créer des applications Web de manière structurée et organisée.

Lorsque vous annotez une classe avec @Controller, Spring la reconnaît comme un contrôleur et lui permet de gérer les requêtes HTTP et de générer des réponses HTTP. Les contrôleurs sont chargés de traiter les demandes des utilisateurs, d'interagir avec la logique métier de l'application (services) et de renvoyer la vue appropriée pour rendre la réponse.

18. Pouvez-vous créer un contrôleur sans utiliser les annotations @Controller ou @RestController ?

Oui, vous pouvez créer un contrôleur dans Spring sans utiliser les annotations @Controller ou @RestController. Les annotations @Controller et @RestController ne sont que des annotations de commodité qui fournissent des fonctionnalités spécifiques, mais vous pouvez obtenir la même fonctionnalité en utilisant d'autres annotations ou configuration.

Pour créer un contrôleur sans utiliser @Controller ou @RestController, vous pouvez utiliser l'approche suivante :

• Implémentez la logique du contrôleur : créez une classe Java standard qui contient la logique de gestion des requêtes HTTP et de génération de réponses.
• Utiliser les annotations appropriées : au lieu de @Controller ou @RestController, vous pouvez utiliser d'autres annotations pour spécifier les mappages de requête et le type de réponse.

19. Qu'est-ce que ContextLoaderListener et que fait-il ?

Le ContextLoaderListener est un composant Spring Framework utilisé dans les applications Web Java pour charger le contexte de l'application Spring au démarrage de l'application Web. Il initialise le conteneur IoC, gère les beans et permet aux composants d'accéder aux beans Spring pour leur traitement.

20. Quelles sont les différences entre les annotations @RequestParam et @PathVariable ?

21. À quoi sert l'annotation @Autowired ?

L'annotation @Autowired dans Spring est utilisée pour câbler (injecter) automatiquement des dépendances dans un bean Spring. Il permet l'injection automatique de dépendances, ce qui signifie que Spring trouvera et injectera automatiquement les dépendances requises dans le bean sans avoir besoin d'une configuration manuelle.

22. Quel est le rôle de l'annotation @ModelAttribute ?

L'annotation @ModelAttribute dans Spring MVC est utilisée pour lier les paramètres de méthode ou les valeurs de retour de méthode aux attributs de modèle. Il joue un rôle crucial dans l'architecture Modèle-Vue-Contrôleur (MVC), où il permet de transférer des données entre le Contrôleur et la Vue.

Le rôle clé de @ModelAttribute est de faciliter le transfert de données entre le contrôleur et la vue. Il vous permet de préremplir les données de formulaire lors de l'affichage des formulaires aux utilisateurs et de lier automatiquement les entrées utilisateur aux attributs de modèle lors du traitement des soumissions de formulaire. De plus, cela aide à ajouter des attributs communs (comme des données de référence) au modèle à travers plusieurs méthodes de contrôleur.

23. Quelle est l'importance de web.xml dans Spring MVC ?

Le fichier web.xml dans Spring MVC est utilisé pour configurer le DispatcherServlet, définir les paramètres de contexte, les filtres et les écouteurs, ainsi que pour gérer les pages d'erreur. Alors que les nouvelles applications Spring reposent davantage sur une configuration basée sur des annotations, web.xml reste essentiel pour certains paramètres et la prise en charge héritée.

24. Quels sont les types d'injection de dépendance Spring MVC ?

Les trois types d'injection de dépendance dans Spring MVC sont :

• Injection de constructeur : Dans l'injection de constructeur, les dépendances sont injectées via le constructeur d'une classe. Elle est considérée comme la méthode préférée d'injection de dépendance car elle garantit que toutes les dépendances requises sont disponibles lors de la création de l'objet.
• Injection de setter : dans l'injection de setter, les dépendances sont injectées à l'aide de méthodes de setter. L'injection de setter permet des dépendances facultatives, car tous les setters n'ont pas besoin d'être appelés lors de la création de l'objet. est créé.
• Injection de champ : dans l'injection de champ, les dépendances sont injectées directement dans les champs de classe.
• C'est la méthode la moins préférée car elle contourne l'ID basée sur le constructeur ou le setter, ce qui rend plus difficile l'application des dépendances et de la testabilité requises.

25. Quelle est l'importance de la portée de la session ?

La portée de la session dans Spring est un mécanisme important pour la gestion des beans dans les applications Web. Il vous permet de créer et de maintenir une instance distincte d'un bean pour chaque session utilisateur, garantissant que les données associées à un utilisateur spécifique sont préservées tout au long de ses interactions avec l'application.

26. Quelle est l'importance de l'annotation @Required ?

L'annotation @Required était utilisée dans les versions antérieures de Spring pour indiquer qu'une propriété d'un bean doit être définie (ou câblée) avec une valeur avant que le bean puisse être entièrement initialisé. Cependant, à partir de Spring 3.0, l'annotation @Required est obsolète et n'est plus recommandée.

27. Différenciez les annotations @Autowired et @Inject.

28. Les beans singleton sont-ils thread-safe ?

Oui, les beans singleton de Spring sont thread-safe par défaut. Lorsque vous définissez un bean avec une portée singleton dans Spring, le conteneur garantit qu'une seule instance de ce bean est créée et partagée entre toutes les requêtes dans le contexte du conteneur.

29. Comment pouvez-vous assurer la sécurité des threads dans les beans ?

Oui, les beans singleton de Spring sont thread-safe par défaut. Lorsque vous définissez un bean avec une portée singleton dans Spring, le conteneur garantit qu'une seule instance de ce bean est créée et partagée entre toutes les requêtes dans le contexte du conteneur.

Les beans singleton de Spring sont thread-safe tant qu'ils sont sans état ou correctement synchronisés lorsqu'ils traitent avec un état mutable. Le conteneur Spring gère l'instanciation et la synchronisation des beans singleton pour assurer la sécurité de leur thread dans le contexte.

30. Quelle est la signification de l'annotation @Repository ?

L'annotation @Repository dans Spring est une annotation stéréotypée spécialisée qui sert de marqueur pour les classes qui remplissent le rôle d'un référentiel de données ou DAO (Data Access Object). Il est principalement utilisé pour indiquer que la classe est responsable des opérations d'accès aux données, telles que la lecture et l'écriture dans une base de données ou toute autre source de données externe.

31. Comment le servlet dispatcher est-il instancié ?

 Le DispatcherServlet est automatiquement instancié et initialisé par le conteneur Servlet lors du démarrage de l'application Web. Il agit en tant que contrôleur frontal pour les applications Spring MVC, gérant l'ensemble du cycle de vie requête-réponse et déléguant le traitement aux composants appropriés dans le contexte de l'application Spring.

32. Comment le contexte d'application racine dans Spring MVC est-il chargé ?

Le contexte d'application racine dans Spring MVC est chargé automatiquement lors du démarrage de l'application Web par ContextLoaderListener. Il gère la configuration globale et la gestion des beans pour l'application, tandis que le DispatcherServlet gère les composants spécifiques au Web et la gestion des demandes.

33. À quoi ressemble le flux Spring MVC ? En d'autres termes, comment un DispatcherServlet sait-il quel contrôleur doit être appelé lorsqu'il y a une demande entrante au Spring MVC ?

Le flux Spring MVC implique plusieurs composants travaillant ensemble pour gérer les demandes entrantes et les acheminer vers les contrôleurs appropriés pour traitement.

Le DispatcherServlet joue un rôle central dans le flux Spring MVC. Il reçoit les demandes entrantes, sélectionne le contrôleur approprié en fonction du mappage d'URL, appelle la méthode du contrôleur pour gérer la demande, prépare les données et la vue du modèle, résout la vue et renvoie enfin la réponse au client. Le flux est orchestré via une combinaison de mappages de gestionnaires, de contrôleurs, de résolveurs de vues et de vues, permettant à Spring MVC de gérer divers types de requêtes et de produire des réponses dynamiques.

34. D'où vient l'accès au modèle depuis la vue ?

Dans Spring MVC, l'objet Model agit comme un conteneur pour transmettre les données du contrôleur à la vue pour le rendu. Le modèle est automatiquement mis à la disposition de la vue par le DispatcherServlet, et la vue peut accéder aux données à l'aide d'un langage d'expression ou d'une syntaxe spécifique au modèle. Cela permet de séparer les problèmes de traitement et de présentation des données dans l'application.

35. Pourquoi avons-nous besoin de BindingResults ?

BindingResult est utilisé dans Spring MVC pour la liaison et la validation des données. Il capture les erreurs lors de la soumission du formulaire, aide à prévenir les exceptions et vous permet de gérer les erreurs avec élégance en affichant des messages d'erreur à l'utilisateur.

36. Que sont les Spring Interceptors ?

Les intercepteurs Spring sont des composants du framework Spring MVC qui vous permettent d'intercepter et de traiter les requêtes et les réponses HTTP. Ils fournissent un moyen d'effectuer des tâches de prétraitement et de post-traitement avant et après que la demande réelle soit traitée par un contrôleur ou après la génération de la réponse.

37. Est-il nécessaire de garderspring-mvc.jar sur le chemin de classe ou est-il déjà présent dans le cadre de Spring-core

Le fichier spring-mvc.jar ne fait pas partie de la bibliothèque spring-core et sert à des fins différentes.

• spring-core : il s'agit du framework Spring de base, qui fournit des éléments fondamentaux du framework, tels que l'injection de dépendances et l'inversion de contrôle.
• spring-webmvc : il s'agit du framework Spring MVC (généralement nommé spring-webmvc.jar et non spring-mvc.jar), qui est construit au-dessus du framework Spring principal et fournit l'architecture Model-View-Controller (MVC) pour la construction des applications Web.

Ainsi, si vous créez une application à l'aide du framework Spring MVC, vous aurez besoin à la fois de spring-core et de spring-webmvc sur votre chemin de classe. Ces bibliothèques sont généralement gérées par un outil de construction comme Maven ou Gradle, et sont automatiquement incluses lorsque vous les spécifiez en tant que dépendances dans votre fichier de construction.

38. Qu'est-ce que le modèle dans Spring MVC ?

Dans le contexte de Spring MVC, le terme "Modèle" représente la couche de données. C'est une carte (similaire à un java.util.Map) qui contient des données à rendre par la vue. Ces données sont généralement le résultat de l'exécution de votre logique métier, que vous souhaitez montrer à l'utilisateur.

39. Quelles sont les différences entre les balises <context:annotation-config> et <context:component-scan> ?

• <context:annotation-config> : Ceci est utilisé pour activer diverses annotations dans les beans gérés par Spring. Par exemple, si vous avez des beans qui sont définis manuellement dans votre fichier XML et que ces beans ont des annotations comme @Autowired, @PostConstruct, @PreDestroy, @Resource, etc., vous avez besoin de <context:annotation-config> pour activer ces annotations. Cependant, il ne détecte pas et n'instancie pas automatiquement les beans à partir du classpath.
• <context:component-scan> : cette balise fait tout ce que fait <context:annotation-config>, mais elle va encore plus loin. Il analyse le chemin de classe pour les classes annotées avec @Component, @Service, @Repository, @Controller, etc., et les enregistre automatiquement en tant que beans dans le contexte de l'application Spring. En d'autres termes, il détecte et instancie automatiquement vos beans. Ainsi, lorsque vous utilisez <context:component-scan>, vous n'avez pas besoin de définir explicitement chaque bean dans votre fichier de configuration XML, tant qu'ils sont annotés correctement et existent dans le package de base spécifié par <context:component- numériser>.

40. Comment la validation des données de formulaire est-elle effectuée dans Spring Web MVC Framework ?

La validation des données de formulaire dans Spring Web MVC Framework est effectuée par :

• Définition des règles de validation : utilisez les annotations de l'API de validation de bean (JSR-303) telles que @NotNull, @Size, @Min, @Max, etc., sur les champs de votre modèle pour définir les règles de validation.
• Activation de la validation : dans votre contrôleur, annotez l'attribut de modèle avec @Valid lors de la gestion de la soumission du formulaire. Cela déclenche le processus de validation.
• Gestion des erreurs de validation : Spring MVC valide les données du formulaire et toutes les erreurs sont placées dans un objet BindingResult. Vous pouvez rechercher des erreurs dans cet objet et les gérer en conséquence, généralement en renvoyant l'utilisateur au formulaire avec des messages d'erreur.
• Affichage des erreurs : dans votre vue (par exemple, Thymeleaf ou JSP), affichez tous les messages d'erreur de validation du BindingResult à l'utilisateur.

41. Comment obtenir les objets ServletConfig et ServletContext dans le bean spring ?

Dans une application Spring, vous pouvez accéder aux objets ServletConfig et ServletContext en implémentant les interfaces ServletContextAware et ServletConfigAware. Ces interfaces fournissent des méthodes setter que Spring utilisera pour injecter les objets nécessaires.

42. Différencier une fabrique de haricots et un contexte d'application.

Fabrique de haricots

• BeanFactory est l'interface racine pour accéder à un conteneur de bean Spring. Il fournit des fonctionnalités de base d'inversion de contrôle (IoC) et d'injection de dépendance (DI).
• BeanFactory est lancé paresseux, ce qui signifie qu'il ne crée un bean que lorsque vous appelez la méthode getBean().
• Il prend en charge l'instanciation/le câblage de bean et vous permet de lire les définitions de bean et d'y accéder à l'aide de la méthode getBean().
• BeanFactory est plus léger et a moins de fonctionnalités que ApplicationContext.

ApplicationContextApplicationContext

• ApplicationContext étend l'interface BeanFactory et possède toutes les fonctionnalités de BeanFactory. Il ajoute des fonctionnalités plus spécifiques à l'entreprise.
• Il fournit des fonctionnalités supplémentaires telles qu'une intégration plus facile avec les fonctionnalités AOP de Spring, la gestion des ressources de message (pour une utilisation dans l'internationalisation), la propagation des événements et des contextes spécifiques à la couche application tels que WebApplicationContext pour les applications Web.
• Les beans dans ApplicationContext sont des singletons et sont lancés au moment du chargement du contexte, pas lorsque getBean() est appelé.
• Il prend en charge l'internationalisation des messages texte, la propagation des événements et divers contextes.
• ApplicationContext fournit également un moyen de résoudre les messages texte, ce qui est une fonctionnalité utile pour l'internationalisation.

43. Comment i18n et la localisation sont-ils pris en charge dans Spring MVC ?

L'internationalisation (i18n) et la localisation (L10n) sont des fonctionnalités importantes pour les applications qui doivent prendre en charge plusieurs langues ou paramètres régionaux. Dans Spring MVC, ceux-ci sont pris en charge à l'aide d'une combinaison de fichiers de propriétés LocaleResolver, LocaleChangeInterceptor et de source de message.

44. Qu'entendez-vous par MultipartResolver ?

MultipartResolver est une interface définie dans le framework Spring MVC qui est utilisée pour télécharger des fichiers. Lorsqu'un formulaire dans une application Web Spring est soumis et qu'il a enctype="multipart/form-data", l'implémentation de MultipartResolver gère la partie de téléchargement de fichier de la demande.

Le MultipartResolver fait partie de la configuration de Spring DispatcherServlet, vous le définirez donc dans votre configuration Spring. 

45. Comment est-il possible d'utiliser le Tomcat JNDI DataSource dans les applications Spring ?

Pour utiliser un Tomcat JNDI DataSource dans une application Spring :

• Configuration de la source de données dans Tomcat : configurez la source de données dans le fichier context.xml de Tomcat avec les paramètres nécessaires (nom d'utilisateur, mot de passe, driverClassName, etc.).
• Configurez DataSource dans Spring : utilisez <jee:jndi-lookup> dans la configuration XML ou JndiDataSourceLookup dans la configuration Java pour indiquer à Spring de rechercher la source de données à partir de JNDI.
• Le DataSource peut ensuite être injecté dans vos beans Spring là où il est nécessaire

Passons à la section suivante des questions d'entrevue de printemps, c'est-à-dire les questions d'entrevue de Spring Beans .

Haricots de printemps - Questions d'entrevue de printemps

16. Expliquez les haricots de printemps ?

• Ce sont les objets qui forment l'épine dorsale de l'application de l'utilisateur.
• Les beans sont gérés par le conteneur Spring IoC.
• Ils sont instanciés, configurés, câblés et gérés par un conteneur Spring IoC
• Les beans sont créés avec les métadonnées de configuration que les utilisateurs fournissent au conteneur.

17. Comment les métadonnées de configuration sont-elles fournies au conteneur Spring ?

Les métadonnées de configuration peuvent être fournies au conteneur Spring des manières suivantes :

• Configuration basée sur XML :  dans Spring Framework, les dépendances et les services requis par les beans sont spécifiés dans des fichiers de configuration au format XML. Ces fichiers de configuration contiennent généralement de nombreuses définitions de bean et des options de configuration spécifiques à l'application. Ils commencent généralement par une étiquette de haricot. Par exemple:

<bean id="studentbean" class="org.edureka.firstSpring.StudentBean">
 <property name="name" value="Edureka"></property>
</bean>

• Configuration basée sur les annotations : au lieu d'utiliser XML pour décrire le câblage d'un bean, vous pouvez configurer le bean dans la classe de composant elle-même en utilisant des annotations sur la classe, la méthode ou la déclaration de champ appropriée. Par défaut, le câblage des annotations n'est pas activé dans le conteneur Spring. Vous devez donc l'activer dans votre fichier de configuration Spring avant de l'utiliser. Par exemple:

<beans>
<context:annotation-config/>
<!-- bean definitions go here -->
</beans>

• Configuration basée sur Java :  les fonctionnalités clés de la nouvelle prise en charge de la configuration Java de Spring Framework sont les classes annotées @Configuration et les méthodes annotées @Bean. 

1. L'annotation @Bean joue le même rôle que l'élément <bean/>. 

2. Les classes @Configuration permettent de définir des dépendances inter-bean en appelant simplement d'autres méthodes @Bean dans la même classe.

@Configuration
public class StudentConfig 
{ 
@Bean
public StudentBean myStudent() 
{ return new StudentBean(); }
}

18. Combien de portées de bean sont prises en charge par Spring ?

Spring Framework prend en charge cinq portées. Ils sont:

• Singleton :  cela fournit une portée pour la définition du bean à une seule instance par conteneur Spring IoC.
• Prototype :  cela permet à une seule définition de bean d'avoir un nombre quelconque d'instances d'objet.
• Requête :  Cela fournit une portée pour une définition de bean à une requête HTTP. 
• Session :  Cela fournit une portée pour une définition de bean à une session HTTP. 
• Global-session :  cela fournit une portée pour une définition de bean à une session HTTP globale. 

Les trois derniers ne sont disponibles que si les utilisateurs utilisent un ApplicationContext compatible Web.

19. Quel est le cycle de vie du haricot dans le conteneur Spring Bean Factory ?

Le cycle de vie du haricot dans le conteneur Spring Bean Factory est le suivant :

1. Le conteneur Spring instancie le bean à partir de la définition du bean dans le fichier XML.
2. Spring remplit toutes les propriétés à l'aide de l'injection de dépendance, comme spécifié dans la définition du bean.
3. La fabrique appelle setBeanName() en transmettant l'ID du bean, si le bean implémente l'interface BeanNameAware.
4. La fabrique appelle setBeanFactory() en transmettant une instance d'elle-même, si le bean implémente l'interface BeanFactoryAware.
5. Les méthodes preProcessBeforeInitialization() sont appelées s'il y a des BeanPostProcessors associés au bean.
6. Si une méthode d'initialisation est spécifiée pour le bean, elle sera appelée.
7. Enfin, les méthodes postProcessAfterInitialization() seront appelées s'il y a des BeanPostProcessors associés au bean.

Pour mieux le comprendre, consultez le schéma ci-dessous :

20. Expliquez les haricots internes au printemps.

Un bean ne peut être déclaré comme bean interne que lorsqu'il est utilisé comme propriété d'un autre bean. Pour définir un bean, les métadonnées de configuration basées sur XML de Spring fournissent l'utilisation de l'élément <bean> à l'intérieur de la <property> ou <constructor-arg>. Les haricots internes sont toujours anonymes et ils sont toujours considérés comme des prototypes. Par exemple, supposons que nous ayons une classe Student ayant pour référence la classe Person. Ici, nous allons créer une seule instance de la classe Person et l'utiliser dans Student.

Voici une classe Student suivie d'un fichier de configuration de bean :

Etudiant.java

public class Student
{
private Person person;
//Setters and Getters
}
public class Person
{
private String name;
private String address;
//Setters and Getters
}

étudiantbean.xml

<bean id=“StudentBean" class="com.edureka.Student">
<property name="person">
<!--This is inner bean -->
<bean class="com.edureka.Person">
<property name="name" value=“Scott"></property>
<property name="address" value=“Bangalore"></property>
</bean>
</property>
</bean>

21. Définir le câblage du bean.

Lorsque les beans sont combinés dans le conteneur Spring, cela s'appelle le câblage ou le câblage de bean. Le conteneur Spring doit savoir quels beans sont nécessaires et comment le conteneur doit utiliser l'injection de dépendances pour lier les beans ensemble, tout en câblant les beans.

22. Qu'entendez-vous par câblage automatique et nommez-en les différents modes ?

Le conteneur Spring est capable de créer automatiquement des relations entre les beans collaborant. Autrement dit, il est possible de laisser Spring résoudre automatiquement les collaborateurs de votre bean en inspectant le contenu de la BeanFactory.
Les différents modes de câblage automatique du bean sont :

1. non :  il s'agit du paramètre par défaut, ce qui signifie qu'il n'y a pas de câblage automatique. Une référence de bean explicite doit être utilisée pour le câblage.
2. byName :  il injecte la dépendance de l'objet en fonction du nom du bean. Il fait correspondre et connecte ses propriétés avec les beans définis par les mêmes noms dans le fichier XML.
3. byType : il injecte la dépendance de l'objet en fonction du type. Il correspond et connecte une propriété si son type correspond exactement à l'un des noms de beans dans le fichier XML.
4. constructeur : Il injecte la dépendance en appelant le constructeur de la classe. Il a un grand nombre de paramètres.
5. autodetect : le conteneur essaie d'abord de se connecter en utilisant autowire by constructor , s'il ne le peut pas, il essaie de se connecter automatiquement by byType .

23. Quelles sont les limites du câblage automatique ?

Voici quelques-unes des limitations auxquelles vous pourriez être confronté avec le câblage automatique :

• Possibilité de remplacement :  vous pouvez toujours spécifier des dépendances à l'aide des paramètres <constructor-arg> et <property> qui remplaceront le câblage automatique.
•  Type de données primitif : les propriétés simples telles que les primitives, les chaînes et les classes ne peuvent pas être câblées automatiquement.
• Nature déroutante : Préférez toujours utiliser un câblage explicite car le câblage automatique est moins précis.

Dans la section suivante, nous discuterons des questions d'entrevue sur les annotations de printemps .

Annotations de printemps - Questions d'entrevue de printemps

24. Qu'entendez-vous par configuration de conteneur basée sur les annotations ?

Au lieu d'utiliser XML pour décrire un câblage de bean, le développeur déplace la configuration dans la classe de composant elle-même en utilisant des annotations sur la classe, la méthode ou la déclaration de champ appropriée. Il agit comme une alternative aux configurations XML. Par exemple:

@Configuration
public class AnnotationConfig
{
@Bean
public MyDemo myDemo()
 { return new MyDemoImpll(); }
}

25. Comment le câblage des annotations peut-il être activé dans Spring ?

Par défaut, le câblage d'annotation n'est pas activé dans le conteneur Spring. Ainsi, pour utiliser le câblage basé sur les annotations, nous devons l'activer dans notre fichier de configuration Spring en configurant l'  élément <context:annotation-config/>  . Par exemple:

<beans xmlns="<a href="http://www.springframework.org/schema/beans">http://www.springframework.org/schema/beans</a>" xmlns:xsi="<a href="http://www.w3.org/2001/XMLSchema-instance">http://www.w3.org/2001/XMLSchema-instance</a>" xmlns:context="<a href="http://www.springframework.org/schema/context">http://www.springframework.org/schema/context</a>">
<context:annotation-config/>
<beans ………… />
</beans>

26. Quelle est la différence entre les annotations @Component, @Controller, @Repository & @Service dans Spring ?

• @Component :  Cela marque une classe Java comme un bean. Il s'agit d'un stéréotype générique pour tout composant géré par Spring. Le mécanisme d'analyse des composants de Spring peut désormais le récupérer et l'insérer dans le contexte de l'application.
• @Controller : Cela marque une classe en tant que contrôleur Spring Web MVC. Les beans marqués ainsi sont automatiquement importés dans le conteneur d'injection de dépendance.
• @Service : cette annotation est une spécialisation de l'annotation de composant. Il ne fournit aucun comportement supplémentaire sur l'annotation @Component. Vous pouvez utiliser @Service sur @Component dans les classes de couche de service car il spécifie mieux l'intention.
• @Repository :  cette annotation est une spécialisation de l'annotation @Component avec une utilisation et des fonctionnalités similaires. Il offre des avantages supplémentaires spécifiquement pour les DAO. Il importe les DAO dans le conteneur DI et  rend les exceptions non contrôlées éligibles pour la traduction dans Spring DataAccessException.

27. Qu'entendez-vous par annotation @Required ?

@Required est appliqué aux méthodes de définition de propriétés de bean. Cette annotation indique simplement que la propriété de bean affectée doit être renseignée au moment de la configuration à l'aide d'une valeur de propriété explicite dans une définition de bean ou avec le câblage automatique. Si la propriété de bean affectée n'a pas été renseignée, le conteneur lancera BeanInitializationException.

Par exemple:

public class Employee
{
private String name;
@Required
public void setName(String name)
{this.name=name; }
public string getName()
{ return name; }
}

28. Qu'entendez-vous par annotation @Autowired ?

L'  annotation @Autowired  fournit un contrôle plus précis sur où et comment le câblage automatique doit être effectué. Cette annotation est utilisée pour câbler automatiquement le bean sur les méthodes setter, le constructeur, une propriété ou des méthodes avec des noms arbitraires ou plusieurs arguments. Par défaut, il s'agit d'une injection pilotée par type.

Par exemple:

public class Employee
{
private String name;
@Autowired
public void setName(String name)
{this.name=name; }
public string getName()
{ return name; }
}

29. Qu'entendez-vous par annotation @Qualifier ?

Lorsque vous créez plus d'un bean du même type et que vous souhaitez lier un seul d'entre eux avec une propriété, vous pouvez utiliser l'  annotation @Qualifier  avec  @Autowired  pour lever l'ambiguïté en spécifiant quel bean exact doit être câblé.

Par exemple, nous avons ici deux classes, respectivement Employee et EmpAccount. Dans EmpAccount, en utilisant @Qualifier, il est spécifié que le bean avec l'id emp1 doit être câblé.

Employé.java

public class Employee
{
private String name;
@Autowired
public void setName(String name)
{ this.name=name; }
public string getName()
{ return name; }
}

EmpAccount.java

public class EmpAccount
{
private Employee emp;
@Autowired
@Qualifier(emp1)
public void showName()
{
System.out.println(“Employee name : ”+emp.getName);
}
}

30. Qu'entendez-vous par annotation @RequestMapping ?

L'annotation @RequestMapping est utilisée pour mapper une méthode de requête HTTP particulière à une classe/méthode spécifique dans le contrôleur qui traitera la requête respective. Cette annotation peut être appliquée aux deux niveaux :

• Niveau de classe : mappe l'URL de la requête
• Niveau méthode : mappe l'URL ainsi que la méthode de requête HTTP

La section suivante des questions d'entrevue du printemps porte sur l'accès aux données .

Accès aux données - Questions d'entrevue de printemps

31. Décrivez la prise en charge de Spring DAO ?

La prise en charge des objets d'accès aux données (DAO) dans Spring facilite l'utilisation cohérente des technologies d'accès aux données telles que JDBC, Hibernate ou JDO. Cela permet de basculer facilement entre les technologies de persistance. Il vous permet également de coder sans vous soucier d'attraper les exceptions spécifiques à chacune de ces technologies.

32. Nommez les exceptions levées par les classes Spring DAO.

Voir le diagramme ci-dessous, il décrit toutes les classes Spring DAO dans l'ordre hiérarchique.

33. Quelles classes sont présentes dans l'API Spring JDBC ?

Les classes présentes dans l'API JDBC sont les suivantes :

1. JdbcTemplate
2. SimpleJdbcTemplate
3. NamedParameterJdbcTemplateNamedParameterJdbcTemplate
4. SimpleJdbcInsert
5. AppelJdbcSimple

34. Quels sont les moyens d'accéder à Hibernate avec Spring ?

Il existe deux façons d'accéder à Hibernate en utilisant Spring :

1. Inversion du contrôle avec un modèle Hibernate et un rappel
2. Extension de HibernateDAOSupport et application d'un nœud AOP Interceptor

35. Nommez les types de gestion des transactions pris en charge par Spring.

Deux types de gestion des transactions sont pris en charge par Spring. Ils sont:

1. Gestion programmatique des transactions : dans ce cas, la transaction est gérée à l'aide de la programmation. Il vous offre une flexibilité extrême, mais il est très difficile à entretenir.
2. Gestion déclarative des transactions : Dans celle-ci, la gestion des transactions est séparée du code métier. Seules des annotations ou des configurations basées sur XML sont utilisées pour gérer les transactions.

36. Quels sont les différents ORM pris en charge par Spring ?

Différents ORM pris en charge par Spring sont représentés via le diagramme ci-dessous :

Programmation orientée aspect (AOP) - Questions d'entrevue de printemps

37. Décrire l'AOP.

La programmation orientée aspect ou AOP est une technique de programmation qui permet aux programmeurs de modulariser les préoccupations ou les comportements transversaux qui traversent les divisions de responsabilité typiques. Des exemples de préoccupations transversales peuvent être la journalisation et la gestion des transactions. Le cœur de l'AOP est un  aspect . Il encapsule les comportements qui peuvent affecter plusieurs classes dans des modules réutilisables.

38. Qu'entendez-vous par Aspect ?

Aspect est une modularisation de l'inquiétude qui traverse plusieurs objets. La gestion des transactions est un bon exemple de préoccupation transversale dans les applications J2EE. Les aspects sont implémentés à l'aide de classes régulières ou de classes régulières annotées avec l'annotation @Aspect dans Spring Framework.

39. Expliquez JoinPoint.

Un point lors de l'exécution d'un programme est appelé JoinPoint, comme l'exécution d'une méthode ou la gestion d'une exception. Dans Spring AOP, un point de jonction représente toujours l'exécution d'une méthode.

40. Qu'est-ce qu'un conseil ?

Une action entreprise par un aspect à un point de jonction particulier est connue sous le nom de conseil. Spring AOP utilise un conseil comme intercepteur, maintenant une chaîne d'intercepteurs "autour" du point de jonction.

41. Quels sont les différents types d'avis ?

Les différents types d'avis dans Spring AOP sont :

1. Avant :  ces types de conseils s'exécutent avant les méthodes de point de jonction et sont configurés à l'aide de  la marque d'annotation @Before  .
2. Après le retour :  ces types de conseils s'exécutent après l'exécution normale des méthodes de point de jonction et sont configurés à l'aide de la marque d'annotation @AfterReturning.
3. After throwing :   ces types de conseils s'exécutent uniquement si la méthode joinpoint se termine en levant une exception et sont configurés à l'aide de la marque d'annotation @AfterThrowing.
4. Après (enfin) : ces types de conseils s'exécutent après une méthode de point de jonction, quelle que soit la sortie de la méthode, qu'il s'agisse d'un retour normal ou exceptionnel, et sont configurés à l'aide de la marque d'annotation @After.
5. Autour :  ces types de conseils s'exécutent avant et après un point de jonction et sont configurés à l'aide de la marque d'annotation @Around.

42. Soulignez la différence entre préoccupation et préoccupation transversale dans Spring AOP ?

Le problème est le comportement que nous voulons avoir dans un module particulier d'une application. Cela peut être défini comme une fonctionnalité que nous voulons implémenter. 

La préoccupation transversale est une préoccupation qui s'applique à l'ensemble de la demande. Cela affecte l'ensemble de l'application. Par exemple, la journalisation, la sécurité et le transfert de données sont les préoccupations nécessaires dans presque tous les modules d'une application, ce sont donc des préoccupations transversales.

43. Quelles sont les différentes implémentations AOP ?

Différentes implémentations AOP sont représentées par le schéma ci-dessous :

44. Quelle est la différence entre Spring AOP et AspectJ AOP ?

Spring AOP vs AspectJ AOP

45. Qu'entendez-vous par Proxy dans Spring Framework ?

Un objet créé après l'application de conseils à un objet cible est appelé proxy. Dans le cas d'objets client, l'objet cible et l'objet proxy sont identiques.

46. ​​Au printemps, qu'est-ce que le tissage ?

Le processus de liaison d'un aspect avec d'autres types d'application ou d'objets pour créer un objet conseillé s'appelle le tissage. Dans Spring AOP, le tissage est effectué à l'exécution. Reportez-vous au schéma ci-dessous :

MVC (Modèle-Vue-Contrôleur) – Questions d'entretien de printemps

47. Qu'entendez-vous par framework Spring MVC ?

Le framework Spring Web MVC fournit une architecture modèle-vue-contrôleur et des composants prêts à l'emploi qui sont utilisés pour développer des applications Web flexibles et faiblement couplées. Le modèle MVC aide à séparer les différents aspects de l'application comme la logique d'entrée, la logique métier et la logique de l'interface utilisateur, tout en fournissant un couplage lâche entre tous ces éléments. 

48. Décrire DispatcherServlet.

Le DispatcherServlet est le cœur du framework Spring Web MVC. Il gère toutes les requêtes et réponses HTTP. Le DispatcherServlet reçoit l'entrée du mappage du gestionnaire à partir du fichier de configuration et transmet la demande au contrôleur. Le contrôleur renvoie ensuite un objet de Model And View. Le DispatcherServlet vérifie l'entrée du résolveur de vue dans le fichier de configuration et appelle le composant de vue spécifié.

49. Expliquez WebApplicationContext.

Le WebApplicationContext est une extension du simple ApplicationContext. Il a quelques fonctionnalités supplémentaires qui sont nécessaires pour les applications Web. Il diffère d'un ApplicationContext normal en termes de capacité à résoudre des thèmes et à décider à quel servlet il est associé.

50. Dans le framework Spring MVC, qu'est-ce que le contrôleur ?

Les contrôleurs permettent d'accéder au comportement de l'application. Ces comportements sont généralement définis via une interface de service. Les contrôleurs interprètent l'entrée de l'utilisateur et la transforment en un modèle qui est représenté à l'utilisateur par la vue. Dans Spring, le contrôleur est implémenté de manière très abstraite. Il vous permet également de créer une grande variété de contrôleurs.

J'espère que cet ensemble de questions et réponses d'entrevue de printemps vous aidera à préparer vos entrevues. Tous mes vœux!

#spring #springboot #springframework #java