JDBC-Datenbankzugriffe mit Spring Data

Spring Boot ist ein beliebtes Framework zur Entwicklung von Java-Webanwendungen, das die Entwicklung von robusten und skalierbaren Anwendungen vereinfacht. In Kombination mit Spring Data bietet es leistungsfähige Funktionen zur Datenbankinteraktion, darunter auch die Arbeit mit JDBC-Datenbanken. In diesem Artikel werden wir uns damit befassen, wie man Entities in einer JDBC-Datenbank aus einer Spring Boot Webanwendung liest und schreibt. Als Beispiel werden wir eine PostgreSQL-Datenbank verwenden.

Konfiguration der Datenbankverbindung

Zuerst müssen wir die Verbindung zur PostgreSQL-Datenbank konfigurieren. In einer Spring Boot-Anwendung erfolgt dies normalerweise in der application.properties oder application.yml-Datei. Hier ist ein Beispiel für eine application.properties-Datei:

spring.datasource.url=jdbc:postgresql://localhost:5432/meine_datenbank
spring.datasource.username=benutzername
spring.datasource.password=passwort
spring.datasource.driverClassName=org.postgresql.DriverCode-Sprache: JavaScript (javascript)

Stellen Sie sicher, dass Sie die URL, den Benutzernamen und das Passwort entsprechend Ihrer Datenbankkonfiguration anpassen.

Erstellung einer Entity-Klasse

Als nächstes erstellen wir eine Entity-Klasse, die unsere Datenbanktabelle repräsentiert. In diesem Beispiel erstellen wir eine einfache Tabelle zur Speicherung von Büchern. Hier ist die Entity-Klasse:

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Buch {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String titel;
    private String autor;

    // Getter und Setter
}Code-Sprache: JavaScript (javascript)

Die Annotation @Entity kennzeichnet diese Klasse als JPA-Entity, was bedeutet, dass sie von Spring Data JPA erkannt und mit der Datenbanktabelle synchronisiert wird.

Erstellung eines Repository-Interfaces

Um auf die Datenbank zuzugreifen, erstellen wir ein Repository-Interface. Spring Data JPA generiert automatisch Implementierungen für die grundlegenden CRUD-Operationen (Create, Read, Update, Delete). Hier ist das Repository-Interface für unsere Buch-Entity:

import org.springframework.data.jpa.repository.JpaRepository;

public interface BuchRepository extends JpaRepository<Buch, Long> {
    // Hier können spezielle Abfragen definiert werden, falls benötigt
}Code-Sprache: PHP (php)

Durch die Verwendung von JpaRepository müssen wir keine benutzerdefinierten DAO-Klassen schreiben, um auf die Datenbank zuzugreifen.

Lese- und Schreiboperationen

Jetzt können wir Lese- und Schreiboperationen auf unsere Datenbanktabelle durchführen. Hier sind einige Beispiele:

Schreiben (Erstellen und Aktualisieren)

@RestController
@RequestMapping("/buecher")
public class BuchController {
    private final BuchRepository buchRepository;

    @Autowired
    public BuchController(BuchRepository buchRepository) {
        this.buchRepository = buchRepository;
    }

    @PostMapping
    public Buch createBuch(@RequestBody Buch buch) {
        return buchRepository.save(buch);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Buch> updateBuch(@PathVariable Long id, @RequestBody Buch buch) {
        if (!buchRepository.existsById(id)) {
            return ResponseEntity.notFound().build();
        }

        buch.setId(id);
        Buch aktualisiertesBuch = buchRepository.save(buch);
        return ResponseEntity.ok(aktualisiertesBuch);
    }
}Code-Sprache: PHP (php)

In diesem Beispiel haben wir einen BuchController erstellt, der POST- und PUT-Endpunkte für das Erstellen und Aktualisieren von Büchern bereitstellt. Die @PostMapping– und @PutMapping-Methoden verwenden das BuchRepository, um Daten in die Datenbank zu schreiben.

Lesen (Abfragen)

@RestController
@RequestMapping("/buecher")
public class BuchController {
    // ...

    @GetMapping("/{id}")
    public ResponseEntity<Buch> getBuch(@PathVariable Long id) {
        Optional<Buch> buch = buchRepository.findById(id);
        return buch.map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build());
    }

    @GetMapping
    public List<Buch> alleBuecher() {
        return buchRepository.findAll();
    }
}Code-Sprache: PHP (php)

Hier haben wir GET-Endpunkte hinzugefügt, um Bücher anhand ihrer ID abzurufen und alle Bücher abzurufen. Wir verwenden findById und findAll von BuchRepository, um Daten aus der Datenbank abzurufen.

Testen der Webanwendung

Um die Webanwendung zu testen, können Sie HTTP-Anfragen an die Endpunkte senden. Zum Beispiel:

• POST-Anfrage zum Erstellen eines neuen Buchs:

POST http://localhost:8080/buecher
Content-Type: application/json

{
    "titel": "Der große Gatsby",
    "autor": "F. Scott Fitzgerald"
}Code-Sprache: JavaScript (javascript)

• GET-Anfrage zum Abrufen aller Bücher:

GET http://localhost:8080/buecherCode-Sprache: JavaScript (javascript)

• PUT-Anfrage zum Aktualisieren eines Buchs nach ID:

PUT http://localhost:8080/buecher/1
Content-Type: application/json

{
    "titel": "Der große Gatsby (aktualisiert)",
    "autor": "F. Scott Fitzgerald"
}Code-Sprache: JavaScript (javascript)

• GET-Anfrage zum Abrufen eines Buchs nach ID:

GET http://localhost:8080/buecher/1Code-Sprache: JavaScript (javascript)

Fazit

Die Kombination von Spring Boot und Spring Data vereinfacht das Lesen und Schreiben von Entities in JDBC-Datenbanken erheblich. Mit minimaler Konfiguration können Sie CRUD-Operationen auf Ihrer Datenbank ausführen, während Spring Data JPA die meisten Aufgaben automatisiert. In diesem Artikel haben wir PostgreSQL als Beispiel verwendet, aber die gleichen Prinzipien gelten auch für andere JDBC-Datenbanken. Mit diesem Wissen sind Sie gut gerüstet, um robuste und skalierbare Webanwendungen mit Spring Boot und Spring