Utilisation d'un dialecte d'InterSystems IRIS pour le nouveau Hibernate 6 dans un projet Springboot

Hibernate est le framework le plus populaire pour réaliser des projets ORM (Mapping Objet-Relationnel). Avec Hibernate, un logiciel peut utiliser les principaux SGBD du marché, et même changer de fournisseur de base de données à tout moment, sans impact sur le code source. Cela est possible car Hibernate prend en charge les dialectes. Chaque produit de base de données a un dialecte différent qui peut être assigné dans un fichier de configuration. Ainsi, si un logiciel utilise Oracle et souhaite évoluer vers InterSystems IRIS, il suffit de modifier le fichier de configuration avec les informations relatives à la connexion et au dialecte. Si votre logiciel nécessite une préparation à l'utilisation de la base de données indiquée par votre client, Hibernate est la solution qu'il vous faut.

 

Est-ce qu'il existe un dialecte d'InterSystems IRIS pour le nouveau Hibernate 6 ?

Actuellement, il n'existe pas de dialecte officiel pour utiliser IRIS avec le nouveau Hibernate 6. Pour résoudre ce problème, Dmitry Maslennikov a proposé une idée dans l'excellent portail d'idées (https://ideas.intersystems.com/ideas/DPI-I-372) et je l'ai mise en œuvre.
Si vous suivez ce tutoriel, vous verrez l'idée et ce nouveau dialecte d'IRIS en action et en fonctionnement.

Ce qu'il vous faut pour réaliser ce tutoriel

Pour réaliser ce tutoriel, vous avez besoin de :
1. Une instance IRIS en cours d'exécution (si vous n'en avez pas, vous pouvez l'obtenir sur https://openexchange.intersystems.com/package/ObjectScript).
2. Les outils Spring Tools installés (téléchargez-les sur https://spring.io/tools). Choisissez la version Eclipse pour ce tutoriel.
3. Java JDK version 17 (téléchargez-le sur https://jdk.java.net/archive/). Choisissez Java 17 pour ce tutoriel.
4. Tout le code source de ce tutoriel : https://github.com/yurimarx/iris-java-tools/tree/main/springboot-sample.

Les étapes du tutoriel

1.    Ouvrez Spring Tool Suite (STS) et choisissez un chemin d'accès valide à l'espace de travail (n'importe quel dossier) et cliquez sur Launch ("lancement") :

2.    Cliquez sur le lien Créer un nouveau Projet Spring Starter :

3.    Cet assistant créera un nouveau projet Spring. Remplissez les champs avec les valeurs suivantes :
•    Service URL: https://start.spring.io
•    Type : Maven (c'est un gestionnaire de paquets comme NPM, ZPM ou IPM)
•    Emballage : Jar (type d'exécutable pour le projet compilé)
•    Version de Java : 17 ou 20 (pour ce tutoriel, j'ai choisi la version 17)
•    Langage : Java
•    Groupe : com.tutorial (domaine du projet pour Maven)
•    Artifact : iris-tutorial (nom du projet pour Maven)
•    Version : 0.0.1-SNAPSHOT (version du projet pour Maven)
•    Description : Tutoriel IRIS
•    Paquet : com.tutorial.iris (paquet roott pour le projet)

4.    Cliquez sur Next (Suivant).
5.    Choisissez les dépendances suivantes pour votre projet :

6.    Cliquez sur Finish (Terminer) pour créer votre projet.
7.    Ouvrez votre fichier pom.xml et incluez 2 nouvelles dépendances (pour le dialecte IRIS et pour le pilote IRIS JDBC), ainsi qu'un dépôt (ce qui est nécessaire car le pilote IRIS JDBC d'InterSystems n'est pas publié dans un dépôt maven public).

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.1</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.tutorial</groupId>
    <artifactId>tutorial-dialect</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>tutorial-dialect</name>
    <description>Tutorial for IRIS Hibernate 6 Dialect</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-hateoas</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-rest-hal-explorer</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.github.yurimarx</groupId>
            <artifactId>hibernateirisdialect</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.intersystems</groupId>
            <artifactId>intersystems-jdbc</artifactId>
            <version>3.7.1</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>InterSystems IRIS DC Git Repository</id>
            <url>
                https://github.com/intersystems-community/iris-driver-distribution/blob/main/JDBC/JDK18</url>
            <snapshots>
                <enabled>true</enabled>
                <updatePolicy>always</updatePolicy>
            </snapshots>
        </repository>
    </repositories>
</project>

8.    Allez dans le fichier application.properties (src > main > java > dossier resources) et définissez les propriétés connection et dialect avec ces valeurs :

spring.datasource.username=_SYSTEM
spring.datasource.url=jdbc:IRIS://localhost:1972/USER
spring.datasource.password=SYS
spring.jpa.properties.hibernate.default_schema=Example
spring.jpa.hibernate.ddl-auto=update
spring.datasource.driver-class-name=com.intersystems.jdbc.IRISDriver
spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults = false
spring.jpa.database-platform=io.github.yurimarx.hibernateirisdialect.InterSystemsIRISDialect
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

9.    Créez une nouvelle classe persistante (cliquez sur le bouton droit de la souris sur le projet > Nouveau > Classe) :

10.    Remplissez les champs suivants pour créer la classe :
•    Paquet: com.tutorial.iris.model
•   Nom: Product (Produit)

11.    Cliquez sur Finish (Terminer) pour créer la classe.
12.    Développez la classe persistante Produit (classe dont les valeurs sont conservées dans un tableau SQL) à l'aide de ce code source :

package com.tutorial.dialect.model;

import java.util.Date;

import com.fasterxml.jackson.annotation.JsonFormat;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.persistence.Temporal;
import jakarta.persistence.TemporalType;

@Entity
@Table(name = "Product")
public class Product {

    
    @Id
    @GeneratedValue (strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    private String description;
    
    private Double height;
    
    private Double width;
    
    private Double weight;
    
    @Column(name="releasedate")
    @Temporal(TemporalType.DATE)
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date releaseDate;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Double getHeight() {
        return height;
    }

    public void setHeight(Double height) {
        this.height = height;
    }

    public Double getWidth() {
        return width;
    }

    public void setWidth(Double width) {
        this.width = width;
    }

    public Double getWeight() {
        return weight;
    }

    public void setWeight(Double weight) {
        this.weight = weight;
    }

    public Date getReleaseDate() {
        return releaseDate;
    }

    public void setReleaseDate(Date releaseDate) {
        this.releaseDate = releaseDate;
    }

}

13.    Créez un référentiel d'interface pour les opérations CRUD sur la classe Produit (cliquez sur le bouton droit de la souris dans le projet > Nouveau > Interface) :

14.    Saisissez les valeurs de l'interface et cliquez sur Finish (Terminer) :
•   Paquet: com.tutorial.iris.repository
•   Nom: ProductRepository

15.    Cliquez sur Finish (Terminer) pour créer l'interface.
16.    Développez l'interface ProductRepository (un référentiel CRUD implémentant les fonctions de sauvegarde, de suppression, de recherche, de recherche unique et de mise à jour) (src > main > java > com > tutoriel > dialecte > dossier référentiel) à l'aide de ce code source :

package com.tutorial.dialect.repository;

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import com.tutorial.dialect.model.Product;

@Repository
public interface ProductRepository extends CrudRepository<Product, Long> {

}

17.    Maintenant, en utilisant le navigateur HAL de Springboot, vous pouvez tester les fonctions CRUD dans un écran web.
18.    Assurez-vous d'exécuter une instance IRIS sur localhost, port 1972 avec l'utilisateur _SYSTEM et le mot de passe SYS (ou modifiez l'application.properties pour d'autres valeurs de connexion).
19.    Exécutez l'application (cliquez avec le bouton droit de la souris sur le projet > Exécuter en tant que > Spring boot app).
20.    Sur la console, vous verrez le journal indiquant le démarrage de l'application :

21.    Allez dans votre navigateur et tapez http://localhost:8080. Découvrez le navigateur HAL :

22.    Cliquez sur le bouton "plus" de produits endpoint pour créer un nouveau produit :

23.    Remplissez les valeurs suivantes pour créer un nouveau produit et cliquez sur le bouton "Go" (aller) pour confirmer :

24.    Un nouveau produit a été lancé :

Vérifier la nouvelle ligne sur IRIS (tableau du produit sur l'espace de noms USER)

 

Testez d'autres opérations, vérifiez la base de données et amusez-vous !