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 :
- En analysant statiquement les entités de leur package.
- 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 :
- Récupérez les champs déclarés avecentityClass.getDeclaredFields().
- Bouclez chaque champ de cette classe.
Pour chaque champ donc, nous :
-
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
Copier après la connexionCopier après la connexionEssentiellement, 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.
-
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 ... }
Copier après la connexionCopier après la connexionCopier après la connexionPour 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 »). 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
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 :
- L'entité mère. C'est l'entité actuelle.
-
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); }); }
Copier après la connexion 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.
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
- 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.
- 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 ?).
- 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.
- 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!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

Dépannage et solutions au logiciel de sécurité de l'entreprise qui fait que certaines applications ne fonctionnent pas correctement. De nombreuses entreprises déploieront des logiciels de sécurité afin d'assurer la sécurité des réseaux internes. ...

Le traitement de la cartographie des champs dans l'amarrage du système rencontre souvent un problème difficile lors de l'exécution d'amarrage du système: comment cartographier efficacement les champs d'interface du système a ...

Lorsque vous utilisez MyBatis-Plus ou d'autres cadres ORM pour les opérations de base de données, il est souvent nécessaire de construire des conditions de requête en fonction du nom d'attribut de la classe d'entité. Si vous manuellement à chaque fois ...

Solutions pour convertir les noms en nombres pour implémenter le tri dans de nombreux scénarios d'applications, les utilisateurs peuvent avoir besoin de trier en groupe, en particulier en un ...

Commencez le printemps à l'aide de la version IntelliJideaultimate ...

Conversion des objets et des tableaux Java: Discussion approfondie des risques et des méthodes correctes de la conversion de type de distribution De nombreux débutants Java rencontreront la conversion d'un objet en un tableau ...

Explication détaillée de la conception des tables SKU et SPU sur les plates-formes de commerce électronique Cet article discutera des problèmes de conception de la base de données de SKU et SPU dans les plateformes de commerce électronique, en particulier comment gérer les ventes définies par l'utilisateur ...

Lorsque vous utilisez TkMyBatis pour les requêtes de base de données, comment obtenir gracieusement les noms de variables de classe d'entité pour créer des conditions de requête est un problème courant. Cet article épinglera ...
