Routen

In ChatGPT öffnen

Routing in webforJ mit Spring funktioniert genau gleich wie in normalen webforJ-Anwendungen. Sie verwenden weiterhin die @Route-Annotation, um Routen zu definieren, die gleichen Navigationsmuster und den gleichen Routenlebenszyklus. Der einzige Unterschied besteht darin, dass Ihre Routen, wenn Spring vorhanden ist, auch Spring-Beans über die Konstruktorinjektion erhalten können.

Wenn Sie zu einer Route navigieren, erstellt webforJ die Routeninstanz - aber mit Spring auf dem Classpath verwendet es den Spring-Container, um Abhängigkeiten aufzulösen. Das bedeutet, dass Ihre Routen die volle Leistungsfähigkeit des Spring-Ökosystems (Dienste, Repositories, benutzerdefinierte Beans) nutzen können, während das vertraute Routing-Verhalten von webforJ beibehalten wird.

Erfahren Sie mehr über die Abhängigkeitsinjektion

Für ein umfassendes Verständnis der Muster zur Abhängigkeitsinjektion und des IoC-Containers von Spring siehe die offizielle Dokumentation zur Abhängigkeitsinjektion von Spring.

Wie webforJ Routen mit Spring erstellt

webforJ behandelt die Routencreation anders, wenn Spring vorhanden ist. Der Objektcreation-Mechanismus des Frameworks erkennt Spring Boot auf dem Classpath und delegiert an Springs AutowireCapableBeanFactory, um Instanzen mit Abhängigkeitsinjektion zu erstellen.

Für Klassen, die durch das Scannen von @Routify entdeckt werden, erstellt webforJ immer frische Instanzen und verwendet niemals vorhandene Spring-Beans. Jeder Benutzernavigation wird eine saubere Routeninstanz ohne gemeinsame Zustände zugewiesen. Der Schaffungsprozess:

1. Benutzer navigiert zu einer Route
2. webforJ fordert eine neue Instanz an (unter Ignorierung vorhandener Spring-Bean-Definitionen)
3. Die Factory von Spring erstellt die Instanz und injiziert die Konstruktordependenzen
4. Die Route wird mit allen erfüllten Abhängigkeiten initialisiert

Dieses Verhalten ist absichtlich und unterscheidet sich von typischen Spring-Beans. Selbst wenn Sie eine Route als Spring-Bean mit @Component registrieren, ignoriert webforJ diese Bean-Definition und erstellt für jede Navigation eine frische Instanz.

Verwendung von Spring-Beans in Routen

Ihre Routenklassen benötigen keine Spring-Annotationen. Die @Route-Annotation allein ermöglicht sowohl die Routenentdeckung als auch die Abhängigkeitsinjektion:

@Route("/dashboard")
public class DashboardView extends Composite<Div> {

  private final Div self = getBoundComponent();
  private final MetricsService metricsService;
  private final UserRepository userRepository;

  public DashboardView(MetricsService metricsService, UserRepository userRepository) {
    this.metricsService = metricsService;
    this.userRepository = userRepository;

    // Verwenden Sie die injizierten Dienste, um die UI zu erstellen
    Div metricsPanel = new Div();
    metricsPanel.setText(metricsService.getCurrentMetrics());

    self.add(metricsPanel);
  }
}

Der Konstruktor kann empfangen:

• Dienste, die mit @Service, @Repository oder @Component annotiert sind
• Spring Data-Repositories (JpaRepository, CrudRepository)
• Konfigurationswerte über @Value-Annotationen
• Spring-Infrastruktur-Beans (ApplicationContext, Environment)
• Jede Bean, die im Spring-Kontext registriert ist

Arbeitsbeispiel

Dieses Beispiel demonstriert ein umfassendes Abhängigkeitsinjektionsszenario, bei dem ein Spring-Dienst in eine webforJ-Route injiziert wird. Der Dienst verwaltet die Geschäftlogik, während die Route die UI-Präsentation behandelt.

Zunächst definieren Sie einen standardmäßigen Spring-Dienst mit der @Service-Annotation. Dieser Dienst wird von Springs Container verwaltet und steht für die Injektion zur Verfügung:

RandomNumberService.java

@Service
public class RandomNumberService {

  public Integer getRandomNumber() {
    return (int) (Math.random() * 100);
  }
}

HelloWorldView.java

@Route("/")
public class HelloWorldView extends Composite<FlexLayout> {

  private final FlexLayout self = getBoundComponent();
  private Button btn = new Button("Zufallszahl generieren");

  public HelloWorldView(RandomNumberService service) {
    self.setDirection(FlexDirection.COLUMN);
    self.setMaxWidth(300);
    self.setStyle("margin", "1em auto");

    btn.setPrefixComponent(TablerIcon.create("dice"))
        .setTheme(ButtonTheme.GRAY)
        .addClickListener(e -> {
          Toast.show("Die neue Zufallszahl ist " + service.getRandomNumber(), Theme.SUCCESS);
        });

    self.add(btn);
  }
}

In diesem Beispiel ist der RandomNumberService ein standardmäßiges Spring-Dienst-Bean. Die Route HelloWorldView erklärt ihn als Konstruktionsparameter, und Spring stellt automatisch die Dienstinstanz zur Verfügung, wenn webforJ die Route erstellt.

Beachten Sie, dass die Routenklasse nur die @Route-Annotation verwendet - keine Spring-Stereotypen wie @Component oder @Controller sind erforderlich. Wenn ein Benutzer den Stammweg / navigiert, führt webforJ:

1. Erstellt eine neue Instanz von HelloWorldView
2. Fragt Spring, um die Abhängigkeit RandomNumberService aufzulösen
3. Übergibt den Dienst an den Konstruktor
4. Die Route verwendet den injizierten Dienst, um Button-Klicks zu verarbeiten

Dieses Muster funktioniert mit jeder Spring-Bean - Diensten, Repositories, Konfigurationsklassen oder benutzerdefinierten Komponenten. Die Abhängigkeitsinjektion erfolgt transparent, sodass Sie sich auf den Aufbau Ihrer UI konzentrieren können, während Spring das Wiring verwaltet.

Already running Spring Boot?

Ask the team how webforJ fits into your existing Spring app.

Gespräch vereinbaren Per E-Mail anfragen

Weiterlernen

ArtikelAvoid UI framework lock-in in Java: keep the views thinArtikelReact with a Java backend: when it fits, and the all-Java optionArtikelThe best web framework for Java in 2026, by jobArtikelReplace React with Java: moving a front end to webforJArtikelJava web app tutorial for beginners: build your first appArtikelAlternatives to Angular for Java teams