Erste Schritte mit MariaDB mit Docker, Java Spring und JDBC

Es gibt viele SQL-Clients, die in freier Wildbahn verfügbar sind. Der Einfachheit halber habe ich mich dafür entschieden, die Verwendung des offiziellen MariaDB-Clients zu demonstrieren, aber Sie können natürlich jeden Client verwenden, den Sie bevorzugen.

Stellen Sie eine Verbindung zu Ihrer MariaDB-Instanz her, indem Sie Folgendes ausführen:

$ mariadb --host 127.0.0.1 -P 3306 --user root -pPassword123!

Sie sollten so etwas wie das Folgende sehen, was bedeutet, dass Sie sich erfolgreich mit der MariaDB-Instanz verbunden haben!

Sobald Sie verbunden sind, können Sie eine neue Datenbank erstellen.

CREATE DATABASE todo;

Erstellen Sie dann eine neue Tabelle.

CREATE TABLE todo.tasks (
  id INT(11) unsigned NOT NULL AUTO_INCREMENT,
  description VARCHAR(500) NOT NULL,
  completed BOOLEAN NOT NULL DEFAULT 0,
  PRIMARY KEY (id)
);

Erste Schritte mit Java Spring, JDBC und MariaDB

Mit einer hochgefahrenen Datenbankinstanz und einem erstellten Schema können Sie eine neue Java-Anwendung erstellen.

Maven-Projekt erstellen

Navigieren Sie zunächst zu https://start.spring.io, wo Sie ein neues Spring-basiertes Maven-Projekt erstellen können. Für dieses Projekt können Sie folgende Kriterien eingeben.

Fügen Sie als Nächstes die folgenden Abhängigkeiten hinzu:

• Lombok: Eine Bibliothek, die es überflüssig macht, Boiler-Plate-Code (z. B. Getter, Setter) innerhalb der Domänenobjekte zu erstellen.
• Frühlingsweb: Eine Bibliothek zum Erstellen und Verfügbarmachen von RESTful-API-Endpunkten.
• Frühlingsdaten JPA: Eine Bibliothek, die Abstraktionen bereitstellt, um Boiler-Plate-Code für die Verbindung zu und Kommunikation mit Datenbanken zu eliminieren.

Klicken Sie abschließend auf die Schaltfläche "GENERATE", um das Projekt (in einer .zip-Datei enthalten) zu erstellen und an einen gewünschten Speicherort auf Ihrem Computer herunterzuladen.

Fügen Sie den MariaDB R2DBC-Connector hinzu

Navigieren Sie zu dem Speicherort, an den Sie das neue Maven-Projekt (ZIP-Datei) heruntergeladen haben, und entpacken Sie es. Verwenden Sie dann einen Code-Editor, um das Projekt zu öffnen, und öffnen Sie pom.xml.

Fügen Sie der Sammlung von Abhängigkeiten eine neue Abhängigkeit für den JDBC-Connector von MariaDB hinzu.

<dependency>             
   <groupId>org.mariadb.jdbc</groupId>           
   <artifactId>mariadb-java-client</artifactId>
   <version>2.6.0</version>
</dependency>

Vorbereitung der Datenintegration

Nachdem Sie nun ein Projekt erstellt haben, das alle benötigten Abhängigkeiten enthält, können Sie in den Java-Code springen. Normalerweise beginne ich gerne damit, die Entitätsklassen zu erstellen.

Navigieren Sie zu /src/main/java/com/mariadb/todo , erstellen Sie einen neuen Ordner namens „domain“ und erstellen Sie darin eine neue Datei namens „Task.java“.

Öffnen Sie "Task.java" und fügen Sie den folgenden Code hinzu.

package com.mariadb.todo.domain;

import javax.persistence.*;

import lombok.Data;

@Data
@Entity
@Table(name = "tasks")
public class Task {
    @Id 
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String description;
    private Boolean completed = false;
}

Erstellen Sie als Nächstes einen neuen Ordner mit dem Namen „repositories“ in /src/main/java/com/mariadb/todo , und erstellen Sie darin eine neue Datei mit dem Namen "TaskRepository.java".

Öffnen Sie „TaskRepository.java“ und fügen Sie den folgenden Code hinzu.

package com.mariadb.todo.repositories;

import com.mariadb.todo.domain.Task;

import org.springframework.data.repository.CrudRepository;

public interface TaskRepository extends CrudRepository<Task, Integer> {
}

Wie der Name schon sagt, bietet die CrudRepository-Schnittstelle grundlegende CRUD-Operationen auf einem Repository für einen generischen Typ (in diesem Fall Ihre Task-Klasse) und den Primärschlüsseltyp für diesen generischen Typ.

Datendienst erstellen

Dienste können verwendet werden, um die Geschäftslogik Ihrer Anwendung zu verwalten. Der einzige Dienst, TaskService, in dieser Anwendung wird zum Validieren eines Task-Objekts und zum Integrieren in das TaskRepository verwendet.

Erstellen Sie unter /src/main/java/com/mariadb/todo einen neuen Ordner mit dem Namen "services". , und erstellen Sie darin eine neue Datei mit dem Namen "TaskService.java".

Öffnen Sie „TaskService.java“ und fügen Sie den folgenden Code hinzu.

package com.mariadb.todo.services;

import java.util.Optional;

import com.mariadb.todo.domain.Task;
import com.mariadb.todo.repositories.TaskRepository;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

// Registered as a Spring Service (Component)
@Service
public class TaskService {

    // Automatically instantiate (via Spring IoC) 
    @Autowired
    private TaskRepository repository;

    // 
    public Boolean isValid(final Task task) {
        if (task != null && !task.getDescription().isEmpty()) {
            return true;
        }
        return false;
    }

    // Get all records from the tasks table
    public Iterable<Task> getAllTasks() {
        return this.repository.findAll();
    }

    // Save a new task record
    public Task createTask(final Task task) {
        return this.repository.save(task);
    }

    // Update an existing task record
    @Transactional
    public Task updateTask(final Task task) {
        Optional<Task> ot = this.repository.findById(task.getId());
        Task t = ot.get();
        t.setDescription(task.getDescription());
        t.setCompleted(task.getCompleted());
        return this.repository.save(t);
    }

    // Delete the task record by specified id
    @Transactional
    public void deleteTask(final int id){
        Optional<Task> ot = this.repository.findById(id);
        Task t = ot.get();
        this.repository.delete(t);
    }
}

API-Endpunkte verfügbar machen

Schließlich müssen Sie einen Controller erstellen, um vier Endpunkte verfügbar zu machen, die verwendet werden können, um die grundlegenden CRUD-Operationen für Ihre Tasks auszuführen.

Erstellen Sie einen neuen Ordner mit dem Namen „controllers“ in /src/main/java/com/mariadb/todo und erstellen Sie darin eine neue Datei mit dem Namen „TaskController.java“.

Öffnen Sie "TaskController.java" und fügen Sie den folgenden Code hinzu.

package com.mariadb.todo.controllers;

import com.mariadb.todo.domain.Task;
import com.mariadb.todo.services.TaskService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/tasks")
public class TaskController {

    @Autowired
    private TaskService service;

    // Get all tasks
    @GetMapping()
    public ResponseEntity<Iterable<Task>> get() {
        return ResponseEntity.ok(this.service.getAllTasks());
    }

    // Create a new task
    @PostMapping()
    public ResponseEntity<Task> post(@RequestBody Task task) {
        if (service.isValid(task)) {
            return ResponseEntity.ok(this.service.createTask(task));
        }
        return ResponseEntity.status(HttpStatus.I_AM_A_TEAPOT).build();
    }

    // Update a task
    @PutMapping()
    public ResponseEntity<Task> put(@RequestBody Task task) {
        if (service.isValid(task)) {
            return ResponseEntity.ok(this.service.updateTask(task));
        }
        return ResponseEntity.status(HttpStatus.I_AM_A_TEAPOT).build();
    }

    // Delete a task
    @DeleteMapping()
    public ResponseEntity<Void> delete(@RequestParam int id) {
        if (id > 0) {
            this.service.deleteTask(id);
            return ResponseEntity.ok().build();
        }
        return ResponseEntity.status(HttpStatus.I_AM_A_TEAPOT).build();
    }
}

Ausprobieren

Jetzt, da alles aufgebaut ist, ist es an der Zeit, es auszuprobieren!

Erstellen Sie zunächst die Anwendung.

$ mvn package

Und dann führe es aus.

$ mvn spring-boot:run

Beginnen Sie zunächst damit, Ihrer Aufgabenliste eine neue Aufgabe hinzuzufügen.

$ curl --header "Content-Type: application/json" \
  --request POST \
  --data '{"description":"A New Task"}' \
  http://localhost:8080/api/tasks

Sie können die Datenbank sicherlich direkt abfragen, um zu bestätigen, dass ein neuer Aufgabendatensatz hinzugefügt wurde, aber wo ist der Spaß dabei? Zurück zur API!

$ curl https://localhost:8080/api/tasks

Wenn alles gut geht, sollten Sie die folgende JSON-Antwort erhalten:

{ "id": 1, "description": "A New Task", "completed": false }

Voilà, eine vollständig reaktive Java Spring-Anwendung mit JDBC und MariaDB! Um diesen Code vollständig anzuzeigen, sehen Sie sich hier die Quelle an. Und wenn Sie sich fragen:„Es wäre sicher schön, eine Implementierung mit einer Benutzeroberfläche zu sehen“, haben Sie Glück! Sie können eine vollständig ausgearbeitete Implementierung einer TODO-Anwendung mit React.js und mehreren API-Projekten Ihrer Wahl finden
(R2DBC, JDBC, Node.js und Python), die hier direkt in MariaDB integriert werden!

Ich fange gerade an

Nachdem Sie nun erfolgreich ein neues Maven-Projekt mit Spring Data JPA, JDBC und MariaDB erstellt haben, verfügen Sie über alle Tools, die Sie benötigen, um mit der Erstellung vollständig reaktiver Anwendungen zu beginnen und die Leistungsfähigkeit von MariaDB selbst zu nutzen! Wenn Sie Fragen haben , Vorschläge oder Bedenken zu diesem Blogbeitrag teilen Sie mir bitte hier mit oder kontaktieren Sie mich direkt auf Twitter unter @probablyrealrob! Vielen Dank, dass Sie sich die Zeit genommen haben, dies zu lesen, und viel Spaß beim Programmieren!