Primeros pasos con MariaDB usando Docker, Java Spring y JDBC

Hay muchos clientes SQL disponibles en la naturaleza. En aras de la simplicidad, he elegido demostrar cómo usar el cliente oficial de MariaDB, pero no dude en usar el cliente que prefiera.

Conéctese a su instancia de MariaDB ejecutando lo siguiente:

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

Debería ver algo como lo siguiente, lo que significa que se ha conectado con éxito a la instancia de MariaDB.

Una vez que esté conectado, puede crear una nueva base de datos.

CREATE DATABASE todo;

Luego crea una nueva tabla.

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

Primeros pasos con Java Spring, JDBC y MariaDB

Con una instancia de base de datos activa y un esquema creado, está listo para crear una nueva aplicación Java.

Crear un proyecto Maven

Comience navegando a https://start.spring.io, que le permitirá crear un nuevo proyecto Maven basado en Spring. Para este proyecto puede ingresar los siguientes criterios.

A continuación, agregue las siguientes dependencias:

• Lombok: Una biblioteca que eliminará la necesidad de crear código estándar (por ejemplo, getters, setters) dentro de los objetos del dominio.
• Telaraña de primavera: Una biblioteca para crear y exponer puntos finales de API RESTful.
• JPA de datos de Spring: Una biblioteca que proporciona abstracciones para ayudar a eliminar el código estándar para conectarse y comunicarse con bases de datos.

Finalmente, haga clic en el botón "GENERAR" para crear y descargar el proyecto (contenido dentro de un archivo .zip) a la ubicación deseada en su máquina.

Agregue el conector MariaDB R2DBC

Navegue a la ubicación donde descargó el nuevo proyecto Maven (archivo .zip) y descomprímalo. Luego use un editor de código para abrir el proyecto y abra pom.xml.

Agregue una nueva dependencia para el conector JDBC de MariaDB a la colección de dependencias.

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

Preparación de la integración de datos

Ahora que ha creado un proyecto que contiene todas las dependencias que necesitará, debe saltar al código Java. Por lo general, me gusta comenzar creando las clases de entidad.

Vaya a /src/main/java/com/mariadb/todo , cree una nueva carpeta llamada "dominio" y cree un nuevo archivo dentro de ella llamado "Tarea.java".

Abra "Task.java" y agregue el siguiente código.

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

A continuación, cree una nueva carpeta llamada "repositorios" en /src/main/java/com/mariadb/todo y cree un nuevo archivo dentro de él denominado "TaskRepository.java".

Abra "TaskRepository.java" y agregue el siguiente código.

package com.mariadb.todo.repositories;

import com.mariadb.todo.domain.Task;

import org.springframework.data.repository.CrudRepository;

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

Como sugiere el nombre, la interfaz CrudRepository proporciona operaciones CRUD básicas en un repositorio para un tipo genérico (su clase Task en este caso) y el tipo de clave principal para ese tipo genérico.

Crear un servicio de datos

Los servicios se pueden utilizar para gestionar la lógica empresarial de su aplicación. El único servicio, TaskService, en esta aplicación se usa para validar un objeto Task e integrarlo con TaskRepository.

Cree una nueva carpeta llamada "servicios" en /src/main/java/com/mariadb/todo y cree un nuevo archivo dentro de él denominado "TaskService.java".

Abra "TaskService.java" y agregue el siguiente código.

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

Exponer puntos finales de API

Finalmente, deberá crear un controlador para exponer cuatro puntos finales que se pueden usar para realizar las operaciones CRUD básicas en sus tareas.

Cree una nueva carpeta llamada "controladores" en /src/main/java/com/mariadb/todo, y cree un nuevo archivo dentro de ella llamado "TaskController.java".

Abra "TaskController.java" y agregue el siguiente código.

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

Probarlo

Ahora que todo se ha construido, ¡es hora de probarlo!

Primero, construye la aplicación.

$ mvn package

Y luego ejecutarlo.

$ mvn spring-boot:run

Primero, comience agregando una nueva tarea a su lista de tareas pendientes.

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

Si bien puede consultar la base de datos directamente para confirmar que se ha agregado un nuevo registro de tareas, ¿dónde está la diversión en eso? ¡Volvamos a la API!

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

Si todo va bien, debería recibir la siguiente respuesta JSON:

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

¡Voilà, una aplicación Java Spring totalmente reactiva que utiliza JDBC y MariaDB! Para ver este código en su totalidad, consulte la fuente aquí. Y si te estás preguntando "sería bueno ver una implementación con una interfaz de usuario", ¡estás de suerte! Puede encontrar una implementación completa de una aplicación TODO usando React.js y su elección de múltiples proyectos API
(R2DBC, JDBC, Node.js y Python) que se integran directamente con MariaDB ¡aquí!

Recién comenzando

Ahora que ha creado con éxito un nuevo proyecto Maven utilizando Spring Data JPA, JDBC y MariaDB, tiene todas las herramientas que necesita para comenzar a crear aplicaciones totalmente reactivas, utilizando el poder de MariaDB, ¡por su cuenta! Si tiene alguna pregunta , sugerencias o inquietudes con esta publicación de blog, hágamelo saber aquí o comuníquese conmigo directamente en Twitter en @probablyrealrob. ¡Gracias por tomarse el tiempo para leer esto y feliz codificación!