Quel est le principe du Spring Boot ?-Javacommencer-php.cn

Quel est le principe du Spring Boot ?

Quel est le principe de Spring Boot :

1. Introduction au contenu

Présentation de Spring Boot via "Spring Boot Experience". " Que peut-on faire ? Cet article analyse principalement les idées de base d'implémentation de ses différents points fonctionnels, afin d'avoir une compréhension globale et rationnelle de Spring Boot.

Gestion des dépendances : Spring Boot a fait beaucoup de starters, et les starters ne sont qu'une entrée pour nous aider à importer des dépendances, simplifiant ainsi la gestion des dépendances du projet
Configuration automatique : Spring Boot fournit des classes de configuration pour de nombreux composants et frameworks courants basés sur la configuration du code Spring, simplifiant ainsi la configuration du projet
Conteneur intégré : un conteneur Web commun qui intègre Java, simplifiant Construction de l'environnement de développement et constitue la base de l'empaquetage de plug-ins pour empaqueter des applications Web dans des fichiers exécutables
Plug-in Maven : utilisé pour empaqueter des fichiers jar ou des fichiers war qui peuvent être exécutés directement , prêt pour le projet prêt à l'emploi Fournir un support, et bien sûr il y a quelques petites fonctions pour aider au développement
Démarrage à chaud : réduire le nombre de démarrages répétés de conteneurs pendant le processus de développement et améliorer l'efficacité du développement
Surveillance des applications : fournit des services de base pour l'audit des applications, la surveillance de l'état et la collecte de données métriques
CLI (outil de ligne de commande ) : pour le prototypage rapide, il n'est pas nécessaire d'utiliser

2. Dépendances de démarrage : starter

Dans un projet Maven standard, si vous souhaitez utiliser un certain framework ou un composant, vous devez importer un grand nombre de dépendances et faire attention à la correspondance de version des dépendances, etc. Le problème est que Spring Boot fournit un grand nombre de démarreurs qui utiliseront le transfert de dépendances de Maven pour nous aider à importer. dépendances liées. Par exemple, le fichier pom suivant ajoutera des dépendances liées au Web, notamment Spring Web, Spring MVC, etc. :

    .......    <dependencies>
        <!--Web应用程序的典型依赖项-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.1.RELEASE</version>
        </dependency>

    </dependencies>
    .......

Copier après la connexion

Principe : nous venons d'importer une dépendance , mais les dépendances utiliser le transfert de dépendances de Maven pour nous aider à importer un grand nombre de packages utilisés dans le développement web. Si on décompresse le fichier fichier Il n'y a en fait aucun contenu substantiel, car il s'agit simplement d'un projet pom, et le contenu substantiel se trouve dans le fichier est créé par mavne Téléchargé lors du téléchargement du fichier jar, de nombreuses dépendances sont déclarées dans le fichier, telles que : spring-webmvc, spring-web, etc.

En bref, si notre projet dépend d'un certain démarreur, alors le démarreur dépendra de nombreuses autres dépendances, et le transfert de dépendances de Maven ajoutera les dépendances dont dépend le démarreur à notre projet. Le starter n'est qu'un intermédiaire d'importation pour les dépendances de notre projet.

Pour plus d'informations sur le transfert de dépendances de maven, veuillez vous référer aux informations pertinentes. Une brève description est la suivante :

Le projet A dépend de B et B dépend de C. Le projet A doit seulement déclarer qu'il dépend de B, mais n'a pas besoin de déclarer qu'il dépend de C. Maven gère automatiquement la livraison de cette dépendance.

2. Configuration automatique : AutoConfiguration

Spring Boot configurera automatiquement les composants ou frameworks associés en utilisant les valeurs par défautselon certaines conditions, réduisant ainsi considérablement les fichiers de configuration du projet. et Ajout de son propre flux de traitement basé sur la configuration du code. Le contenu suivant présente d'abord brièvement la configuration basée sur le code de Spring, puis présente ce que fait Spring Boot.

(1) Configuration basée sur le code Spring

Avant Spring 3, la façon d'utiliser le contexte Spring était généralement la suivante :

Fichier de configuration Spring

<!-- 数据源 -->
 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
 <property name="url" value="jdbc:oracle:thin:@localhost:1521:xe" />
 <property name="username" value="hr" />
 <property name="password" value="hr" /></bean>
 <!--组件扫描-->
 <context:component-scan base-package="com.demo.spring.sample.step03.?rvic?" />

Copier après la connexion

Code commercial

package com.demo.spring.sample.step03.service.impl;.......@Service("userService")
public class UserService implements IUserService {   
   @Autowired
   private IUserDAO userDAO = null;
}

Copier après la connexion

Créer un contexte Spring

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

Copier après la connexion

Résumé :

Indiquez à Spring via l'analyse des composants d'analyser le chemin de classe pour @Component, @Repository, @Service, @ Pour les classes annotées avec Controller, Spring instancie ces classes et enregistre les instances dans le contexte Spring. Cependant, les beans tiers tels que les sources de données et les fichiers de propriétés sont toujours configurés à l'aide de fichiers XML. n'est toujours pas réalisable. Oui, si cela doit être fait, c'est relativement gênant.

L'utilisation de fichiers de configuration XML présente des avantages et des inconvénients. L'un des inconvénients est que vous ne pouvez pas trop personnaliser le processus d'instanciation du bean. Par exemple, pour la source de données ci-dessus, vous n'avez besoin de l'instancier que si vous le souhaitez. pour avoir le pilote jdbc d'Oracle sur le chemin de classe, cela ne peut pas être accompli. Un autre inconvénient est que la logique du code est dispersée, car une partie de la logique est configurée en XML. Bien sûr, l'avantage est que la configuration est centralisée et qu'il est pratique de changer de configuration ;

Après Spring 3, vous pouvez utiliser le conteneur Spring de la manière suivante :

Classe de configuration Spring

@Configuration // 表明当前类提供Spring配置文件的作用，Spring上下文会从当前类的注解中提取配置信息
@ComponentScan(basePackages = "com.demo.spring.sample.step08") 
// 开启组件扫描
public class AppConfig {
    @Bean // 表示这个方法实例化一个bean，id=dataSource
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(userName);
        dataSource.setPassword(password);
        return dataSource;
    }}

Copier après la connexion

Code commercial

package com.demo.spring.sample.step03.service.impl;.......@Service("userService")
public class UserService implements IUserService {   
   @Autowired
   private IUserDAO userDAO = null;
}

Copier après la connexion

Créer un contexte Spring

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

Copier après la connexion

Résumé :

La configuration basée sur XML n'est plus utilisée lors de la création d'un contexte Spring. Le fichier de configuration disparaît et est remplacé par la classe AppConfig. et cette classe peut avoir des méthodes annotées @Bean, le conteneur appellera automatiquement ces méthodes pour instancier le Bean.

(2), la configuration automatique de Spring Boot

Spring Boot a permis d'écrire un grand nombre de classes annotées avec @Configuration. Chaque classe fournit une configuration de composant ou de framework, telle que la classe interne DataSourceConfiguration Static. Dbcp2 en .java, qui fournit la configuration des sources de données DBCP

//DBCP 数据源配置.
@Configuration //这个注解在实际代码中没有加，当前类被其它配置类Import
@ConditionalOnClass(org.apache.commons.dbcp2.BasicDataSource.class)
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(name = "spring.datasource.type",  matchIfMissing = true,havingValue = "org.apache.commons.dbcp2.BasicDataSource")
static class Dbcp2 {

   @Bean
   @ConfigurationProperties(prefix = "spring.datasource.dbcp2")
   public org.apache.commons.dbcp2.BasicDataSource dataSource(
         DataSourceProperties properties) {
      return createDataSource(properties,
            org.apache.commons.dbcp2.BasicDataSource.class);
   }

}

Copier après la connexion

Résumé :

当Spring Boot启动的基本步骤走完后，如果启用了自动配置，Spring Boot会加载下的<\META-INF\spring.factories>文件中的内容，该文件中定义了有关自动配置的信息，其中EnableAutoConfiguration对应的每一个类中都加入了注解@Configuration，也就是说这样的每一个类都相当于Spring的一个或多个配置文件，而其中加注解@Bean的方法是bean的工厂方法,会由Spring上下文自动调用，并且将返回的对象注册到上下文中。

spring.factories文件中自动配置类的部分内容

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
......
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
......

Copier après la connexion

(三)、如何覆盖自动配置的属性

Spring Boot的自动配置会采用大量的默认值(约定由于配置)，可以通过在类路径下提供application.properties或者application.yml配置文件来覆盖默认值，当然部分属性值必须通过该配置文件来提供，比如如果要使用Spring Boot对数据源的自动配置，则在配置文件中必须提供jdbc的url，否则会抛出异常。

三、集成内嵌容器：main方法

Spring Boot支持的内嵌容器Tomcat、Jetty、Undertow本身就支持在Java中内嵌使用，因为这些容器本身就是使用Java编写的，只不过Spring Boot在main方法的调用链中根据自动配置嵌入了这样的容器。

不使用这样的内嵌容器也是可以的，在Maven中移除这样的依赖就可以，当然这个时候如果要通过Spring Boot使用Web相关框架，则需要打包为war包后独立部署，或者在开发过程中使用IDE环境的开发部署功能。

不使用内嵌容器的Web应用在打包时需要对工程进行一定的修改。

四、打包可运行文件：maven-plugin

Maven使用的默认打包工具支持打包jar文件或者war文件，但是打包后的jar文件中不能再嵌入jar文件，而打包后的war文件不能直接运行，为了把工程所有文件打包为一个可直接运行的jar文件或war文件，spring提供了一个maven插件来解决这样的问题。当然这个插件还提诸如spring-boot:run这样的开发功能

五、热启动：devtools

在开发过程中，当完成一个功能单元后，我们会启动程序查看运行效果，如果代码需要再次修改，则修改后需要关掉程序，然后重启程序，这个过程不断迭代，从而完成代码的编写、调试。

Spring Boot 热启动通过重写容器的类加载器，完成程序的部分重启，从而简化、加速程序的调试过程。spring-boot-devtools通过两个类加载器分别加载依赖库和项目代码，当spring-boot-devtools发现项目的编译输出路径下有变化时，通过其中的一个类加载器重新加载所有的项目自有代码，从而完成热启动。这样的热启动比冷启动(关闭、重启)要快很多，到底快多少取决于项目自有代码的数量。

和热启动对应的还有一个热替换，是指单独地替换被修改的某一个class到jvm中，甚至可以单独替换class的某个方法，这种方式比热启动要快，通常使用 JavaAgent 拦截默认加载器的行为来实现，spring有个独立的项目Spring Loaded就是这么做的，但是项目已经被移到了 attic 了，也就是被Spring束之高阁，所以不建议使用。

六、应用监控：actuator

如果类路径中有actuator这个组件的话，Spring Boot的自动配置会自动创建一些端点(端点：遵循Restful设计风格的资源，对应于Controller的某一个处理请求的方法)，这些端点接受请求后返回有关应用的相关信息，比如：健康信息、线程信息等。返回的是json格式的数据，而使用 Spring Boot Admin 可以实现这些 JSON 数据的视图展现，当然也可以为其他应用监控系统监控当前系统提供服务。

七、问题：

为什么pom文件中要继承spring-boot-starter-parent？

spring-boot-starter-parent是spring-boot提供的一个pom，在该pom中定义了很多属性，比如：java源文件的字符编码，编译级别等，还有依赖管理、资源定义的相关pom配置，项目的pom如果继承starter-parent，可以减少相关配置

推荐教程：《java教程》

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!