Spring-Boot
Debutant
Quiz-Springboot-Debutant
Spring-Annotations
Ioc
Spring-Beans
Spring-Data-Jpa
Rest-Controllers
Auto-Configuration
Questions-Entretien-Spring
Qcm-Springboot
Java
Framework-Backend
Back-End
📝
Entretien Spring Boot Débutant : annotations et IoC
20 questions Spring Boot niveau débutant : annotations, IoC, beans, Spring Data JPA, REST controllers, application.properties et auto-configuration pour entretien.
Banque de révision : les 30 questions corrigées
Voici l'intégralité des 30 questions de « Entretien Spring Boot Débutant : annotations et IoC », chacune avec sa bonne réponse et son explication. Le quiz interactif ci-dessus en tire une sélection aléatoire à chaque tentative — utilisez cette liste complète pour réviser.
Explication :
Spring Boot est un framework qui facilite la création d'applications Spring en fournissant de l'auto-configuration, un serveur embarqué (Tomcat, Jetty) et des starters pour simplifier les dépendances.
Spring Boot suit le principe "Convention over Configuration". Il suffit d'ajouter la dépendance
spring-boot-starter-web pour avoir une application web fonctionnelle.
Explication :
@SpringBootApplication est une annotation de commodité qui combine trois annotations : @Configuration, @EnableAutoConfiguration et @ComponentScan.
La classe annotée avec
@SpringBootApplication doit contenir la méthode public static void main(String[] args) et appeler SpringApplication.run().
Explication :
Les starters (ex:
spring-boot-starter-web) sont des POM qui regroupent toutes les dépendances nécessaires pour une fonctionnalité. Ils simplifient la gestion des dépendances et évitent les conflits de versions.
Quelques starters essentiels :
spring-boot-starter-web (REST), spring-boot-starter-data-jpa (BDD), spring-boot-starter-test (tests).
Explication :
Les propriétés de configuration se trouvent dans
application.properties ou application.yml (ou application.yaml), situés dans src/main/resources/.
Spring Boot charge automatiquement ce fichier. Vous pouvez avoir des profils différents avec
application-dev.properties ou application-prod.properties.
Explication :
L'auto-configuration (
@EnableAutoConfiguration) analyse le classpath et configure automatiquement les beans nécessaires. Si spring-webmvc est présent, Spring Boot configure automatiquement DispatcherServlet.
Vous pouvez exclure des auto-configurations avec
@EnableAutoConfiguration(exclude = { DataSourceAutoConfiguration.class }).
Explication :
@RestController est une annotation spécialisée qui combine @Controller et @ResponseBody. Toutes les méthodes retournent directement des données (JSON/XML) au lieu de vues.
Pour un contrôleur MVC classique (avec vues), utilisez
@Controller. Pour une API REST, utilisez @RestController.
Explication :
@GetMapping("/chemin") est un raccourci pour @RequestMapping(method = RequestMethod.GET). Il existe aussi @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping.
Exemple complet :
@GetMapping("/users/{id}") public User getUser(@PathVariable Long id) { ... }.
Explication :
L'injection de dépendances se fait via
@Autowired. La méthode recommandée est l'injection par constructeur (plus testable, immuable). Depuis Spring 4.3, @Autowired est optionnel si la classe a un seul constructeur.
Préférez l'injection par constructeur :
public UserService(UserRepository repo) { this.repo = repo; }. C'est plus sûr et facilite les tests.
Explication :
@Entity (JPA) indique que la classe est une entité persistante. Chaque instance correspond à une ligne dans une table de base de données. On utilise aussi @Id pour la clé primaire et @GeneratedValue pour l'auto-incrémentation.
Par défaut, le nom de la table est le nom de la classe. Pour le personnaliser :
@Table(name = "utilisateurs").
Explication :
Il suffit de créer une interface qui étend
JpaRepository<Entite, Long>. Spring Data JPA génère automatiquement l'implémentation avec les méthodes CRUD de base (save, findById, findAll, delete).
Pour des requêtes personnalisées, utilisez les query methods :
List<User> findByLastName(String lastName);. Spring génère la requête SQL automatiquement.
Explication :
Spring Boot inclut un serveur embarqué (Tomcat par défaut). L'application se lance comme un JAR autonome avec
java -jar monapp.jar, sans déployer de WAR sur un serveur externe.
Pour changer de serveur, excluez Tomcat et incluez Jetty ou Undertow dans vos dépendances.
Explication :
@PathVariable lie une variable du template d'URL à un paramètre de méthode. Exemple : @GetMapping("/users/{id}") public User getUser(@PathVariable Long id).
Si le nom du paramètre diffère du nom dans l'URL :
@PathVariable("id") Long userId.
Explication :
@Service est un stéréotype Spring qui indique que la classe contient la logique métier. C'est une spécialisation de @Component. Elle permet la détection automatique via le classpath scanning.
Techniquement,
@Service est identique à @Component, mais elle apporte une sémantique métier claire dans votre code.
Explication :
Dans
application.properties : server.port=8081. Dans application.yml : server: port: 8081. On peut aussi le passer en ligne de commande : --server.port=8081.
Pour désactiver complètement le serveur web (application batch) :
spring.main.web-application-type=none.
Explication :
Les profils permettent de définir des configurations différentes par environnement. On peut avoir
application-dev.properties et application-prod.properties, activés via spring.profiles.active=dev.
Activez un profil en ligne de commande :
java -jar app.jar --spring.profiles.active=prod.
Explication :
@RequestParam extrait les paramètres de la query string. Exemple : /users?page=1 → @RequestParam int page. On peut rendre le paramètre optionnel : @RequestParam(defaultValue = "0") int page.
Pour un paramètre optionnel sans valeur par défaut :
@RequestParam(required = false) String filter.
Explication :
@ExceptionHandler dans un contrôleur gère les exceptions spécifiques. @ControllerAdvice permet une gestion globale des exceptions pour tous les contrôleurs. Spring fournit aussi ResponseEntityExceptionHandler.
Créez une classe annotée
@RestControllerAdvice avec des méthodes @ExceptionHandler pour centraliser la gestion des erreurs.
Explication :
CommandLineRunner et ApplicationRunner sont des interfaces avec une méthode run() exécutée après l'initialisation du contexte Spring. On peut avoir plusieurs runners, ordonnés avec @Order. CommandLineRunner reçoit les arguments bruts (String[]), ApplicationRunner reçoit les arguments parsés (ApplicationArguments).
Explication :
@Value("${propriete}") injecte la valeur d'une propriété de configuration dans un champ. On peut aussi fournir une valeur par défaut : @Value("${propriete:defaut}").
Pour injecter des propriétés complexes, utilisez
@ConfigurationProperties sur une classe dédiée.
Explication :
Deux façons principales : 1) Annoter une classe avec
@Component (ou stéréotypes), scannée automatiquement. 2) Déclarer une méthode @Bean dans une classe @Configuration pour un contrôle explicite.
Utilisez
@Bean quand vous ne contrôlez pas le code source de la classe (ex: beans de bibliothèques tierces).
Explication :
Spring Data JPA facilite l'implémentation de la couche d'accès aux données. Il suffit de définir des interfaces étendant
JpaRepository. Les méthodes CRUD et les query methods sont générées automatiquement.
Pour des requêtes complexes, utilisez
@Query avec JPQL ou SQL natif : @Query("SELECT u FROM User u WHERE u.email = ?1").
Explication :
Spring s'intègre avec Bean Validation (javax.validation / jakarta.validation). On annote le DTO avec
@NotNull, @Size, @Email, et on ajoute @Valid dans le contrôleur.
Pour les groupes de validation :
@Validated(OnCreate.class). Très utile pour différencier la création et la mise à jour.
Explication :
Spring Boot Actuator (dépendance
spring-boot-starter-actuator) expose des endpoints comme /actuator/health (santé), /actuator/metrics (métriques), /actuator/info.
En production, sécurisez les endpoints Actuator avec Spring Security. Exposez uniquement ce qui est nécessaire.
Explication :
Spring Boot configure automatiquement une datasource si les drivers sont dans le classpath. Il suffit de définir
spring.datasource.url, username, password et driver-class-name.
Pour du développement rapide, utilisez H2 (base en mémoire) :
spring.datasource.url=jdbc:h2:mem:testdb.
Explication :
Spring Data REST (dépendance
spring-boot-starter-data-rest) expose automatiquement les repositories JPA en API REST. Un UserRepository devient accessible via /users avec GET, POST, PUT, DELETE.
Pour personnaliser les endpoints, utilisez
@RepositoryRestResource(path = "utilisateurs").
Explication :
SpringApplication.run(MaClasse.class, args) est le point d'entrée. Elle crée le ApplicationContext, déclenche l'auto-configuration, scanne les composants et démarre le serveur embarqué.
Vous pouvez personnaliser le démarrage avec
new SpringApplicationBuilder(MaClasse.class).profiles("dev").run(args).
Explication :
@Transactional définit une méthode ou classe comme transactionnelle. Spring gère le début, le commit (si OK) et le rollback (si exception non vérifiée). Cela garantit l'intégrité des données.
Par défaut, le rollback se fait pour les RuntimeException et Error. Pour les exceptions vérifiées, utilisez
@Transactional(rollbackFor = Exception.class).
Explication :
On peut exclure via
@EnableAutoConfiguration(exclude = { SecurityAutoConfiguration.class }) ou via spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.
Utilisez cette fonctionnalité avec précaution. Comprenez d'abord pourquoi l'auto-configuration ne convient pas avant de l'exclure.
Explication :
Spring Boot DevTools (
spring-boot-devtools) offre le redémarrage automatique lors de changements de code, le LiveReload pour rafraîchir le navigateur, et désactive certains caches en développement.
En production, DevTools est automatiquement désactivé. Incluez-le en dépendance
optional ou developmentOnly.
Explication :
La structure recommandée :
com.example.demo (package racine), avec .controller, .service, .repository, .model (ou .entity), .dto, .config, .exception.
Le package racine doit contenir la classe
@SpringBootApplication. Les sous-packages sont automatiquement scannés. 
Quiz
Junior
20 questions
15 min
Entretien Spring Boot Junior : Security et JPA
Quiz
Senior
20 questions
15 min
Entretien Spring Boot Senior : microservices et cloud
Quiz
Débutant
20 questions
15 min
NestJS Débutant — Modules & Services
Quiz
Débutant
20 questions
15 min
Entretien TypeScript Débutant — Types et Interfaces
Quiz
Débutant
20 questions
15 min
Entretien Next.js Débutant : pages, routing et SSR
Quiz
Débutant
20 questions
15 min
Entretien JavaScript Débutant : variables et syntaxe
Quiz
Débutant
20 questions
15 min
HTML Débutant — Balises et structure
Quiz
Débutant
20 questions
15 min
Scrum Débutant — Rôles et Artifacts
Quiz
Débutant
20 questions
15 min
Entretien Git Débutant — Commits, Branches et Remote
Quiz
Débutant
20 questions
15 min
Entretien Node.js Débutant — Modules, NPM et Callbacks
Quiz
Débutant
20 questions
15 min
Entretien React Débutant — Composants, Props et State
Quiz
Débutant
20 questions
15 min
Entretien Tailwind CSS Débutant — Utilities et Bases
Quiz
Débutant
20 questions
15 min
Entretien CSS Débutant — Sélecteurs et Box Model
Quiz
Débutant
20 questions
15 min
Entretien Angular Débutant — Composants, Pipes et Routing
Quiz
Débutant
20 questions
15 min
jQuery Débutant — DOM & Sélecteurs
Quiz
Senior
20 questions
15 min
Entretien Node.js Senior — Performance, Streams et Scaling
Quiz
Junior
20 questions
15 min
Entretien Node.js Junior — Express, REST et Middleware
Quiz
Senior
20 questions
15 min
Entretien TypeScript Senior — Decorators et Utility Types
Quiz
Junior
20 questions
15 min
Entretien TypeScript Junior — Generics, Classes et Modules
Quiz
Débutant
20 questions
15 min