Conversion des entités JPA en Mendix

Récemment, en explorant Mendix, j'ai remarqué qu'ils disposaient d'un SDK Platform qui vous permet d'interagir avec le modèle d'application Mendix via une API.

Cela m'a donné une idée à explorer si cela peut être utilisé pour créer notre modèle de domaine. Plus précisément, pour créer un modèle de domaine basé sur une application traditionnelle existante.

Si cela est généralisé davantage, cela pourrait être utilisé pour convertir n'importe quelle application existante en Mendix et poursuivre le développement à partir de là.

Conversion d'une application Web Java/Spring en Mendix

J'ai donc créé une petite application Web Java/Spring avec une simple API et une couche de base de données. Il utilise une base de données H2 intégrée pour plus de simplicité.

Dans cet article, nous allons uniquement convertir les entités JPA. Jetons-y un coup d'œil :

@Entity
@Table(name = "CAT")
class Cat {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;
    private int age;
    private String color;

    @OneToOne
    private Human humanPuppet;

    ... constructor ...
    ... getters ...
}

@Entity
@Table(name = "HUMAN")
public class Human {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;

    ... constructor ...
    ... getters ...
}

Comme vous pouvez le voir, ils sont assez simples : un chat avec un nom, un âge, une couleur et sa marionnette humaine, puisque les chats gouvernent le monde tel que nous le connaissons.

Les deux ont un champ d'identification généré automatiquement. Le chat a une association individuelle avec un humain afin qu'il puisse appeler son humain quand il le souhaite. (Si ce n'était pas une entité JPA, j'aurais mis une méthode meow() mais laissons cela pour le futur).

L'application fonctionne pleinement, mais pour le moment, seule la couche de données nous intéresse.

Extraction des métadonnées d'entité dans json

Cela peut être fait de différentes manières :

1. En analysant statiquement les entités de leur package.
2. En utilisant la réflexion pour lire ces entités au moment de l'exécution.

J'ai opté pour l'option 2 car c'est plus rapide et je n'ai pas pu trouver facilement une bibliothèque capable de faire l'option 1.

Ensuite, nous devons décider comment exposer json une fois que nous l'avons construit. Pour simplifier les choses, nous allons simplement l'écrire dans un fichier. Certaines méthodes alternatives pourraient être :

• L'exposer via une API. C'est plus compliqué car vous devez également vous assurer que le point de terminaison est très bien sécurisé car nous ne devons pas exposer nos métadonnées publiquement.
• L'exposer via un outil de gestion, comme l'actionneur Spring Boot ou jmx. C'est plus sûr, mais la configuration prend quand même du temps.

Voyons maintenant le code réel :

public class MendixExporter {
    public static void exportEntitiesTo(String filePath) throws IOException {
        AnnotatedTypeScanner typeScanner = new AnnotatedTypeScanner(false, Entity.class);

        Set<Class<?>> entityClasses = typeScanner.findTypes(JavaToMendixApplication.class.getPackageName());
        log.info("Entity classes are: {}", entityClasses);

        List<MendixEntity> mendixEntities = new ArrayList<>();

        for (Class<?> entityClass : entityClasses) {
            List<MendixAttribute> attributes = new ArrayList<>();
            for (Field field : entityClass.getDeclaredFields()) {

                AttributeType attributeType = determineAttributeType(field);
                AssociationType associationType = determineAssociationType(field, attributeType);
                String associationEntityType = determineAssociationEntityType(field, attributeType);

                attributes.add(
                        new MendixAttribute(field.getName(), attributeType, associationType, associationEntityType));
            }
            MendixEntity newEntity = new MendixEntity(entityClass.getSimpleName(), attributes);
            mendixEntities.add(newEntity);
        }

        writeToJsonFile(filePath, mendixEntities);
    }
    ...
}

Nous commençons par rechercher toutes les classes de notre application marquées de l'annotation @Entity de JPA.
Ensuite, pour chaque cours, nous :

1. Récupérez les champs déclarés avecentityClass.getDeclaredFields().
2. Bouclez chaque champ de cette classe.

Pour chaque champ donc, nous :

1. Déterminez le type de l'attribut :
   

   private static final Map<Class<?>, AttributeType> JAVA_TO_MENDIX_TYPE = Map.ofEntries(
           Map.entry(String.class, AttributeType.STRING),
           Map.entry(Integer.class, AttributeType.INTEGER),
           ...
           );
   // we return AttributeType.ENTITY if we cannot map to anything else
   

   Essentiellement, nous faisons simplement correspondre le type Java avec nos valeurs d'énumération personnalisées en les recherchant dans la carte JAVA_TO_MENDIX_TYPE.

2. Ensuite, nous vérifions si cet attribut est réellement une association (pointe vers une autre @Entity). Si tel est le cas, nous déterminons de quel type d'association il s'agit : un-à-un, un-à-plusieurs, plusieurs-à-plusieurs :
   

   @Entity
   @Table(name = "CAT")
   class Cat {
       @Id
       @GeneratedValue(strategy = GenerationType.AUTO)
       private Long id;
   
       private String name;
       private int age;
       private String color;
   
       @OneToOne
       private Human humanPuppet;
   
       ... constructor ...
       ... getters ...
   }
   
   @Entity
   @Table(name = "HUMAN")
   public class Human {
       @Id
       @GeneratedValue(strategy = GenerationType.AUTO)
       private Long id;
   
       private String name;
   
       ... constructor ...
       ... getters ...
   }
   

   Pour ce faire, nous vérifions simplement le type d'attribut précédemment mappé. Dans le cas où il s'agit d'une entité, cela signifie simplement qu'à l'étape précédente, nous n'avons pas pu le mapper à un type Java primitif, String ou Enum.
   Ensuite, nous devons également décider de quel type d’association il s’agit. La vérification est simple : s'il s'agit d'un type Liste, alors c'est un-à-plusieurs, sinon un-à-un (je n'ai pas encore implémenté « plusieurs-à-plusieurs »).

3. Nous créons ensuite un objet MendixAttribute pour chaque champ trouvé.

Une fois cela fait, nous créons simplement un objet MendixEntity pour l'entité avec une liste d'attributs attribués.
MendixEntity et MendixAttribute sont des classes que nous utiliserons pour mapper vers json plus tard :

public class MendixExporter {
    public static void exportEntitiesTo(String filePath) throws IOException {
        AnnotatedTypeScanner typeScanner = new AnnotatedTypeScanner(false, Entity.class);

        Set<Class<?>> entityClasses = typeScanner.findTypes(JavaToMendixApplication.class.getPackageName());
        log.info("Entity classes are: {}", entityClasses);

        List<MendixEntity> mendixEntities = new ArrayList<>();

        for (Class<?> entityClass : entityClasses) {
            List<MendixAttribute> attributes = new ArrayList<>();
            for (Field field : entityClass.getDeclaredFields()) {

                AttributeType attributeType = determineAttributeType(field);
                AssociationType associationType = determineAssociationType(field, attributeType);
                String associationEntityType = determineAssociationEntityType(field, attributeType);

                attributes.add(
                        new MendixAttribute(field.getName(), attributeType, associationType, associationEntityType));
            }
            MendixEntity newEntity = new MendixEntity(entityClass.getSimpleName(), attributes);
            mendixEntities.add(newEntity);
        }

        writeToJsonFile(filePath, mendixEntities);
    }
    ...
}

Enfin, nous enregistrons une liste vers un fichier json en utilisant jackson.

Importer des entités dans Mendix

Voici la partie amusante, comment lire le fichier json que nous avons généré ci-dessus et créer des entités mendix à partir de celui-ci ?

Le SDK Platform de Mendix dispose d'une API Typescript pour interagir avec lui.
Nous allons d’abord créer des objets pour représenter nos entités et attributs, ainsi que des énumérations pour les types d’association et d’attribut :

private static final Map<Class<?>, AttributeType> JAVA_TO_MENDIX_TYPE = Map.ofEntries(
        Map.entry(String.class, AttributeType.STRING),
        Map.entry(Integer.class, AttributeType.INTEGER),
        ...
        );
// we return AttributeType.ENTITY if we cannot map to anything else

Ensuite, nous devons obtenir notre application avec un appId, créer une copie de travail temporaire, ouvrir le modèle et trouver le modèle de domaine qui nous intéresse :

private static AssociationType determineAssociationType(Field field, AttributeType attributeType) {
    if (!attributeType.equals(AttributeType.ENTITY))
        return null;
    if (field.getType().equals(List.class)) {
        return AssociationType.ONE_TO_MANY;
    } else {
        return AssociationType.ONE_TO_ONE;
    }
}

Le SDK extraira notre application Mendix de git et travaillera dessus.

Après avoir lu le fichier json, nous allons boucler les entités :

public record MendixEntity(
        String name,
        List<MendixAttribute> attributes) {
}

public record MendixAttribute(
        String name,
        AttributeType type,
        AssociationType associationType,
        String entityType) {

    public enum AttributeType {
        STRING,
        INTEGER,
        DECIMAL,
        AUTO_NUMBER,
        BOOLEAN,
        ENUM,
        ENTITY;
    }

    public enum AssociationType {
        ONE_TO_ONE,
        ONE_TO_MANY
    }
}

Ici, nous utilisons domainmodels.Entity.createIn(domainModel); pour créer une nouvelle entité dans notre modèle de domaine et lui attribuer un nom. Nous pouvons attribuer plus de propriétés, comme la documentation, les index, voire l'emplacement où l'entité sera rendue dans le modèle de domaine.

Nous traitons les attributs dans une fonction distincte :

interface ImportedEntity {
    name: string;
    generalization: string;
    attributes: ImportedAttribute[];
}

interface ImportedAttribute {
    name: string;
    type: ImportedAttributeType;
    entityType: string;
    associationType: ImportedAssociationType;
}

enum ImportedAssociationType {
    ONE_TO_ONE = "ONE_TO_ONE",
    ONE_TO_MANY = "ONE_TO_MANY"
}

enum ImportedAttributeType {
    INTEGER = "INTEGER",
    STRING = "STRING",
    DECIMAL = "DECIMAL",
    AUTO_NUMBER = "AUTO_NUMBER",
    BOOLEAN = "BOOLEAN",
    ENUM = "ENUM",
    ENTITY = "ENTITY"
}

La seule chose ici sur laquelle nous devons faire des efforts est de mapper le type d'attribut à un type Mendix valide.

Ensuite, nous traitons les associations. Premièrement, puisque dans nos entités Java, les associations étaient déclarées par un champ, nous devons distinguer quels champs sont de simples attributs et lesquels sont des associations. Pour ce faire, il suffit de vérifier s'il s'agit d'un type ENTITY ou d'un type primitif :

const client = new MendixPlatformClient();
const app = await client.getApp(appId);
const workingCopy = await app.createTemporaryWorkingCopy("main");
const model = await workingCopy.openModel();
const domainModelInterface = model.allDomainModels().filter(dm => dm.containerAsModule.name === MyFirstModule")[0];
const domainModel = await domainModelInterface.load();

Créons les associations :

function createMendixEntities(domainModel: domainmodels.DomainModel, entitiesInJson: any) {
    const importedEntities: ImportedEntity[] = JSON.parse(entitiesInJson);

    importedEntities.forEach((importedEntity, i) => {
        const mendixEntity = domainmodels.Entity.createIn(domainModel);
        mendixEntity.name = importedEntity.name;

        processAttributes(importedEntity, mendixEntity);
    });

    importedEntities.forEach(importedEntity => {
        const mendixParentEntity = domainModel.entities.find(e => e.name === importedEntity.name) as domainmodels.Entity;
        processAssociations(importedEntity, domainModel, mendixParentEntity);
    });
}

Nous avons 4 propriétés importantes à définir, en plus du nom :

1. L'entité mère. C'est l'entité actuelle.

2. L'entité enfant. Dans la dernière étape, nous avons créé des entités Mendix pour chaque entité Java. Il ne nous reste plus qu'à trouver l'entité correspondante en fonction du type du champ java dans notre entité :
   

   function processAttributes(importedEntity: ImportedEntity, mendixEntity: domainmodels.Entity) {
       importedEntity.attributes.filter(a => a.type !== ImportedAttributeType.ENTITY).forEach(a => {
           const mendixAttribute = domainmodels.Attribute.createIn(mendixEntity);
           mendixAttribute.name = capitalize(getAttributeName(a.name, importedEntity));
           mendixAttribute.type = assignAttributeType(a.type, mendixAttribute);
       });
   }
   

3. Type d'association. Si c'est un à un, il correspond à une référence. S'il s'agit d'un à plusieurs, il correspond à un ensemble de référence. Nous allons sauter plusieurs à plusieurs pour l'instant.

4. Le propriétaire de l'association. Les associations un-à-un et plusieurs-à-plusieurs ont le même type de propriétaire : les deux. Pour un face-à-face, le type de propriétaire doit être Par défaut.

Le SDK Mendix Platform aura créé les entités dans sa copie de travail locale de notre application Mendix. Il ne nous reste plus qu'à lui dire de valider les modifications :

@Entity
@Table(name = "CAT")
class Cat {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;
    private int age;
    private String color;

    @OneToOne
    private Human humanPuppet;

    ... constructor ...
    ... getters ...
}

@Entity
@Table(name = "HUMAN")
public class Human {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;

    ... constructor ...
    ... getters ...
}

Après quelques secondes, vous pouvez ouvrir l'application dans Mendix Studio Pro et vérifier les résultats :

Voilà : une entité Chat et Humain avec une association individuelle entre eux.

Si vous souhaitez expérimenter vous-même ou voir le code complet, rendez-vous sur ce dépôt.

Des idées pour l'avenir

1. Dans cet exemple, j'ai utilisé une application Java/Spring pour effectuer la conversion car je la maîtrise le mieux, mais n'importe quelle application peut être utilisée. Il suffit de pouvoir lire les données de type (statiquement ou au moment de l'exécution) pour extraire les noms de classe et de champ.
2. Je suis curieux d'essayer de lire et d'exporter de la logique Java vers les microflux Mendix. Nous ne pouvons probablement pas vraiment convertir la logique métier elle-même, mais nous devrions pouvoir en obtenir la structure (au moins les signatures de méthodes métier ?).
3. Le code de cet article pourrait être généralisé et transformé en bibliothèque : le format json peut rester le même, et il pourrait y avoir une bibliothèque pour exporter les types Java et une autre pour importer des entités mendix.
4. Nous pourrions utiliser la même approche pour faire l'inverse : convertir un mendix dans une autre langue.

Conclusion

Le SDK Mendix Platform est une fonctionnalité puissante permettant d'interagir avec l'application Mendix par programmation. Ils répertorient quelques exemples de cas d'utilisation tels que l'importation/exportation de code, l'analyse de la complexité des applications.
Jetez-y un œil si vous êtes intéressé.
Pour cet article, vous pouvez trouver le code complet ici.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!