Spring Boot

Open in ChatGPT

Spring Boot is een populaire keuze voor het bouwen van Java-apps, waarbij afhankelijkheidsinjectie, automatische configuratie en een ingebed serversysteem worden geboden. Wanneer je Spring Boot gebruikt met webforJ, kun je services, repositories en andere door Spring beheerde beans direct in je UI-componenten injecteren via constructorinjectie.

Wanneer je Spring Boot met webforJ gebruikt, draait je app als een uitvoerbare JAR met een ingebedde Tomcat-server in plaats van dat je een WAR-bestand naar een externe app-server deployt. 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: het gebruik van de grafische startforJ-tool of de Maven-opdrachtregel.

Optie 1: Gebruik startforJ

De eenvoudigste manier om een nieuwe webforJ-app te maken is startforJ, waarmee een minimale starterproject wordt gegenereerd op basis van een gekozen webforJ-archetype. Dit starterproject bevat alle vereiste afhankelijkheden, configuratiebestanden en een vooraf gemaakte lay-out, zodat je er direct op kunt voortbouwen.

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

Basis projectmetadata (App Naam, Groep ID, Artifact ID)
webforJ versie en Java versie
Thema Kleur en Pictogram
Archetype
Flavor - Kies webforJ Spring om een Spring Boot-project te maken

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

Optie 2: Gebruik de opdrachtregel

Als je de voorkeur geeft aan de opdrachtregel, genereer je een Spring Boot webforJ-project direct met 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 een Spring Boot-project te genereren in plaats van een standaard webforJ-project.

Dit maakt een volledig Spring Boot-project aan met:

Spring Boot parent POM-configuratie
webforJ Spring Boot starter afhankelijkheid
Hoofdapp-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 te wijzigen. Dit proces omvat het bijwerken van je Maven-configuratie, het toevoegen van Spring-afhankelijkheden en het converteren van je hoofdapp-klasse.

Alleen voor bestaande projecten

Sla deze sectie over als je een nieuw project vanaf nul maakt.

Stap 1: Update Maven-configuratie

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 parent 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 configuraties, zoals:
- maven-war-plugin
- Verwijzingen naar de webapp-directory
- web.xml gerelateerde configuratie

Als je al een parent 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. Houd je bestaande webforJ-afhankelijkheid:

pom.xml
<dependencies>
    <!-- Je bestaande webforJ afhankelijkheid -->
    <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 in je IDE opslaat, wordt de browser automatisch opnieuw geladen zonder handmatige tussenkomst. Zie de Spring DevTools gids voor configuratiedetails.

Stap 3: Werk buildplugins bij

Vervang de Jetty-plugin door de Spring Boot Maven-plugin. Verwijder eventuele bestaande Jetty-configuraties 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 hoofdklasse App in een Spring Boot-app door de nodige 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 schakelt de automatische configuratie en component scanning van Spring in. De annotatie @Routify blijft hetzelfde en blijft je kijkpakketten scannen op routes.

Stap 5: Voeg Spring-configuratie toe

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

application.properties
# App Naam
spring.application.name=Hallo Wereld 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

Je bestaande webforj.conf-bestand blijft werken. Wijzig het naar je hoofdklasse:

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

Voer de Spring Boot-app uit

Zodra je alles hebt geconfigureerd, voer je je app uit met:

mvn spring-boot:run

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

Configuratieverschillen

Wanneer je overschakelt naar Spring Boot, veranderen verschillende configuratieaspecten:

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

Maak een Spring Boot-app​

Optie 1: Gebruik startforJ​

Optie 2: Gebruik de opdrachtregel​

Voeg Spring Boot toe aan bestaande projecten​

Stap 1: Update Maven-configuratie​

Stap 2: Voeg Spring-afhankelijkheden toe​

Stap 3: Werk buildplugins bij​

Stap 4: Converteer je app-klasse​

Stap 5: Voeg Spring-configuratie toe​

Voer de Spring Boot-app uit​

Configuratieverschillen​