sql >> Databáze >  >> RDS >> MariaDB

Začínáme s MariaDB pomocí Docker, Java Spring a JDBC

Od roku 2009, kdy byla vytvořena z MySQL, se MariaDB za poslední desetiletí stala jednou z nejoblíbenějších databází pro vývojáře. Zatímco mnoho technologů k němu pravděpodobně tíhlo jako k řešení kvůli jeho kořenům s otevřeným zdrojovým kódem a tomu, že je zakořeněno ve světě relačních databází, ve skutečnosti to teprve začíná poškrábat povrch toho, co MariaDB nabízí.

V průběhu let se MariaDB od MySQL odchýlila přidáním mnoha funkcí a funkcí, z nichž mnohé se nebudeme moci ponořit v kontextu tohoto článku. Jedna věc však především zůstala stejná; poskytuje moderní, open source, vysoce kvalitní databázové řešení, které mohou vývojáři využít k podpoře svých inovací.

Než se však budete moci ponořit do MariaDB a prozkoumat vše, co nabízí, budete muset odpovědět na nejzákladnější otázky; jak začnete používat MariaDB?

MariaDB a Java Database Connectivity (JDBC)

Pravděpodobně není žádným překvapením, že Java a nakonec i prostředí Java Virtual Machine (JVM) jako celek je extrémně populární možností, kterou vývojáři používají k vytváření aplikací.

S ohledem na to jsem sepsal tento krátký návod, který vás provede kroky, jak začít s MariaDB (Community Server) pomocí obrázku Docker, Javy a klienta MariaDB JDBC.

V tomto návodu využijete MariaDB a JDBC k vytvoření jednoduché (založené na Maven) aplikaci „To do“, která pomocí Java Spring odhalí různé koncové body, které lze použít k provádění základního CRUD (vytvoření-přečtení-aktualizace-smazání ) operace na instanci databáze MariaDB.

Začněme!

Požadavky

Než se pustíte do kódu, budete se muset ujistit, že máte na počítači několik věcí:

  • Klient MariaDB
  • Docker
  • Java (v. 8+)
  • Curl (pro testování koncových bodů API)

Vytvoření nové instance MariaDB pomocí Dockeru

Jedním z nejjednodušších způsobů, jak začít s MariaDB, bez ohledu na to, jaký operační systém používáte, je stáhnout obrázek MariaDB Server Docker z Docker Hub a použít jej k vytvoření nového kontejneru.

Chcete-li to provést, jednoduše otevřete okno terminálu a spusťte následující:

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

A je to. Nyní byste měli mít spuštěnou instanci MariaDB. Docela bezbolestné, že?

Instanci v kontejneru Docker můžete potvrdit spuštěním následujícího:

$ docker ps

A ve výstupu byste měli vidět svůj kontejner.

Připojování k MariaDB

Nyní, když máte spuštěnou instanci serveru MariaDB v novém kontejneru Docker, bude dalším krokem připojení k instanci databáze a komunikaci s ní pomocí klienta MariaDB.

Ve volné přírodě je k dispozici mnoho SQL klientů. Pro jednoduchost jsem se rozhodl předvést, jak používat oficiálního klienta MariaDB, ale určitě můžete použít jakéhokoli klienta, který preferujete.

Připojte se k instanci MariaDB provedením následujícího:

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

Měli byste vidět něco jako následující, což znamená, že jste se úspěšně připojili k instanci MariaDB!

Jakmile se připojíte, můžete vytvořit novou databázi. 

CREATE DATABASE todo;

Poté vytvořte novou tabulku. 

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

Začínáme s Java Spring, JDBC a MariaDB

Po spuštění instance databáze a vytvoření schématu jste připraveni vytvořit novou Java aplikaci.

Vytvořte projekt Maven

Začněte přechodem na https://start.spring.io, který vám umožní vytvořit nový projekt Maven založený na jaře. Pro tento projekt můžete zadat následující kritéria.

Dále přidejte následující závislosti:

  • Lombok: Knihovna, která eliminuje nutnost vytvářet kód kotle (např. gettry, settery) v rámci doménových objektů.
  • Jarní web: Knihovna pro vytváření a vystavení koncových bodů RESTful API.
  • Jarní data JPA: Knihovna, která poskytuje abstrakce, které pomáhají eliminovat kód pro připojení k databázím a komunikaci s nimi.

Nakonec klikněte na tlačítko "GENEROVAT" pro vytvoření a stažení projektu (obsaženého v souboru .zip) do požadovaného umístění na vašem počítači.

Přidejte konektor MariaDB R2DBC

Přejděte do umístění, kam jste stáhli nový projekt Maven (soubor .zip), a rozbalte jej. Poté pomocí editoru kódu otevřete projekt a otevřete pom.xml.

Přidejte do kolekce závislostí novou závislost pro konektor JDBC MariaDB. 

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

Příprava integrace dat

Nyní, když jste vytvořili projekt, který obsahuje všechny závislosti, které budete potřebovat, je třeba skočit do kódu Java. Obvykle bych rád začal vytvořením tříd entit.

Přejděte na /src/main/java/com/mariadb/todo, vytvořte novou složku s názvem „doména“ a vytvořte v ní nový soubor s názvem „Task.java“.

Otevřete „Task.java“ a přidejte následující kód. 

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

Dále vytvořte novou složku s názvem „úložiště“ v /src/main/java/com/mariadb/todo a vytvořte v něm nový soubor s názvem „TaskRepository.java“.

Otevřete „TaskRepository.java“ a přidejte následující kód. 

package com.mariadb.todo.repositories;

import com.mariadb.todo.domain.Task;

import org.springframework.data.repository.CrudRepository;

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

Jak název napovídá, rozhraní CrudRepository poskytuje základní operace CRUD na úložišti pro generický typ (v tomto případě pro vaši třídu Task) a typ primárního klíče pro tento generický typ.

Vytvořte datovou službu

Služby lze použít ke správě obchodní logiky vaší aplikace. Jediná služba, TaskService, v této aplikaci se používá k ověření objektu Task a integraci s TaskRepository.

Vytvořte novou složku s názvem „services“ v /src/main/java/com/mariadb/todo a vytvořte v něm nový soubor s názvem „TaskService.java“.

Otevřete „TaskService.java“ a přidejte následující kód. 

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

Odhalit koncové body rozhraní API

Nakonec budete muset vytvořit řadič pro vystavení čtyř koncových bodů, které lze použít k provádění základních operací CRUD na vašich Úkolech.

Vytvořte novou složku s názvem „controllers“ v /src/main/java/com/mariadb/todo a vytvořte v ní nový soubor s názvem „TaskController.java“.

Otevřete „TaskController.java“ a přidejte následující kód. 

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

Testování

Nyní, když je vše zkonstruováno, je čas to otestovat!

Nejprve vytvořte aplikaci. 

$ mvn package

A pak to spusťte. 

$ mvn spring-boot:run

Nejprve začněte přidáním nového úkolu do seznamu úkolů. 

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

I když se můžete dotázat přímo na databázi, abyste potvrdili, že byl přidán nový záznam úkolu, kde je v tom zábava? Zpět k API! 

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

Pokud vše půjde dobře, měli byste obdržet následující odpověď JSON:

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

Voilà, plně reaktivní Java Spring aplikace využívající JDBC a MariaDB! Chcete-li tento kód zobrazit celý, podívejte se na zdroj zde. A pokud se ptáte:„Určitě by bylo hezké vidět implementaci s uživatelským rozhraním“, máte štěstí! Můžete najít plně propracovanou implementaci TODO aplikace pomocí React.js a vašeho výběru z více projektů API
(R2DBC, JDBC, Node.js a Python), které se přímo integrují s MariaDB zde!

Právě začínáme

Nyní, když jste úspěšně vytvořili nový projekt Maven pomocí Spring Data JPA, JDBC a MariaDB, máte všechny nástroje, které potřebujete, abyste mohli začít vytvářet plně reaktivní aplikace, využívající sílu MariaDB, vaší vlastní! Máte-li nějaké otázky , návrhy nebo připomínky k tomuto příspěvku na blogu mi prosím dejte vědět zde nebo mě kontaktujte přímo na Twitteru na adrese @probablyrealrob! Děkujeme, že jste si našli čas na přečtení tohoto příspěvku, a přejeme hodně štěstí!


  1. SQLDeveloper nezobrazuje žádné tabulky pod připojeními, kde je uvedeno tabulky

  2. Oracle Security Alert pro CVE-2021-44228

  3. SQL SELECT AND operátor

  4. Jak vložit více než 1000 hodnot do klauzule Oracle IN