English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Configuration automatique SpringBoot

L'auto-configuration de SpringBoot se fait automatiquement en fonction des dépendances JAR ajoutées à l'application SpringBoot.

Par exemple, si le fichier H existe dans le chemin de classes2un fichier JAR de base de données, et nous n'avons pas configuré manuellement de bean lié à la base de données, la fonctionnalité d'auto-configuration de Spring Boot le configure automatiquement dans le projet.

Nous pouvons activer l'auto-configuration en utilisant l'annotation @EnableAutoConfiguration fonctionnalités de configuration. Mais cette annotation n'est pas utilisée, car elle est encapsulée dans @SpringBootApplication dans les annotations. L'annotation @SpringBootApplication est une combinaison des trois annotations suivantes: @ComponentScan, @EnableAutoConfiguration, @Configuration . Mais nous utilisons l'annotation @SpringBootApplication plutôt que @EnableAutoConfiguration.

@SpringBootApplication = @ComponentScan + @EnableAutoConfiguration + @Configuration

lorsque vous ajoutez l'utilisation de spring dans le projet-boot-starter-web Lorsque des dépendances sont utilisées, l'auto-configuration de Spring Boot recherche automatiquement Spring MVC dans le chemin de classes. Elle configure automatiquement dispatcherServlet par défaut pages d'erreurbouteille réseau.

De même, lorsque nous ajoutons spring-boot-starter-data-les dépendances JPA, nous voyons que Spring Boot automatise la configuration source de donnéesgestionnaire d'entités.

Toute la logique de configuration automatique se trouve dans spring-boot-autoconfigure.jar comme indiqué dans l'image ci-dessous.

nécessitant une configuration automatique

Les applications basées sur Spring nécessitent beaucoup de configurations. Lorsque nous utilisons Spring MVC, nous devons configurer servlet de gestionnaire, analyseur de vue, Web jars Voici un exemple typique de configuration du servlet de gestionnaire de la web application :

<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/todo-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

De même, lorsque nous utilisons Hibernate/Lorsque nous utilisons JPA, nous devons configurer les sources de données, les gestionnaires de transactions, les fabricants d'entités, etc.

Configurer des sources de données

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass" value="${db.driver}" /><br
<property name="jdbcUrl" value="${db.url}" /><br
<property name="user" value="${db.username}" /><br
<property name="password" value="${db.password}" /><br
</bean>
<jdbc:initialize-database data-source="dataSource">
<jdbc:script location="classpath:config/schema.sql" /><br
<jdbc:script location="classpath:config/data.sql" /><br
</jdbc:initialize-database>

Configurer le fabricant d'entités

<bean
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
id="entityManagerFactory">
<property name="persistenceUnitName" value="hsql_pu" /><br
<property name="dataSource" ref="dataSource" /><br
</bean>

Configurer le gestionnaire de transactions

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" /><br
<property name="dataSource" ref="dataSource" /><br
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/><br

Désactiver les classes de configuration automatique

Si nous ne voulons pas être appliqué, nous pouvons également désactiver des classes de configuration automatique spécifiques. Nous utilisons l'annotation @EnableAutoConfiguration exclude Les propriétés pour désactiver les classes de configuration automatique. Par exemple:

import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;
@Configuration(proxyBeanMethods = false)
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration 
"},"health":{"path":{"href":"http:
}

Si la classe n'est pas dans le chemin de la classe, nous pouvons utiliser les attributs de l'annotation @EnableAutoConfiguration excludeName 并指定类的 qualified 名称。我们可以使用属性 spring.autoconfigure.exclude 排除任何数量的自动配置类。

Spring Boot自动配置示例

在以下示例中,我们将看到Spring Boot的自动配置功能如何工作。

étape1: 打开spring Initializr https://start.spring.io/.

第2步: 名称。我们提供了 com.w3codebox .

étape3: 提供 工件 ID。我们提供了 spring-boot-autoconfiguration-example .

étape4: 添加依赖项: Spring Web,Spring Data JPA,一个 H2数据库.

étape5: 单击 Generate (生成)按钮。当我们单击"生成"按钮时,它会将项目包装在 Jar 文件中,并将其下载到本地系统。

第6步: 提取 Jar文件并将其粘贴到STS工作区中。

étape7: 将项目文件夹导入STS。

文件->导入->现有Maven项目->浏览->选择文件夹spring-boot-autoconfiguration-example->完成

导入需要一些时间。

étape8: 在目录中创建名称为 com.w3codebox.controller 的程序包。文件夹 src/main/java .

étape9: 在包中创建名称为 ControllerDemo 的Controller类。3codebox.controller 。

ControllerDemo.java

package com.w3codebox.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class ControllerDemo 
"},"health":{"path":{"href":"http:
    @RequestMapping("/")
    public String home()
    "},"health":{"path":{"href":"http:
        return "home.jsp";
    }
}

étape10: 在文件夹 src/main/java 中创建另一个名为 com.w3codebox.model 的包。

étape11: 在包   com.w3codebox.model 中创建一个名称为   User 的类。

User.java

package com.w3codebox.model;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="userdata")
public class User 
"},"health":{"path":{"href":"http:
    @Id
    private int id;
    private String username;
    public int getId() 
    "},"health":{"path":{"href":"http:
        return id;
    }
    public void setId(int id) 
    "},"health":{"path":{"href":"http:
        this.id = id;
    }
    public String getUname() 
    "},"health":{"path":{"href":"http:
        return username;
    }
    public void setUname(String username) 
    "},"health":{"path":{"href":"http:
        this.username = username;
    }
    @Override
     
    "},"health":{"path":{"href":"http:
        return \ + id + ", uname=" + username + "]";
    }
}
 

现在,我们需要配置H2数据库。

étape12: Ouvrez   application.properties 文件并配置以下内容:  端口,启用H2控制台,数据源,和   URL。

application.properties

server.port=8085
spring.h2.console.enabled=true
spring.datasource.platform=h2
spring.datasource.url=jdbc:h2:mem:w3codebox
 

étape13: 在文件夹   src/main/resources中创建一个 SQL fichier.

右键单击src/main/resources文件夹->新建->文件->提供文件名->完成

我们提供了文件名   data.sql 并将以下数据插入其中。

data.sql

insert into userdata values(101Tom');
insert into userdata values(102Andrew');
insert into userdata values(103Tony');
insert into userdata values(104Bob');
insert into userdata values(105Sam');
 

étape14: 在   src 文件夹中创建一个名称为   webapp 的文件夹。

étape15: 使用我们在   ControllerDemo 中返回的名称创建一个JSP文件。在ControllerDemo.java中,我们返回了   home.jsp .

home.jsp

<%@page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insérer un titre ici</title>
</title>
head>
body>
<form action="addUser"> /><br
Nom d'utilisateur :<br1<input type="text" name="t /><br
ID :<br /><br
Nom d'utilisateur :<br2<input type="text" name="t /><br
>
</<input type="submit" value="Add">
</form>
</body>
 

étape16: 运行   html> SpringBootAutoconfigurationExampleApplication.java   8085 sous forme de fichier. Nous pouvons voir dans la console que notre application s'est démarquée avec succès sur le port

étape17: 打开浏览器并调用URL   http: //localhost: 8085/h2-console/. Il affiche la table définie dans   application.properties configuré dans le fichier  Classe du pilote,   JDBC URL et le nom d'utilisateur par défaut   sa .

Nous pouvons également tester la connexion en cliquant sur le  Tester la connexionbouton. Si la connexion est réussie, un message est affiché  Test réussi.

étape18: 单击  connexionbouton. Il affiche la table définie dans le fichier User.java   userdata de la structure.

étape19: Exécuter la requête suivante pour voir ce que nous avons inséré   data.sql les données du fichier

SELECT * FROM USERDATA;
 

Regardons attentivement la console. Nous voyons   TransactionManagement, DispatcherServlet, EntityManagerFactory,和   DataSource sera configuré automatiquement, comme indiqué dans l'image suivante.

Débogage de la configuration automatique

Nous pouvons trouver plus d'informations sur la configuration automatique de la manière suivante: Utiliser les deux méthodes suivantes:

Ouvrir le débogage des journaux Utiliser Spring Boot Actuator

Ouvrir le débogage des journaux

Nous pouvons le faire en   application.properties Ajouter des propriétés pour le débogage des fichiers de journalisation dans le fichier. Réalisons le débogage des journaux dans l'exemple ci-dessus. Ouvrez   application.properties Ajouter les propriétés suivantes au fichier

logging.level.org.springframework: DEBUG
 

Redémarrez maintenant l'application. Nous voyons qu'un rapport de configuration automatique est imprimé dans le journal. Ce rapport inclut toutes les classes configurées automatiquement. Il est divisé en deux parties:  Correspondance positive和  Correspondance négativecomme indiqué dans l'image suivante.

Correspondance positive

Correspondance négative

Spring Boot Actuator

Nous pouvons également utiliser le   Actuator Débogage de la configuration automatique. Nous ajouterons également   Navigateur HALpour simplifier les opérations.

Créons un exemple de Spring Boot Actuator.

étape1: Ouvrir Spring Initializr http://start.spring.io 。

étape2: 提供  名称。我们提供了   com.w3codebox。

étape3: 提供  工件 ID。我们提供了  执行器自动配置示例。

étape4: 添加依赖项:   Spring Web 和   Spring Boot Actuator。

<dependency>
<groupId>org.springframework.boot</<groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</<groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
 

étape5: 单击   Generate (生成)按钮。它将与项目相关的所有规范绑定到一个   jar 文件中,并将其下载到我们的本地系统中。

étape6: 提取下载的jar文件。

étape7: 使用以下步骤导入项目文件夹:

文件->导入->现有Maven项目->下一步->浏览- >选择项目文件夹->完成

导入项目后,我们可以在IDE的   Package Explorer 部分中看到以下目录结构。

étape8: 在包中创建Controller类   com.w3codebox。我们创建了一个名为   DemoRestController的控制器类。

在Controller中,我们定义了一个名为   hello( ),它返回一个字符串。

DemoRestController.java

package com.w3codebox;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class DemoRestController 
"},"health":{"path":{"href":"http:
    @GetMapping("/hello()
    public String hello() 
    "},"health":{"path":{"href":"http:
        return "Hello User, have a nice day.";
    }
}
 

étape9: 运行   ActuatorAutoConfigurationExampleApplication.java fichier.

étape10: 打开浏览器并调用URL   http: //localhost: 8080/hello 。它返回我们在控制器中指定的字符串。

现在调用执行器URL   http: //localhost: 8080/actuator 。它将启动显示以下三个URL的执行器:   self ,   "},"templated":false},"health"}}} 和   info ,如下所示。

{"_links":{"self":{"href":"http://localhost:8080/"actuator","templated":false}//localhost:8080/actuator/health","templated":false},"health-path":{"href":"http://localhost:8080/actuator/"},"templated":false},"health"}}}/"},"health":{"path":{"href":"http:*"},"path":{"href":"http://localhost:8080/actuator/{"info":{"href":"http:
 

étape11: Ouvrez   pom.xml fichier et ajoutez   Navigateur HALDépendances.

<dependency>
<groupId>org.springframework.data</<groupId>
<artifactId>spring-data-rest-hal-browser</artifactId>
</dependency>
 

étape12: Encore une fois, exécutez   ActuatorAutoConfigurationExampleApplication.java fichier.

Pour accéder au navigateur HAL, tapez   http://localhost:8080 Dans le navigateur, puis appuyez sur la touche Entrée.

Nous pouvons maintenant accéder à l'exécuteur via le navigateur HAL.

Dans la zone de texte du gestionnaire de ressources, tapez  /actuator , puis cliquez sur   Aller > bouton.

Il montre avec l'exécuteur. Le plus important dans l'exécuteur est   beans .

Lorsque nous cliquons sur la flèche du bean, elle affiche toutes

Le graphique suivant montre toutes les configurations automatiques.   beans détails.