Zum Inhalt springen
Startseite » Blog » Spring Boot API – PostgreSQL – Docker

Spring Boot API – PostgreSQL – Docker

Einführung

In diesem Lernprojekt werden Spring Boot, PostgreSQL und Docker integriert, um zu zeigen, wie man eine RESTful API mit Spring Boot entwickelt, eine PostgreSQL-Datenbank in Docker containerisiert und Bestelldaten verwaltet. Es bietet eine praktische Einführung in die Kombination von Backend-Entwicklung und modernen DevOps-Praktiken.

Projektübersicht

Das Ziel dieses Projekts ist die Erstellung einer Spring Boot Anwendung, die POST-Anfragen für Bestellungen verarbeitet und diese in einer PostgreSQL-Datenbank speichert, die in einem Docker-Container läuft. Die Anwendung folgt einer mehrschichtigen Architektur, um eine klare Trennung der Verantwortlichkeiten zu gewährleisten, was sie pflegbar und skalierbar macht.

Architektur der Anwendung

Das Projekt besteht aus mehreren Kernkomponenten, von denen jede eine spezifische Aufgabe innerhalb der Anwendung übernimmt:

Spring Boot

  • Framework: Spring Boot bildet das Rückgrat der Anwendung und verwaltet alles, von der Dependency Injection bis zur Lebenszyklusverwaltung.
  • Warum Spring Boot? Es vereinfacht die Erstellung produktionsreifer Spring-Anwendungen, insbesondere für RESTful APIs.

REST Controller

  • Endpoints:
    • /order – Verarbeitet POST-Anfragen für einzelne Bestellungen.
    • /orders – Verarbeitet POST-Anfragen für mehrere Bestellungen.
  • Verantwortlichkeiten:
    • Der Controller empfängt eingehende HTTP-POST-Anfragen.
    • Er validiert die eingehenden Daten, um sicherzustellen, dass sie der erwarteten Struktur entsprechen.
    • Nach der Validierung werden die Daten zur weiteren Verarbeitung an die Service-Schicht weitergeleitet.

Service-Schicht

  • Verantwortlichkeiten:
    • Hier befindet sich die Kernlogik der Anwendung.
    • Die Service-Schicht kommuniziert mit dem Repository, um Datenbankoperationen durchzuführen.
  • Warum eine Service-Schicht? Sie sorgt für eine klare Trennung zwischen der Geschäftslogik und den Datenbankoperationen, was die Organisation des Codes und die Testbarkeit verbessert.

Repository-Schicht

  • Technologie: Spring Data JPA
  • Verantwortlichkeiten:
    • Diese Schicht ist für die Interaktion mit der PostgreSQL-Datenbank zuständig.
    • Sie bietet eine Schnittstelle, um CRUD-Operationen (Erstellen, Lesen, Aktualisieren, Löschen) auf der Datenbank auszuführen.
  • Warum Spring Data JPA? Es abstrahiert einen Großteil des Boilerplate-Codes, der für Datenbankoperationen erforderlich ist, sodass du dich auf die Geschäftslogik konzentrieren kannst.

Docker für PostgreSQL

  • Zweck: Docker wird verwendet, um die PostgreSQL-Datenbank zu containerisieren, was eine konsistente Entwicklungsumgebung sicherstellt.
  • Konfiguration:
    • Eine Dockerfile enthält Anweisungen zur Einrichtung des PostgreSQL-Containers.
    • Eine docker-compose.yml Datei orchestriert den PostgreSQL-Container, sodass die Datenbank mit einem einzigen Befehl gestartet werden kann.
  • Warum Docker? Docker bietet eine isolierte und reproduzierbare Umgebung, die die Verwaltung von Abhängigkeiten und Datenbankdiensten vereinfacht.

PostgreSQL-Datenbank

  • Rolle: Dauerhafter Speicher für alle Bestelldaten.
  • Konfiguration: Die Verbindung zwischen der Spring Boot-Anwendung und PostgreSQL wird über die application.properties Datei verwaltet, was eine sichere und effiziente Kommunikation ermöglicht.

Datenfluss in der Anwendung

Um besser zu verstehen, wie die Komponenten zusammenarbeiten, werfen wir einen Blick auf den Datenfluss:

  1. Client-Anfrage: Der Prozess beginnt, wenn ein Client eine POST-Anfrage an den /order oder /orders-Endpunkt sendet und die Bestelldetails übermittelt.
  2. Controller-Verarbeitung: Der REST-Controller empfängt die Anfrage und validiert die eingehenden Daten, um sicherzustellen, dass sie der geforderten Struktur entsprechen.
  3. Service-Schicht-Verarbeitung: Nach der Validierung übergibt der Controller die Daten an die Service-Schicht, wo die eigentliche Geschäftslogik verarbeitet wird.
  4. Interaktion mit dem Repository: Die Service-Schicht kommuniziert mit der Repository-Schicht, um die Bestelldaten in der PostgreSQL-Datenbank zu speichern.
  5. Datenbankspeicherung: Die Repository-Schicht führt die erforderlichen CRUD-Operationen aus, und die Daten werden dauerhaft in der PostgreSQL-Datenbank gespeichert.

Einrichtung von Docker und PostgreSQL

So konfigurierst du Docker für PostgreSQL in diesem Projekt:

  1. Dockerfile: Diese Datei enthält Anweisungen, um den PostgreSQL-Datenbankcontainer einzurichten. Sie installiert PostgreSQL, legt die erforderlichen Ports frei und definiert Umgebungsvariablen wie Datenbankname, Benutzer und Passwort.
  2. docker-compose.yml: Diese Datei orchestriert den PostgreSQL-Container, wodurch es einfach wird, die Datenbank zu starten und zu verwalten. Mit dem Befehl docker-compose up startet die Datenbank automatisch, und Spring Boot kann sofort über die Konfiguration in application.properties darauf zugreifen.

Beispiel für eine postgres.yml Datei:

services:
  db:
    image: postgres:latest
    restart: always
    shm_size: 128mb
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: db
    ports:
      - "5432:5432"
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - internal
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]
      interval: 10s
      timeout: 5s
      retries: 5
  adminer:
    image: adminer:latest
    restart: always
    ports:
      - "8080:8080"
    networks:
      - internal
    environment:
      ADMINER_DEFAULT_SERVER: db

volumes:
  db_data:

networks:
  internal:
    driver: bridge

Warum diese Architektur sinnvoll ist

Diese Architektur ist so gestaltet, dass sie skalierbar, wartbar und leicht verständlich ist. Jede Schicht hat eine klare Aufgabe, was für eine saubere Trennung der Verantwortlichkeiten sorgt:

  • Der REST-Controller bearbeitet lediglich eingehende HTTP-Anfragen und gibt Antworten zurück.
  • Die Service-Schicht verwaltet die Kernlogik und sorgt für Flexibilität und leichte Testbarkeit.
  • Die Repository-Schicht kümmert sich um alle Dateninteraktionen mit PostgreSQL, wobei Spring Data JPA die Abstraktion übernimmt.
  • Docker stellt sicher, dass die Datenbankumgebung isoliert und einfach replizierbar ist, was die Verwaltung im Entwicklungs- und Produktionsprozess erleichtert.

Get Started

Um mit diesem Projekt zu beginnen, befolge diese Schritte, um deine Entwicklungsumgebung einzurichten und die Anwendung auszuführen:

1. Spring Boot Projekt klonen

Klonen das Repository, das du gerade erstellt hast:

git clone https://github.com/integration-developer-de/Spring-Boot-API-PostgreSQL-Docker
cd DEIN_REPOSITORY

3. PostgreSQL-Datenbank mit Docker starten

Stelle sicher, dass Docker installiert und im Hintergrund ausgeführt wird.
Starte die PostgreSQL-Datenbank mit dem folgenden Befehl:

docker compose -f postgres.yml up -d

Der -d-Schalter startet die Container im Hintergrund.

4. Maven-Abhängigkeiten laden

Öffne das Projekt in deiner bevorzugten IDE (z. B. IntelliJ IDEA oder Eclipse). Stelle sicher, dass die pom.xml Datei die erforderlichen Abhängigkeiten enthält:

mvn clean install

5. Spring Boot-Anwendung starten

Starte die Spring Boot-Anwendung. Du kannst dies tun, indem du die main-Methode in der Hauptanwendungsdatei ausführst oder den folgenden Befehl in der Kommandozeile nutzt:

mvn spring-boot:run

Die Anwendung sollte nun unter http://localhost:8080 erreichbar sein.

6. API POST-Befehle mit Postman senden

Lade Postman herunter und installiere es, wenn du es noch nicht hast. Führe die folgenden Schritte aus, um POST-Anfragen zu testen:

  1. Öffne Postman und klicke auf New -> HTTP Request.
  2. Wähle die Methode POST.
  3. Gib die URL ein:
  • Für eine einzelne Bestellung: http://localhost:8080/order
  • Für mehrere Bestellungen: http://localhost:8080/orders
  1. Im Body-Tab wähle raw und setze den Typ auf JSON. Füge die Bestelldaten im JSON-Format hinzu, z. B.:
{
    "name": "Sample Product",
    "price": 19.99,
    "in_stock": 100,
    "description": "This is a sample product."
}
  1. Klicke auf Send, um die Anfrage abzusetzen.

7. Datenbank in DBeaver überprüfen

Um sicherzustellen, dass die Daten korrekt in der PostgreSQL-Datenbank gespeichert wurden, kannst du DBeaver verwenden:

  1. Lade DBeaver herunter und installiere es, wenn du es noch nicht getan hast.
  2. Starte DBeaver und erstelle eine neue Verbindung:
  • Wähle PostgreSQL aus der Liste der verfügbaren Datenbanktreiber.
  • Gib die Verbindungsdetails ein:
    • Host: localhost
    • Port: 5432
    • Datenbank: orders
    • Benutzer: myuser (root)
    • Passwort: password
  1. Klicke auf Test Connection, um sicherzustellen, dass die Verbindung funktioniert, und klicke dann auf Finish.
  2. Du solltest jetzt in der Lage sein, die Datenbank und die Tabellen zu durchsuchen. Überprüfe die Tabelle, in der die Bestellungen gespeichert werden, um sicherzustellen, dass die eingehenden Daten korrekt gespeichert wurden.

Fazit

Durch die Erstellung dieser Spring Boot-Anwendung mit einer in Docker containerisierten PostgreSQL-Datenbank erhältst du praxisnahes Wissen in mehreren wichtigen Technologien. Du lernst, wie man eine REST-API aufbaut, Geschäftslogik mit Services abwickelt und effizient mit einer Datenbank interagiert. Die Containerisierung mit Docker stellt sicher, dass die Datenbankumgebung einfach zu verwalten und zu replizieren ist, was dieses Projekt zu einer hervorragenden Lernerfahrung für die moderne Backend-Entwicklung macht.

Weitere Blogartikel

Schlagwörter: