[DOCKER] Essayez d'obtenir des données de la base de données en utilisant MyBatis dans le projet Micronaut + Kotlin

Dernière fois

Bonjour le monde avec Micronaut + Kotlin Étendez le projet précédent et essayez de vous connecter à la base de données à l'aide de MyBatis.

Le référentiel réellement créé sera ici.

Préparer la base de données

Préparez un conteneur PostgreSQL avec Docker. J'ai créé ce qui suit dans la même hiérarchie que le projet créé la dernière fois.

• Docker-compose.yml pour créer un environnement DB

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

• Dossier Data et SQL pour stocker SQL pour la création de table

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

--Données initiales pour confirmation
INSERT INTO book (id, name, publisher, publication_date, created_at, updated_at) VALUES (1, 'Livre de test 1', 'Éditeur de test A', null, current_timestamp, current_timestamp);
INSERT INTO book (id, name, publisher, publication_date, created_at, updated_at) VALUES (2, 'Livre de test 2', 'Éditeur de test A', null, current_timestamp, current_timestamp);

• .Gitignore pour supprimer les données DB de la gestion Git

.gitignore

data

Allez dans le dossier avec docker-compose et démarrez le conteneur.

$ docker-compose up -d

La base de données est maintenant prête.

Rénovation du projet

Ajouter une bibliothèque

Modifiez build.gradle et ajoutez la bibliothèque.

server/build.gradle

dependencies {
    //réduction
    implementation("org.mybatis:mybatis:3.4.6")
    implementation("io.micronaut.sql:micronaut-jdbc-hikari")
    runtimeOnly("org.postgresql:postgresql")
    //réduction
}

Ajouter des paramètres de connexion

Modifiez application.yml.

• Ajouter une destination de connexion
• Ajout des paramètres MyBatis

server/src/main/resources/application.yml

micronaut:
  application:
    name: helloworld
#Ajoutez ce qui suit
datasources:
  default:
    url: jdbc:postgresql://localhost:5432/books
    username: postgres
    password: postgres
    driverClassName: org.postgresql.Driver
mybatis:
  #Spécifiez l'emplacement de stockage du fichier xml du mappeur
  mapper-locations: classpath:example/mapper/*.xml
  configuration:
    map-underscore-to-camel-case: true
    default-fetch-size: 100
    default-statement-timeout: 30
    cache-enabled: false

Créer un modèle

Créez une classe pour stocker les données obtenues à partir de la base de données.

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

package example.model

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

/**
 *Classe de données de livre
 */
@Introspected
data class Book(
        var id: Int?,
        var name: String,
        var publisher: String?,
        var publicationDate: Date?,
)

Créer une SqlSessionFactory

Créez une classe Factory qui prépare une SqlSession.

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)
        //Spécifiez le package pour analyser le mappeur.
        configuration.addMappers("example")

        return SqlSessionFactoryBuilder().build(configuration)
    }
}

Créer un mappeur

Créez un mappeur qui s'interfacera avec SQL.

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
}

Le corps SQL à exécuter est décrit en XML.

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>

Créez une classe de service en tant qu'implémentation de l'interface.

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

Créer un contrôleur

Créez une API pour accéder à la base de données.

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

    /**
     *Acquisition d'informations sur le livre.
     *Spécification d'identification
     *
     * @ID de paramètre ID de livre
     *
     * @return HttpResponse
     */
    @Get("/book/{id}")
    fun readById(id: Int): HttpResponse<Book> {
        return HttpResponse.ok(bookMapper.findById(id))
    }
}

Terminé pour le moment

Jusqu'à présent, si vous accédez au point de terminaison de / book / {id}, vous pouvez obtenir les données. Je vais essayer.

Exécutez le serveur.

$ cd server 
$ ./gradlew run

Accédez à «http: // localhost: 8080 / book / 1».

$ curl -X GET  http://localhost:8080/book/1
{"id":1,"name":"Livre de test 1","publisher":"Éditeur de test A"}

J'ai pu obtenir les données de la base de données.

référence

Access a database with MyBatis