Quelles sont les questions et réponses d'entretien pour SpringBoot ?

1. Qu'est-ce que Spring Boot ?

Spring Boot est un sous-projet de l'organisation open source Spring. Il s'agit d'une solution unique pour les composants Spring. Elle simplifie principalement la difficulté d'utilisation de
Spring, enregistre une configuration lourde et fournit divers lanceurs afin que les développeurs puissent obtenir. a commencé rapidement.

2. Pourquoi utiliser SpringBoot

Développement rapide, intégration rapide, configuration simplifiée, conteneur de services intégré

3 La différence entre SpringBoot et SpringCloud

SpringBoot est un framework Spring développé rapidement, SpringCloud est un framework de microservices complet, SpringCloud Depends. sur SpringBoot.

4. Quels sont les avantages de Spring Boot ?

Spring Boot présente principalement les avantages suivants : il est facile de démarrer, améliore l'efficacité du développement et fournit un cadre de développement plus rapide et plus simple pour le développement Spring. Fonctionne immédiatement, sans configuration fastidieuse. Il fournit une série de fonctions non commerciales communes aux projets à grande échelle, telles que les serveurs embarqués, la gestion de la sécurité, la surveillance des données d'exploitation, le contrôle de santé et la configuration externe, etc. Le résumé de Spring Boot est de simplifier le codage, la configuration, le déploiement et la surveillance, etc.

5. Quelles sont les principales annotations de Spring Boot ?

De quelles annotations se compose-t-il principalement ? L'annotation sur la classe de démarrage est @SpringBootApplication, qui est également l'annotation principale de Spring Boot. La combinaison principale comprend les trois annotations suivantes : @SpringBootConfiguration : combine l'annotation @Configuration pour implémenter la fonction du fichier de configuration. @EnableAutoConfiguration : activez la fonction de configuration automatique ou désactivez une option de configuration automatique, par exemple :
@ComponentScan : analyse des composants Spring.
java 如关闭数据源自动配置功能： @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。6. Quels frameworks de journalisation Spring Boot prend-il en charge ? Quel est le cadre de journalisation recommandé et par défaut ?

Spring Boot prend en charge Java Util Logging, Log4j2 et Lockback comme frameworks de journalisation. Si vous utilisez Starters pour lancer

, Spring Boot utilisera Logback comme framework de journalisation par défaut, mais quel que soit le framework de journalisation, il prend en charge la sortie des fichiers de configuration. à consoler ou à classer.

7. Le principe de fonctionnement de SpringBoot Starter

Je comprends personnellement que SpringBoot est composé de différents Starters. Nous pouvons également développer le Starter nous-mêmes. Lorsque sprinBoot démarre, l'annotation @SpringBootApplication ira automatiquement à maven pour lire les informations contenues dans chacun. starter. le fichier

spring.factories, qui configure tous les beans qui doivent être créés dans le conteneur Spring et effectue une configuration automatique pour injecter le

bean dans SpringContext // (SpringContext est le fichier de configuration de Spring)

8. .X Quoi de neuf ? En quoi est-ce différent de 1.X ?

Changement de configuration Mise à niveau de la version JDK Mise à niveau de la bibliothèque de classes tierce La programmation Responsive Spring prend en charge HTTP/2 Prise en charge de la liaison des attributs de configuration Plus d'améliorations et d'améliorations

9. Quels modèles frontaux SpringBoot prend-il en charge

thymeleaf, freemarker, jsp, officiellement ? non recommandé JSP aura des limites

10. Inconvénients de SpringBoot

Je pense que c'est embarrassant. Je ne pense pas que SpringBoot ait des défauts pour le moment. Si je dois en trouver un, je pense que c'est parce que je n'en ai pas besoin. pour le configurer moi-même, il est donc difficile de localiser le moment où une erreur est signalée.

11. Quelles sont les manières d’exécuter Spring Boot ?

Emballez-le avec des commandes ou placez-le dans un conteneur pour l'exécuter

Utilisez le plug-in Maven/Gradle pour exécuter

Exécutez directement la méthode principale pour l'exécuter

12. Spring Boot doit-il être exécuté dans un conteneur indépendant ?

Pas besoin de conteneurs intégrés tels que Tomcat/Jetty.

13. Quels sont les moyens d'activer les fonctionnalités de Spring Boot ?

Hériter du projet spring-boot-starter-parent

Importer les dépendances du projet spring-boot-dependencies

14 Quelles sont les manières d'implémenter un déploiement à chaud dans SpringBoot ?

Le déploiement à chaud signifie que le code d'arrière-plan de l'opération peut être automatiquement mis à jour dans le projet en cours sans réexécuter le projet SpringBoot.

Il existe deux manières principales :

Spring Loaded

Spring-boot-devtools

15. choses

Les choses dans Spring Boot sont très simples. Utilisez d'abord l'annotation EnableTransactionManagement pour ouvrir l'objet, puis ajoutez l'annotation Transactional à la méthode

Service.

16. Méthode d'appel asynchrone asynchrone

L'utilisation des appels asynchrones dans SpringBoot est très simple. Il vous suffit d'utiliser l'annotation @Async sur la méthode pour réaliser un appel asynchrone de la méthode. Remarque : Vous devez ajouter @EnableAsync à la classe de démarrage pour que l'annotation d'appel asynchrone @Async prenne effet.

17. Comment exécuter un code spécifique au démarrage de Spring Boot ?

Vous pouvez implémenter l'interface ApplicationRunner ou CommandLineRunner. Ces deux interfaces sont implémentées de la même manière. Elles

ne fournissent qu'une seule méthode d'exécution

18. Quelles sont les manières de lire la configuration dans Spring Boot ?

Spring Boot peut lier des variables via les annotations @PropertySource, @Value, @Environment, @ConfigurationPropertie

19. Qu'est-ce que JavaConfig ?

Spring JavaConfig est un produit de la communauté Spring. Il a été introduit dans Spring 3.0. Il fournit une méthode
pur Java pour configurer le conteneur Spring IOC. Cela permet donc d'éviter d'utiliser la configuration XML. Les avantages de l'utilisation de JavaConfig sont :
Configuration orientée objet. Les configurations étant définies sous forme de classes dans JavaConfig, les utilisateurs peuvent profiter pleinement des fonctionnalités orientées objet de Java. Une classe de configuration peut hériter d'une autre, remplacer ses méthodes @Bean, etc.
Réduisez ou éliminez la configuration XML. Les avantages d’une configuration externalisée basée sur les principes d’injection de dépendances ont été prouvés. Cependant, de nombreux développeurs ne souhaitent pas basculer entre XML et Java. JavaConfig fournit aux développeurs un moyen purement Java de configurer des conteneurs Spring similaires aux concepts de configuration XML. D'un point de vue technique, il est possible de configurer un conteneur en utilisant uniquement la classe de configuration JavaConfig, mais en pratique, de nombreuses personnes pensent que mélanger et faire correspondre JavaConfig avec XML est idéal.
Type sûr et convivial pour la refactorisation. JavaConfig fournit un moyen sécurisé de configurer les conteneurs Spring. Grâce à la prise en charge des génériques par Java
5.0, il est désormais possible de récupérer les beans par type plutôt que par nom, sans avoir besoin de transtypages ou de recherches basées sur des chaînes.
Config Java couramment utilisée :
@Configuration : Écrivez cette annotation sur la classe pour indiquer que cette classe est une classe de configuration
@ComponentScan : Ajoutez l'annotation @ComponentScan sur la classe de configuration. Cette annotation analysera toutes les classes de configuration sous le package où la classe se trouve par défaut, ce qui équivaut au précédent.
@Bean : injection de bean : équivalent au précédent < bean id="objectMapper"
class="org.codehaus.jackson.map.ObjectMapper" />
@EnableWebMvc : équivalent au
@ImportResource : équivalent à xml< import resource="applicationContextcache.xml">

20. Quel est le principe de configuration automatique de SpringBoot

Il s'agit principalement de l'annotation de base de la classe de démarrage de Spring Boot. Annotation SpringBootApplication Classe de configuration principale. . Avec cette configuration principale, lorsque la classe est démarrée, une fonction de configuration automatique d'annotation @EnableAutoConfiguration sera activée pour SpringBoot.

Avec cet EnableAutoConfiguration, il va :
Charger les classes d'auto-configuration utilisables à partir du fichier de configuration META_INF/Spring.factories
Supprimer la duplication, et exclure les classes portées par les attributs Exclure et ExclureName
Filtre, et les conditions ( @Conditional) sera respecté. La classe de configuration automatique renvoie

21. Comment comprenez-vous l'ordre de chargement de la configuration Spring Boot ?

Dans Spring Boot, vous pouvez utiliser les méthodes suivantes pour charger la configuration.

1.fichier propriétés ;

2.fichier YAML ;
3. Variables d'environnement système ;
4. Paramètres de ligne de commande ;
etc......

22.

YAML est un langage de sérialisation de données lisible par l'homme. Il est généralement utilisé dans les fichiers de configuration. Comparés aux fichiers de propriétés, les fichiers YAML sont plus structurés et moins déroutants si l'on souhaite

ajouter des propriétés complexes dans un fichier de configuration. On peut voir que YAML possède des données de configuration hiérarchiques.

23. Quels sont les avantages de la configuration YAML ?

YAML peut désormais être considéré comme un format de fichier de configuration très populaire, visible à la fois en front-end et en back-end. Alors, quels sont les avantages de la configuration YAML par rapport à la configuration des propriétés traditionnelles ?

Configuration ordonnée. Dans certains scénarios particuliers, une configuration ordonnée est cruciale

Elle est concise et claire. Les éléments du tableau peuvent être des types de données ou des objets de base. a L'inconvénient est qu'il ne prend pas en charge l'annotation @PropertySource pour importer une configuration YAML personnalisée.

24. Spring Boot peut-il utiliser la configuration XML ?

Spring Boot recommande d'utiliser la configuration Java au lieu de la configuration XML, mais la configuration XML peut également être utilisée dans Spring Boot. Une configuration XML peut être introduite via l'annotation @ImportResource.

25. Quel est le fichier de configuration de base de Spring Boot ? Quelle est la différence entre bootstrap.properties et application.properties ?

Si vous développez simplement Spring Boot, il n'est peut-être pas facile de rencontrer le fichier de configuration bootstrap.properties, mais lorsqu'il est combiné avec Spring Cloud, cette configuration sera souvent rencontrés, notamment en cas de besoin lors du chargement de certains fichiers de configuration distants.

Deux fichiers de configuration au cœur du Spring Boot :

bootstrap (. yml ou . Properties) : boostrap est chargé par le ApplicationContext parent et est chargé avant l'application. La configuration prend effet dans la phase de démarrage du contexte d'application. De manière générale, nous utiliserons ce fichier dans la configuration Spring Cloud. Et les propriétés de boostrap ne peuvent pas être écrasées ;
application (. yml ou . Properties) : chargée par ApplicationContext, utilisée pour la configuration automatique du projet Spring Boot

.

26. Que sont les profils Spring ?

Lors du développement du projet, certains fichiers de configuration peuvent être différents selon les environnements tels que le développement, les tests ou la production, comme la connexion à la base de données
la connexion, la configuration redis, etc. Alors, comment changer automatiquement de configuration dans différents environnements ? Spring nous fournit le mécanisme
profiles qui nous offre la fonction de basculer les fichiers de configuration d'avant en arrière.
Spring Profiles permet aux utilisateurs d'enregistrer des beans en fonction des fichiers de configuration (dev, test, prod, etc.). . Ainsi, lorsque l'application
est en cours de développement, seuls certains beans peuvent être chargés, tandis qu'en PRODUCTION, certains autres beans peuvent être chargés.
Supposons que notre exigence soit que la documentation Swagger soit uniquement disponible dans l'environnement QA et que toutes les autres documentations soient désactivées. Cela peut être fait en utilisant le fichier de configuration
. Spring Boot facilite grandement le travail avec les fichiers de configuration.

27. L'idée de diviser plusieurs sources de données dans SpringBoot

Configurez d'abord deux sources de données dans le fichier de configuration des propriétés, créez un mappeur de sous-traitance et utilisez @ConfigurationProperties# 🎜🎜# Lisez la configuration dans les propriétés et utilisez @MapperScan pour l'enregistrer dans le package du mappeur correspondant

28 Comment gérer les transactions multi-sources de données SpringBoot

La première façon. est dans la couche de service Utilisez transactionManager dans @TransactionManager pour spécifier la transaction configurée dans

DataSourceConfig
La seconde consiste à utiliser jta-atomikos pour implémenter la gestion distribuée des transactions

29. les méthodes pour protéger les applications Spring Boot ?

Utilisez HTTPS en production

Vérifiez vos dépendances avec Snyk
Mettez à niveau vers la dernière version
Activez la protection CSRF
Utilisez la politique de sécurité du contenu pour empêcher les attaques XSS # 🎜🎜#
30. Comment implémenter la sécurité dans les applications Spring Boot ?

Pour implémenter la sécurité Spring Boot, nous utilisons la dépendance spring-boot-starter-security et

la configuration de sécurité doit être ajoutée. Cela nécessite très peu de code. Les classes de configuration devront étendre WebSecurityConfigurerAdapter et remplacer ses méthodes.

31. Comparez les avantages et les inconvénients de Spring Security et Shiro

Puisque Spring Boot propose officiellement un grand nombre de démarreurs très pratiques, dont Spring Security.

Starter facilite l'utilisation de Spring Security dans Spring Boot. Il vous suffit même d'ajouter une dépendance pour

protéger toutes les interfaces. Par conséquent, s'il s'agit d'un projet Spring Boot, choisissez généralement Spring Security. Bien sûr, ce n'est qu'une

une combinaison suggérée D'un point de vue purement technique, peu importe la façon dont vous la combinez, il n'y aura aucun problème. Par rapport à Spring Security
, Shiro présente principalement les caractéristiques suivantes :
Spring Security est un cadre de gestion de sécurité lourd ; Shiro est un cadre de gestion de sécurité léger
Spring Security Concept Configuration complexe et lourde ; concept simple et configuration simple
Spring Security est puissant ; Shiro a des fonctions simples

32 Comment résoudre les problèmes inter-domaines dans Spring Boot ?

Inter-domaine. les problèmes peuvent être résolus via JSONP sur le front-end, mais JSONP ne peut envoyer que des requêtes GET et ne peut pas envoyer d'autres types de requêtes. Dans les applications de style RESTful, cela semble très inutile, nous vous recommandons donc de l'utiliser sur le back-end ( CORS (Crossorigin). partage de ressources) pour résoudre des problèmes inter-domaines. Cette solution n'est pas propre à Spring Boot. Dans le framework

SSM traditionnel, CORS peut être utilisé pour résoudre des problèmes inter-domaines. Cependant, avant de configurer CORS dans des fichiers XML,

peut désormais être résolu via Implement. l'interface WebMvcConfigurer, puis réécrivez la méthode addCorsMappings pour résoudre les problèmes inter-domaines.

@Configuration
public class CorsConfig implements WebMvcConfigurer {
	@Override
	public void addCorsMappings(CorsRegistry registry) {
		registry.addMapping("/**")
		.allowedOrigins("*")
		.allowCredentials(true)
		.allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
		.maxAge(3600);
	}
}

33. Qu'est-ce qu'un moniteur dans Spring Boot ?

L'actionneur de démarrage à ressort est l'une des fonctions importantes du cadre de démarrage à ressort. Spring Boot Monitor vous aide à accéder à l'état actuel des applications en cours d'exécution dans votre environnement de production. Plusieurs métriques doivent être vérifiées et surveillées dans un environnement de production. Même certaines applications externes peuvent utiliser ces services pour déclencher des messages d'alerte aux personnes concernées. Le module de surveillance expose un ensemble de points de terminaison REST accessibles directement

sous forme d'URL HTTP pour vérifier l'état.

34. Comment utiliser Spring Boot pour implémenter la gestion globale des exceptions ?

Spring fournit un moyen très utile de gérer les exceptions à l'aide de ControllerAdvice. Nous traitons toutes les exceptions levées par la classe contrôleur en implémentant une classe
ControlerAdvice.

35. Comment surveiller tous les microservices Spring Boot ?

Spring Boot fournit des points de terminaison de surveillance pour surveiller les métriques des microservices individuels. Ces points de terminaison sont utiles pour obtenir des informations

sur les applications (par exemple si elles sont démarrées) et si leurs composants (comme les bases de données, etc.) fonctionnent correctement. Cependant, un inconvénient ou une difficulté majeur de l'utilisation de monitor
est que nous devons ouvrir le point de connaissance de l'application individuellement pour connaître son état ou sa santé. Imaginez un

microservice impliquant 50 applications, l'administrateur devrait toucher les terminaux d'exécution des 50 applications. Pour nous aider

à faire face à cette situation, nous utiliserons le projet open source situé à l'adresse . Il est construit sur Spring Boot Actuator, qui fournit

une interface utilisateur Web qui nous permet de visualiser les métriques de plusieurs applications.

36. SpringBoot性能如何优化

如果项目比较大，类比较多，不使用@SpringBootApplication，采用@Compoment指定扫包范
围
在项目启动时设置JVM初始内存和最大内存相同
将springboot内置服务器由tomcat设置为undertow

37. 如何重新加载 Spring Boot 上的更改，而无需重新启动服务器？Spring Boot项目如何热部署？

这可以使用 DEV 工具来实现。通过这种依赖关系，您可以节省任何更改，嵌入式tomcat 将重新启
动。Spring Boot 有一个开发工具（DevTools）模块，它有助于提高开发人员的生产力。Java 开
发人员面临的一个主要挑战是将文件更改自动部署到服务器并自动重启服务器。开发人员可以重新
加载 Spring Boot 上的更改，而无需重新启动服务器。这将消除每次手动部署更改的需要。Spring
Boot 在发布它的第一个版本时没有这个功能。这是开发人员最需要的功能。DevTools 模块完全满
足开发人员的需求。该模块将在生产环境中被禁用。它还提供 H2 数据库控制台以更好地测试应用
程序。

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-devtools</artifactId>
</dependency>

38. SpringBoot微服务中如何实现 session 共享 ?

在微服务中，一个完整的项目被拆分成多个不相同的独立的服务，各个服务独立部署在不同的服务
器上，各自的 session 被从物理空间上隔离开了，但是经常，我们需要在不同微服务之间共享
session ，常见的方案就是 Spring Session + Redis 来实现 session 共享。将所有微服务的
session 统一保存在 Redis 上，当各个微服务对 session 有相关的读写操作时，都去操作 Redis 上
的 session 。这样就实现了 session 共享，Spring Session 基于 Spring 中的代理过滤器实现，使
得 session 的同步操作对开发人员而言是透明的，非常简便。

39. 您使用了哪些 starter maven 依赖项？

使用了下面的一些依赖项
spring-boot-starter-web 嵌入tomcat和web开发需要servlet与jsp支持
spring-boot-starter-data-jpa 数据库支持
spring-boot-starter-data-redis redis数据库支持
spring-boot-starter-data-solr solr支持
mybatis-spring-boot-starter 第三方的mybatis集成starter
自定义的starter(如果自己开发过就可以说出来)

40. Spring Boot 中的 starter 到底是什么 ?

首先，这个 Starter 并非什么新的技术点，基本上还是基于 Spring 已有功能来实现的。首先它提
供了一个自动化配置类，一般命名为 XXXAutoConfiguration ，在这个配置类中通过条件注解来
决定一个配置是否生效（条件注解就是 Spring 中原本就有的），然后它还会提供一系列的默认配
置，也允许开发者根据实际情况自定义相关配置，然后通过类型安全的属性(spring.factories)注入
将这些配置属性注入进来，新注入的属性会代替掉默认属性。正因为如此，很多第三方框架，我们
只需要引入依赖就可以直接使用了。当然，开发者也可以自定义 Starter

41. Spring Boot 中如何实现定时任务 ?

在 Spring Boot 中使用定时任务主要有两种不同的方式，一个就是使用 Spring 中的 @Scheduled
注解，另一-个则是使用第三方框架 Quartz。
使用 Spring 中的 @Scheduled 的方式主要通过 @Scheduled 注解来实现。

42. spring-boot-starter-parent 有什么用 ?

我们都知道，新创建一个 Spring Boot 项目，默认都是有 parent 的，这个 parent 就是 springboot-starter-parent ，spring-boot-starter-parent 主要有如下作用：
定义了 Java 编译版本为 1.8 。
使用 UTF-8 格式编码。
继承自 spring-boot-dependencies，这个里边定义了依赖的版本，也正是因为继承了这个依
赖，所以我们在写依赖时才不需要写版本号。
执行打包操作的配置。
自动化的资源过滤。
自动化的插件配置。
针对 application.properties 和 application.yml 的资源过滤，包括通过 profile 定义的不同
环境的配置文件，例如 application-dev.properties 和 application-dev.yml。
总结就是打包用的

43. SpringBoot如何实现打包

进入项目目录在控制台输入mvn clean package，clean是清空已存在的项目包，package进行打
包或者点击左边选项栏中的Mavne，先点击clean在点击package

44. Quelle est la différence entre le jar produit par Spring Boot et le jar ordinaire ?

Le jar finalement empaqueté par le projet Spring Boot est un jar exécutable. Ce type de jar peut être exécuté directement via java -jar xxx. Commande jar. Ce type de fichier jar ne peut pas être utilisé par d'autres projets comme un fichier jar ordinaire, et même s'il est dépendant, les classes qu'il contient ne peuvent pas être utilisées.
Le pot de Spring Boot ne peut pas être utilisé par d'autres projets, principalement parce que sa structure est différente de celle des pots ordinaires. Pour un package jar ordinaire, après décompression, ce sera directement le nom du package, et le package sera notre code. Cependant, après décompression, le jar exécutable empaqueté par Spring Boot sera notre code dans le répertoire BOOTINFclasses, il ne peut donc pas l'être. directement référencé. Si vous devez le référencer, vous pouvez ajouter une configuration dans le fichier pom.xml et regrouper le projet Spring Boot dans deux fichiers jar, un exécutable et un référençable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!