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

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
   

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

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

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

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!