Pierwsze kroki z MariaDB przy użyciu Dockera, Java Spring i JDBC

Istnieje wiele klientów SQL dostępnych na wolności. Dla uproszczenia postanowiłem zademonstrować, jak korzystać z oficjalnego klienta MariaDB, ale z pewnością możesz używać dowolnego klienta.

Połącz się z instancją MariaDB, wykonując następujące czynności:

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

Powinieneś zobaczyć coś takiego jak poniżej, co oznacza, że ​​udało Ci się połączyć z instancją MariaDB!

Po połączeniu możesz utworzyć nową bazę danych.

CREATE DATABASE todo;

Następnie utwórz nową tabelę.

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)
);

Pierwsze kroki z Java Spring, JDBC i MariaDB

Po uruchomieniu instancji bazy danych i utworzeniu schematu możesz rozpocząć tworzenie nowej aplikacji Java.

Utwórz projekt Maven

Zacznij od wejścia na stronę https://start.spring.io, która umożliwi Ci utworzenie nowego projektu Maven opartego na Springu. Dla tego projektu możesz wprowadzić następujące kryteria.

Następnie dodaj następujące zależności:

• Lombok: Biblioteka, która wyeliminuje konieczność tworzenia kodu płyty kotłowej (np. getterów, seterów) w obrębie obiektów domeny.
• Wiosenna sieć: Biblioteka do tworzenia i eksponowania punktów końcowych API RESTful.
• Spring Data JPA: Biblioteka, która zapewnia abstrakcje, które pomagają wyeliminować kod płyty kotłowej do łączenia się z bazami danych i komunikacji z nimi.

Na koniec kliknij przycisk „GENERUJ”, aby utworzyć i pobrać projekt (zawarty w pliku .zip) do wybranej lokalizacji na komputerze.

Dodaj złącze MariaDB R2DBC

Przejdź do lokalizacji, do której pobrano nowy projekt Maven (plik .zip) i rozpakuj. Następnie użyj edytora kodu, aby otworzyć projekt i otwórz pom.xml.

Dodaj nową zależność dla łącznika JDBC MariaDB do kolekcji zależności.

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

Przygotowywanie integracji danych

Teraz, gdy stworzyłeś projekt, który zawiera wszystkie potrzebne zależności, przejdź do kodu Java. Zazwyczaj lubię zacząć od stworzenia klas encji.

Przejdź do /src/main/java/com/mariadb/todo , utwórz nowy folder o nazwie „domena” i utwórz w nim nowy plik o nazwie „Zadanie.java”.

Otwórz „Task.java” i dodaj następujący kod.

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;
}

Następnie utwórz nowy folder o nazwie „repozytoria” w /src/main/java/com/mariadb/todo i utwórz w nim nowy plik o nazwie "TaskRepository.java".

Otwórz „TaskRepository.java” i dodaj następujący kod.

package com.mariadb.todo.repositories;

import com.mariadb.todo.domain.Task;

import org.springframework.data.repository.CrudRepository;

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

Jak sama nazwa wskazuje, interfejs CrudRepository zapewnia podstawowe operacje CRUD w repozytorium dla typu ogólnego (w tym przypadku klasy Task) i typu klucza podstawowego dla tego typu ogólnego.

Utwórz usługę danych

Usługi mogą służyć do zarządzania logiką biznesową aplikacji. Jedyna usługa, TaskService, w tej aplikacji służy do sprawdzania poprawności obiektu Task i integracji z TaskRepository.

Utwórz nowy folder o nazwie „usługi” w /src/main/java/com/mariadb/todo i utwórz w nim nowy plik o nazwie „TaskService.java”.

Otwórz „TaskService.java” i dodaj następujący kod.

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);
    }
}

Pokaż punkty końcowe interfejsu API

Na koniec musisz utworzyć kontroler, aby odsłonić cztery punkty końcowe, których można użyć do wykonywania podstawowych operacji CRUD na zadaniach.

Utwórz nowy folder o nazwie „kontrolery” w /src/main/java/com/mariadb/todo i utwórz w nim nowy plik o nazwie „TaskController.java”.

Otwórz „TaskController.java” i dodaj następujący kod.

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();
    }
}

Testowanie

Teraz, gdy wszystko zostało już skonstruowane, czas to przetestować!

Najpierw zbuduj aplikację.

$ mvn package

A potem go uruchom.

$ mvn spring-boot:run

Najpierw zacznij od dodania nowego zadania do swojej listy rzeczy do zrobienia.

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

Chociaż z pewnością możesz wysłać zapytanie bezpośrednio do bazy danych, aby potwierdzić, że dodano nowy rekord zadania, gdzie jest w tym zabawa? Powrót do API!

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

Jeśli wszystko pójdzie dobrze, powinieneś otrzymać następującą odpowiedź JSON:

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

Voilà, w pełni reaktywna aplikacja Java Spring korzystająca z JDBC i MariaDB! Aby wyświetlić ten kod w całości, sprawdź źródło tutaj. A jeśli zastanawiasz się, „byłoby miło zobaczyć implementację z interfejsem użytkownika”, masz szczęście! Możesz znaleźć w pełni dopracowaną implementację aplikacji TODO za pomocą React.js i wybór wielu projektów API
(R2DBC, JDBC, Node.js i Python), które integrują się bezpośrednio z MariaDB tutaj!

Dopiero zaczynam

Teraz, po pomyślnym utworzeniu nowego projektu Maven przy użyciu Spring Data JPA, JDBC i MariaDB, masz wszystkie narzędzia potrzebne do rozpoczęcia tworzenia w pełni reaktywnych aplikacji, wykorzystujących własne możliwości MariaDB! , sugestie lub wątpliwości dotyczące tego posta na blogu, proszę daj mi znać tutaj lub skontaktuj się ze mną bezpośrednio na Twitterze pod adresem @probablyrealrob!Dziękujemy za poświęcenie czasu na przeczytanie tego i miłego kodowania!