Verbinden Sie Spring Boot mit MySQL

Hallo zusammen,

In diesem Tutorial erkläre ich den Prozess, den ich befolgt habe, um Spring Boot mit MySQL zu verbinden, um eine API für mein Front-End zu erstellen.

Voraussetzungen:

• IDE (Ich verwende Intellij IDEA, daher basiert dieses Tutorial darauf)

• MySql Workbench

Klicken Sie hier für den Quellcode.

Erstellen Sie ein Spring Boot-Projekt mit Spring Initializr

Besuchen Sie start.spring.io und wählen Sie:
Projekt: Maven
Sprache: Java
Spring Boot: 3.3.0
Beschreiben Sie die notwendigen Felder mit Ihrem Inhalt
Verpackung: JAR
Java: 17

Was die Abhängigkeiten betrifft, benötigen wir:

• MySQL-Treiber

• Frühlingsnetz

• Spring Data JPA

Danach sollte die Initialisierung so aussehen:

Klicken Sie auf „Generieren“, speichern Sie den Ordner im gewünschten Pfad und extrahieren Sie den Inhalt des Ordners.

Intellij- und MySQL-Konfiguration

Erstellen Sie zunächst eine Datenbank in MySQL. Ich habe dafür MySQL Workbench verwendet.

Selbst die einfachste Datenbank funktioniert, einfach so:

Öffnen Sie den Inhalt des Ordners in Ihrer gewünschten IDE. Ich werde dieses Tutorial mit Intellij IDEA abdecken.

Öffnen Sie die Datei application.properties, die sich unter scr/resources/application.properties befindet

In dieser Datei konfigurieren wir die Einstellungen, die uns bei der Verbindung mit unserer Datenbank helfen.

Schreiben Sie diese Einstellungen in die Datei:

Ersetzen Sie ${DB_NAME}, ${DB_USER}, ${DB_PASSWORD} durch die Anmeldeinformationen Ihrer Datenbank.

Diese Einstellungen helfen uns, eine Verbindung mit der von uns erstellten Datenbank herzustellen:

spring.jpa.show-sql=true:

Dies ermöglicht die Protokollierung der von Hibernate generierten SQL-Anweisungen. Wenn es auf „true“ gesetzt ist, gibt Hibernate die SQL-Anweisungen auf der Konsole aus.

spring.jpa.hibernate.ddl-auto=update:

Diese Einstellung wird verwendet, um das Datenbankschema automatisch zu aktualisieren, damit es mit den Entitätsdefinitionen übereinstimmt. Die Wertaktualisierung bedeutet, dass Hibernate das vorhandene Schema aktualisiert und alle neuen Spalten oder Tabellen hinzufügt, die für die Entitätszuordnungen erforderlich sind.

logging.level.org.hibernate.SQL=DEBUG:

Dadurch wird die Protokollierungsstufe für den Hibernate-SQL-Logger auf DEBUG gesetzt. Es enthält detaillierte Informationen zu den ausgeführten SQL-Anweisungen.

logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE:

Dadurch wird die Protokollierungsstufe für den SQL-Binder des Hibernate-Typdeskriptors auf TRACE gesetzt. Dadurch werden detaillierte Informationen über die Bindung von Parametern in SQL-Anweisungen protokolliert.

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver:

Dies gibt den JDBC-Treiberklassennamen für MySQL an. Es teilt Spring Boot mit, welcher Treiber zum Herstellen der Verbindung zur Datenbank verwendet werden soll.

spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect:

Dadurch wird der Hibernate-Dialekt auf MySQLDialect gesetzt, der für MySQL optimiert ist. Es ermöglicht Hibernate, SQL-Anweisungen zu generieren, die mit MySQL kompatibel sind.

Erstellen Sie nun ein Unterpaket im Hauptpaket Ihres Projekts und nennen Sie es „Modell“. Erstellen Sie darin eine Klasse, die sie so nennt, wie Sie möchten. In meinem Fall nenne ich sie „Benutzer“.

package com.evaluation.evaluationSystem.model;

import jakarta.persistence.*;

@Entity
@Table(name = "users")
public class Users {
    public Long getId() {
        return id;
    }

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

    @Column(name = "email")
    private String email;

    @Column(name = "password")
    private String password;

    public void setId(Long id) {
        this.id = id;
    }

    public String getEmail() {
        return email;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

In dieser Datei definieren wir eine JPA-Entität „Benutzer“, die einer Datenbanktabelle „Benutzer“ zugeordnet wird. Die Klasse enthält Felder für ID, E-Mail und Passwort, die den Spalten in der Benutzertabelle entsprechen. Stellen Sie daher sicher, dass das Feld mit den Spalten Ihrer Datenbank übereinstimmt.

Erstellen Sie anschließend ein weiteres Unterpaket namens „Controller“ und erstellen Sie darin eine Datei.

package com.evaluation.evaluationSystem.controller;

import com.evaluation.evaluationSystem.model.Users;
import com.evaluation.evaluationSystem.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
public class UsersController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public List<Users> getUsers(@RequestParam("search") Optional<String> searchParam){
        return searchParam.map(param -> userRepository.getContainingQuote(param))
                .orElse(userRepository.findAll());
    }
}

In dieser Datei definieren wir einen RESTful-API-Endpunkt (/users), der optional Benutzerentitäten basierend auf einem Suchparameter filtern kann. Es nutzt UserRepository für die Datenbankinteraktion und gibt Ergebnisse aufgrund der @RestController-Annotation im JSON-Format zurück. Ersetzen Sie „/users“ durch einen beliebigen Endpunkt.

Erstellen Sie ein weiteres (letztes) Unterpaket namens „Repository“ und erstellen Sie eine Dateischnittstelle (seien Sie vorsichtig, nicht Klasse).

package com.evaluation.evaluationSystem.repository;

import com.evaluation.evaluationSystem.model.Users;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface UserRepository extends JpaRepository<Users, Long> {
    @Query("SELECT u FROM Users u WHERE u.email LIKE %:word%")
    List<Users> getContainingQuote(@Param("word") String word);
}

In dieser Datei definieren wir die Abfrage, die es uns ermöglicht, die Daten aus der Datenbank abzurufen. Stellen Sie sicher, dass Sie es entsprechend Ihren Anforderungen bearbeiten. Wir schreiben diese Abfrage mit JPQL (Java Persistence Query Language). Es handelt sich um eine Abfragesprache, die als Teil der Java Persistence API (JPA)-Spezifikation definiert ist und zur Durchführung von Datenbankoperationen an Java-Objekten und -Entitäten verwendet wird.

Ihre letzte Ordnerstruktur sollte so aussehen:

Navigieren Sie nun zur Hauptdatei (in meinem Fall EvaluationSystemApplication) und führen Sie das Projekt aus. Wenn alles gut funktioniert, werden beim Besuch von localhost:8080/users (oder dem von Ihnen gewählten Endpunkt) Ihre Daten aus der Datenbank angezeigt. Stellen Sie sicher, dass Sie die Datentabelle mit etwas Inhalt füllen.

Abschluss

Ich hoffe, dieses Tutorial hat Ihnen geholfen. Ich bin auch neu in diesem Umfeld, also lerne ich auch. Jeder Kommentar und Vorschlag ist herzlich willkommen!

Folgen Sie mir gerne auf meinem GitHub-Konto, um über meinen Weg zur Entwicklung einer Full-Stack-Webanwendung mit Spring Boot, MySQL und React auf dem Laufenden zu bleiben!

Das obige ist der detaillierte Inhalt vonVerbinden Sie Spring Boot mit MySQL. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!