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 ?
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 :
Commençons par la première section des questions d'entrevue de printemps qui sont les questions générales.
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. |
Voici quelques-unes des principales fonctionnalités de Spring Framework :
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.
Quelques modules divers sont donnés ci-dessous :
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.
Une application Spring se compose généralement des composants suivants :
Spring Framework peut être utilisé de différentes manières. Ils sont répertoriés comme suit :
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.
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.
De manière générale, l'injection de dépendances peut se faire de trois manières, à savoir :
Dans Spring Framework, seules les injections de constructeur et de setter sont utilisées.
Injection de constructeur | Injection de poseur |
---|---|
Il n'y a pas d'injection partielle. | Il peut y avoir injection partielle. |
Il ne remplace pas la propriété setter. | Il remplace la propriété du constructeur. |
Il créera une nouvelle instance si une modification est effectuée. | Il ne créera pas de nouvelle instance si une modification est effectuée. |
Cela fonctionne mieux pour de nombreuses propriétés. | Cela fonctionne mieux pour quelques propriétés. |
Fabrique de haricots | ApplicationContextApplicationContext |
---|---|
C'est une interface définie dans org.springframework.beans.factory. Fabrique de haricots | C'est une interface définie dans org.springframework.context. ApplicationContextApplicationContext |
Il utilise l'initialisation paresseuse | Il utilise une initialisation Eager / Agressive |
Il fournit explicitement un objet ressource en utilisant la syntaxe | Il crée et gère lui-même des objets ressources |
Il ne prend pas en charge l'internationalisation | Il soutient l'internationalisation |
Il ne prend pas en charge la dépendance basée sur les annotations | Il prend en charge la dépendance basée sur les annotations |
Certains des avantages de l'IoC sont :
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 :
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 ?
@requestParam | @pathVariable | |
But | Extrait les paramètres de requête de la chaîne de requête de l'URL. | Extrait les valeurs du chemin URI lui-même (modèle d'URL). |
Syntaxe | Suivi du nom du paramètre dans la liste des paramètres de la méthode du contrôleur. | Suivi du nom de la variable entre accolades {} dans le mappage d'URL. |
Exemple d'URL | /example?name=Jean | /exemple/{id} |
Exemple d'utilisation | @RequestParam("nom") Nom de la chaîne | @PathVariable("id") ID de chaîne |
Cas d'utilisation | Convient aux paramètres ou données facultatifs dans la chaîne de requête. | Utile pour extraire des valeurs dynamiques du chemin de l'URL. |
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 :
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.
@autowired | @injecter | |
Cadre | Fait partie du cadre de printemps | Fait partie de la norme JSR-330 (Java Dependency Injection) |
Configuration | Nécessite l'activation de l'analyse des composants dans Spring | Nécessite un framework DI conforme JSR-330 |
Qualification | Prend en charge les qualificatifs tels que @Qualifier et @Primary | N'a pas de prise en charge intégrée des qualificateurs |
Dépendance facultative | Par défaut, la dépendance est obligatoire | Par défaut, la dépendance n'est pas requise |
Configuration facultative | Peut utiliser @Autowired (obligatoire = faux) | Peut utiliser @Inject sans changer son comportement par défaut |
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.
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> ?
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 :
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
ApplicationContextApplicationContext
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 :
Passons à la section suivante des questions d'entrevue de printemps, c'est-à-dire les questions d'entrevue de Spring Beans .
Les métadonnées de configuration peuvent être fournies au conteneur Spring des manières suivantes :
<bean id="studentbean" class="org.edureka.firstSpring.StudentBean">
<property name="name" value="Edureka"></property>
</bean>
<beans>
<context:annotation-config/>
<!-- bean definitions go here -->
</beans>
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(); }
}
Spring Framework prend en charge cinq portées. Ils sont:
Les trois derniers ne sont disponibles que si les utilisateurs utilisent un ApplicationContext compatible Web.
Le cycle de vie du haricot dans le conteneur Spring Bean Factory est le suivant :
Pour mieux le comprendre, consultez le schéma ci-dessous :
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>
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.
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 :
Voici quelques-unes des limitations auxquelles vous pourriez être confronté avec le câblage automatique :
Dans la section suivante, nous discuterons des questions d'entrevue sur les annotations de printemps .
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(); }
}
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>
@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; }
}
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; }
}
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);
}
}
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 :
La section suivante des questions d'entrevue du printemps porte sur l'accès aux données .
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.
Voir le diagramme ci-dessous, il décrit toutes les classes Spring DAO dans l'ordre hiérarchique.
Les classes présentes dans l'API JDBC sont les suivantes :
Il existe deux façons d'accéder à Hibernate en utilisant Spring :
Deux types de gestion des transactions sont pris en charge par Spring. Ils sont:
Différents ORM pris en charge par Spring sont représentés via le diagramme ci-dessous :
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.
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.
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.
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.
Les différents types d'avis dans Spring AOP sont :
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.
Différentes implémentations AOP sont représentées par le schéma ci-dessous :
AOP de printemps | Aspect J AOP |
---|---|
Le tissage d'exécution via le proxy est terminé | Le tissage du temps de compilation via les outils Java AspectJ est terminé |
Il ne prend en charge que PointCut au niveau de la méthode | Il prend en charge les Pointcuts au niveau du champ |
Il est basé sur DTD | Il est basé sur un schéma et une configuration d'annotation |
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.
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 :
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.
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é.
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é.
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