Guida introduttiva a MariaDB utilizzando Docker, Java Spring e JDBC

Ci sono molti client SQL disponibili in natura. Per semplicità, ho scelto di mostrare come utilizzare il client ufficiale MariaDB, ma di certo sentiti libero di usare qualsiasi client tu preferisca.

Connettiti alla tua istanza MariaDB eseguendo quanto segue:

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

Dovresti vedere qualcosa di simile al seguente, il che significa che ti sei connesso correttamente all'istanza MariaDB!

Una volta connesso, puoi creare un nuovo database.

CREATE DATABASE todo;

Quindi crea una nuova tabella.

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

Introduzione a Java Spring, JDBC e MariaDB

Con un'istanza del database avviata e lo schema creato, sei pronto per creare una nuova applicazione Java.

Crea un progetto Maven

Inizia accedendo a https://start.spring.io, che ti consentirà di creare un nuovo progetto Maven basato su Spring. Per questo progetto puoi inserire i seguenti criteri.

Quindi, aggiungi le seguenti dipendenze:

• Lombok: Una libreria che eliminerà la necessità di creare codice boiler plate (ad es. getter, setter) all'interno degli oggetti di dominio.
• Web primaverile: Una libreria per creare ed esporre endpoint API RESTful.
• APP dati di primavera: Una libreria che fornisce astrazioni per eliminare il codice boiler plate per la connessione e la comunicazione con i database.

Infine, fai clic sul pulsante "GENERA" per creare e scaricare il progetto (contenuto all'interno di un file .zip) nella posizione desiderata sulla tua macchina.

Aggiungi il connettore MariaDB R2DBC

Passa alla posizione in cui hai scaricato il nuovo progetto Maven (file .zip) e decomprimi. Quindi usa un editor di codice per aprire il progetto e apri pom.xml.

Aggiungi una nuova dipendenza per il connettore JDBC di MariaDB alla raccolta delle dipendenze.

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

Preparazione dell'integrazione dei dati

Ora che hai creato un progetto che contiene tutte le dipendenze di cui avrai bisogno, devi passare al codice Java. In genere, mi piace iniziare creando le classi di entità.

Passa a /src/main/java/com/mariadb/todo , crea una nuova cartella chiamata "domain" e crea un nuovo file al suo interno chiamato "Task.java".

Apri "Task.java" e aggiungi il codice seguente.

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

Quindi, crea una nuova cartella chiamata "repository" in /src/main/java/com/mariadb/todo e crea un nuovo archivio al suo interno denominato "TaskRepository.java".

Apri "TaskRepository.java" e aggiungi il codice seguente.

package com.mariadb.todo.repositories;

import com.mariadb.todo.domain.Task;

import org.springframework.data.repository.CrudRepository;

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

Come suggerisce il nome, l'interfaccia CrudRepository fornisce operazioni CRUD di base su un repository per un tipo generico (la tua classe Task in questo caso) e il tipo di chiave primaria per quel tipo generico.

Crea un servizio dati

I servizi possono essere utilizzati per gestire la logica aziendale della tua applicazione. L'unico servizio, TaskService, in questa applicazione viene utilizzato per la convalida di un oggetto Task e l'integrazione con TaskRepository.

Crea una nuova cartella denominata "servizi" in /src/main/java/com/mariadb/todo , e crea un nuovo archivio al suo interno denominato "TaskService.java".

Apri "TaskService.java" e aggiungi il codice seguente.

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

Esponi gli endpoint dell'API

Infine, dovrai creare un controller per esporre quattro endpoint che possono essere utilizzati per eseguire le operazioni CRUD di base sulle tue attività.

Crea una nuova cartella denominata "controllers" in /src/main/java/com/mariadb/todo e crea un nuovo archivio denominato "TaskController.java".

Apri "TaskController.java" e aggiungi il codice seguente.

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

Prova

Ora che tutto è stato costruito, è il momento di provarlo!

Innanzitutto, crea l'applicazione.

$ mvn package

E poi eseguilo.

$ mvn spring-boot:run

Innanzitutto, inizia aggiungendo una nuova attività alla tua lista di cose da fare.

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

Anche se puoi certamente interrogare direttamente il database per confermare che è stato aggiunto un nuovo record di attività, dov'è il divertimento? Torna all'API!

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

Se tutto va bene, dovresti ricevere la seguente risposta JSON:

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

Voilà, un'applicazione Java Spring completamente reattiva che utilizza JDBC e MariaDB! Per visualizzare questo codice nella sua interezza, controlla la fonte qui. E se ti stai chiedendo "sarebbe sicuramente bello vedere un'implementazione con un'interfaccia utente", sei fortunato! Puoi trovare un'implementazione completa di un'applicazione TODO utilizzando React.js e la tua scelta di più progetti API
(R2DBC, JDBC, Node.js e Python) che si integrano direttamente con MariaDB qui!

Ho appena iniziato

Ora che hai creato con successo un nuovo progetto Maven utilizzando Spring Data JPA, JDBC e MariaDB, hai tutti gli strumenti necessari per iniziare a creare applicazioni completamente reattive, utilizzando la potenza di MariaDB, tutto tuo!Se hai domande , suggerimenti o dubbi con questo post del blog, faccelo sapere qui o contattami direttamente su Twitter all'indirizzo @probablyrealrob! Grazie per aver dedicato del tempo a leggere questo e buona codifica!