sql >> Database >  >> RDS >> MariaDB

Aan de slag met MariaDB met Docker, Java Spring en JDBC

Sinds MariaDB in 2009 van MySQL werd gevorkt, is het de afgelopen tien jaar een van de populairste databases voor ontwikkelaars geworden. Hoewel veel technologen het waarschijnlijk als een oplossing hebben aangetrokken vanwege de open source-wortels en dat het is geworteld in de relationele databasewereld, begint dat eigenlijk pas de oppervlakte te bekrassen van wat MariaDB te bieden heeft.

In de loop der jaren is MariaDB afgeweken van MySQL door veel functies en functionaliteit toe te voegen, waarvan we er in de context van dit artikel niet veel op zullen kunnen ingaan. Maar bovenal is één ding hetzelfde gebleven; een moderne, open-source database-oplossing van hoge kwaliteit die ontwikkelaars kunnen gebruiken om hun innovatie kracht bij te zetten.

Maar voordat je in MariaDB kunt duiken en alles kunt bekijken wat het te bieden heeft, moet je de meest fundamentele vragen beantwoorden; hoe ga je aan de slag met MariaDB?

MariaDB en Java Database Connectivity (JDBC)

Het is waarschijnlijk geen verrassing dat Java, en uiteindelijk de Java Virtual Machine (JVM)-omgeving als geheel, een extreem populaire optie is geweest die door ontwikkelaars wordt gebruikt om applicaties te maken.

Met dat in gedachten heb ik deze korte handleiding geschreven om je door de stappen te leiden om aan de slag te gaan met MariaDB (Community Server) met behulp van een Docker-image, Java en de MariaDB JDBC-client.

In deze walkthrough gebruik je MariaDB en JDBC om een ​​eenvoudige (op Maven gebaseerde) "To do"-toepassing te maken die, met behulp van Java Spring, een verscheidenheid aan eindpunten blootlegt om te gebruiken om elementaire CRUD uit te voeren (create-read-update-delete ) bewerkingen op een MariaDB-database-instantie.

Laten we beginnen!

Vereisten

Voordat je in de code springt, moet je ervoor zorgen dat je een paar dingen op je computer hebt staan:

  • MariaDB-client
  • Dokker
  • Java (v. 8+)
  • Curl (voor het testen van de API-eindpunten)

Een nieuwe MariaDB-instantie maken met Docker

Een van de eenvoudigste manieren om met MariaDB aan de slag te gaan, ongeacht welk besturingssysteem u gebruikt, is door de MariaDB Server Docker-image uit Docker Hub te halen en deze te gebruiken om een ​​nieuwe container te maken.

Om dit te doen, opent u eenvoudig een terminalvenster en voert u het volgende uit:

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

Dat is het. U zou nu een actief exemplaar van MariaDB moeten hebben. Vrij pijnloos, toch?

U kunt de instantie binnen een Docker-container bevestigen door het volgende uit te voeren:

$ docker ps

En u zou uw container in de uitvoer moeten zien.

Verbinding maken met MariaDB

Nu u een actieve MariaDB Server-instantie in een nieuwe Docker-container heeft, is de volgende stap om verbinding te maken met en te communiceren met de database-instantie met behulp van de MariaDB-client.

Er zijn veel SQL-clients beschikbaar in het wild. Omwille van de eenvoud heb ik ervoor gekozen om te demonstreren hoe je de officiële MariaDB Client gebruikt, maar voel je zeker vrij om welke client dan ook te gebruiken.

Maak verbinding met uw MariaDB-instantie door het volgende uit te voeren:

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

Je zou iets als het volgende moeten zien, wat betekent dat je succesvol verbinding hebt gemaakt met de MariaDB-instantie!

Zodra u bent verbonden, kunt u een nieuwe database maken. 

CREATE DATABASE todo;

Maak dan een nieuwe tabel aan. 

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

Aan de slag met Java Spring, JDBC en MariaDB

Nu een database-instantie is opgetuigd en een schema is gemaakt, bent u klaar om een ​​nieuwe Java-toepassing te maken.

Een Maven-project maken

Begin door te navigeren naar https://start.spring.io, waarmee u een nieuw op Spring gebaseerd Maven-project kunt maken. Voor dit project kunt u de volgende criteria invoeren.

Voeg vervolgens de volgende afhankelijkheden toe:

  • Lombok: Een bibliotheek die het maken van boilerplate-code (bijv. getters, setters) binnen de domeinobjecten overbodig maakt.
  • Lenteweb: Een bibliotheek om RESTful API-eindpunten te maken en beschikbaar te stellen.
  • JPA voorjaarsgegevens: Een bibliotheek die abstracties biedt om boiler plate-code te elimineren voor het verbinden met en communiceren met databases.

Klik ten slotte op de knop "GENEREREN" om het project (in een .zip-bestand) te maken en te downloaden naar een gewenste locatie op uw computer.

Voeg de MariaDB R2DBC-connector toe

Navigeer naar de locatie waar je het nieuwe Maven-project (.zip-bestand) hebt gedownload en pak het uit. Gebruik vervolgens een code-editor om het project te openen en open pom.xml.

Voeg een nieuwe afhankelijkheid voor MariaDB's JDBC-connector toe aan de verzameling afhankelijkheden. 

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

De gegevensintegratie voorbereiden

Nu je een project hebt gemaakt dat alle afhankelijkheden bevat die je nodig hebt, moet je in de Java-code springen. Meestal begin ik graag met het maken van de entiteitsklassen.

Navigeer naar /src/main/java/com/mariadb/todo , maak een nieuwe map met de naam "domain" en maak er een nieuw bestand in met de naam "Task.java".

Open "Task.java" en voeg de volgende code toe. 

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

Maak vervolgens een nieuwe map met de naam "repositories" in /src/main/java/com/mariadb/todo , en maak er een nieuw bestand in met de naam "TaskRepository.java".

Open "TaskRepository.java" en voeg de volgende code toe. 

package com.mariadb.todo.repositories;

import com.mariadb.todo.domain.Task;

import org.springframework.data.repository.CrudRepository;

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

Zoals de naam doet vermoeden, biedt de CrudRepository-interface basis-CRUD-bewerkingen op een repository voor een generiek type (in dit geval uw taakklasse) en het primaire sleuteltype voor dat generieke type.

Maak een dataservice

Services kunnen worden gebruikt om de bedrijfslogica van uw applicatie te beheren. De enige service, TaskService, in deze applicatie wordt gebruikt voor het valideren van een Task-object en voor integratie met de TaskRepository.

Maak een nieuwe map met de naam 'services' in /src/main/java/com/mariadb/todo , en maak er een nieuw bestand in met de naam "TaskService.java".

Open "TaskService.java" en voeg de volgende code toe. 

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-eindpunten blootleggen

Ten slotte moet u een controller maken om vier eindpunten bloot te leggen die kunnen worden gebruikt om de basis CRUD-bewerkingen op uw taken uit te voeren.

Maak een nieuwe map met de naam 'controllers' in /src/main/java/com/mariadb/todo en maak daarin een nieuwe map met de naam 'TaskController.java'.

Open "TaskController.java" en voeg de volgende code toe. 

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

Het uittesten

Nu alles is gebouwd, is het tijd om het uit te testen!

Bouw eerst de applicatie. 

$ mvn package

En voer het dan uit. 

$ mvn spring-boot:run

Begin eerst met het toevoegen van een nieuwe taak aan uw takenlijst. 

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

Hoewel u de database zeker rechtstreeks kunt doorzoeken om te bevestigen dat er een nieuw taakrecord is toegevoegd, wat is daar dan het plezier aan? Terug naar de API! 

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

Als alles goed gaat, zou u het volgende JSON-antwoord moeten ontvangen:

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

Voilà, een volledig reactieve Java Spring-applicatie die JDBC en MariaDB gebruikt! Bekijk de bron hier om deze code in zijn geheel te bekijken. En als je je afvraagt ​​"het zou leuk zijn om een ​​implementatie met een gebruikersinterface te zien", dan heb je geluk! U kunt een volledig uitgewerkte implementatie van een TODO-toepassing vinden met behulp van React.js en uw keuze uit meerdere API-projecten
(R2DBC, JDBC, Node.js en Python) die hier rechtstreeks met MariaDB kunnen worden geïntegreerd!

Net begonnen

Nu je met succes een nieuw Maven-project hebt gemaakt met Spring Data JPA, JDBC en MariaDB, heb je alle tools die je nodig hebt om te beginnen met het maken van volledig reactieve applicaties, gebruikmakend van de kracht van je eigen MariaDB! Als je vragen hebt , suggesties of opmerkingen met betrekking tot deze blogpost, laat het me dan hier weten of neem rechtstreeks contact met me op via Twitter op @probablyrealrob! Bedankt voor het lezen van dit bericht en veel plezier met coderen!


  1. Records ophalen waarbij de json-kolomsleutel null is

  2. 7 manieren om dubbele rijen in SQL Server te vinden terwijl u een primaire sleutel negeert

  3. Wat is het gemiddelde salaris van een SQL-ontwikkelaar?

  4. pg -v 0.17.1 installeren