[SpringBoot de l'entrée à la maîtrise] Chapitre 2 Introduction à SpringBoot

2. Premiers pas avec SpringBoot

2.1 Liste des outils système

1. JDK 1.8 ou version ultérieure ;
2. maven3.x : Maven 3.3 ou supérieur ;
3. IDÉE IntelliJ、STS；
4. La version officielle de Spring Boot est la 2.6.9 ;

2.2 configuration maven

Définissez le compilateur maven sur la version 1.8 et ajoutez à la balise profiles du fichier de configuration settings.xml de maven :

<profile>
    <id>jdk-1.8</id>
    <activation>
        <activeByDefault>true</activeByDefault>
        <jdk>1.8</jdk>
    </activation>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>
</profile>

2.3 Fonction de réalisation de projet

Le navigateur envoie une requête hello, le serveur accepte et traite la requête, et répond avec une chaîne Hello World.

Il existe deux manières principales de créer un projet Spring Boot :

1. Créez un projet maven et ajoutez les dépendances pom correspondantes.
2. Utilisez l'initialiseur fourni par spring boot pour créer un projet.

2.3.1 Créer un projet Maven

2.3.2 Introduction des dépendances

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!--引入spirngboot的父项目-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.9</version>
    </parent>

    <groupId>com.newcapec</groupId>
    <artifactId>springboot01-helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--当前项目到打包方式为jar-->
    <packaging>jar</packaging>

    <!--引入核心依赖-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

2.3.3 Écrire le programme principal

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 *  @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
 */
@SpringBootApplication
public class MainApplication {
    
    

    public static void main(String[] args) {
    
    
        //通过SpringApplication启动程序
        SpringApplication.run(MainApplication.class, args);
    }
}

2.3.4 Contrôleur d'écriture

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {
    
    

    @GetMapping("/hello")
    public String hello(){
    
    
        System.out.println("hello方法执行了...");
        return "hello springboot我来了...";
    }
}

2.3.5 Tests en cours

De retour dans la classe MainApplicaiton, exécutez la méthode main() pour démarrer l'application springboot :

Entrez localhost:8080 dans le navigateur pour tester :

Entrez localhost:8080/hello dans le navigateur pour tester :

2.3.6 Déploiement simplifié

Le plug-in d'emballage Springboot peut empaqueter l'application dans un package jar exécutable.

<!--Springboot打包插件-->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Appelez le plug-in maven d'idea et exécutez-le packagepour exécuter la commande d'empaquetage

Entrez dans cmdla fenêtre de ligne de commande et accédez au répertoire dans lequel le fichier jar est empaqueté.

Empaquetez cette application dans un package jar et exécutez-la directement java -jar springboot01-helloworld-1.0-SNAPSHOT.jarà l'aide de la commande.

Une fois le programme exécuté avec succès, vous pouvez vérifier à nouveau si le service hello revient correctement via le navigateur.

2.4 Initialisation du printemps

Pour créer un projet Spring Boot Maven, Spring Initializr (https://start.spring.io) est fortement recommandé. Il s'agit essentiellement d'une application Web capable de générer une structure de projet Spring Boot pour vous.

En utilisant IntelliJ IDEA, les étapes pour créer Spring Boot sont les suivantes :

1. Dans le menu Fichier, sélectionnez Nouveau > Projet ;
2. Sélectionnez ensuite Spring Initializr;
3. Remplissez les informations du projet ;
4. Version et dépendances de l'option Springboot.

Le projet Spring Boot généré par défaut :

• Le programme principal a été généré, il vous suffit d'ajouter le code de contrôle de la logique métier requis (contrôleur, service, dao, etc.).
• src, répertoire du code source.
• La structure des répertoires dans le dossier des ressources.
  • statique : stocker toutes les ressources statiques (js, css, images) ;
  • templates : enregistrez toutes les pages de modèles. Le package jar par défaut de Spring Boot utilise Tomcat intégré, ne prend pas en charge les pages JSP et peut utiliser des moteurs de modèles (freemarker, thymeleaf) ;
  • application.properties : le fichier de configuration de l'application Spring Boot.
• .gitignore - le fichier de configuration du système de contrôle de version distribué git, ce qui signifie ignorer les commits.
• mvnw - le nom complet est maven wrapper. Son principe est d'enregistrer la version de maven que vous souhaitez utiliser dans le fichier maven-wrapper.properties. Lorsque l'utilisateur exécute la commande mvnw clean et constate que la version de maven de l'utilisateur actuel est incompatible avec le version attendue, puis téléchargez la version souhaitée, puis utilisez la version souhaitée pour exécuter la commande mvn, telle que mvn clean tout à l'heure.
• Dossier .mvn - stockez maven-wrapper.properties et les packages jar associés.
• mvn.cmd - entrée cmd pour l'exécution des commandes mvnw.
• .Idea stocke les informations de configuration du projet, y compris les enregistrements historiques, les informations de contrôle de version, etc. En fait, vous pouvez l'ignorer ou vous pouvez le configurer pour le masquer dans IDEA.