Spring Boot

Openen in ChatGPT

Spring Boot is een populaire keuze voor het bouwen van Java-apps, en biedt afhankelijkheidsinjectie, automatische configuratie en een embedded servermodel. Wanneer je Spring Boot gebruikt met webforJ, kun je services, repositories en andere door Spring beheerde beans rechtstreeks in je UI-componenten injecteren via constructorinjectie.

Wanneer je Spring Boot gebruikt met webforJ, draait je app als een uitvoerbare JAR met een embedded Tomcat-server in plaats van een WAR-bestand naar een externe app-server te implementeren. Dit verpakkingsmodel vereenvoudigt de implementatie en sluit aan bij cloud-native implementatiepraktijken. Het componentmodel en de routering van webforJ werken samen met de app-context van Spring voor het beheren van afhankelijkheden en configuratie.

Maak een Spring Boot-app

Je hebt twee opties om een nieuwe webforJ-app met Spring Boot te maken: gebruik de grafische startforJ-tool of de Maven-opdrachtregel.

Optie 1: Gebruik startforJ

De eenvoudigste manier om een nieuwe webforJ-app te maken, is met startforJ, dat een minimale starterproject genereert op basis van een gekozen webforJ-archetype. Dit starterproject bevat alle vereiste afhankelijkheden, configuratiebestanden en een vooraf gemaakt lay-out, zodat je er meteen mee aan de slag kunt.

Wanneer je een app maakt met startforJ, kun je deze aanpassen door de volgende informatie te verstrekken:

Basisprojectmetadata (App-naam, Groep ID, Artifact ID)
webforJ-versie en Java-versie
Thema-kleur en pictogram
Archetype
Flavor - Selecteer webforJ Spring om een Spring Boot-project te maken

Met deze informatie zal startforJ een basisproject maken van het gekozen archetype dat is geconfigureerd voor Spring Boot. Je kunt ervoor kiezen om je project als een ZIP-bestand te downloaden of het rechtstreeks naar GitHub te publiceren.

Optie 2: Gebruik de opdrachtregel

Als je liever de opdrachtregel gebruikt, genereer dan een Spring Boot webforJ-project rechtstreeks met behulp van de officiële webforJ-archetypes:

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

De flavor parameter vertelt het archetype om een Spring Boot-project te genereren in plaats van een standaard webforJ-project.

Dit creëert een compleet Spring Boot-project met:

Spring Boot-ouder POM-configuratie
webforJ Spring Boot starterafhankelijkheid
Hoofd-app-klasse met @SpringBootApplication en @Routify
Voorbeeldweergaven
Configuratiebestanden voor zowel Spring als webforJ

Voeg Spring Boot toe aan bestaande projecten

Als je een bestaande webforJ-app hebt, kun je Spring Boot toevoegen door je projectconfiguratie aan te passen. Dit proces omvat het bijwerken van je Maven-configuratie, het toevoegen van Spring-afhankelijkheden en het converteren van je hoofd-app-klasse.

Alleen voor bestaande projecten

Sla deze sectie over als je een nieuw project vanaf nul maakt. Deze gids veronderstelt webforJ versie 25.11 of later.

Stap 1: Werk de Maven-configuratie bij

Maak de volgende wijzigingen in je POM-bestand:

Wijzig de verpakking van WAR naar JAR:
pom.xml
```
<packaging>jar</packaging>
```

Stel Spring Boot in als de ouder POM:

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

Verwijder alle WAR-specifieke configuratie zoals:
- maven-war-plugin
- Verwijzingen naar de webapp-directory
- Configuratie gerelateerd aan web.xml

Als je al een ouder POM hebt, moet je in plaats daarvan de Spring Boot Bill of Materials (BOM) importeren:

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>

Stap 2: Voeg Spring-afhankelijkheden toe

Voeg de webforJ Spring Boot-starter toe aan je afhankelijkheden:

webforJ 25.11+ vereenvoudiging

Vanaf webforJ versie 25.11 bevat de webforj-spring-boot-starter automatisch alle kern webforJ-afhankelijkheden. Je hoeft de com.webforj:webforj afhankelijkheid niet expliciet toe te voegen.

Voor versies voor 25.11 moet je beide afhankelijkheden afzonderlijk opnemen.

Voor webforJ 25.11 en later:

pom.xml
<dependencies>
    <!-- Voeg Spring Boot-starter toe (bevat webforJ transitief) -->
    <dependency>
        <groupId>com.webforj</groupId>
        <artifactId>webforj-spring-boot-starter</artifactId>
        <version>${webforj.version}</version>
    </dependency>

    <!-- Voeg devtools toe -->
    <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>

Voor versies vóór 25.11:

pom.xml
<dependencies>
    <!-- Voeg expliciet de webforJ-afhankelijkheid toe -->
    <dependency>
        <groupId>com.webforj</groupId>
        <artifactId>webforj</artifactId>
        <version>${webforj.version}</version>
    </dependency>
    
    <!-- Voeg Spring Boot-starter toe -->
    <dependency>
        <groupId>com.webforj</groupId>
        <artifactId>webforj-spring-boot-starter</artifactId>
        <version>${webforj.version}</version>
    </dependency>

    <!-- Voeg devtools toe -->
    <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 voor automatische browservernieuwing

De webforj-spring-devtools afhankelijkheid breidt Spring DevTools uit met automatische browservernieuwing. Wanneer je wijzigingen opslaat in je IDE, herlaadt de browser automatisch zonder handmatige tussenkomst. Zie de Spring DevTools gids voor configuratiedetails.

Stap 3: Werk bouwplugins bij

Vervang de Jetty-plugin door de Spring Boot Maven-plugin. Verwijder alle bestaande Jetty-configuratie en voeg toe:

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

Stap 4: Converteer je app-klasse

Transformeer je hoofd App-klasse in een Spring Boot-app door de noodzakelijke Spring-annotaties en een hoofdmethode toe te voegen:

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);
    }
    
    // Houd je bestaande run() methode als je die hebt
    @Override
    public void run() throws WebforjException {
      // Je bestaande initialisatiecode 
    }
}

De annotatie @SpringBootApplication stelt de automatische configuratie en componentenscan van Spring in. De annotatie @Routify blijft hetzelfde en blijft je weergavepakketten scannen naar routes.

Stap 5: Voeg Spring-configuratie toe

Maak application.properties aan in src/main/resources:

application.properties
# Volledig gekwalificeerde klassennaam van de applicatie-ingangspunt
webforj.entry = org.example.Application

# App-naam
spring.application.name=Hello World Spring

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

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

Voer de Spring Boot-app uit

Eenmaal geconfigureerd, voer je je app uit met:

mvn spring-boot:run

De app start met een embedded Tomcat-server op poort 8080 standaard. Je bestaande webforJ-weergaven en routes werken precies zoals voorheen, maar nu kun je Spring beans injecteren en Spring-functies gebruiken.

Configuratie

Gebruik het application.properties-bestand in src/main/resources om je app te configureren. Zie Property Configuratie voor informatie over webforJ-configuratie-eigendommen.

De volgende webforJ application.properties instellingen zijn specifiek voor Spring:

Eigenschap	Type	Beschrijving	Standaard
`webforj.servlet-mapping`	String	URL-mappingpatroon voor de webforJ-servlet.	`/*`
`webforj.exclude-urls`	Lijst	URL-patronen die niet door webforJ moeten worden afgehandeld wanneer gemapped naar root. Wanneer webforJ is gemapped naar de rootcontext (`/*`), worden deze URL-patronen uitgesloten van de afhandeling door webforJ en kunnen ze in plaats daarvan door Spring MVC-controllers worden afgehandeld. Dit stelt REST-eindpunten en andere Spring MVC-mappings in staat om samen te bestaan met webforJ-routes.	`[]`

Configuratiedifferentiëlen

Wanneer je overschakelt naar Spring Boot, veranderen verschillende configuraspecten:

Aspect	Standaard webforJ	Spring Boot webforJ
Verpakking	WAR-bestand	Uitvoerbare JAR
Server	Extern (Jetty, Tomcat)	Embedded Tomcat
Uitvoeren opdracht	`mvn jetty:run`	`mvn spring-boot:run`
Hoofdconfiguratie	`webforj.conf` alleen	`application.properties` + `webforj.conf`
Profielen	`webforj-dev.conf`, `webforj-prod.conf`	Spring-profielen met `application-{profile}.properties`
Poortconfiguratie	In pluginconfiguratie	`server.port` in eigenschappen

Maak een Spring Boot-app​

Optie 1: Gebruik startforJ​

Optie 2: Gebruik de opdrachtregel​

Voeg Spring Boot toe aan bestaande projecten​

Stap 1: Werk de Maven-configuratie bij​

Stap 2: Voeg Spring-afhankelijkheden toe​

Stap 3: Werk bouwplugins bij​

Stap 4: Converteer je app-klasse​

Stap 5: Voeg Spring-configuratie toe​

Voer de Spring Boot-app uit​

Configuratie​

Configuratiedifferentiëlen​