Présentation de SpringBoot, introduction, avantages, cas d'entrée SpringBoot, méthodes de démarrage SpringBoot deux, introduction de dépendance SpringBoot-day01

1. Présentation de SpringBoot

• Le framework Spring n'est pas étranger à de nombreux développeurs Java. Depuis sa sortie en 2002, le framework Spring est devenu un framework de base très populaire dans le domaine du développement d'applications d'entreprise. Un grand nombre d'applications d'entreprise sont développées sur la base du framework Spring. Le framework Spring contient des dizaines de sous-projets différents couvrant différents aspects du développement d'applications. Avec autant de sous-projets et de composants, d'une part, il est pratique pour les développeurs à utiliser, et d'autre part, cela pose également des problèmes d'utilisation. Chaque sous-projet a une certaine courbe d'apprentissage. Les développeurs doivent comprendre les détails spécifiques de ces sous-projets et composants afin de savoir comment intégrer ces sous-projets pour former une solution complète. Il n'y a pas de bonnes pratiques pertinentes pour fournir des conseils sur la façon d'utiliser ces composants. Pour les développeurs qui sont nouveaux dans le framework Spring, ils ne savent pas comment mieux utiliser ces composants. Un autre problème courant avec le framework Spring est qu'il est difficile de créer rapidement une application en cours d'exécution. Spring Boot est un nouveau sous-projet du framework Spring, utilisé pour créer des projets Spring 4.0. Son développement a commencé en 2013. La version 1.0.0 est sortie en avril 2014. Il peut configurer automatiquement les différents composants de Spring et ne repose pas sur la génération de code et les fichiers de configuration XML. Spring Boot fournit également des configurations de composants recommandées pour les scénarios courants. Spring Boot peut considérablement améliorer l'efficacité du développement lors de l'utilisation du framework Spring.

1.1 Introduction

• Avec Spring boot, vous pouvez facilement créer des programmes en cours d'exécution indépendants et il est très facile de créer des composants de service indépendants.C'est un outil puissant pour la mise en œuvre d'une architecture distribuée et d'une architecture de microservices.
  

• Spring boot simplifie la référence des packages tiers et simplifie la configuration des packages dépendants via le démarreur fourni.

1.2 Avantages de la botte à ressort

• Créez facilement des applications Spring autonomes.
• Les conteneurs Web intégrés tels que Tomcat et jetty n'ont pas besoin de déployer des fichiers WAR.
• Une série de "démarreurs" sont fournis pour simplifier la configuration de Maven sans ajouter de nombreuses dépendances.
• Dès que possible, configurez Spring automatiquement.

1.3 Conteneur de servlet intégré Spring Boot

2. Cas d’entrée de SpringBoot

Étape 1: Configurer Maven

• Lien: https://blog.csdn.net/qq_43414199/article/details/109049076 .

Étape 2: créer un projet Maven

• Créez rapidement à l'aide de modèles dans idea
  
  
  
  

Étape 3: Ajouter une dépendance spring-boot-starter-web dans pom.xml

<parent>
    <!--SpringBoot的父依赖-->
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
  </parent>

  <dependencies>
    <!--SpringBoot配置web依赖-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>

• Le rôle de spring-boot-starter-parent: introduisez spring-boot-start-parent dans pom.xml, qui peut fournir la gestion des dépendances (gestion des dépendances). Après l'introduction, la version n'est pas requise lors de la déclaration d'autres dépendances. Vous pouvez voir plus tard À.

• rôle spring-boot-starter-web: composants de base de springweb

Étape 4: Écrivez un contrôleur et exécutez-le

package com.it.web.controller;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassName HelloController
 * @Author shuyy
 * @Date 2020/10/25
 **/
@RestController//相当于声明Controller，并提供restful风格
@EnableAutoConfiguration//自动配置不需要写Spring配置文件
public class HelloController {
    
    

    @RequestMapping("hello")//映射路径
    @ResponseBody//响应体
    public String hello(){
    
    
        return "Hello SpringBoot";
    }

    public static void main(String[] args) {
    
    
        //启动程序（这里只是测试一下，以后一般不这样启动）
        SpringApplication.run(HelloController.class,args);
    }
}

• style reposant
  
  

3. Deux méthodes de démarrage de SpringBoot

Le premier [non recommandé]

• Configurez EnableAutoConfiguration dans le contrôleur et utilisez SpringApplication pour démarrer le programme [comment démarrer s'il y a plusieurs contrôleurs]
  

La deuxième [utilisation recommandée]

• Créez une classe App, configurez EnableAutoConfiguration et l'analyse des composants ComponentScan dans la classe App, puis utilisez SpringApplication pour démarrer le programme, afin que vous puissiez accéder à plusieurs contrôleurs

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;

/**
 * @ClassName App
 * @Author shuyy
 * @Date 2020/10/25
 **/
@EnableAutoConfiguration//只能写一个，这里配置了，其它Controller无需写了
@ComponentScan(basePackages = "com.it.web.controller")//配置扫描包
//@ComponentScan(basePackages = {"com.it.web.controller",""})//配置多个扫描包
public class App {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(App.class,args);
    }
}

• Ecrire un autre test UserController pour ouvrir plusieurs contrôleurs
• Ecrire une entité utilisateur, fournir un paramètre, aucune structure de paramètre, obtenir / définir, toString
  
  

package com.it.web.controller;

import com.it.model.User;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassName HelloController
 * @Author shuyy
 * @Date 2020/10/25
 **/
@RestController//相当于声明Controller，并提供restful风格
//@EnableAutoConfiguration//自动配置不需要写Spring配置文件
public class UserController {
    
    

    @RequestMapping("user/{id}")//映射路径【restful风格】
    @ResponseBody//响应体
    public User userInfo(@PathVariable Integer id){
    
    

        User user = new User("shu","123");
        user.setId(id);
        return user;
    }

    /*public static void main(String[] args) {
        //启动程序（这里只是测试一下，以后一般不这样启动）
        SpringApplication.run(HelloController.class,args);
    }*/
}

• courir
  
  

4. Introduction aux dépendances SpringBoot

démarreur à ressort	Core POM, y compris la prise en charge de la configuration automatique, la bibliothèque de journaux et la prise en charge des fichiers de configuration YAML
ressort-démarrage-amqp	Prise en charge de la file d'attente de messages AMQP via spring-rabbit
ressort-démarrage-aop	Inclut spring-aop et AspectJ pour prendre en charge la programmation orientée aspect (AOP)
lot de démarrage à ressort	Prise en charge de Spring Batch, y compris le traitement par lots HSQLDB
spring-boot-starter-data-jpa	Inclut spring-data-jpa, spring-orm et Hibernate pour prendre en charge JPA
spring-boot-starter-data-mongodb	Incluez spring-data-mongodb pour prendre en charge MongoDB
ressort-boot-starter-data-rest	Grâce au support spring-data-rest-webmvc pour exposer Spring Data Warehouse de manière REST
ressort-boot-starter-jdbc	Prise en charge de l'utilisation de JDBC pour accéder à la base de données
ressort-boot-starter-security	Comprend une sécurité à ressort
test de démarrage à ressort	Contient les dépendances requises pour les tests couramment utilisés, tels que JUnit, Hamcrest, Mockito et spring-test, etc.
vitesse de démarrage du ressort	Prise en charge de l'utilisation de Velocity comme moteur de modèle
ressort-boot-starter-web	Soutenir le développement d'applications Web, y compris Tomcat et spring-mvc
ressort-boot-starter-websocket	Prise en charge de l'utilisation de Tomcat pour développer des applications WebSocket
ressort-démarreur-ws	Soutenir les services Web Spring
actionneur de démarrage à ressort	Ajouter des fonctions adaptées aux environnements de production, telles que des indicateurs de performance et des fonctions de surveillance
coque-de-démarrage-démarrage-à-ressort	Ajouter la prise en charge SSH à distance
jetée de démarrage à ressort	Utilisez Jetty au lieu du Tomcat par défaut comme serveur d'applications
démarrage-à-ressort-log4j	Ajouter le support Log4j
enregistrement de démarrage à ressort	Utiliser le cadre de journalisation par défaut de Spring Boot Logback
ressort-démarrage-tomcat	Utilisez Tomcat par défaut de Spring Boot comme serveur d'applications

ressort-boot-starter-web

• Comme vous pouvez le voir dans le fichier POM, il y a peu de dépendances déclarées par l'application
• Il n'y a qu'un seul "org.springframework.boot: spring-boot-starter-web"
• Au lieu de déclarer de nombreuses dépendances comme d'autres projets Spring.
• Lors de l'utilisation de la commande Maven "mvn dependency: tree" pour afficher les dépendances réelles du projet
• On constate qu'il contient des dépendances telles que le framework SpringMVC, SLF4J, Jackson, Hibernate Validator et Tomcat.
• Il s'agit en fait d'une combinaison de bibliothèques open source recommandées par Spring pour une utilisation dans les applications Web.
• Structure arborescente
  
  

EnableAutoConfiguration

• La fonction de l'annotation "EnableAutoConfiguration" est de permettre à Spring Boot de configurer automatiquement le framework Spring en fonction des dépendances déclarées par l'application, ce qui réduit la charge de travail des développeurs.
• Spring Boot recommande une méthode de configuration basée sur les annotations Java au lieu du XML traditionnel. Il vous suffit d'ajouter l'annotation "@EnableAutoConfiguration" à la classe Java de configuration principale pour activer la configuration automatique.
• Les annotations "@RestController" et "@RequestMapping" sont fournies par Spring MVC pour créer des services REST. Ces deux annotations n'ont rien à voir avec Spring Boot lui-même.