ENTRETIEN SPRING BOOT

1. Qu’est-ce que Spring boot ?

Sprint boot est un framework spring basé sur Java utilisé pour le développement
accéléré d’applications (pour construire des microservices autonomes). Il dispose
d’un support supplémentaire d’auto-configuration et d’un serveur d’application
embarqué comme tomcat

2. Quelles sont les caractéristiques de Spring Boot qui le rendent

différent ?
 Crée une application Spring autonome avec une configuration minimale.

 Il intègre tomcat et jetty, ce qui permet de coder et d’exécuter l’application.

 Absolument aucune exigence pour la configuration XML

3. Quels sont les avantages de l’utilisation de Spring Boot ?

 Facile à comprendre et à développer des applications Spring.

 Spring Boot n’est rien d’autre qu’un framework existant avec l’ajout d’un serveur

HTTP intégré et d’une configuration d’annotation, ce qui le rend plus facile à

comprendre et accélère le processus de développement.

 Augmente la productivité et réduit le temps de développement.

 Configuration minimale.

 Nous n’avons pas besoin d’écrire de configuration XML, seules quelques annotations

sont nécessaires pour effectuer la configuration.

4. Quels sont les composants clés de Spring Boot ?

 Autoconfiguration de Spring Boot.

 CLI de Spring Boot.

 POMs de démarrage de Spring Boot.

 Les actionneurs de Spring Boot.

5. Pourquoi préférer Spring Boot à Spring ?
 Gestion des versions

 Auto Configuration.

 Analyse des composants.

 Serveur embarqué.

 Base de données en mémoire.

 Starter POM.

 Actionneurs.

6. Quelles sont les dépendances Spring Boot Starter ?

 Data JPA starter.

 Test Starter.

 Security starter.

 Web starter.

 Mail starter.

 Thymeleaf starter.

7. Comment fonctionne Spring Boot ?

Spring Boot configure automatiquement votre application en fonction des
dépendances que vous avez ajoutées au projet en utilisant des
annotations. Le point d’entrée de l’application Spring Boot est la classe qui
contient l’annotation @SpringBootApplication et la méthode main.
Spring Boot scanne automatiquement tous les composants inclus dans le
projet en utilisant l’annotation @ComponentScan.

8. Que fait l’annotation @SpringBootApplication en interne ?

L’annotation @SpringBootApplication équivaut à utiliser @Configuration,
@EnableAutoConfiguration et @ComponentScan avec leurs attributs par défaut.
Spring Boot permet au développeur d’utiliser une seule annotation au lieu d’en
utiliser plusieurs. Mais, comme nous le savons, Spring a fourni des fonctionnalités
faiblement couplées que nous pouvons utiliser pour chaque annotation en
fonction des besoins de notre projet.
9. Quel est le but de l’utilisation de @ComponentScan dans une classe ?
L’application Spring Boot scanne tous les beans et les déclarations de package lors
de l’initialisation de l’application. Vous devez ajouter l’annotation
@ComponentScan à votre classe pour analyser les composants ajoutés à votre
projet.

10. Comment démarre une application Spring Boot ?

Comme tout autre programme Java, une application Spring Boot doit avoir une
méthode main. Cette méthode sert de point d’entrée, qui invoque la méthode

Springboot.run pour démarrer l’application

11. Qu’est-ce que Spring Initializer?

Spring Initializer est une application web qui vous aide à créer une structure
initiale de projet Spring Boot et fournit un fichier maven ou gradle pour construire
votre code. Il résout le problème de la mise en place d’un framework lorsque vous
démarrez un projet à partir de zéro.

12. Qu’est-ce que Spring Boot CLI et quels sont ses avantages ?
Spring Boot CLI est une interface en ligne de commande qui vous permet de créer
une application java basée sur Spring à l’aide de Groovy.

13. Quel est le port par défaut de tomcat dans spring boot ?
Le port par défaut du serveur tomcat est 8080. Il peut être modifié en ajoutant la
propriété « sever.port » dans le fichier « application.property ».

14. Peut-on remplacer le serveur Tomcat embarqué dans Spring Boot ?

Oui, nous pouvons remplacer le serveur Tomcat embarqué par n’importe quel
serveur en utilisant la dépendance Starter dans le fichier pom.xml. Par exemple,
vous pouvez utiliser spring-boot-starter-jetty comme dépendance pour utiliser un
serveur jetty dans votre projet.

15. Peut-on désactiver le serveur web par défaut dans une application
Spring boot ?
Oui, on peut utiliser « application.properties » pour configurer le type
d’application web, c’est-à-dire

spring.main.web-application-type=none
.
16. Comment désactiver l’autoconfiguration pour une classe spécifique?
Vous pouvez utiliser l’attribut « exclude » de « @EnableAutoConfiguration »
si vous souhaitez que l’autoconfiguration ne s’applique pas à une classe
spécifique. Exemple:
@EnableAutoConfiguration(exclude={className})

17. Quel est le moteur de template HTML par défaut dans Spring Boot ?
Thymeleaf

18. Peut-on créer une application non-web dans Spring Boot ?

Oui, nous pouvons créer une application non-web en supprimant les dépendances
web du classpath et en modifiant la façon dont Spring Boot crée le contexte de
l’application.

18. Expliquez l’annotation @RestController dans Sprint boot ?

Il s’agit d’une combinaison de @Controller et @ResponseBody, utilisée pour créer
un contrôleur restful. Il convertit la réponse en JSON ou XML. Il garantit que les
données renvoyées par chaque méthode seront écrites directement dans le corps
de la réponse au lieu de renvoyer un template.

19. Quelle est la différence entre @RestController et @Controller dans

Spring Boot ?
@Controller fait correspondre l’objet du modèle à la vue et le rend lisible, mais
@RestController renvoie simplement l’objet et les données de l’objet sont
directement écrites dans la réponse HTTP sous forme de JSON ou de XML.

20. Quelle est la différence entre RequestMapping et GetMapping ?

RequestMapping peut être utilisé avec GET, POST, PUT, et beaucoup d’autres
méthodes de requête en utilisant l’attribut « method » de l’annotation. Alors que
getMapping n’est qu’une extension de RequestMapping qui vous aide à améliorer
la lisibilité de la requête.
21. Quelle est l’utilité de « Profiles » dans Spring Boot ?
Lors du développement de l’application, nous avons affaire à plusieurs
environnements tels que dev, test, Prod, et chaque environnement
nécessite une configuration différente. Par exemple, nous pouvons utiliser
une base de données H2 intégrée pour le développement, mais pour la
production, nous pouvons avoir un Oracle ou un DB2 propriétaire. Même si
le SGBD est le même dans tous les environnements, les URLs seront
différentes.
Pour rendre cela facile et propre, Spring a prévu des profils pour garder la
configuration séparée des environnements.

22. A quoi sert l’actionneur dans Spring ? Quels sont ses avantages ?
Un actionneur est une fonctionnalité supplémentaire de Spring qui vous aide à
surveiller et à gérer votre application lorsque vous la mettez en production. Ces
actionneurs comprennent l’audit, la healthcheck, l’utilisation du CPU, les hits
HTTP, la collecte de métriques, et bien d’autres choses encore qui sont
automatiquement appliquées à votre application.

23. Comment activer un actionneur dans une application Spring boot ?

Pour activer la fonctionnalité de l’actionneur spring, nous devons ajouter la
dépendance de « spring-boot-starter-actuator » dans pom.xml.
<dependency>
<groupId> org.springframework.boot</groupId>
<artifactId> spring-boot-starter-actuator </artifactId>
</dependency>

24. Comment récupérer la liste de tous les beans de votre application

Spring boot ?
L’actionneur Spring Boot « /Beans » est utilisé pour obtenir la liste de tous les
« spring beans » de votre application.

25. Comment vérifier les propriétés de l’environnement dans votre

application Spring boot ?
L’actionneur Spring Boot « /env » renvoie la liste de toutes les propriétés de
l’environnement d’exécution de l’application Spring Boot.
26. Comment activer le log de débogage dans une application Spring
Boot ?

 Nous pouvons démarrer l’application avec le paramètre

--debug
.

 Nous pouvons définir la propriété

logging.level.root=debug
dans le fichier application.property.

 Nous pouvons définir le niveau de journalisation sur debug dans le fichier de

configuration de log fourni.

27. Où définir les propriétés dans une application Spring Boot ?

Vous pouvez définir les propriétés liées à l’application et à Spring boot dans un
fichier appelé « application.properties ». Vous pouvez créer ce fichier
manuellement ou utiliser Spring Initializer pour créer ce fichier. Vous n’avez pas
besoin d’effectuer une configuration spéciale pour demander à Spring Boot de
charger ce fichier. S’il existe dans le classpath, Spring Boot le charge
automatiquement et se configure lui-même ainsi que le code de l’application en
conséquence.

28. Qu’est-ce qu’un conteneur IOC ?

IoC Container est un framework pour implémenter l’injection automatique de
dépendances. Il gère la création des objets et leur durée de vie et injecte
également les dépendances dans la classe.

29. Lequel des éléments suivants est utilisé par Maven ?

A Pom.xml

30. Qulles sont Les dépendances nécessaires pour créer une application
web Spring Boot?
A Spring-boot-starter-web

31. Points de départ d’une application Spring Boot ?

B @SpringBootApplication

32. L’objet de base de données doit être annoté avec _____

C @Entity

33. Qu'est-ce que Spring Boot et quelles sont ses principales caractéristiques ?

Spring Boot est essentiellement un cadre pour le développement rapide d'applications construit au-
dessus du Spring Framework.
Grâce à son auto-configuration et à la prise en charge du serveur d'application intégré, ainsi qu'à la
documentation complète et au soutien de la communauté, Spring Boot est l'une des technologies les
plus populaires de Java.
et le soutien de la communauté, Spring Boot est l'une des technologies les plus populaires de
l'écosystème Java à ce jour.

Voici quelques-unes de ses principales caractéristiques :

+ Starters - un ensemble de descripteurs de dépendances permettant d'inclure les dépendances

pertinentes en une seule fois.
+ Auto-configuration - un moyen de configurer automatiquement une application en fonction des
dépendances présentes sur le chemin d'accès (classpath).
+ Actuator - pour obtenir des fonctionnalités prêtes pour la production, telles que la surveillance
+ Sécurité
+ Logging

34. Quelles sont les différences entre Spring et Spring Boot ?

Le Spring Framework offre de nombreuses fonctionnalités qui facilitent le développement

d'applications web.
Ces fonctionnalités comprennent l'injection de dépendances, la liaison de données, la programmation
orientée aspect, l'accès aux données et bien d'autres encore.

Au fil des années, Spring est devenu de plus en plus complexe, et la quantité de configuration qu'une
telle application requiert
peut être intimidante. C'est là que Spring Boot s'avère utile : il facilite la configuration d'une
application Spring.

Essentiellement, alors que Spring n'a pas d'opinion, Spring Boot a une opinion de la plateforme et des
bibliothèques,
ce qui nous permet de démarrer rapidement.

Voici deux des avantages les plus importants apportés par Spring Boot :

+ Auto-configurer les applications en fonction des artefacts qu'il trouve sur le chemin d'accès
(classpath)
+ Fournir des fonctionnalités non fonctionnelles communes aux applications en production, telles que
la sécurité ou les contrôles de santé.

35. Comment désactiver une configuration automatique spécifique ?

Si nous voulons désactiver une configuration automatique spécifique, nous pouvons l'indiquer en
utilisant l'attribut exclude de l'annotation @EnableAutoConfiguration.
l'annotation @EnableAutoConfiguration.

Par exemple, cet extrait de code neutralise DataSourceAutoConfiguration :

``java
// autres annotations
@EnableAutoConfiguration(exclude = DataSourceAutoConfiguration.class)
public class MyConfiguration { }
```

Nous pouvons également désactiver une auto-configuration à l'aide de la propriété d'environnement

spring.autoconfigure.exclude.
Ce paramètre dans le fichier application.properties fait la même chose que précédemment :

``properties
spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfigur
ation
```

36. Comment utiliser Spring Boot pour les applications en ligne de commande ?

Comme tout autre programme Java, une application en ligne de commande Spring Boot doit avoir une
méthode main.

Cette méthode sert de point d'entrée, qui invoque la méthode SpringApplication#run pour démarrer
l'application :

``Java
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class) ;
// autres déclarations
}
}
```

La classe SpringApplication lance alors un conteneur Spring et configure automatiquement les

haricots.

Remarquez que nous devons passer une classe de configuration à la méthode run pour qu'elle serve de
source de configuration primaire.
Par convention, cet argument est la classe d'entrée elle-même.

Après avoir appelé la méthode run, nous pouvons exécuter d'autres instructions comme dans un
programme normal.

37.Quelles sont les sources possibles de configuration externe ?

Spring Boot prend en charge la configuration externe, ce qui nous permet d'exécuter la même
application dans différents environnements.
Nous pouvons utiliser des fichiers de propriétés, des fichiers YAML, des variables d'environnement,
des propriétés système et des arguments d'options de ligne de commande pour
spécifier des propriétés de configuration.

Nous pouvons ensuite accéder à ces propriétés à l'aide de l'annotation @Value, d'un objet lié à l'aide
de l'annotation
l'annotation @ConfigurationProperties, ou l'abstraction Environment.

38. Qu'est-ce que cela signifie que Spring Boot supporte le Relaxed Binding ?

La liaison détendue dans Spring Boot s'applique à la liaison sécurisée des propriétés de configuration.

Avec la liaison détendue, la clé d'une propriété n'a pas besoin de correspondre exactement au nom
d'une propriété.
Une telle propriété d'environnement peut être écrite en camelCase, kebab-case, snake_case, ou en
majuscules avec des mots séparés par des underscores.
séparés par des traits de soulignement.

Par exemple, si une propriété dans une classe de haricot avec l'annotation @ConfigurationProperties
est nommée myProp,
elle peut être liée à l'une des propriétés d'environnement suivantes : myProp, my-prop, my_prop ou
MY_PROP.

39. Comment écrire des tests d'intégration ?

Lors de l'exécution de tests d'intégration pour une application Spring, nous devons disposer d'un
ApplicationContext.

Pour nous faciliter la tâche, Spring Boot fournit une annotation spéciale pour les tests -
@SpringBootTest.
Cette annotation crée un ApplicationContext à partir des classes de configuration indiquées par son
attribut classes.

Si l'attribut classes n'est pas défini, Spring Boot recherche la classe de configuration primaire.
La recherche commence à partir du paquetage contenant le test jusqu'à ce qu'il trouve une classe
annotée
avec @SpringBootApplication ou @SpringBootConfiguration.

40. A quoi sert Spring Boot Actuator ?

Essentiellement, Actuator donne vie aux applications Spring Boot en activant des fonctionnalités
prêtes pour la production.
Ces fonctionnalités nous permettent de surveiller et de gérer les applications lorsqu'elles fonctionnent
en production.

Voici quelques-uns des points d'extrémité intégrés les plus courants fournis par Actuator :

+ env expose les propriétés de l'environnement

+ health affiche des informations sur la santé de l'application
+ httptrace affiche des informations sur la trace HTTP
+ info affiche des informations arbitraires sur l'application
+ metrics affiche des informations sur les métriques
+ loggers affiche et modifie la configuration des loggers dans l'application
+ mappings affiche une liste de tous les chemins @RequestMapping

41. Quelles sont les annotations de base offertes par Spring Boot ?

Les principales annotations offertes par Spring Boot se trouvent dans

org.springframework.boot.autoconfigure et ses sous-packages.

Voici quelques annotations de base :

+ @EnableAutoConfiguration - pour que Spring Boot recherche des beans d'autoconfiguration sur son
classpath et les applique automatiquement.
+ @SpringBootApplication - pour désigner la classe principale d'une application Boot. Cette
annotation combine @Configuration,
@EnableAutoConfiguration et @ComponentScan avec leurs attributs par défaut.

42.Quels sont les serveurs intégrés pris en charge par Spring Boot et comment changer la valeur par
défaut ?

A ce jour, Spring MVC supporte Tomcat, Jetty et Undertow. Tomcat est le serveur d'application par
défaut pris en charge
par le démarreur web de Spring Boot.

Spring WebFlux supporte Reactor Netty, Tomcat, Jetty et Undertow avec Reactor Netty par défaut.

Dans Spring MVC, pour changer la valeur par défaut, disons pour Jetty, nous devons exclure Tomcat
et inclure Jetty dans les dépendances.

43. Quels sont les sous-projets Spring que vous connaissez ? Décrivez-les brièvement.

+ Core - un module clé qui fournit des parties fondamentales du cadre, telles que IoC ou DI
+ JDBC - permet une couche d'abstraction JDBC qui supprime la nécessité de coder JDBC pour les
bases de données d'un fournisseur spécifique.
+ Intégration ORM - fournit des couches d'intégration pour les API de mappage objet-relationnel les
plus répandues, telles que JPA, JDO et Hibernate.
+ Web - un module d'intégration orienté web qui permet le téléchargement de fichiers en plusieurs
parties,
Web - un module d'intégration orienté web qui fournit des fonctionnalités de téléchargement de
fichiers multipartites, d'écoute de servlets et de contexte d'application orienté web
+ Cadre MVC - module web mettant en œuvre le modèle de conception Modèle-Vue-Contrôleur
(MVC)
+ Module AOP - implémentation de la programmation orientée aspect permettant la définition
d'intercepteurs de méthodes et de raccourcis propres.

44. Qu'est-ce que l'injection de dépendance ?

L'injection de dépendance, un aspect de l'inversion de contrôle (IoC), est un concept général selon
lequel nous ne créons pas nos objets manuellement, mais nous décrivons la manière dont ils doivent
être créés.
objets manuellement, mais que nous décrivons la manière dont ils doivent être créés.
Ensuite, un conteneur IoC instanciera les classes requises si nécessaire.

45. Comment pouvons-nous injecter des beans dans Spring ?

Il existe quelques options différentes pour injecter des beans Spring :
+ injection de setter
+ Injection de constructeur
+ Injection de champ
La configuration peut se faire à l'aide de fichiers XML ou d'annotations.

46. Quelle est la meilleure façon d'injecter des beans et pourquoi ?

L'approche recommandée est d'utiliser des arguments de constructeur pour les dépendances
obligatoires et des paramètres pour les dépendances optionnelles.
En effet, l'injection de constructeur permet d'injecter des valeurs dans des champs immuables et
facilite les tests.

47. Qu'est-ce qu'un Spring Bean ?

Les Spring Beans sont des objets Java qui sont initialisés par le conteneur Spring IoC.

48. Quelle est la portée par défaut d'un Bean dans Spring Framework ?
Par défaut, un Spring Bean est initialisé en tant que singleton.
49.Comment définir la portée d'un Bean ?
Pour définir la portée d'un Spring Bean, on peut utiliser l'annotation @Scope ou l'attribut "scope" dans
les fichiers de configuration XML. Notez qu'il y a cinq portées supportées :
+ Singleton
+ Prototype
+ Requête
+ Session
+ Session globale

50.Les Singleton Beans sont-ils sûrs pour les threads ?

Non, les beans singleton ne sont pas sûrs pour les threads, car la sécurité des threads concerne
l'exécution,
alors que le singleton est un modèle de conception qui se concentre sur la création. La sécurité des
threads dépend uniquement de l'implémentation du bean lui-même.

51. A quoi ressemble le cycle de vie d'un Spring Bean ?

Tout d'abord, un Spring Bean doit être instancié sur la base d'une définition Java ou XML.
Il peut également être nécessaire d'effectuer une certaine initialisation pour le rendre utilisable.
Ensuite, lorsque le bean n'est plus nécessaire, il est retiré du conteneur IoC.

52. Qu'est-ce que Spring Security ?

Spring Security est un module séparé du framework Spring qui se concentre sur la fourniture de
méthodes d'authentification et d'autorisation dans les applications Java.
et d'autorisation dans les applications Java. Il s'occupe également de la plupart des vulnérabilités de
sécurité courantes
telles que les attaques CSRF.
Pour utiliser Spring Security dans les applications web, nous pouvons commencer par la simple
annotation @EnableWebSecurity.
53. Nommez quelques-uns des modèles de conception utilisés dans le cadre Spring ?

+ Singleton Pattern - haricots à portée de singleton

+ Modèle d'usine - classes d'usine de haricots
+ Modèle de prototype - haricots à portée de prototype
+ Modèle d'adaptateur - Spring Web et Spring MVC
+ Modèle de proxy - support de Spring Aspect-Oriented Programming
+ Modèle de méthode modèle - JdbcTemplate, HibernateTemplate, etc.
+ Contrôleur frontal - Spring MVC DispatcherServlet
+ Objet d'accès aux données - support Spring DAO
+ Contrôleur modèle-vue - Spring MVC

54. Quel est le rôle de l'annotation @Autowired ?

L'annotation @Autowired peut être utilisée avec des champs ou des méthodes pour injecter un bean
par type.
Cette annotation permet à Spring de résoudre et d'injecter des beans collaborateurs dans votre bean.

55.Quel est le rôle de l'annotation @Qualifier ?

Elle est utilisée en même temps que l'annotation @Autowired pour éviter toute confusion lorsque
plusieurs instances d'un type de haricot sont présentes.

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

+ @Controller - indique que la classe joue le rôle d'un contrôleur,

et détecte les annotations @RequestMapping dans la classe.
+ @Service - indique que la classe contient une logique commerciale et appelle des méthodes dans la
couche de référentiel.
+ @Repository - indique que la classe définit un référentiel de données ; son rôle est d'attraper les
exceptions spécifiques à la plate-forme et de les relancer dans le cadre d'une des couches du
référentiel.
et de les relancer comme l'une des exceptions unifiées et non vérifiées de Spring.

57. Qu'est-ce qu'un contrôleur dans Spring MVC ?

En termes simples, toutes les demandes traitées par le DispatcherServlet sont dirigées vers des classes
annotées avec @Controller.
Chaque classe de contrôleur associe une ou plusieurs demandes à des méthodes qui traitent et
exécutent les demandes avec les données d'entrée fournies.

58.Comment fonctionne l'annotation @RequestMapping ?

L'annotation @RequestMapping est utilisée pour faire correspondre les requêtes web aux méthodes du
contrôleur Spring. Outre les cas d'utilisation simples, nous pouvons l'utiliser pour le mappage des en-
têtes HTTP,
nous pouvons l'utiliser pour mapper les en-têtes HTTP, lier des parties de l'URI avec @PathVariable,
et travailler avec des paramètres URI et l'annotation @RequestParam.
et l'annotation @RequestParam.
59. Expliquer la différence entre @Controller et @RestController ?
La principale différence entre les annotations @Controller et @RestController est que l'annotation
@ResponseBody
est automatiquement incluse dans le @RestController. Cela signifie que nous n'avons pas besoin
d'annoter nos méthodes de traitement avec l'annotation
avec le @ResponseBody. Nous devons le faire dans une classe @Controller si nous voulons écrire le
type de réponse directement dans le corps de la réponse HTTP.
dans le corps de la réponse HTTP.

60. Décrire une variable de chemin d'accès

Nous pouvons utiliser l'annotation @PathVariable comme paramètre d'une méthode de traitement afin
d'extraire la valeur d'une variable de modèle URI.

Par exemple, si nous voulons récupérer un utilisateur par son identifiant à partir de
www.mysite.com/user/123,
nous devrions mapper notre méthode dans le contrôleur comme /user/{id} :

``Java
@RequestMapping("/user/{id}")
public String handleRequest(@PathVariable("id") String userId, Model map) {}
```
La variable @PathVariable n'a qu'un seul élément nommé value. Il est facultatif et nous l'utilisons
pour définir le nom de la variable du modèle URI.
Si nous omettons l'élément value, le nom de la variable modèle URI doit correspondre au nom du
paramètre de la méthode.

Il est également permis d'avoir plusieurs annotations @PathVariable, soit en les déclarant l'une après
l'autre :

``java
@RequestMapping("/user/{userId}/name/{userName}")
public String handleRequest(@PathVariable String userId,
@PathVariable String userName, Model map) {}
```
ou en les plaçant tous dans une Map<String, String> ou MultiValueMap<String, String> :
``Java
@RequestMapping("/user/{userId}/name/{userName}")
public String handleRequest(@PathVariable Map<String, String> varsMap, Model map) {}}

61. Validation à l'aide de Spring MVC

Spring MVC prend en charge les spécifications JSR-303 par défaut. Nous devons ajouter JSR-303 et
ses dépendances d'implémentation à notre
à notre application Spring MVC. Hibernate Validator, par exemple, est l'une des implémentations JSR-
303 à notre disposition.

La JSR-303 est une spécification de l'API Java pour la validation des beans, qui fait partie de Jakarta
EE et de JavaSE, et qui garantit
que les propriétés d'un bean répondent à des critères spécifiques, en utilisant des annotations telles que
@NotNull, @Min et @Max.

Spring propose l'annotation @Validator et la classe BindingResult. L'implémentation du validateur

lèvera des erreurs dans
la méthode de traitement des requêtes du contrôleur lorsque les données ne sont pas valides. Nous
pouvons alors utiliser la classe BindingResult pour obtenir ces erreurs.

62. Que sont les annotations @RequestBody et @ResponseBody ?

L'annotation @RequestBody, utilisée comme paramètre d'une méthode de traitement, lie le corps de la
requête HTTP à un transfert ou à un objet de domaine.
un objet de domaine. Spring désérialise automatiquement les requêtes HTTP entrantes en objets Java à
l'aide des convertisseurs de messages Http.

Lorsque nous utilisons l'annotation @ResponseBody sur une méthode de traitement dans le contrôleur
Spring MVC,
elle indique que nous écrirons le type de retour de la méthode directement dans le corps de la réponse
HTTP.
Nous ne le placerons pas dans un modèle et Spring ne l'interprétera pas comme un nom de vue.

63. Qu'est-ce que le BindingResult ?

BindingResult est une interface du paquet org.springframework.validation qui représente les résultats
de la liaison.
Nous pouvons l'utiliser pour détecter et signaler les erreurs dans le formulaire soumis.
Il est facile de l'invoquer - nous devons juste nous assurer que nous le plaçons en tant que paramètre
juste après l'objet du formulaire que nous validons.
Le paramètre optionnel Model doit venir après le BindingResult, comme on peut le voir dans le
tutoriel du validateur personnalisé :

``Java
@PostMapping("/user")
public String submitForm(@Valid NewUserForm newUserForm,
BindingResult result, Model model) {
if (result.hasErrors()) {
return "userHome" ;
}
model.addAttribute("message", "Valid form") ;
return "userHome" ;
}
```

Lorsque Spring voit l'annotation @Valid, il essaie d'abord de trouver le validateur de l'objet à valider.

64.Qu'est-ce que la classe Spring JdbcTemplate et comment l'utiliser ?

Le modèle Spring JDBC est la principale API qui nous permet d'accéder à la logique des opérations de
base de données qui nous intéressent :
Création et fermeture de connexions
Exécution d'instructions et d'appels de procédures stockées
L'itération sur le ResultSet et le retour des résultats.
Pour l'utiliser, nous devons définir la configuration simple de DataSource :

``java
@Configuration
@ComponentScan("org.baeldung.jdbc")
public class SpringJdbcConfig {
@Bean
public DataSource mysqlDataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource() ;
dataSource.setDriverClassName("com.mysql.jdbc.Driver") ;
dataSource.setUrl("jdbc:mysql://localhost:3306/springjdbc") ;
dataSource.setUsername("guest_user") ;
dataSource.setPassword("guest_password") ;

return dataSource ;
}
}
```

65. Comment activer les transactions dans Spring et quels sont leurs avantages ?

Il existe deux façons distinctes de configurer les transactions - avec des annotations
ou en utilisant la Programmation Orientée Aspect (AOP) - chacune avec ses avantages.

Voici les avantages de l'utilisation de Spring Transactions, selon la documentation officielle :

+ Fournir un modèle de programmation cohérent entre les différentes API de transaction telles que
JTA, JDBC, Hibernate, JPA et JDO.
+ Prise en charge de la gestion déclarative des transactions
+ Fournir une API plus simple pour la gestion programmatique des transactions que certaines API de
transaction complexes telles que JTA
+ S'intègre très bien avec les différentes abstractions d'accès aux données de Spring.

66. Qu'est-ce que Spring DAO ?

Spring Data Access Object (DAO) est le support fourni par Spring pour travailler avec des
technologies d'accès aux données telles que JDBC,
Hibernate et JPA de manière cohérente et simple.

67. Expliquer un advice controller

@ControllerAdvice est une annotation dans Spring qui permet d'écrire du code global
applicable à une gamme de contrôleurs. Elle peut être appliquée à des packages ou des
classes spécifiques à l'aide de propriétés telles que basePackages ou
basePackageClasses. Cette annotation est souvent utilisée en conjonction avec
@ExceptionHandler pour créer un mécanisme global de gestion des erreurs pour les
exceptions générées par les contrôleurs. L'annotation @ExceptionHandler permet de
définir des méthodes qui gèrent des exceptions spécifiques de manière globale, évitant ainsi
la nécessité de traiter les exceptions dans chaque contrôleur individuellement. Il est
important d'associer l'exception déclarée dans @ExceptionHandler à l'exception réellement
générée pour assurer une gestion appropriée. Plusieurs méthodes @ExceptionHandler
peuvent être définies pour différentes exceptions, offrant ainsi une flexibilité dans la
configuration de la gestion des erreurs.

68. What Does the @ExceptionHandler Annotation Do?

En résumé, l'annotation @ExceptionHandler permet de définir une méthode qui gère les
exceptions. Il est recommandé de l'utiliser avec l'annotation @ControllerAdvice pour
configurer un mécanisme de gestion globale des erreurs. Cela évite d'avoir à répéter le code
de gestion des exceptions dans chaque contrôleur. L'exemple donné dans l'article montre
comment utiliser l'annotation pour gérer les exceptions IllegalArgumentException et
IllegalStateException. Il est important de noter que les exceptions déclarées avec
@ExceptionHandler doivent correspondre à l'exception utilisée comme argument de la
méthode. De plus, il est possible de définir plusieurs méthodes @ExceptionHandler pour la
même exception.

69.Gestion des exceptions dans les applications Web

Nous disposons de trois options pour la gestion des exceptions dans Spring MVC :

+ par exception
+ par contrôleur
+ globalement
Si une exception non gérée est levée pendant le traitement d'une requête web, le serveur renverra une
réponse HTTP 500.
Pour éviter cela, nous devons annoter toutes nos exceptions personnalisées avec l'annotation
@ResponseStatus.
Ce type d'exception est résolu par le HandlerExceptionResolver.

Cela permettra au serveur de renvoyer une réponse HTTP appropriée avec le code d'état spécifié
lorsqu'une méthode du contrôleur
lève notre exception. Nous devons garder à l'esprit que nous ne devons pas gérer notre exception
ailleurs pour que cette approche fonctionne.

Une autre façon de gérer les exceptions est d'utiliser l'annotation @ExceptionHandler.
Nous ajoutons des méthodes @ExceptionHandler à n'importe quel contrôleur et les utilisons pour
gérer les exceptions lancées à l'intérieur de ce contrôleur.
Ces méthodes peuvent gérer les exceptions sans l'annotation @ResponseStatus, rediriger l'utilisateur
vers une vue d'erreur dédiée,
ou construire une réponse d'erreur totalement personnalisée.

Nous pouvons également passer les objets liés au servlet (HttpServletRequest, HttpServletResponse,
HttpSession et Principal)
comme paramètres des méthodes de traitement. Cependant, nous devons nous rappeler que nous ne
pouvons pas mettre l'objet Model en tant que paramètre directement.

La troisième option pour gérer les erreurs est d'utiliser les classes @ControllerAdvice. Elles nous
permettront d'appliquer les mêmes techniques,
mais cette fois au niveau de l'application et pas seulement à un contrôleur particulier.
Gestion des versions
Gestion des versions.
Gestion des version