Tutorials

Tutorial: MySQL mit Spring Boot verbinden und Tabellen erstellen

Melden

Hier ist ein ausführliches Tutorial, wie du eine MySQL-Datenbank mit Spring Boot verbindest und automatisch Tabellen generieren lässt.

Dieses Tutorial zeigt dir Schritt für Schritt, wie du eine Java-Anwendung mit einer MySQL-Datenbank verknüpfst und das Datenmodell (Entity) so konfigurierst, dass Spring Boot die Tabelle automatisch für dich erstellt.

1. Voraussetzungen

Bevor du startest, stelle sicher, dass Folgendes installiert ist:

  • Java Development Kit (JDK)
  • IDE (z. B. IntelliJ IDEA, Eclipse oder VS Code)
  • MySQL Server (lokal oder Docker)
  • Maven (in den meisten IDEs integriert)

2. Projekt erstellen (Spring Initializr)

Gehe auf start.spring.io und erstelle ein neues Projekt mit folgenden Einstellungen:

  • Project: Maven Project
  • Language: Java
  • Spring Boot: (Wähle die aktuelle stabile Version)
  • Dependencies (Abhängigkeiten):
    1. Spring Data JPA (Für die Datenbankinteraktion)
    2. MySQL Driver (Um die Verbindung zu MySQL zu ermöglichen)
    3. Spring Web (Optional, falls du eine REST-API baust)
    4. Lombok (Optional, um Getter/Setter Code zu sparen)

Lade das Projekt herunter, entpacke es und öffne es in deiner IDE.

3. Datenbank in MySQL anlegen

Bevor Spring Boot sich verbinden kann, muss die Datenbank (das Schema) existieren. Öffne dein MySQL-Terminal oder MySQL Workbench und gib ein:

CREATE DATABASE meine_datenbank;

4. Verbindung konfigurieren (application.properties)

Öffne die Datei src/main/resources/application.properties und trage die Zugangsdaten für deine Datenbank ein:

# Datenbank-URL (ersetze 'meine_datenbank' durch deinen Namen)
spring.datasource.url=jdbc:mysql://localhost:3306/meine_datenbank?serverTimezone=UTC

# Benutzername und Passwort
spring.datasource.username=root
spring.datasource.password=deinPasswort

# Hibernate Einstellungen
# 'update' sorgt dafür, dass Tabellen automatisch erstellt oder aktualisiert werden
spring.jpa.hibernate.ddl-auto=update

# Zeige SQL-Befehle in der Konsole an (hilfreich zum Debuggen)
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect

5. Das Datenmodell erstellen (Die Tabelle)

In Spring Boot wird eine Tabelle durch eine einfache Java-Klasse repräsentiert, die mit @Entity markiert ist. Erstelle eine Klasse namens User.java:

package com.example.demo.model;

import jakarta.persistence.*;

@Entity // Markiert diese Klasse als Datenbank-Tabelle
@Table(name = "users") // Optional: Legt den Tabellennamen fest
public class User {

    @Id // Primärschlüssel
    @GeneratedValue(strategy = GenerationType.IDENTITY) // Auto-Inkrement
    private Long id;

    @Column(nullable = false) // Tabellenspalte darf nicht leer sein
    private String name;

    private String email;

    // Standard-Konstruktor (wichtig für JPA)
    public User() {}

    // Getter und Setter
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

6. Repository Interface erstellen

Das Repository ist die Schnittstelle für Datenbankoperationen (Speichern, Löschen, Suchen). Erstelle ein Interface UserRepository.java:

package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // Hier können eigene Abfragen definiert werden
}

7. Anwendung starten

Starte deine Anwendung über die Hauptklasse (die mit @SpringBootApplication annotiert ist).

Was passiert jetzt?

  1. Spring Boot verbindet sich mit der MySQL-Datenbank.
  2. Dank der Einstellung spring.jpa.hibernate.ddl-auto=update scannt Hibernate deine @Entity-Klassen.
  3. Hibernate stellt fest, dass die Tabelle users noch nicht existiert, und führt automatisch den SQL-Befehl CREATE TABLE aus.

8. Erfolg prüfen

Du kannst nun in deinem MySQL-Tool prüfen, ob die Tabelle erstellt wurde:

USE meine_datenbank;
DESCRIBE users;

Du wirst sehen, dass die Spalten id, name und email automatisch angelegt wurden.

Zusammenfassung der wichtigsten Befehle

  • @Entity: Erstellt die Tabelle.
  • @Id: Definiert den Primärschlüssel.
  • spring.jpa.hibernate.ddl-auto=update: Erlaubt Spring Boot, das Schema automatisch zu verwalten.
  • JpaRepository: Gibt dir alle Standard-Methoden wie save(), findAll() oder deleteById().
0