Lernmaterialien

Introduction

Spring Boot

Spring Boot ist ein Framework auf Basis von Spring, mit dem man Java-Anwendungen sehr schnell entwickeln und starten kann, besonders Webanwendungen und REST-APIs.

Einfach gesagt:

Mit Spring Boot musst du viel weniger selbst konfigurieren als beim klassischen Spring Framework.

Was es besonders macht:

• Automatische Konfiguration: Spring Boot erkennt oft selbst, was deine Anwendung braucht.

• Eingebetteter Server: Zum Beispiel Tomcat ist direkt dabei. Du musst also nicht extra einen Webserver installieren.

• Schneller Start: Ideal für Microservices und moderne Backend-Anwendungen.

• Viele Starter-Pakete: Etwa spring-boot-starter-web, spring-boot-starter-data-jpa, spring-boot-starter-security.

Kleines Beispiel:

@SpringBootApplication
@RestController
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @GetMapping("/")
    public String hello() {
        return "Hallo Welt";
    }
}

Damit hast du schon eine kleine Webanwendung.

Unterschied kurz:

• Spring = großes, flexibles Framework

• Spring Boot = macht Spring einfacher, schneller und mit weniger Konfiguration nutzbar

Typische Einsatzgebiete:

• REST-APIs

• Webanwendungen

• Microservices

• Datenbankanwendungen

Maven

Maven ist ein Build- und Projektmanagement-Tool für Java.

Es hilft dir dabei,

• Bibliotheken automatisch einzubinden

• Code zu kompilieren

• Tests auszuführen

• JAR- oder WAR-Dateien zu erzeugen

• das Projekt einheitlich zu verwalten

Das Zentrale in Maven ist die Datei pom.xml.

Darin steht zum Beispiel:

• wie das Projekt heißt

• welche Abhängigkeiten gebraucht werden

• welche Java-Version verwendet wird

• wie gebaut werden soll

Einfaches Beispiel:

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.beispiel</groupId>
    <artifactId>demo</artifactId>
    <version>1.0</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.2.0</version>
        </dependency>
    </dependencies>
</project>

Was Maven praktisch macht:

Früher musste man JAR-Dateien oft manuell herunterladen. Maven lädt sie automatisch aus einem Repository.

Kurz gesagt:

Maven organisiert, baut und verwaltet Java-Projekte.

Zusammenhang mit Spring Boot:

Spring-Boot-Projekte werden sehr oft mit Maven gebaut.

Die Lifecycle-Tasks in Maven sind die Standardphasen, die ein Projekt beim Bauen durchläuft.

Du kannst sie dir wie eine feste Reihenfolge vorstellen:

1. Projekt prüfen

2. Code kompilieren

3. Tests ausführen

4. Paket erzeugen

5. Artefakt installieren oder veröffentlichen

In IntelliJ siehst du rechts im Maven-Fenster unter Lifecycle diese Phasen:

• clean Löscht alte Build-Ergebnisse, meist den target-Ordner.

• validate Prüft, ob das Projekt korrekt aufgebaut ist, zum Beispiel ob die pom.xml gültig ist.

• compile Kompiliert den Hauptcode aus src/main/java.

• test Kompiliert und startet die Tests aus src/test/java.

• package Baut das Ergebnis als JAR oder WAR.

• verify Führt zusätzliche Prüfungen aus, um sicherzustellen, dass das Paket gültig ist.

• install Kopiert das gebaute Artefakt in dein lokales Maven-Repository (.m2), damit andere lokale Projekte es verwenden können.

• site Erstellt eine Projektdokumentation.

• deploy Lädt das Artefakt in ein entferntes Repository hoch, zum Beispiel für ein Team oder einen Server.

Wichtig ist: Wenn du in Maven eine Phase startest, werden alle vorherigen Phasen automatisch mit ausgeführt.

Beispiel:

• Startest du test, dann macht Maven vorher auch validate und compile

• Startest du install, dann macht Maven normalerweise:

  validate -> compile -> test -> package -> verify -> install

Für dein Projekt bedeutet das meist:

• clean: alles Alte löschen

• test: Tests laufen lassen

• package: JAR bauen

• install: Projekt lokal verfügbar machen

Merksatz: Je weiter unten die Phase steht, desto mehr wird automatisch erledigt.

Für Anfänger sind am wichtigsten:

• clean

• compile

• test

• package

• install

Vaadin startup project

Vaadin

Vaadin ist ein Java-Framework für die Entwicklung von modernen Webanwendungen. Es erlaubt dir, mit Java (oder Kotlin) vollständige UI-Anwendungen zu bauen, ohne dass du dich direkt mit HTML, CSS oder JavaScript beschäftigen musst.

Server-Side UI Framework

• Die gesamte UI-Logik läuft auf dem Server (Java).
• Der Browser zeigt nur die gerenderte Oberfläche an, die Vaadin automatisch per WebSocket/HTTP aktualisiert.

• HTTP: Klassisches Anfrage-Antwort-Prinzip
  → Client schickt Anfrage, Server antwortet, Verbindung endet. „Fragen & Antworten“
• WebSocket: Dauerhafte Verbindung
  → Client und Server können jederzeit beidseitig Daten senden (live). „offenes Gespräch“

Komponentenbasiert

• Du baust die Oberfläche mit fertigen Komponenten wie TextField, Grid, Button, DatePicker, usw. – ähnlich wie bei Swing/JavaFX, aber fürs Web.

Routing

• Jede View (Seite) ist eine Java-Klasse.

• Über @Route("delivery") definierst du, unter welcher URL sie erreichbar ist.

  => http://localhost:8080/delivery

Binder & Validation

• Mit Binder kannst du deine Formularfelder direkt an Java-Objekte (DTOs, Entities) binden.
• Unterstützt Bean Validation (@NotNull, @Min, @Pattern …).

Integration

• Funktioniert nahtlos mit Spring Boot.
• Kann auch standalone in einem Servlet-Container laufen (z. B. Tomcat, Jetty).

Modi

• Vaadin Flow: klassisches serverseitiges Java → UI wird automatisch gerendert.
• Vaadin Fusion (heißt jetzt Hilla): Kombination aus Java Backend + TypeScript Frontend.

Create the application

https://start.vaadin.com/app?continue

Mit Start Playing gela`ngt man in den design mode

Man muss dann die Views definieren. Es können später auch im IntelliJ views hinzugefügt werden!

Wir legen drei Views an - content Empty:

• Home

• Orders

• Delivery

Mit download wird dann das Projekt heruntergeladen oder über https://github.com gepushed.

Sie steht in der pom.xml, zum Beispiel so:

    <groupId>at.spengergasse</groupId>
    <artifactId>pizzagriesy</artifactId>
    <name>pizzagriesy</name>
    <version>1.0-SNAPSHOT</version>

Bedeutung der Teile:

• groupId = wer das Projekt herstellt, zum Beispiel Firma, Organisation oder Paketgruppe
• artifactId = wie das konkrete Projekt heißt
• version = welche Version es ist

Zusammen identifiziert Maven ein Projekt eindeutig: groupId:artifactId:version

Nach dem clone wird daraus ein IntelliJ Projekt.

src/main/resources/application.properties

spring.datasource.url = jdbc:postgresql://localhost:5432/pizzagriesy
spring.datasource.username = pizzagriesy
spring.datasource.password = pizzagriesy

Die Datenbank postgres muss dann noch gestartet werden und Datenbank und Benutzer angelegt werden:

docker run --name postgres -e POSTGRES_PASSWORD=postgres  -p 5432:5432 -d postgres
docker stop postgres
docker start postgres

psql "postgresql://postgres:postgres@localhost:5432"
CREATE DATABASE pizzagriesy;
CREATE USER pizzagriesy WITH PASSWORD 'pizzagriesy';
GRANT ALL PRIVILEGES ON DATABASE pizzagriesy TO pizzagriesy;
quit;

Das Projekt dann mvwn ausführen.

Das Projekt kann nun von der Konsole gestartet werden:

rm -rf ~/.m2/repository/com/vaadin
cd "/home/thomas/Desktop/Code_2025/pizzagriesy"
./mvnw clean package -U
./mvnw spring-boot:run

mvnw und mvnw.cmd sind die Maven Wrapper-Startdateien.

Damit kann man Maven benutzen, ohne Maven vorher selbst global zu installieren.

Unterschied:

• mvnw = für Linux/macOS

• mvnw.cmd = für Windows

Was sie machen:

• Sie prüfen, welche Maven-Version das Projekt benutzen soll

• Sie laden diese Version bei Bedarf automatisch herunter

• Sie starten dann Maven mit genau dieser Version

Vorteil: Alle, die am Projekt arbeiten, benutzen dieselbe Maven-Version. Das verhindert viele Probleme.

Unter Linux/macOS:

./mvnw test

Unter Windows:

mvnw.cmd test

Oder oft auch:

mvnw clean package

Warum das praktisch ist:

• keine manuelle Maven-Installation nötig

• gleiche Version für alle

Einfach gesagt: mvnw ist ein projektspezifischer Starter für Maven.

Es öffnet sich der browser und das Projekt wird ausgeführt.

Project structure

• MainLayout.java in src/main/java contains the navigation setup (i.e., the side/top bar and the main menu). This setup uses App Layout.
• views package in src/main/java contains the server-side Java views of your application.
• views folder in src/main/frontend contains the client-side JavaScript views of your application.
• themes folder in src/main/frontend contains the custom CSS styles.

Useful links

• Read the documentation at vaadin.com/docs.
• Follow the tutorial at vaadin.com/docs/latest/tutorial/overview.
• Create new projects at start.vaadin.com.
• Search UI components and their usage examples at vaadin.com/docs/latest/components.
• View use case applications that demonstrate Vaadin capabilities at vaadin.com/examples-and-demos.
• Build any UI without custom CSS by discovering Vaadin’s set of CSS utility classes.
• Find a collection of solutions to common use cases at cookbook.vaadin.com.
• Find add-ons at vaadin.com/directory.
• Ask questions on Stack Overflow or join our Forum.
• Report issues, create pull requests in GitHub.