Spring Boot

Ouvrir dans ChatGPT

Spring Boot est un choix populaire pour construire des applications Java, offrant l'injection de dépendances, la configuration automatique et un modèle de serveur embarqué. Lorsque vous utilisez Spring Boot avec webforJ, vous pouvez injecter des services, des dépôts et d'autres beans gérés par Spring directement dans vos composants d'interface utilisateur par le biais de l'injection par le constructeur.

Lorsque vous utilisez Spring Boot avec webforJ, votre application s'exécute en tant que JAR exécutable avec un serveur Tomcat embarqué au lieu de déployer un fichier WAR sur un serveur d'application externe. Ce modèle d'emballage simplifie le déploiement et s'aligne avec les pratiques de déploiement cloud-native. Le modèle de composants de webforJ et le routage fonctionnent avec le contexte d'application de Spring pour gérer les dépendances et la configuration.

Créer une application Spring Boot

Vous avez deux options pour créer une nouvelle application webforJ avec Spring Boot : utiliser l'outil graphique startforJ ou la ligne de commande Maven.

Option 1: Utiliser startforJ

La manière la plus simple de créer une nouvelle application webforJ est startforJ, qui génère un projet de démarrage minimal basé sur un archétype webforJ choisi. Ce projet de démarrage comprend toutes les dépendances requises, les fichiers de configuration et une mise en page prédéfinie, vous permettant de commencer à construire immédiatement.

Lorsque vous créez une application avec startforJ, vous pouvez la personnaliser en fournissant les informations suivantes :

Métadonnées de base du projet (Nom de l'application, ID de groupe, ID d'artéfact)
Version de webforJ et version de Java
Couleur du thème et icône
Archétype
Saveur - Sélectionnez webforJ Spring pour créer un projet Spring Boot

À partir de ces informations, startforJ créera un projet de base depuis l'archétype choisi, configuré pour Spring Boot. Vous pouvez choisir de télécharger votre projet en tant que fichier ZIP ou de le publier directement sur GitHub.

Option 2: Utiliser la ligne de commande

Si vous préférez utiliser la ligne de commande, générez un projet webforJ Spring Boot directement en utilisant les archétypes officiels de webforJ :

mvn -B archetype:generate \
  -DarchetypeGroupId=com.webforj \
  -DarchetypeArtifactId=webforj-archetype-hello-world \
  -DarchetypeVersion=LATEST \
  -DgroupId=org.example \
  -DartifactId=my-app \
  -Dversion=1.0-SNAPSHOT \
  -Dflavor=webforj-spring

Le paramètre flavor indique à l'archétype de générer un projet Spring Boot au lieu d'un projet webforJ standard.

Cela crée un projet Spring Boot complet avec :

Configuration POM parent Spring Boot
Dépendance de démarrage Spring Boot webforJ
Classe principale d'application avec @SpringBootApplication et @Routify
Vues d'exemple
Fichiers de configuration pour Spring et webforJ

Ajouter Spring Boot à des projets existants

Si vous avez une application webforJ existante, vous pouvez ajouter Spring Boot en modifiant la configuration de votre projet. Ce processus implique de mettre à jour votre configuration Maven, d'ajouter des dépendances Spring et de convertir votre classe principale d'application.

Pour les projets existants uniquement

Ignorez cette section si vous créez un nouveau projet de zéro.

Étape 1: Mettre à jour la configuration Maven

Apportez les modifications suivantes à votre fichier POM :

Changez l'emballage de WAR en JAR :
pom.xml
```
<packaging>jar</packaging>
```

Définissez Spring Boot comme POM parent :

pom.xml
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.5.3</version>
    <relativePath/>
</parent>

Supprimez toute configuration spécifique à WAR telle que :
- maven-war-plugin
- Références au répertoire webapp
- Configuration liée à web.xml

Si vous avez déjà un POM parent, vous devrez importer le Bill of Materials (BOM) de Spring Boot à la place :

pom.xml
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>3.5.3</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Étape 2: Ajouter des dépendances Spring

Ajoutez le démarrage Spring Boot webforJ à vos dépendances. Conservez votre dépendance webforJ existante :

pom.xml
<dependencies>
    <!-- Votre dépendance webforJ existante -->
    <dependency>
        <groupId>com.webforj</groupId>
        <artifactId>webforj</artifactId>
        <version>${webforj.version}</version>
    </dependency>
    
    <!-- Ajouter le démarrage Spring Boot -->
    <dependency>
        <groupId>com.webforj</groupId>
        <artifactId>webforj-spring-boot-starter</artifactId>
        <version>${webforj.version}</version>
    </dependency>

    <!-- Ajouter les devtools -->
    <dependency>
      <groupId>com.webforj</groupId>
      <artifactId>webforj-spring-devtools</artifactId>
      <optional>true</optional>
    </dependency>

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

webforJ DevTools pour un rafraîchissement automatique du navigateur

La dépendance webforj-spring-devtools étend Spring DevTools avec un rafraîchissement automatique du navigateur. Lorsque vous enregistrez des modifications dans votre IDE, le navigateur se recharge automatiquement sans intervention manuelle. Consultez le guide Spring DevTools pour les détails de configuration.

Étape 3: Mettre à jour les plugins de construction

Remplacez le plugin Jetty par le plugin Maven Spring Boot. Supprimez toute configuration Jetty existante et ajoutez :

pom.xml
<build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <excludeDevtools>true</excludeDevtools>
        </configuration>
      </plugin>
    </plugins>
</build>

Étape 4: Convertir votre classe d'application

Transformez votre classe principale App en une application Spring Boot en ajoutant les annotations Spring nécessaires et une méthode main :

Application.java
package com.example;

import com.webforj.App;
import com.webforj.annotation.Routify;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@Routify(packages = "com.example.views")
public class Application extends App {
    
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    
    // Conservez votre méthode run() existante si vous en avez une
    @Override
    public void run() throws WebforjException {
      // Votre code d'initialisation existant 
    }
}

L'annotation @SpringBootApplication active la configuration automatique et le scan des composants de Spring. L'annotation @Routify reste la même, continuant de scanner vos paquets de vues pour les routes.

Étape 5: Ajouter la configuration Spring

Créez application.properties dans src/main/resources :

application.properties
# Nom de l'application
spring.application.name=Hello World Spring

# Configuration du serveur
server.port=8080
server.shutdown=immediate

# Configuration des DevTools webforJ
spring.devtools.livereload.enabled=false
webforj.devtools.livereload.enabled=true
webforj.devtools.livereload.static-resources-enabled=true

Votre fichier webforj.conf existant continue de fonctionner. Pointez-le vers votre classe principale :

webforj.conf
webforj.entry = org.example.Application

Exécuter l'application Spring Boot

Une fois configurée, exécutez votre application en utilisant :

mvn spring-boot:run

L'application démarre avec un serveur Tomcat embarqué sur le port 8080 par défaut. Vos vues et routes webforJ existantes fonctionnent exactement comme avant, mais maintenant vous pouvez injecter des beans Spring et utiliser les fonctionnalités de Spring.

Différences de configuration

Lorsque vous passez à Spring Boot, plusieurs aspects de la configuration changent :

Aspect	webforJ standard	webforJ Spring Boot
Emballage	Fichier WAR	JAR Exécutable
Serveur	Externe (Jetty, Tomcat)	Tomcat embarqué
Commande d'exécution	`mvn jetty:run`	`mvn spring-boot:run`
Configuration principale	Seulement `webforj.conf`	`webforj.conf` + `application.properties`
Profils	`webforj-dev.conf`, `webforj-prod.conf`	Profils Spring avec `application-{profile}.properties`
Configuration du port	Dans la configuration du plugin	`server.port` dans properties

Créer une application Spring Boot​

Option 1: Utiliser startforJ​

Option 2: Utiliser la ligne de commande​

Ajouter Spring Boot à des projets existants​

Étape 1: Mettre à jour la configuration Maven​

Étape 2: Ajouter des dépendances Spring​

Étape 3: Mettre à jour les plugins de construction​

Étape 4: Convertir votre classe d'application​

Étape 5: Ajouter la configuration Spring​

Exécuter l'application Spring Boot​

Différences de configuration​