Spring Boot

ChatGPT öffnen

Spring Boot ist eine beliebte Wahl zum Erstellen von Java-Anwendungen und bietet Dependency Injection, automatische Konfiguration und ein eingebettetes Servermodell. Wenn Sie Spring Boot mit webforJ verwenden, können Sie Dienste, Repositories und andere von Spring verwaltete Beans direkt in Ihre UI-Komponenten durch Konstruktor-Injection einfügen.

Wenn Sie Spring Boot mit webforJ verwenden, wird Ihre App als ausführbare JAR mit einem eingebetteten Tomcat-Server ausgeführt, anstatt eine WAR-Datei auf einem externen Anwendungsserver bereitzustellen. Dieses Verpackungsmodell vereinfacht die Bereitstellung und entspricht den Praktiken für cloud-native Bereitstellungen. Das Komponentenmodell und das Routing von webforJ arbeiten zusammen mit dem Anwendungs-Kontext von Spring, um Abhängigkeiten und Konfiguration zu verwalten.

Erstellen einer Spring Boot-App

Sie haben zwei Optionen, um eine neue webforJ-App mit Spring Boot zu erstellen: mit dem grafischen Tool startforJ oder über die Maven-Befehlszeile.

Option 1: Verwendung von startforJ

Die einfachste Möglichkeit, eine neue webforJ-App zu erstellen, ist startforJ, das ein minimales Starterprojekt basierend auf einem ausgewählten webforJ-Archetyp generiert. Dieses Starterprojekt enthält alle erforderlichen Abhängigkeiten, Konfigurationsdateien und ein vorgefertigtes Layout, sodass Sie sofort mit dem Aufbau beginnen können.

Wenn Sie eine App mit startforJ erstellen, können Sie sie anpassen, indem Sie die folgenden Informationen angeben:

Grundlegende Projektmetadaten (App-Name, Gruppennummer, Artefakt-ID)
webforJ-Version und Java-Version
Themenfarbe und Icon
Archetyp
Flavor - Wählen Sie webforJ Spring, um ein Spring Boot-Projekt zu erstellen

Mit diesen Informationen wird startforJ ein grundlegendes Projekt aus Ihrem gewählten Archetyp erstellen, das für Spring Boot konfiguriert ist. Sie können wählen, ob Sie Ihr Projekt als ZIP-Datei herunterladen oder es direkt auf GitHub veröffentlichen möchten.

Option 2: Verwendung der Befehlszeile

Wenn Sie die Befehlszeile bevorzugen, generieren Sie ein Spring Boot webforJ-Projekt direkt mit den offiziellen webforJ-Archetypen:

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

Der Parameter flavor sagt dem Archetyp, ein Spring Boot-Projekt anstelle eines Standard-webforJ-Projekts zu generieren.

Dies erzeugt ein vollständiges Spring Boot-Projekt mit:

Spring Boot-Eltern-POM-Konfiguration
webforJ Spring Boot-Starter-Abhängigkeit
Hauptanwendungsklasse mit @SpringBootApplication und @Routify
Beispielansichten
Konfigurationsdateien für sowohl Spring als auch webforJ

Spring Boot zu bestehenden Projekten hinzufügen

Wenn Sie eine bestehende webforJ-App haben, können Sie Spring Boot hinzufügen, indem Sie Ihre Projektkonfiguration ändern. Dieser Prozess umfasst die Aktualisierung Ihrer Maven-Konfiguration, das Hinzufügen von Spring-Abhängigkeiten und die Umwandlung Ihrer Hauptanwendungsklasse.

Nur für bestehende Projekte

Überspringen Sie diesen Abschnitt, wenn Sie ein neues Projekt von Grund auf neu erstellen.

Schritt 1: Maven-Konfiguration aktualisieren

Nehmen Sie die folgenden Änderungen in Ihrer POM-Datei vor:

Ändern Sie das Packaging von WAR zu JAR:
pom.xml
```
<packaging>jar</packaging>
```

Setzen Sie Spring Boot als Eltern-POM:

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

Entfernen Sie alle WAR-spezifischen Konfigurationen wie:
- maven-war-plugin
- webapp-Verzeichnisreferenzen
- web.xml-bezogene Konfiguration

Wenn Sie bereits eine Eltern-POM haben, müssen Sie stattdessen die Bill of Materials (BOM) von Spring Boot importieren:

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>

Schritt 2: Spring-Abhängigkeiten hinzufügen

Fügen Sie den webforJ Spring Boot-Starter zu Ihren Abhängigkeiten hinzu. Behalten Sie Ihre vorhandene webforJ-Abhängigkeit:

pom.xml
<dependencies>
    <!-- Ihre vorhandene webforJ-Abhängigkeit -->
    <dependency>
        <groupId>com.webforj</groupId>
        <artifactId>webforj</artifactId>
        <version>${webforj.version}</version>
    </dependency>
    
    <!-- Fügen Sie den Spring Boot-Starter hinzu -->
    <dependency>
        <groupId>com.webforj</groupId>
        <artifactId>webforj-spring-boot-starter</artifactId>
        <version>${webforj.version}</version>
    </dependency>

    <!-- Fügen Sie devtools hinzu -->
    <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 für automatisches Browser-Refresh

Die Abhängigkeit webforj-spring-devtools erweitert Spring DevTools mit automatischem Browser-Refresh. Wenn Sie Änderungen in Ihrer IDE speichern, wird der Browser automatisch ohne manuelles Eingreifen neu geladen. Weitere Informationen finden Sie im Leitfaden zu Spring DevTools für Konfigurationsdetails.

Schritt 3: Build-Plugins aktualisieren

Ersetzen Sie das Jetty-Plugin durch das Spring Boot Maven-Plugin. Entfernen Sie alle vorhandenen Jetty-Konfigurationen und fügen Sie hinzu:

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

Schritt 4: Ihre App-Klasse umwandeln

Transformieren Sie Ihre Hauptklasse App in eine Spring Boot-App, indem Sie die erforderlichen Spring-Anmerkungen und eine Hauptmethode hinzufügen:

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);
    }
    
    // Behalten Sie Ihre vorhandene run() Methode, falls vorhanden
    @Override
    public void run() throws WebforjException {
      // Ihr vorhandener Initialisierungscode 
    }
}

Die Annotation @SpringBootApplication aktiviert die automatische Konfiguration und die Komponenten-Scannung von Spring. Die Annotation @Routify bleibt unverändert und scannt weiterhin Ihre Ansichtspakete nach Routen.

Schritt 5: Spring-Konfiguration hinzufügen

Erstellen Sie application.properties in src/main/resources:

application.properties
# App Name
spring.application.name=Hallo Welt Spring

# Serverkonfiguration
server.port=8080
server.shutdown=immediate

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

Ihre vorhandene webforj.conf-Datei funktioniert weiterhin. Zeigen Sie auf Ihre Hauptklasse:

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

Führen Sie die Spring Boot-App aus

Nach der Konfiguration führen Sie Ihre App mit folgendem Befehl aus:

mvn spring-boot:run

Die App wird standardmäßig mit einem eingebetteten Tomcat-Server auf Port 8080 gestartet. Ihre vorhandenen webforJ-Ansichten und Routen funktionieren genau wie zuvor, aber jetzt können Sie Spring-Beans injizieren und Spring-Funktionen nutzen.

Konfigurationsunterschiede

Wenn Sie zu Spring Boot wechseln, ändern sich mehrere Konfigurationsaspekte:

Aspekt	Standard webforJ	Spring Boot webforJ
Packaging	WAR-Datei	Ausführbare JAR
Server	Extern (Jetty, Tomcat)	Eingebetteter Tomcat
Ausführungsbefehl	`mvn jetty:run`	`mvn spring-boot:run`
Hauptkonfiguration	Nur `webforj.conf`	`webforj.conf` + `application.properties`
Profile	`webforj-dev.conf`, `webforj-prod.conf`	Spring-Profile mit `application-{profile}.properties`
Portkonfiguration	In der Plugin-Konfiguration	`server.port` in den Eigenschaften

Erstellen einer Spring Boot-App​

Option 1: Verwendung von startforJ​

Option 2: Verwendung der Befehlszeile​

Spring Boot zu bestehenden Projekten hinzufügen​

Schritt 1: Maven-Konfiguration aktualisieren​

Schritt 2: Spring-Abhängigkeiten hinzufügen​

Schritt 3: Build-Plugins aktualisieren​

Schritt 4: Ihre App-Klasse umwandeln​

Schritt 5: Spring-Konfiguration hinzufügen​

Führen Sie die Spring Boot-App aus​

Konfigurationsunterschiede​