Konvertieren von JPA-Entitäten in Mendix

Als ich kürzlich Mendix erkundete, ist mir aufgefallen, dass es ein Plattform-SDK gibt, mit dem Sie über eine API mit dem Mendix-App-Modell interagieren können.

Das brachte mich auf die Idee zu untersuchen, ob es zur Erstellung unseres Domänenmodells verwendet werden kann. Konkret geht es darum, ein Domänenmodell basierend auf einer vorhandenen herkömmlichen Anwendung zu erstellen.

Bei weiterer Verallgemeinerung könnte dies verwendet werden, um jede vorhandene Anwendung in Mendix zu konvertieren und die Entwicklung von dort aus fortzusetzen.

Konvertieren einer Java/Spring-Webanwendung in Mendix

Also habe ich eine kleine Java/Spring-Webanwendung mit einer einfachen API und einer Datenbankschicht erstellt. Der Einfachheit halber wird eine eingebettete H2-Datenbank verwendet.

In diesem Beitrag werden wir nur JPA-Entitäten konvertieren. Werfen wir einen Blick darauf:

@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 ...
}

Wie Sie sehen, sind sie ganz einfach: eine Katze mit einem Namen, einem Alter, einer Farbe und ihrer menschlichen Marionette, denn wie wir wissen, regieren Katzen die Welt.

Beide verfügen über ein automatisch generiertes ID-Feld. Die Katze hat eine Eins-zu-eins-Verbindung mit einem Menschen, sodass sie ihren Menschen jederzeit anrufen kann. (Wenn es keine JPA-Entität wäre, hätte ich eine meow()-Methode eingesetzt, aber das belassen wir für die Zukunft.)

Die App ist voll funktionsfähig, aber im Moment interessiert uns nur die Datenschicht.

Extrahieren von Entitätsmetadaten in JSON

Dies kann auf verschiedene Arten erfolgen:

1. Durch statische Analyse von Entitäten in ihrem Paket.
2. Durch die Verwendung von Reflektion zum Lesen dieser Entitäten zur Laufzeit.

Ich habe mich für Option 2 entschieden, weil es schneller geht und ich nicht einfach eine Bibliothek finden konnte, die Option 1 kann.

Als nächstes müssen wir entscheiden, wie wir JSON verfügbar machen, sobald wir es erstellt haben. Der Einfachheit halber schreiben wir es einfach in eine Datei. Einige alternative Möglichkeiten könnten sein:

• Offenlegung über eine API. Dies ist komplizierter, da Sie auch sicherstellen müssen, dass der Endpunkt sehr gut gesichert ist, da wir unsere Metadaten nicht öffentlich zugänglich machen dürfen.
• Stellen Sie es über ein Verwaltungstool wie Spring Boot Actuator oder JMX bereit. Es ist sicherer, aber die Einrichtung nimmt trotzdem Zeit in Anspruch.

Sehen wir uns nun den eigentlichen Code an:

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);
    }
    ...
}
</mendixattribute></mendixentity></class>

Wir beginnen damit, alle Klassen in unserer App zu finden, die mit der @Entity-Annotation von JPA gekennzeichnet sind.
Dann machen wir für jede Klasse:

1. Rufen Sie die deklarierten Felder mit entityClass.getDeclaredFields() ab.
2. Schleifen Sie jedes Feld dieser Klasse.

Für jedes Feld gilt dann:

1. Bestimmen Sie den Typ des Attributs:
   

   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
   </class>

   Im Wesentlichen gleichen wir einfach den Java-Typ mit unseren benutzerdefinierten Enum-Werten ab, indem wir sie in der JAVA_TO_MENDIX_TYPE-Karte nachschlagen.

2. Als nächstes prüfen wir, ob dieses Attribut tatsächlich eine Assoziation ist (auf eine andere @Entity verweist). Wenn ja, bestimmen wir, um welche Art von Assoziation es sich handelt: eins-zu-eins, eins-zu-viele, viele-zu-viele:
   

   @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 ...
   }
   

   Dazu überprüfen wir einfach den zuvor zugeordneten Attributtyp. Falls es Entity ist, bedeutet das nur, dass wir es im vorherigen Schritt keinem primitiven Java-Typ, String oder Enum zuordnen konnten.
   Dann müssen wir auch entscheiden, um welche Art von Assoziation es sich handelt. Die Prüfung ist einfach: Wenn es sich um einen Listentyp handelt, dann ist es eins-zu-viele, andernfalls eins-zu-eins ('many-to-many' wurde noch nicht implementiert).

3. Wir erstellen dann für jedes gefundene Feld ein MendixAttribute-Objekt.

Sobald dies erledigt ist, erstellen wir einfach ein MendixEntity-Objekt für die Entität mit einer Liste zugewiesener Attribute.
MendixEntity und MendixAttribute sind Klassen, die wir später für die Zuordnung zu JSON verwenden werden:

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);
    }
    ...
}
</mendixattribute></mendixentity></class>

Zuletzt speichern wir eine Liste in eine JSON-Datei mit jackson.

Entitäten in Mendix importieren

Hier kommt der lustige Teil: Wie lesen wir die JSON-Datei, die wir oben generiert haben, und erstellen daraus Mendix-Entitäten?

Das Plattform-SDK von Mendix verfügt über eine Typescript-API für die Interaktion.
Zuerst erstellen wir Objekte zur Darstellung unserer Entitäten und Attribute sowie Aufzählungen für Assoziations- und Attributtypen:

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
</class>

Als nächstes müssen wir unsere App mit einer App-ID abrufen, eine temporäre Arbeitskopie erstellen, das Modell öffnen und das Domänenmodell finden, an dem wir interessiert sind:

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

Das SDK wird tatsächlich unsere Mendix-App aus Git ziehen und daran arbeiten.

Nachdem wir aus der JSON-Datei gelesen haben, werden wir die Entitäten in einer Schleife ausführen:

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
    }
}
</mendixattribute>

Hier verwenden wir domainmodels.Entity.createIn(domainModel); um eine neue Entität in unserem Domänenmodell zu erstellen und ihr einen Namen zuzuweisen. Wir können weitere Eigenschaften zuweisen, wie Dokumentation, Indizes und sogar den Ort, an dem die Entität im Domänenmodell gerendert wird.

Wir verarbeiten die Attribute in einer separaten Funktion:

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

Das Einzige, was wir hier tun müssen, ist, den Attributtyp einem gültigen Mendix-Typ zuzuordnen.

Als nächstes verarbeiten wir die Assoziationen. Da in unseren Java-Entitäten Assoziationen durch ein Feld deklariert wurden, müssen wir erstens unterscheiden, welche Felder einfache Attribute und welche Assoziationen sind. Dazu müssen wir nur prüfen, ob es sich um einen ENTITY-Typ oder einen primitiven Typ handelt:

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

Lassen Sie uns die Assoziationen erstellen:

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

Wir müssen neben dem Namen noch 4 wichtige Eigenschaften festlegen:

1. Die Muttergesellschaft. Dies ist die aktuelle Entität.

2. Die untergeordnete Entität. Im letzten Schritt haben wir Mendix-Entitäten für jede Java-Entität erstellt. Jetzt müssen wir nur noch die passende Entität basierend auf dem Typ des Java-Felds in unserer Entität finden:
   

   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. Verknüpfungstyp. Wenn es eineindeutig ist, wird es einer Referenz zugeordnet. Wenn es eins zu viele ist, wird es einem Referenzsatz zugeordnet. Auf Many-to-Many verzichten wir vorerst.

4. Der Vereinsinhaber. Sowohl Eins-zu-Eins- als auch Viele-zu-Viele-Zuordnungen haben denselben Besitzertyp: Beide. Für 1:1 muss der Besitzertyp „Standard“ sein.

Das Mendix Platform SDK hat die Entitäten in seiner lokalen Arbeitskopie unserer Mendix-Anwendung erstellt. Jetzt müssen wir es nur noch anweisen, die Änderungen zu übernehmen:

@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 ...
}

Nach ein paar Sekunden können Sie die App in Mendix Studio Pro öffnen und die Ergebnisse überprüfen:

Da haben Sie es: eine Katze und ein Mensch mit einer Eins-zu-Eins-Verbindung zwischen ihnen.

Wenn Sie selbst experimentieren oder den vollständigen Code sehen möchten, besuchen Sie dieses Repo.

Ideen für die Zukunft

1. In diesem Beispiel habe ich eine Java/Spring-Anwendung zum Konvertieren verwendet, da ich mich damit am besten auskenne, aber jede Anwendung kann verwendet werden. Es reicht aus, nur Typdaten (statisch oder zur Laufzeit) lesen zu können, um die Klassen- und Feldnamen zu extrahieren.
2. Ich bin neugierig, etwas Java-Logik zu lesen und in Mendix-Mikroflüsse zu exportieren. Wir können die Geschäftslogik selbst wahrscheinlich nicht wirklich konvertieren, aber wir sollten in der Lage sein, ihre Struktur zu ermitteln (zumindest Geschäftsmethodensignaturen?).
3. Der Code aus diesem Artikel könnte verallgemeinert und in eine Bibliothek umgewandelt werden: Das JSON-Format kann gleich bleiben, und es könnte eine Bibliothek zum Exportieren von Java-Typen und eine andere zum Importieren von Mendix-Entitäten geben.
4. Wir könnten den gleichen Ansatz verwenden, um das Gegenteil zu tun: einen Mendix in eine andere Sprache umwandeln.

Abschluss

Das Mendix Platform SDK ist eine leistungsstarke Funktion, die eine programmgesteuerte Interaktion mit der Mendix-App ermöglicht. Sie listen einige Beispielanwendungsfälle auf, wie das Importieren/Exportieren von Code und das Analysieren der App-Komplexität.
Schauen Sie sich diese an, falls Sie interessiert sind.
Den vollständigen Code für diesen Artikel finden Sie hier.

Das obige ist der detaillierte Inhalt vonKonvertieren von JPA-Entitäten in Mendix. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!