sql >> Databasteknik >  >> RDS >> MariaDB

Komma igång med MariaDB med Docker, Java Spring och JDBC

Sedan den splittrades från MySQL 2009 har MariaDB blivit en av de mest populära databaserna för utvecklare under det senaste decenniet. Även om många teknologer sannolikt har dragit till det som en lösning på grund av dess rötter med öppen källkod och att den är rotad i relationsdatabasvärlden, börjar det egentligen bara skrapa på ytan av vad MariaDB har att erbjuda.

Under årens lopp har MariaDB avvikit från MySQL genom att lägga till många funktioner och funktioner, varav mycket vi inte kommer att kunna dyka in i inom ramen för denna artikel. En sak, framför allt, har dock förblivit densamma; tillhandahåller en modern, öppen källkod och högkvalitativ databaslösning som utvecklare kan använda för att driva sin innovation.

Men innan du kan dyka in i MariaDB och kolla in allt det har att erbjuda måste du svara på de mest grundläggande frågorna; hur kommer du igång med MariaDB?

MariaDB och Java Database Connectivity (JDBC)

Det kommer förmodligen inte som någon överraskning att Java, och i slutändan Java Virtual Machine (JVM) miljön som helhet, har varit ett extremt populärt alternativ som används av utvecklare för att skapa applikationer.

Med det i åtanke har jag skrivit den här korta genomgången för att ta dig igenom stegen för att komma igång med MariaDB (Community Server) med hjälp av en Docker-bild, Java och MariaDB JDBC-klienten.

I den här genomgången kommer du att använda MariaDB och JDBC för att skapa en enkel (Maven-baserad) "att göra"-applikation som, med hjälp av Java Spring, kommer att exponera en mängd olika slutpunkter att använda för att utföra grundläggande CRUD (skapa-läs-uppdatera-ta bort ) operationer på en MariaDB-databasinstans.

Låt oss komma igång!

Krav

Innan du hoppar in i kod måste du se till att du har några saker på din dator:

  • MariaDB-klient
  • Docker
  • Java (v. 8+)
  • Curl (för att testa API-slutpunkterna)

Skapa en ny MariaDB-instans med Docker

Ett av de enklaste sätten att komma igång med MariaDB, oavsett vilket operativsystem du använder, är att hämta MariaDB Server Docker-bilden från Docker Hub och använda den för att skapa en ny behållare.

För att göra detta öppnar du bara ett terminalfönster och kör följande:

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

Det är allt. Du bör nu ha en körande instans av MariaDB. Ganska smärtfritt, eller hur?

Du kan bekräfta instansen i en Docker-behållare genom att köra följande:

$ docker ps

Och du bör se din behållare i utgången.

Ansluter till MariaDB

Nu när du har en körande MariaDB Server-instans i en ny Docker-behållare blir nästa steg att ansluta till och kommunicera med databasinstansen med hjälp av MariaDB-klienten.

Det finns många SQL-klienter tillgängliga ute i naturen. För enkelhetens skull har jag valt att visa hur man använder den officiella MariaDB-klienten, men använd gärna vilken klient du föredrar.

Anslut till din MariaDB-instans genom att utföra följande:

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

Du bör se något i stil med följande, vilket betyder att du framgångsrikt har anslutit till MariaDB-instansen!

När du är ansluten kan du skapa en ny databas. 

CREATE DATABASE todo;

Skapa sedan en ny tabell. 

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

Komma igång med Java Spring, JDBC och MariaDB

Med en databasinstans snurrad upp och ett schema skapat är du redo att skapa en ny Java applikation.

Skapa ett Maven-projekt

Börja med att navigera till https://start.spring.io, vilket gör att du kan skapa ett nytt vårbaserat Maven-projekt. För detta projekt kan du ange följande kriterier.

Lägg sedan till följande beroenden:

  • Lombok: Ett bibliotek som eliminerar behovet av att skapa pannplåtskod (t.ex. getters, seters) inom domänobjekten.
  • Vårwebben: Ett bibliotek för att skapa och exponera RESTful API-slutpunkter.
  • Spring Data JPA: Ett bibliotek som tillhandahåller abstraktioner för att eliminera pannplåtskod för att ansluta till och kommunicera med databaser.

Klicka slutligen på knappen "GENERERA" för att skapa och ladda ner projektet (som finns i en .zip-fil) till önskad plats på din dator.

Lägg till MariaDB R2DBC-kontakten

Navigera till platsen där du laddade ner det nya Maven-projektet (.zip-fil) till och packa upp. Använd sedan en kodredigerare för att öppna projektet och öppna pom.xml.

Lägg till ett nytt beroende för MariaDB:s JDBC-kontakt till samlingen av beroenden. 

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

Förbereder dataintegreringen

Nu när du har skapat ett projekt som innehåller alla beroenden du behöver, är det att hoppa in i Java-koden. Vanligtvis gillar jag att börja med att skapa entitetsklasserna.

Navigera till /src/main/java/com/mariadb/todo , skapa en ny mapp som heter "domän" och skapa en ny fil i den med namnet "Task.java".

Öppna "Task.java" och lägg till följande 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;
}

Skapa sedan en ny mapp som heter "repositories" i /src/main/java/com/mariadb/todo , och skapa en ny arkiverad i den med namnet "TaskRepository.java".

Öppna "TaskRepository.java" och lägg till följande 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> {
}

Som namnet antyder tillhandahåller CrudRepository-gränssnittet grundläggande CRUD-operationer på ett arkiv för en generisk typ (din Task-klass i det här fallet) och den primära nyckeltypen för den generiska typen.

Skapa en datatjänst

Tjänster kan användas för att hantera din applikations affärslogik. Den enda tjänsten, TaskService, i denna applikation används för att validera ett Task-objekt och integrera med TaskRepository.

Skapa en ny mapp som heter "tjänster" i /src/main/java/com/mariadb/todo , och skapa en ny fil med namnet "TaskService.java".

Öppna "TaskService.java" och lägg till följande 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);
    }
}

Exponera API-slutpunkter

Slutligen måste du skapa en kontroller för att exponera fyra slutpunkter som kan användas för att utföra de grundläggande CRUD-operationerna på dina uppgifter.

Skapa en ny mapp som heter "controllers" i /src/main/java/com/mariadb/todo och skapa en ny mapp i den med namnet "TaskController.java".

Öppna "TaskController.java" och lägg till följande 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();
    }
}

Testar

Nu när allt har konstruerats är det dags att testa det!

Bygg först applikationen. 

$ mvn package

Och sedan köra den. 

$ mvn spring-boot:run

Börja först med att lägga till en ny uppgift till din att göra-lista. 

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

Även om du säkert kan fråga databasen direkt för att bekräfta att en ny uppgiftspost har lagts till, var är det roliga med det? Tillbaka till API! 

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

Om allt går bra bör du få följande JSON-svar:

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

Voilà, en helt reaktiv Java Spring-applikation som använder JDBC och MariaDB! För att se den här koden i sin helhet kolla in källan här. Och om du undrar "det skulle säkert vara trevligt att se en implementering med ett användargränssnitt", har du tur! Du kan hitta en fullständig implementering av en TODO-applikation med hjälp av React.js och ditt val av flera API-projekt
(R2DBC, JDBC, Node.js och Python) som integreras direkt med MariaDB här!

Bara att börja

Nu när du framgångsrikt har skapat ett nytt Maven-projekt med hjälp av Spring Data JPA, JDBC och MariaDB, har du alla verktyg du behöver för att komma igång med att skapa helt reaktiva applikationer, använda kraften i MariaDB, din egen! Om du har några frågor , förslag eller funderingar med det här blogginlägget, vänligen meddela mig här eller kontakta mig direkt på Twitter på @probablyrealrob! Tack för att du tog dig tid att läsa detta och glad kodning!


  1. Hur säkerhetskopierar och återställer man en databas som en kopia på samma server?

  2. Hur uppstår databaskorruption?

  3. Hur hittar jag MySQL my.cnf-platsen

  4. Knee-Jerk Performance Tuning:Lägg bara till en SSD