[DOCKER] Versuchen Sie, mit MyBatis im Micronaut + Kotlin-Projekt Daten aus der Datenbank abzurufen

Letztes Mal

Hallo Welt mit Micronaut + Kotlin Erweitern Sie das vorherige Projekt und versuchen Sie, mit MyBatis eine Verbindung zur Datenbank herzustellen.

Das tatsächlich erstellte Repository ist hier.

Datenbank vorbereiten

Bereiten Sie mit Docker einen PostgreSQL-Container vor. Ich habe Folgendes in derselben Hierarchie erstellt wie das zuletzt erstellte Projekt.

• Docker-compose.yml zum Erstellen einer DB-Umgebung

docker-compose.yml

version: '3'
services: 
  db:
    image: postgres
    restart: always
    container_name: postgres
    environment: 
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: books
    volumes:
      - ./data/postgres/db-data:/var/lib/postgresql/data
      - ./database:/docker-entrypoint-initdb.d
    ports:
      - 5432:5432

• Datenordner und SQL zum Speichern von SQL für die Tabellenerstellung

database/init.sql

set client_encoding = 'UTF8';

CREATE TABLE book (
  id SERIAL,
  name VARCHAR(200) NOT NULL,
  publisher VARCHAR(200),
  publication_date DATE,
  created_at TIMESTAMP NOT NULL,
  updated_at TIMESTAMP NOT NULL,
  CONSTRAINT pk_book PRIMARY KEY (id)
);

--Anfangsdaten zur Bestätigung
INSERT INTO book (id, name, publisher, publication_date, created_at, updated_at) VALUES (1, 'Testbuch 1', 'Testverlag A.', null, current_timestamp, current_timestamp);
INSERT INTO book (id, name, publisher, publication_date, created_at, updated_at) VALUES (2, 'Testbuch 2', 'Testverlag A.', null, current_timestamp, current_timestamp);

• .Gitignore zum Entfernen von DB-Daten aus der Git-Verwaltung

.gitignore

data

Gehen Sie mit "Docker-Compose" in den Ordner und starten Sie den Container.

$ docker-compose up -d

Jetzt ist die DB fertig.

Projektrenovierung

Bibliothek hinzufügen

Bearbeiten Sie build.gradle und fügen Sie die Bibliothek hinzu.

server/build.gradle

dependencies {
    //Kürzung
    implementation("org.mybatis:mybatis:3.4.6")
    implementation("io.micronaut.sql:micronaut-jdbc-hikari")
    runtimeOnly("org.postgresql:postgresql")
    //Kürzung
}

Verbindungseinstellungen hinzufügen

Bearbeiten Sie application.yml.

• Verbindungsziel hinzufügen
• MyBatis-Einstellungen hinzugefügt

server/src/main/resources/application.yml

micronaut:
  application:
    name: helloworld
#Fügen Sie Folgendes hinzu
datasources:
  default:
    url: jdbc:postgresql://localhost:5432/books
    username: postgres
    password: postgres
    driverClassName: org.postgresql.Driver
mybatis:
  #Geben Sie den Speicherort für die Mapper-XML-Datei an
  mapper-locations: classpath:example/mapper/*.xml
  configuration:
    map-underscore-to-camel-case: true
    default-fetch-size: 100
    default-statement-timeout: 30
    cache-enabled: false

Modell erstellen

Erstellen Sie eine Klasse zum Speichern der aus der Datenbank erhaltenen Daten.

server/src/main/kotlin/example/model/Book.kt

package example.model

import io.micronaut.core.annotation.Introspected
import java.sql.Date

/**
 *Datenklasse buchen
 */
@Introspected
data class Book(
        var id: Int?,
        var name: String,
        var publisher: String?,
        var publicationDate: Date?,
)

Erstellen einer SqlSessionFactory

Erstellen Sie eine Factory-Klasse, die eine SqlSession vorbereitet.

server/src/main/kotlin/example/MybatisFactory.kt

package example

import io.micronaut.context.annotation.Factory
import org.apache.ibatis.mapping.Environment
import org.apache.ibatis.session.Configuration
import org.apache.ibatis.session.SqlSessionFactory
import org.apache.ibatis.session.SqlSessionFactoryBuilder
import org.apache.ibatis.transaction.TransactionFactory
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory
import javax.inject.Singleton
import javax.sql.DataSource

@Factory
class MybatisFactory(private val dataSource: DataSource) {

    @Singleton
    fun sqlSessionFactory(): SqlSessionFactory {
        val transactionFactory: TransactionFactory = JdbcTransactionFactory()

        val environment = Environment("dev", transactionFactory, dataSource)
        val configuration = Configuration(environment)
        //Geben Sie das Paket an, das den Mapper scannen soll.
        configuration.addMappers("example")

        return SqlSessionFactoryBuilder().build(configuration)
    }
}

Erstellen eines Mappers

Erstellen Sie einen Mapper, der mit SQL verbunden ist.

server/src/main/kotlin/example/mapper/BookMapper.kt

package example.mapper

import example.model.Book
import org.apache.ibatis.annotations.Mapper

@Mapper
interface BookMapper {
    fun findById(id: Int): Book
}

Der auszuführende SQL-Body wird in XML beschrieben.

server/src/main/resources/example/mapper/BookMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="example.mapper.BookMapper">

    <select id="findById" resultType="example.model.Book">
        SELECT
        id,
        name,
        publisher,
        publication_date
        FROM book
        <where>
            id = #{id}
        </where>
    </select>

</mapper>

Erstellen Sie eine Serviceklasse als Implementierung der Schnittstelle.

server/src/main/kotlin/example/service/BookService.kt

package example.service

import example.mapper.BookMapper
import example.model.Book
import org.apache.ibatis.session.SqlSessionFactory
import javax.inject.Singleton

@Singleton
class BookService(private val sqlSessionFactory: SqlSessionFactory) : BookMapper {

    override fun findById(id: Int): Book {
        sqlSessionFactory.openSession().use { session ->
            val bookMapper = session.getMapper(BookMapper::class.java)
            return bookMapper.findById(id)
        }
    }
}

Controller erstellen

Erstellen Sie eine API für den Zugriff auf die Datenbank.

server/src/main/kotlin/example/controller/BookController.kt

package example.controller

import example.mapper.BookMapper
import example.model.Book
import io.micronaut.http.HttpResponse
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get


@Controller()
class BookController(private val bookMapper: BookMapper) {

    /**
     *Erwerb von Buchinformationen.
     *ID-Spezifikation
     *
     * @param id Buch-ID
     *
     * @return HttpResponse
     */
    @Get("/book/{id}")
    fun readById(id: Int): HttpResponse<Book> {
        return HttpResponse.ok(bookMapper.findById(id))
    }
}

Vorerst abgeschlossen

Wenn Sie bisher auf den Endpunkt von / book / {id} zugreifen, können Sie die Daten abrufen. Ich werde es versuchen.

Führen Sie den Server aus.

$ cd server 
$ ./gradlew run

Gehen Sie zu "http: // localhost: 8080 / book / 1".

$ curl -X GET  http://localhost:8080/book/1
{"id":1,"name":"Testbuch 1","publisher":"Testverlag A."}

Ich konnte die Daten aus der Datenbank abrufen.

Referenz

Access a database with MyBatis