Questions et réponses d’entretien Spring

Tutoriels
Spring

I have posted a lot of Spring Tutorials recently. This post will help you get through Spring interview Questions explaining the core concepts in detail.

Spring Framework est l’un des frameworks Java EE les plus populaires pour les applications web. Injection de dépendances et la programmation orientée aspect sont au cœur du framework Spring. Si vous maîtrisez le framework Spring, les chances d’être sélectionné augmentent considérablement lors des entretiens Java.

Conseil professionnel: Core Java est la base de tout framework basé sur Java, donc si vous vous préparez pour des entretiens, parcourez les articles sur les Questions d’entretien Core Java et les Questions d’entretien Java.

Questions et réponses d’entretien Spring

Je fournis ici près de 50 questions d’entretien Spring et leurs réponses. C’est mis à jour jusqu’à Spring 5, donc cela couvre toutes les dernières fonctionnalités telles que Spring WebFlux pour la programmation réactive.

1. Qu’est-ce que le Framework Spring?

Spring est l’un des frameworks Java EE les plus largement utilisés. Les concepts fondamentaux du framework Spring sont « Injection de dépendances » et « Programmation orientée aspect ».

Le framework Spring peut également être utilisé dans des applications Java normales pour réaliser un couplage lâche entre différents composants en implémentant l’injection de dépendances. Nous pouvons effectuer des tâches transversales telles que le journalisation et l’authentification en utilisant le support de Spring pour la programmation orientée aspect.

I like spring because it provides a lot of features and different modules for specific tasks such as Spring MVC and Spring JDBC. Since it’s an open-source framework with a lot of online resources and active community members, working with the Spring framework is easy and fun at the same time.

Lecture recommandée: Framework Spring

2. Quelles sont certaines des caractéristiques importantes du Framework Spring?

Le Framework Spring est construit sur deux concepts de conception – l’injection de dépendances et la programmation orientée aspect.

Certaines des fonctionnalités du framework Spring sont :

  • Léger et très peu de surcharge lors de l’utilisation d’un framework pour notre développement.
  • Injection de dépendances ou inversion de contrôle pour écrire des composants indépendants les uns des autres, le conteneur Spring se charge de les connecter pour réaliser notre travail.
  • Le conteneur Spring IoC gère le cycle de vie des beans Spring et les configurations spécifiques au projet telles que la recherche JNDI.
  • Le framework Spring MVC peut être utilisé pour créer des applications web ainsi que des services web RESTful capables de renvoyer des réponses XML et JSON.
  • Il prend en charge la gestion des transactions, les opérations JDBC, le téléchargement de fichiers, la gestion des exceptions, etc., avec très peu de configurations, soit en utilisant des annotations, soit en utilisant un fichier de configuration de beans Spring.

3. Quel est l’avantage d’utiliser le framework Spring ?

Certains des avantages d’utiliser le framework Spring sont les suivants :

  • Réduction des dépendances directes entre les différents composants de l’application. Le conteneur Spring IoC est responsable de l’initialisation des ressources ou des beans et de leur injection en tant que dépendances.
  • Il est facile d’écrire des cas de test unitaires dans le framework Spring car notre logique métier n’a pas de dépendances directes avec les classes d’implémentation réelles des ressources. Nous pouvons facilement écrire une configuration de test et injecter nos beans de simulation à des fins de test.
  • Réduction de la quantité de code redondant, tel que l’initialisation des objets, l’ouverture/fermeture des ressources. J’aime beaucoup la classe JdbcTemplate car elle nous aide à supprimer tout le code redondant lié à la programmation JDBC.
  • Le framework Spring est divisé en plusieurs modules, ce qui nous aide à maintenir notre application légère. Par exemple, si nous n’avons pas besoin des fonctionnalités de gestion de transactions de Spring, nous n’avons pas besoin d’ajouter cette dépendance à notre projet.
  • Le framework Spring prend en charge la plupart des fonctionnalités de Java EE et même bien plus. Il est toujours à la pointe des nouvelles technologies. Par exemple, il existe un projet Spring pour Android qui nous aide à écrire un meilleur code pour les applications Android natives. Cela fait du framework Spring un package complet et nous n’avons pas besoin de rechercher différents frameworks pour différents besoins.

4. Quelles sont les caractéristiques importantes de Spring 5 ?

Spring 5 est une refonte majeure de Spring 4. Certaines des caractéristiques importantes sont :

  • Prise en charge de Java 8 et des versions supérieures, ce qui nous permet d’utiliser des expressions lambda.
  • Prise en charge de Java EE7 et des spécifications Servlet 4.0.
  • Les opérations sur les fichiers sont désormais effectuées via les flux NIO 2, une énorme amélioration si votre application effectue beaucoup de manipulations de fichiers.
  • Introduction de spring-jcl pour rationaliser la journalisation, auparavant c’était un chaos en raison de l’absence d’un point unique à des fins de journalisation.
  • Prise en charge de Kotlin, Lombok, Reactor 3.1 Flux, et Mono ainsi que RxJava.
  • Spring WebFlux qui introduit la programmation réactive dans Spring.
  • Prise en charge de JUnit 5
  • Prise en charge de la fourniture d’informations sur les composants Spring via le fichier d’index « META-INF/spring.components » plutôt que par analyse du classpath.

Veuillez consulter les fonctionnalités de Spring 5 pour avoir un aperçu détaillé de cette version.

5. Qu’est-ce que Spring WebFlux ?

Spring WebFlux est le nouveau module introduit dans Spring 5. Spring WebFlux est le premier pas vers le modèle de programmation réactif dans le framework Spring.

Spring WebFlux est une alternative au module Spring MVC. Spring WebFlux est utilisé pour créer une application entièrement asynchrone et non bloquante basée sur le modèle d’exécution de la boucle d’événements.

Vous pouvez en savoir plus à ce sujet sur Tutoriel Spring WebFlux.

6. Que comprenez-vous par Injection de dépendances ?

Le modèle de conception de l’injection de dépendances nous permet de supprimer les dépendances codées en dur et de rendre notre application faiblement couplée, extensible et maintenable. Nous pouvons implémenter le modèle d’injection de dépendances pour déplacer la résolution des dépendances de la compilation à l’exécution.

Certains des avantages de l’utilisation de l’injection de dépendance sont la séparation des préoccupations, la réduction du code boilerplate, la configuration des composants et les tests unitaires faciles.

En savoir plus sur Tutoriel sur l’injection de dépendance. Nous pouvons également utiliser Google Guice pour l’injection de dépendance afin d’automatiser le processus d’injection de dépendance. Mais dans la plupart des cas, nous recherchons plus que simplement l’injection de dépendance et c’est là que Spring se démarque.

7. Comment implémenter l’ID dans le framework Spring?

Nous pouvons utiliser la configuration basée sur XML et la configuration basée sur les annotations pour mettre en œuvre l’ID dans les applications Spring. Pour une meilleure compréhension, veuillez lire l’exemple Injection de dépendance avec Spring où vous pouvez apprendre les deux méthodes avec un cas de test JUnit. L’article contient également un fichier projet d’exemple que vous pouvez télécharger et expérimenter pour en savoir plus.

8. Quels sont les avantages d’utiliser Spring Tool Suite?

Nous pouvons installer des plugins dans Eclipse pour obtenir toutes les fonctionnalités de Spring Tool Suite. Cependant, STS est livré avec Eclipse avec d’autres éléments importants tels que le support Maven, des modèles pour créer différents types de projets Spring et tc server pour de meilleures performances avec les applications Spring.

I like STS because it highlights the Spring components and if you are using AOP pointcuts and advice, then it clearly shows which methods will come under the specific pointcut. So rather than installing everything on our own, I prefer using STS when developing Spring-based applications.

9. Nommez quelques-uns des modules importants de Spring?

Quelques-uns des modules importants du framework Spring sont :

  • Spring Context – pour l’injection de dépendances.
  • Spring AOP – pour la programmation orientée aspect.
  • Spring DAO – pour les opérations de base de données utilisant le modèle DAO
  • Spring JDBC – pour le support JDBC et DataSource.
  • Spring ORM – pour le support des outils ORM tels que Hibernate
  • Module Spring Web – pour la création d’applications web.
  • Spring MVC – Mise en œuvre du modèle-vue-contrôleur pour la création d’applications web, de services web, etc.

10. Qu’entendez-vous par Programmation Orientée Aspect (AOP)?

Les applications d’entreprise ont certains préoccupations transversales communes qui sont applicables à différents types d’objets et de modules d’application, telles que la journalisation, la gestion des transactions, la validation des données, l’authentification, etc. La modularité de l’application est réalisée par des classes en programmation orientée objet. En AOP, la modularité de l’application est réalisée par des Aspects et ils sont configurés pour traverser différentes méthodes de classe.

L’AOP élimine la dépendance directe des tâches transversales des classes qui ne sont pas possibles dans la programmation orientée objet normale. Par exemple, nous pouvons avoir une classe distincte pour la journalisation, mais les autres classes devront appeler ces méthodes. Mais, en AOP, nous configurons les aspects et l’exécution de la méthode se produit automatiquement. En savoir plus sur le support AOP Spring à Exemple AOP Spring.

11. Qu’est-ce qu’un Aspect, un Advice, un Pointcut, un JointPoint et des Arguments d’Advice en AOP?

Aspect: Aspect est une classe qui met en œuvre des préoccupations transversales, telles que la gestion des transactions. Les aspects peuvent être une classe normale configurée, puis configurée dans le fichier de configuration Spring Bean, ou nous pouvons utiliser le support Spring AspectJ pour déclarer une classe comme un aspect en utilisant l’annotation @Aspect.

Advice: L’avis est l’action entreprise pour un point de jonction particulier. En termes de programmation, ce sont des méthodes qui sont exécutées lorsqu’un point de jonction spécifique avec un point de coupe correspondant est atteint dans l’application. Vous pouvez penser à l’avis comme à des intercepteurs Spring ou à des filtres Servlet.

Pointcut: Les pointcuts sont des expressions régulières qui correspondent aux points de jonction pour déterminer si un avis doit être exécuté ou non. Le pointcut utilise différents types d’expressions qui correspondent aux points de jonction. Le framework Spring utilise le langage d’expression de pointcut AspectJ pour déterminer les points de jonction où les méthodes d’avis seront appliquées.

JoinPoint: Un point de jonction est un point spécifique dans l’application tel que l’exécution d’une méthode, la gestion des exceptions, la modification des valeurs de variable d’objet, etc. Dans AOP Spring, un point de jonction est toujours l’exécution d’une méthode.

Arguments de conseil: Nous pouvons passer des arguments dans les méthodes de conseil. Nous pouvons utiliser l’expression args() dans le point de coupe à appliquer à toute méthode correspondant au modèle d’argument. Si nous utilisons cela, alors nous devons utiliser le même nom dans la méthode de conseil à partir de laquelle le type d’argument est déterminé.

Ces concepts semblent confus au début, mais si vous parcourez Spring Aspect, Exemple de conseil, vous pouvez facilement les relier.

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

AspectJ est l’implémentation de référence de l’Aspect-Oriented Programming tandis que Spring implémente AOP pour certains cas. Les principales différences entre Spring AOP et AspectJ sont :

  • Spring AOP est plus simple à utiliser que AspectJ car nous n’avons pas besoin de nous soucier du processus de tissage.
  • Spring AOP prend en charge les annotations AspectJ, donc si vous êtes familier avec AspectJ, travailler avec Spring AOP est plus facile.
  • Spring AOP ne prend en charge que l’AOP basé sur des proxy, donc il ne peut être appliqué qu’aux points de jointure de l’exécution de méthode. AspectJ prend en charge tous les types de points de coupe.
  • Un des inconvénients de Spring AOP est qu’il ne peut être appliqué qu’aux beans créés à travers le contexte Spring.

13. Qu’est-ce que le conteneur Spring IoC?

L’Inversion de Contrôle (IoC) est le mécanisme permettant d’atteindre un faible couplage entre les dépendances des objets. Pour obtenir un couplage faible et une liaison dynamique des objets au moment de l’exécution, les objets définissent leurs dépendances qui sont injectées par d’autres objets assembleurs. Le conteneur Spring IoC est le programme qui injecte les dépendances dans un objet et le rend prêt à être utilisé.

Les classes de conteneur IoC du framework Spring font partie des packages org.springframework.beans et org.springframework.context et nous offrent différentes façons de découpler les dépendances des objets.

Certaines des implémentations ApplicationContext utiles que nous utilisons sont :

  • AnnotationConfigApplicationContext : pour les applications Java autonomes utilisant une configuration basée sur des annotations.
  • ClassPathXmlApplicationContext : pour les applications Java autonomes utilisant une configuration basée sur XML.
  • FileSystemXmlApplicationContext : similaire à ClassPathXmlApplicationContext, sauf que le fichier de configuration XML peut être chargé de n’importe où dans le système de fichiers.
  • AnnotationConfigWebApplicationContext et XmlWebApplicationContext pour les applications web.

14. Qu’est-ce qu’un Spring Bean?

Une classe Java normale initialisée par le conteneur Spring IoC est appelée Spring Bean. Nous utilisons ApplicationContext de Spring pour obtenir l’instance du Spring Bean.

Le conteneur Spring IoC gère le cycle de vie du Spring Bean, les étendues de bean et injecte les dépendances requises dans le bean.

15. Quelle est l’importance du fichier de configuration des beans Spring?

Nous utilisons le fichier de configuration des beans Spring pour définir tous les beans qui seront initialisés par le contexte Spring. Lorsque nous créons l’instance de l’ApplicationContext Spring, elle lit le fichier XML des beans Spring et les initialise tous. Une fois le contexte initialisé, nous pouvons l’utiliser pour obtenir différentes instances de beans.

Outre la configuration des beans Spring, ce fichier contient également des intercepteurs MVC Spring, des résolveurs de vues et d’autres éléments pour prendre en charge les configurations basées sur des annotations.

16. Quelles sont les différentes façons de configurer une classe en tant que Spring Bean?

Il existe trois façons différentes de configurer un Spring Bean.

Configuration XML: C’est la configuration la plus populaire et nous pouvons utiliser l’élément bean dans le fichier de contexte pour configurer un Spring Bean. Par exemple:

<bean name="myBean" class="com.journaldev.spring.beans.MyBean"></bean>

Configuration basée sur Java: Si vous n’utilisez que des annotations, vous pouvez configurer un Spring bean en utilisant l’annotation @Bean. Cette annotation est utilisée avec les classes @Configuration pour configurer un bean Spring. Configuration d’exemple:

@Configuration
@ComponentScan(value="com.journaldev.spring.main")
public class MyConfiguration {

	@Bean
	public MyService getService(){
		return new MyService();
	}
}

Pour obtenir ce bean à partir du contexte Spring, nous devons utiliser le code suivant:

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
		MyConfiguration.class);
MyService service = ctx.getBean(MyService.class);

Configuration basée sur les annotations: Nous pouvons également utiliser les annotations @Component, @Service, @Repository et @Controller avec les classes pour les configurer en tant que bean Spring. Pour cela, nous devrions fournir l’emplacement du package de base à analyser pour ces classes. Par exemple:

<context:component-scan base-package="com.journaldev.spring" />

17. Quels sont les différents scopes de Spring Bean?

Il existe cinq scopes définis pour les Spring Beans.

  1. singleton: Une seule instance du bean sera créée pour chaque conteneur. C’est la portée par défaut des Spring Beans. Lors de l’utilisation de cette portée, assurez-vous que le bean Spring n’a pas de variables d’instance partagées, sinon cela pourrait entraîner des problèmes d’incohérence des données car il n’est pas thread-safe.
  2. prototype: Une nouvelle instance sera créée à chaque fois que le bean est demandé.
  3. request: C’est la même chose que la portée prototype, cependant, elle est destinée à être utilisée pour les applications web. Une nouvelle instance du bean sera créée pour chaque requête HTTP.
  4. session: Un nouveau bean sera créé pour chaque session HTTP par le conteneur.
  5. global-session: Cela est utilisé pour créer des beans de session globaux pour les applications portlets.

Le framework Spring est extensible et nous pouvons créer nos propres scopes également. Mais la plupart du temps, nous utilisons les scopes fournis par le framework. Pour définir les scopes des beans Spring, nous pouvons utiliser l’attribut « scope » dans l’élément bean ou l’annotation @Scope pour les configurations basées sur les annotations.

18. Quel est le cycle de vie du Spring Bean?

Les Spring Beans sont initialisés par le conteneur Spring et toutes les dépendances sont également injectées. Lorsque le contexte est détruit, il détruit également tous les beans initialisés. Cela fonctionne bien dans la plupart des cas, mais parfois nous voulons initialiser d’autres ressources ou effectuer certaines validations avant de rendre nos beans prêts à l’emploi. Le framework Spring prend en charge les méthodes de post-initialisation et de pré-destruction dans les beans Spring.

Nous pouvons le faire de deux manières – en implémentant les interfaces InitializingBean et DisposableBean, ou en utilisant les attributs init-method et destroy-method dans les configurations de bean Spring. Pour plus de détails, veuillez lire Les méthodes du cycle de vie du Spring Bean.

19. Comment obtenir l’objet ServletContext et ServletConfig dans un Spring Bean?

Il existe deux façons d’obtenir des objets spécifiques au conteneur dans le bean Spring.

  • Implémentation des interfaces *Aware de Spring, pour ces interfaces ServletContextAware et ServletConfigAware, pour un exemple complet de ces interfaces conscientes, veuillez lire Interfaces Spring Aware.
  • Utilisation de l’annotation @Autowired avec une variable de bean de type ServletContext et ServletConfig. Ils fonctionneront uniquement dans des environnements spécifiques aux conteneurs de servlets uniquement.
@Autowired
ServletContext servletContext;

20. Qu’est-ce que le câblage de bean et l’annotation @Autowired?

Le processus d’injection des dépendances de bean spring lors de l’initialisation est appelé câblage de bean Spring.

Généralement, il est préférable de faire le câblage explicite de toutes les dépendances de bean, mais le framework spring prend également en charge l’autocâblage. Nous pouvons utiliser l’annotation @Autowired avec des champs ou des méthodes pour l’autocâblage par type. Pour que cette annotation fonctionne, nous devons également activer la configuration basée sur les annotations dans le fichier de configuration de bean spring. Cela peut être fait par l’élément context:annotation-config.

Pour plus de détails sur l’annotation @Autowired, veuillez lire Exemple d’autocâblage Spring.

21. Quels sont les différents types d’autocâblage de Spring Bean ?

Il existe quatre types d’autocâblage dans le framework Spring.

  1. autocâblage par nom
  2. autocâblage par type
  3. autocâblage par constructeur
  4. L’autocâblage se fait à l’aide des annotations @Autowired et @Qualifier

Avant Spring 3.1, l’autocâblage par détection automatique (autowire by autodetect) était également pris en charge, ce qui était similaire à l’autocâblage par constructeur ou par type. Pour plus de détails sur ces options, veuillez lire l’autocâblage des Spring Beans.

22. Les Spring Beans fournissent-ils une sécurité au niveau des threads ?

La portée par défaut d’un Spring Bean est singleton, donc il n’y aura qu’une seule instance par contexte. Cela signifie que toutes les variables de niveau de classe que n’importe quel thread peut mettre à jour conduiront à des données incohérentes. Par conséquent, en mode par défaut, les Spring Beans ne sont pas sûrs pour les threads.

Cependant, nous pouvons changer la portée du bean Spring en requête, prototype ou session pour garantir la sécurité des threads au détriment des performances. C’est une décision de conception basée sur les exigences du projet.

23. Qu’est-ce qu’un contrôleur dans Spring MVC ?

Tout comme le modèle de conception MVC, le contrôleur est la classe qui s’occupe de toutes les demandes des clients et les envoie aux ressources configurées pour les traiter. Dans Spring MVC, DispatcherServlet est la classe du contrôleur frontal qui initialise le contexte en fonction des configurations des beans Spring.

A Controller class is responsible to handle a different kind of client requests based on the request mappings. We can create a controller class by using @Controller annotation. Usually, it’s used with @RequestMapping annotation to define handler methods for specific URI mapping.

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

@Component est utilisé pour indiquer qu’une classe est un composant. Ces classes sont utilisées pour la détection automatique et configurées en tant que bean lorsque des configurations basées sur des annotations sont utilisées.

@Controller est un type spécifique de composant, utilisé dans les applications MVC et principalement utilisé avec l’annotation RequestMapping.

@Repository est utilisée pour indiquer qu’un composant est utilisé comme référentiel et un mécanisme pour stocker/récupérer/rechercher des données. Nous pouvons appliquer cette annotation avec des classes d’implémentation du modèle DAO.

@Service est utilisé pour indiquer qu’une classe est un Service. Généralement, les classes de façade métier qui fournissent certains services sont annotées avec cela.

Nous pouvons utiliser l’une des annotations ci-dessus pour une classe pour la détection automatique mais différents types sont fournis afin que vous puissiez facilement distinguer le but des classes annotées.

25. Qu’est-ce que DispatcherServlet et ContextLoaderListener?

DispatcherServlet est le contrôleur frontal dans une application Spring MVC et il charge le fichier de configuration des beans Spring et initialise tous les beans qui sont configurés. Si les annotations sont activées, il scanne également les packages et configure tout bean annoté avec les annotations @Component, @Controller, @Repository ou @Service.

ContextLoaderListener est l’auditeur pour démarrer et arrêter le WebApplicationContext racine de Spring. Ses fonctions importantes sont d’associer le cycle de vie de ApplicationContext au cycle de vie de ServletContext et d’automatiser la création de ApplicationContext. Nous pouvons l’utiliser pour définir des beans partagés qui peuvent être utilisés dans différents contextes Spring.

26. Qu’est-ce que ViewResolver dans Spring?

Les implémentations de ViewResolver sont utilisées pour résoudre les pages de vue par leur nom. Nous le configurons dans le fichier de configuration des beans Spring. Par exemple : 

<!-- Résout les vues sélectionnées pour le rendu par les @Controllers vers les ressources .jsp dans le répertoire /WEB-INF/views -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<beans:property name="prefix" value="/WEB-INF/views/" />
	<beans:property name="suffix" value=".jsp" />
</beans:bean>

InternalResourceViewResolver est l’une des implémentations de l’interface ViewResolver et nous fournissons le répertoire des pages de vue et l’emplacement du suffixe à travers les propriétés du bean. Ainsi, si une méthode de gestionnaire de contrôleur renvoie « home », le résolveur de vue utilisera la page de vue située à /WEB-INF/views/home.jsp.

27. Qu’est-ce qu’un MultipartResolver et quand est-il utilisé?

L’interface MultipartResolver est utilisée pour télécharger des fichiers – CommonsMultipartResolver et StandardServletMultipartResolver sont deux implémentations fournies par le framework Spring pour le téléchargement de fichiers. Par défaut, aucun résolveur multipart n’est configuré, mais pour les utiliser pour télécharger des fichiers, nous devons simplement définir un bean nommé « multipartResolver » avec le type MultipartResolver dans les configurations de bean Spring.

Une fois configurée, toute demande multipartie sera résolue par le MultipartResolver configuré et transmise par un HttpServletRequest enveloppé. Ensuite, il est utilisé dans la classe de contrôleur pour obtenir le fichier et le traiter. Pour un exemple complet, veuillez lire Exemple de téléchargement de fichiers Spring MVC.

28. Comment gérer les exceptions dans le framework Spring MVC ?

Le framework Spring MVC offre plusieurs façons de nous aider à mettre en place une gestion robuste des exceptions.

Basé sur le contrôleur – Nous pouvons définir des méthodes de gestion des exceptions dans nos classes de contrôleur. Il suffit d’annoter ces méthodes avec l’annotation @ExceptionHandler.

Gestionnaire d’exceptions global – La gestion des exceptions est une préoccupation transversale, et Spring fournit l’annotation @ControllerAdvice que nous pouvons utiliser avec n’importe quelle classe pour définir notre gestionnaire d’exceptions global.

Implémentation de HandlerExceptionResolver – Pour les exceptions génériques, la plupart du temps, nous servons des pages statiques. Spring Framework fournit une interface HandlerExceptionResolver que nous pouvons implémenter pour créer un gestionnaire d’exceptions global. La raison derrière cette façon supplémentaire de définir le gestionnaire d’exceptions global est que le framework Spring fournit également des classes d’implémentation par défaut que nous pouvons définir dans notre fichier de configuration du bean Spring pour bénéficier de la gestion des exceptions par le framework Spring.

Pour un exemple complet, veuillez lire Spring Exception Handling Example.

29. Comment créer ApplicationContext dans un programme Java?

Il existe plusieurs façons de créer le contexte Spring dans un programme Java autonome.

  1. AnnotationConfigApplicationContext: Si nous utilisons Spring dans des applications Java autonomes et que nous utilisons des annotations pour la configuration, alors nous pouvons utiliser ceci pour initialiser le conteneur et obtenir les objets de bean.
  2. ClassPathXmlApplicationContext: Si nous avons un fichier de configuration XML de bean Spring dans une application autonome, alors nous pouvons utiliser cette classe pour charger le fichier et obtenir l’objet conteneur.
  3. FileSystemXmlApplicationContext: Cela est similaire à ClassPathXmlApplicationContext, sauf que le fichier de configuration XML peut être chargé de n’importe où dans le système de fichiers.

30. Pouvons-nous avoir plusieurs fichiers de configuration Spring?

Pour les applications Spring MVC, nous pouvons définir plusieurs fichiers de configuration de contexte Spring via contextConfigLocation. Cette chaîne d’emplacement peut être composée de plusieurs emplacements séparés par n’importe quel nombre de virgules et d’espaces. Par exemple;

<servlet>
	<servlet-name>appServlet</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
            <param-name>contextConfigLocation</param-name>
	    <param-value>/WEB-INF/spring/appServlet/servlet-context.xml,/WEB-INF/spring/appServlet/servlet-jdbc.xml</param-value>
	</init-param>
	<load-on-startup>1</load-on-startup>
</servlet>

Nous pouvons également définir plusieurs configurations racines de spring et les charger via context-param. Par exemple;

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/spring/root-context.xml /WEB-INF/spring/root-security.xml</param-value>
</context-param>

Une autre option est d’utiliser l’élément d’importation dans le fichier de configuration de contexte pour importer d’autres configurations, par exemple:

<beans:import resource="spring-jdbc.xml"/>

31. Qu’est-ce que ContextLoaderListener?

ContextLoaderListener est la classe de listener utilisée pour charger le contexte racine et définir les configurations de bean Spring qui seront visibles pour tous les autres contextes. Il est configuré dans le fichier web.xml comme suit:

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
	
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

32. Quelles sont les configurations minimales nécessaires pour créer une application Spring MVC?

Pour créer une application Spring MVC simple, nous devrions effectuer les tâches suivantes.

  • Ajouter les dépendances spring-context et spring-webmvc dans le projet.
  • Configure DispatcherServlet dans le fichier web.xml pour gérer les requêtes via le conteneur Spring.
  • Fichier de configuration des beans Spring pour définir les beans, s’il utilise des annotations alors il doit être configuré ici. De plus, nous devons configurer le résolveur de vue pour les pages de vue.
  • Classe de contrôleur avec des mappages de requêtes définis pour gérer les requêtes client.

Les étapes ci-dessus devraient suffire pour créer une application Spring MVC Hello World simple.

33. Comment relieriez-vous le Framework Spring MVC à l’architecture MVC?

Comme son nom l’indique, Spring MVC est construit sur l’architecture Modèle-Vue-Contrôleur (MVC). DispatcherServlet est le contrôleur frontal dans l’application Spring MVC qui prend en charge toutes les requêtes entrantes et les délègue à différentes méthodes de gestion de contrôleur.

Le modèle peut être n’importe quel bean Java dans le framework Spring, tout comme tout autre framework MVC, Spring fournit la liaison automatique des données de formulaire aux beans Java. Nous pouvons définir les beans de modèle comme des attributs à utiliser dans les pages de vue.

Les pages de vue peuvent être des JSP, du HTML statique, etc. et les résolveurs de vue sont responsables de trouver la page de vue correcte. Une fois que la page de vue est identifiée, le contrôleur DispatcherServlet reprend le contrôle. DispatcherServlet est responsable du rendu de la vue et de la renvoi de la réponse finale au client.

34. Comment réaliser la localisation dans les applications Spring MVC ?

Spring offre une excellente prise en charge de la localisation ou i18n grâce aux bundles de ressources. Les étapes de base nécessaires pour rendre notre application localisée sont les suivantes :

  • Créer des bundles de ressources de messages pour différentes langues, tels que messages_en.properties, messages_fr.properties, etc.
  • Définir le bean messageSource dans le fichier de configuration des beans Spring, de type ResourceBundleMessageSource ou ReloadableResourceBundleMessageSource.
  • Pour prendre en charge le changement de langue, définir le bean localeResolver de type CookieLocaleResolver et configurer l’intercepteur LocaleChangeInterceptor. Un exemple de configuration est indiqué comme suit : 
<beans:bean id="messageSource"
class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
<beans:property name="basename" value="classpath:messages" />
<beans:property name="defaultEncoding" value="UTF-8" />
</beans:bean>
 
<beans:bean id="localeResolver"
    class="org.springframework.web.servlet.i18n.CookieLocaleResolver">
    <beans:property name="defaultLocale" value="en" />
    <beans:property name="cookieName" value="myAppLocaleCookie"></beans:property>
    <beans:property name="cookieMaxAge" value="3600"></beans:property>
</beans:bean>
 
<interceptors>
    <beans:bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
        <beans:property name="paramName" value="locale" />
    </beans:bean>
</interceptors>
  • Utiliser l’élément spring:message dans les pages de vue avec des noms de clé, DispatcherServlet récupère la valeur correspondante et rend la page dans la langue correspondante avant de la renvoyer en réponse.

Pour un exemple complet, veuillez lire Exemple de localisation avec Spring.

35. Comment pouvons-nous utiliser Spring pour créer un service Web Restful renvoyant une réponse JSON ?

Nous pouvons utiliser le framework Spring pour créer des services Web Restful qui renvoient des données JSON. Spring fournit une intégration avec l’API Jackson JSON que nous pouvons utiliser pour envoyer des réponses JSON dans un service Web Restful.

Voici les étapes à suivre pour configurer notre application Spring MVC afin d’envoyer une réponse JSON :

1. Ajouter les dépendances Jackson JSON, si vous utilisez Maven, cela peut être fait avec le code suivant :

<!-- Jackson -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${jackson.databind-version}</version>
</dependency>

2. Configurer le bean RequestMappingHandlerAdapter dans le fichier de configuration des beans Spring et définir la propriété des convertisseurs de messages sur le bean MappingJackson2HttpMessageConverter. La configuration exemple sera :

<!-- Configuration pour brancher JSON en tant que requête et réponse dans le gestionnaire de méthode -->
<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <beans:property name="messageConverters">
        <beans:list>
            <beans:ref bean="jsonMessageConverter"/>
        </beans:list>
    </beans:property>
</beans:bean>
     
<!-- Configurer le bean pour convertir JSON en POJO et vice versa -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</beans:bean>

3. Dans les méthodes de gestionnaire du contrôleur, retourner l’objet en réponse en utilisant l’annotation @ResponseBody. Code exemple :

@RequestMapping(value = EmpRestURIConstants.GET_EMP, method = RequestMethod.GET)
public @ResponseBody Employee getEmployee(@PathVariable("id") int empId) {
    logger.info("Start getEmployee. ID="+empId);
     
    return empData.get(empId);
}

4. Vous pouvez invoquer le service REST via n’importe quelle API, mais si vous voulez utiliser Spring, vous pouvez facilement le faire en utilisant la classe RestTemplate.

Pour un exemple complet, veuillez lire Spring Restful Webservice Example.

36. Quelles sont certaines des annotations Spring importantes que vous avez utilisées?

Certaines des annotations Spring que j’ai utilisées dans mon projet sont:

  • @Controller – pour les classes de contrôleur dans un projet Spring MVC.
  • @RequestMapping – pour configurer la correspondance d’URI dans les méthodes de gestionnaire de contrôleur. Il s’agit d’une annotation très importante, donc vous devriez consulter Spring MVC RequestMapping Annotation Examples
  • @ResponseBody – pour envoyer un objet en tant que réponse, généralement pour envoyer des données XML ou JSON en tant que réponse.
  • @PathVariable – pour mapper des valeurs dynamiques de l’URI aux arguments de la méthode de gestionnaire.
  • @Autowired – pour l’injection automatique des dépendances dans les beans Spring.
  • @Qualifier – avec l’annotation @Autowired pour éviter les confusions lorsque plusieurs instances du même type de bean sont présentes.
  • @Service – pour les classes de service.
  • @Scope – pour configurer la portée du bean Spring.
  • @Configuration, @ComponentScan, et @Bean – pour les configurations basées sur Java.
  • Annotations AspectJ pour configurer les aspects et les conseils, @Aspect, @Before, @After, @Around, @Pointcut, etc.

37. Est-ce que nous pouvons envoyer un objet en tant que réponse de la méthode de gestionnaire du contrôleur?

Oui, nous le pouvons en utilisant l’annotation @ResponseBody. C’est ainsi que nous envoyons une réponse basée sur JSON ou XML dans les services web RESTful.

38. Comment télécharger des fichiers dans une application Spring MVC?

Spring fournit une prise en charge intégrée pour le téléchargement de fichiers via les implémentations de l’interface MultipartResolver. C’est très facile à utiliser et nécessite uniquement des modifications de configuration pour le faire fonctionner. Nous devrions écrire une méthode de gestionnaire de contrôleur pour gérer le fichier entrant et le traiter. Pour un exemple complet, veuillez consulter l’exemple de téléchargement de fichiers Spring.

39. Comment valider les données de formulaire dans le framework Spring Web MVC?

Spring prend en charge les validations basées sur les annotations JSR-303 ainsi que fournit une interface Validator que nous pouvons implémenter pour créer notre propre validateur personnalisé. Pour utiliser la validation basée sur JSR-303, nous devons annoter les variables de bean avec les validations requises.

Pour une implémentation de validateur personnalisé, nous devons le configurer dans la classe du contrôleur. Pour un exemple complet, veuillez lire Exemple de validation de formulaire Spring MVC.

40. Qu’est-ce qu’un intercepteur Spring MVC et comment l’utiliser?

Les intercepteurs Spring MVC sont similaires aux filtres Servlet et nous permettent d’intercepter les requêtes des clients et de les traiter. Nous pouvons intercepter les requêtes clients à trois endroits – preHandle, postHandle, et afterCompletion.

Nous pouvons créer un intercepteur Spring en implémentant l’interface HandlerInterceptor ou en étendant la classe abstraite HandlerInterceptorAdapter.

Nous devons configurer des intercepteurs dans le fichier de configuration du bean Spring. Nous pouvons définir un intercepteur pour intercepter toutes les requêtes client ou nous pouvons le configurer pour des mappages d’URI spécifiques également. Pour un exemple détaillé, veuillez consulter Exemple d’intercepteur Spring MVC.

41. Qu’est-ce que la classe Spring JdbcTemplate et comment l’utiliser ?

Le framework Spring offre une excellente intégration avec l’API JDBC et fournit la classe utilitaire JdbcTemplate que nous pouvons utiliser pour éviter le code répétitif de nos opérations de base de données telles que l’ouverture/fermeture de la connexion, ResultSet, PreparedStatement, etc.

Pour un exemple de JdbcTemplate, veuillez consulter Exemple Spring JDBC.

42. Comment utiliser Tomcat JNDI DataSource dans une application Web Spring ?

Pour utiliser un conteneur de servlet configuré avec une source de données JNDI, nous devons le configurer dans le fichier de configuration des beans Spring, puis l’injecter dans les beans Spring en tant que dépendances. Ensuite, nous pouvons l’utiliser avec JdbcTemplate pour effectuer des opérations sur la base de données.

<beans:bean id="dbDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>
</beans:bean>

Pour un exemple complet, veuillez consulter Spring Tomcat JNDI Example.

43. Comment réaliser la gestion des transactions dans Spring ?

Le framework Spring offre une prise en charge de la gestion des transactions à la fois par gestion déclarative des transactions et par gestion programmatique des transactions. La gestion déclarative des transactions est la plus couramment utilisée car elle est facile à utiliser et fonctionne dans la plupart des cas.

Nous utilisons l’annotation @Transactional pour la gestion déclarative des transactions. Nous devons configurer le gestionnaire de transactions pour la source de données dans le fichier de configuration des beans Spring.

<bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

44. Qu’est-ce que Spring DAO ?

Le support DAO de Spring est fourni pour travailler avec des technologies d’accès aux données telles que JDBC, Hibernate de manière cohérente et facile. Par exemple, nous avons JdbcDaoSupport, HibernateDaoSupport, JdoDaoSupport et JpaDaoSupport pour les technologies respectives.

Spring DAO assure également une cohérence dans la hiérarchie des exceptions, et nous n’avons pas besoin de capturer des exceptions spécifiques.

45. Comment intégrer les frameworks Spring et Hibernate ?

Nous pouvons utiliser le module Spring ORM pour intégrer les frameworks Spring et Hibernate si vous utilisez Hibernate 3+ où SessionFactory fournit la session actuelle. Dans ce cas, il est préférable d’éviter d’utiliser les classes HibernateTemplate ou HibernateDaoSupport et d’opter plutôt pour le modèle DAO avec injection de dépendances pour l’intégration.

Spring ORM prend en charge l’utilisation de la gestion des transactions déclarative de Spring, vous devriez donc l’utiliser plutôt que d’opter pour le code boilerplate Hibernate pour la gestion des transactions.

Pour une meilleure compréhension, vous devriez consulter les tutoriels suivants :

46. Qu’est-ce que Spring Security?

Le framework Spring Security se concentre sur la fourniture à la fois de l’authentification et de l’autorisation dans les applications Java. Il prend également en charge la plupart des vulnérabilités de sécurité courantes telles que les attaques CSRF.

Il est très bénéfique et facile à utiliser Spring Security dans les applications web, grâce à l’utilisation d’annotations telles que @EnableWebSecurity. Vous devriez consulter les articles suivants pour apprendre à utiliser le framework Spring Security.

47. Comment injecter un java.util.Properties dans un Bean Spring?

Nous devons définir le bean propertyConfigurer qui chargera les propriétés à partir du fichier de propriétés donné. Ensuite, nous pouvons utiliser le support Spring EL pour injecter des propriétés dans d’autres dépendances de bean. Par exemple:

<bean id="propertyConfigurer" 
  class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
    <property name="location" value="/WEB-INF/application.properties" />
</bean> 

<bean class="com.journaldev.spring.EmployeeDaoImpl">
    <property name="maxReadResults" value="${results.read.max}"/>
</bean>

Si vous utilisez l’annotation pour configurer le bean Spring, vous pouvez injecter une propriété comme indiqué ci-dessous.

@Value("${maxReadResults}") 
private int maxReadResults;

48. Nommez certains des motifs de conception utilisés dans Spring Framework?

Le framework Spring utilise de nombreux motifs de conception, certains des plus courants sont les suivants:

  1. Singleton Pattern: Création de beans avec une portée par défaut.
  2. Factory Pattern: Classes de fabrique de beans
  3. Prototype Pattern: Portées de beans
  4. Adapter Pattern: Web Spring et Spring MVC
  5. Proxy Pattern: Prise en charge de la programmation orientée aspect dans Spring
  6. Template Method Pattern: JdbcTemplate, HibernateTemplate, etc
  7. Contrôleur frontal: DispatcherServlet Spring MVC
  8. Objet d’accès aux données: Support DAO Spring
  9. Injection de dépendance et programmation orientée aspect

49. Quelles sont certaines des meilleures pratiques pour le Framework Spring ?

Certaines des meilleures pratiques pour le Framework Spring sont :

  • Évitez les numéros de version dans les références de schéma pour vous assurer d’avoir les configurations les plus récentes.
  • Divisez les configurations des beans Spring en fonction de leurs préoccupations, telles que spring-jdbc.xml, spring-security.xml.
  • Pour les beans Spring utilisés dans plusieurs contextes dans Spring MVC, créez-les dans le contexte racine et initialisez-les avec le listener.
  • Configurez autant que possible les dépendances entre les beans, essayez d’éviter autant que possible le câblage automatique.
  • Pour les propriétés au niveau de l’application, la meilleure approche est de créer un fichier de propriétés et de le lire dans le fichier de configuration du bean Spring.
  • Pour les applications plus petites, les annotations sont utiles, mais pour les applications plus importantes, les annotations peuvent devenir contraignantes. Si nous avons toutes les configurations dans des fichiers XML, leur maintenance sera plus facile.
  • @Service Utilisez les annotations correctes pour les composants afin de comprendre facilement leur objectif. Pour les DAO beans, utilisez @Repository.
  • Spring framework dispose de nombreux modules, utilisez ce dont vous avez besoin. Supprimez toutes les dépendances supplémentaires ajoutées habituellement lors de la création de projets à partir de modèles Spring Tool Suite.
  • Si vous utilisez des Aspects, assurez-vous de restreindre le point de jonction autant que possible pour éviter les conseils sur des méthodes non souhaitées. Considérez des annotations personnalisées plus faciles à utiliser pour éviter tout problème.
  • Utilisez l’injection de dépendances uniquement s’il y a un bénéfice réel. Ne l’utilisez pas simplement pour le couplage lâche, mais parce que cela facilite la maintenance.

50. Qu’est-ce que Spring Boot?

Spring Boot rend le framework Spring unique. Il nous offre un moyen facile de créer différents types d’applications Java et de les attacher à l’environnement d’exécution du conteneur servlet. Ainsi, nous obtenons un seul fichier JAR que nous pouvons exécuter pour exécuter le projet. Cela nous fait gagner beaucoup de temps pour obtenir rapidement le projet squelette prêt pour le déploiement du produit. De cette façon, nous pouvons nous concentrer davantage sur la logique métier plutôt que de passer par le processus courant de construction du code, puis de le déployer sur un conteneur servlet. Comme il s’agit d’un sujet très vaste, je vous suggère de consulter les Questions d’entretien sur Spring Boot.

C’est tout pour les questions d’entretien sur le framework Spring. J’espère que ces questions vous aideront lors de votre prochain entretien sur Java EE. Je continuerai à ajouter plus de questions à la liste dès que je les trouverai. Si vous connaissez d’autres questions qui devraient faire partie de la liste, assurez-vous d’ajouter un commentaire à ce sujet et je l’inclurai.

Source:
https://www.digitalocean.com/community/tutorials/spring-interview-questions-and-answers