MariaDB
 sql >> Base de données >  >> RDS >> MariaDB

Premiers pas avec MariaDB en utilisant Docker, Java Spring et JDBC

Depuis qu'elle a été dérivée de MySQL en 2009, MariaDB est devenue l'une des bases de données de choix les plus populaires pour les développeurs au cours de la dernière décennie. Alors que de nombreux technologues l'ont probablement considéré comme une solution en raison de ses racines open source et de son enracinement dans le monde des bases de données relationnelles, cela ne fait que commencer à effleurer la surface de ce que MariaDB a à offrir.

Au fil des ans, MariaDB a divergé de MySQL en ajoutant de nombreuses fonctionnalités et fonctionnalités, dont la plupart ne seront pas en mesure de plonger dans le contexte de cet article. Cependant, une chose, par-dessus tout, est restée la même; fournir une solution de base de données moderne, open source et de haute qualité que les développeurs peuvent utiliser pour alimenter leur innovation.

Mais avant de pouvoir plonger dans MariaDB et découvrir tout ce qu'il a à offrir, vous devrez répondre aux questions les plus fondamentales; comment commencer à utiliser MariaDB ?

Connectivité de base de données MariaDB et Java (JDBC)

Il n'est probablement pas surprenant que Java, et finalement l'environnement Java Virtual Machine (JVM) dans son ensemble, ait été une option extrêmement populaire utilisée par les développeurs pour créer des applications.

Dans cet esprit, j'ai rédigé ce court tutoriel pour vous guider tout au long des étapes de démarrage de MariaDB (Community Server) à l'aide d'une image Docker, de Java et du client MariaDB JDBC.

Dans cette procédure pas à pas, vous utiliserez MariaDB et JDBC pour créer une application "à faire" simple (basée sur Maven) qui, à l'aide de Java Spring, exposera une variété de points de terminaison à utiliser pour effectuer des opérations CRUD de base (create-read-update-delete ) opérations sur une instance de base de données MariaDB.

Commençons !

Exigences

Avant de vous lancer dans le code, vous devrez vous assurer que vous avez quelques éléments sur votre machine :

  • Client MariaDB
  • Docker
  • Java (version 8+)
  • Curl (pour tester les points de terminaison de l'API)

Créer une nouvelle instance MariaDB à l'aide de Docker

L'un des moyens les plus simples de démarrer avec MariaDB, quel que soit le système d'exploitation que vous utilisez, consiste à extraire l'image MariaDB Server Docker de Docker Hub et à l'utiliser pour créer un nouveau conteneur.

Pour ce faire, ouvrez simplement une fenêtre de terminal et exécutez ce qui suit :

$ docker run -p 3306:3306 -d --name mariadb -eMARIADB_ROOT_PASSWORD=Password123! mariadb/server:10.4

C'est ça. Vous devriez maintenant avoir une instance en cours d'exécution de MariaDB. Assez indolore, non?

Vous pouvez confirmer l'instance dans un conteneur Docker en exécutant ce qui suit :

$ docker ps

Et vous devriez voir votre conteneur dans la sortie.

Connexion à MariaDB

Maintenant que vous avez une instance de serveur MariaDB en cours d'exécution dans un nouveau conteneur Docker, l'étape suivante consiste à vous connecter et à communiquer avec l'instance de base de données à l'aide du client MariaDB.

Il existe de nombreux clients SQL disponibles dans la nature. Par souci de simplicité, j'ai choisi de montrer comment utiliser le client MariaDB officiel, mais n'hésitez pas à utiliser le client que vous préférez.

Connectez-vous à votre instance MariaDB en exécutant ce qui suit :

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

Vous devriez voir quelque chose comme ce qui suit, ce qui signifie que vous vous êtes connecté avec succès à l'instance MariaDB !

Une fois connecté, vous pouvez créer une nouvelle base de données. 

CREATE DATABASE todo;

Créez ensuite un nouveau tableau. 

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

Premiers pas avec Java Spring, JDBC et MariaDB

Avec une instance de base de données lancée et un schéma créé, vous êtes prêt à créer une nouvelle application Java.

Créer un projet Maven

Commencez par accéder à https://start.spring.io, qui vous permettra de créer un nouveau projet Maven basé sur Spring. Pour ce projet, vous pouvez entrer les critères suivants.

Ensuite, ajoutez les dépendances suivantes :

  • Lombok : Une bibliothèque qui évitera d'avoir à créer du code passe-partout (par exemple, des getters, des setters) dans les objets du domaine.
  • Spring Web : Une bibliothèque pour créer et exposer des points de terminaison d'API RESTful.
  • Spring Data JPA : Une bibliothèque qui fournit des abstractions pour aider à éliminer le code passe-partout pour la connexion et la communication avec les bases de données.

Enfin, cliquez sur le bouton "GÉNÉRER" pour créer et télécharger le projet (contenu dans un fichier .zip) à l'emplacement souhaité sur votre machine.

Ajouter le connecteur MariaDB R2DBC

Accédez à l'emplacement où vous avez téléchargé le nouveau projet Maven (fichier .zip) et décompressez. Utilisez ensuite un éditeur de code pour ouvrir le projet et ouvrez pom.xml.

Ajoutez une nouvelle dépendance pour le connecteur JDBC de MariaDB à la collection de dépendances. 

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

Préparer l'intégration des données

Maintenant que vous avez créé un projet qui contient toutes les dépendances dont vous aurez besoin, il faut sauter dans le code Java. En règle générale, j'aime commencer par créer les classes d'entités.

Accédez à /src/main/java/com/mariadb/todo , créez un nouveau dossier appelé "domaine" et créez-y un nouveau fichier nommé "Task.java".

Ouvrez "Task.java" et ajoutez le code suivant. 

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

Ensuite, créez un nouveau dossier appelé "dépôts" dans /src/main/java/com/mariadb/todo , et créez un nouveau fichier nommé "TaskRepository.java".

Ouvrez "TaskRepository.java" et ajoutez le code suivant. 

package com.mariadb.todo.repositories;

import com.mariadb.todo.domain.Task;

import org.springframework.data.repository.CrudRepository;

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

Comme son nom l'indique, l'interface CrudRepository fournit des opérations CRUD de base sur un référentiel pour un type générique (votre classe Task dans ce cas) et le type de clé primaire pour ce type générique.

Créer un service de données

Les services peuvent être utilisés pour gérer la logique métier de votre application. Le seul service, TaskService, dans cette application est utilisé pour valider un objet Task et s'intégrer au TaskRepository.

Créez un nouveau dossier appelé "services" dans /src/main/java/com/mariadb/todo , et créez un nouveau fichier nommé "TaskService.java".

Ouvrez "TaskService.java" et ajoutez le code suivant. 

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

Exposer les points de terminaison de l'API

Enfin, vous devrez créer un contrôleur pour exposer quatre points de terminaison pouvant être utilisés pour effectuer les opérations CRUD de base sur vos tâches.

Créez un nouveau dossier appelé "controllers" dans /src/main/java/com/mariadb/todo, et créez un nouveau fichier à l'intérieur nommé "TaskController.java".

Ouvrez "TaskController.java" et ajoutez le code suivant. 

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

Tester

Maintenant que tout est construit, il est temps de le tester !

Tout d'abord, créez l'application. 

$ mvn package

Et puis lancez-le. 

$ mvn spring-boot:run

Tout d'abord, commencez par ajouter une nouvelle tâche à votre liste de tâches. 

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

Bien que vous puissiez certainement interroger directement la base de données pour confirmer qu'un nouvel enregistrement de tâche a été ajouté, où est le plaisir ? Retour à l'API ! 

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

Si tout se passe bien, vous devriez recevoir la réponse JSON suivante :

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

Voilà, une application Java Spring entièrement réactive utilisant JDBC et MariaDB ! Pour afficher ce code dans son intégralité, consultez la source ici. Et si vous vous demandez "ce serait bien de voir une implémentation avec une interface utilisateur", vous avez de la chance ! Vous pouvez trouver une implémentation complète d'une application TODO en utilisant React.js et votre choix de plusieurs projets d'API
(R2DBC, JDBC, Node.js et Python) qui s'intègrent directement à MariaDB ici !

Je ne fais que commencer

Maintenant que vous avez créé avec succès un nouveau projet Maven à l'aide de Spring Data JPA, JDBC et MariaDB, vous disposez de tous les outils dont vous avez besoin pour commencer à créer des applications entièrement réactives, en utilisant la puissance de MariaDB, par vous-même !Si vous avez des questions , suggestions ou préoccupations concernant cet article de blog, veuillez m'en faire part ici ou contactez-moi directement sur Twitter à @probablyrealrob ! Merci d'avoir pris le temps de lire ceci et bon codage !