最近在探索 Mendix 時，我注意到他們有一個 Platform SDK，讓您可以透過 API 與 mendix 應(yīng)用程式模型互動。

這給了我一個想法，探索它是否可以用於創(chuàng)建我們的領(lǐng)域模型。具體來說，是基於現(xiàn)有的傳統(tǒng)應(yīng)用程式創(chuàng)建領(lǐng)域模型。

如果進(jìn)一步推廣，這可用於將任何現(xiàn)有應(yīng)用程式轉(zhuǎn)換為 Mendix 並從那裡繼續(xù)開發(fā)。

將 Java/Spring Web 應(yīng)用程式轉(zhuǎn)換為 Mendix

因此，我創(chuàng)建了一個帶有簡單 API 和資料庫層的小型 Java/Spring Web 應(yīng)用程式。為了簡單起見，它使用嵌入式 H2 資料庫。

在這篇文章中，我們將只轉(zhuǎn)換 JPA 實(shí)體。讓我們來看看它們：

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

如你所見，它們非常簡單：一隻有名字、年齡、顏色的貓和它的人類傀儡，因?yàn)檎缥覀兯埥y(tǒng)治著世界。

它們都有一個自動產(chǎn)生的 ID 欄位。貓與人類有一對一的聯(lián)繫，這樣它就可以隨時稱呼它的人類。 （如果它不是 JPA 實(shí)體，我會放置一個 meow() 方法，但讓我們將其留到將來）。

應(yīng)用程式功能齊全，但現(xiàn)在我們只對資料層感興趣。

提取 json 中的實(shí)體元數(shù)據(jù)

這可以用幾種不同的方式來完成：

1. 透過靜態(tài)分析套件中的實(shí)體。
2. 透過使用反射在運(yùn)行時讀取這些實(shí)體。

我選擇了選項(xiàng) 2，因?yàn)樗?，而且我無法輕鬆找到可以執(zhí)行選項(xiàng) 1 的庫。

接下來，我們需要決定建造後如何公開 json。為了簡單起見，我們只需將其寫入文件即可。一些替代方法可能是：

• 透過 api 公開它。這更加複雜，因?yàn)槟€需要確保端點(diǎn)受到良好的保護(hù)，因?yàn)槲覀儾荒芄_暴露我們的元資料。
• 透過一些管理工具公開它，例如 Spring Boot Actuator 或 jmx。它更安全，但仍然需要時間來設(shè)定。

現(xiàn)在讓我們來看看實(shí)際的程式碼：

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

我們首先尋找應(yīng)用程式中標(biāo)有 JPA 的 @Entity 註解的所有類別。
然後，對於每堂課，我們：

1. 使用entityClass.getDeclaredFields()取得聲明的欄位。
2. 循環(huán)該類別的每個欄位。

對於每個字段，我們：

1. 確定屬性的類型：
   

   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
   

   本質(zhì)上，我們只是透過在 JAVA_TO_MENDIX_TYPE 映射中尋找 java 類型與我們的自訂枚舉值進(jìn)行匹配。

2. 接下來，我們檢查這個屬性是否實(shí)際上是一個關(guān)聯(lián)（指向另一個@Entity）。如果是這樣，我們確定關(guān)聯(lián)的類型：一對一、一對多、多對多：
   

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

   為此，我們只需檢查先前映射的屬性類型。如果它是 Entity，這僅意味著在先前的步驟中我們無法將其對應(yīng)到任何原始 java 類型、String 或 Enum。
   然後我們還需要決定它是什麼類型的關(guān)聯(lián)。檢查很簡單：如果是 List 類型，則它是一對多，否則是一對一（尚未實(shí)現(xiàn)「多對多」）。

3. 然後我們?yōu)檎业降拿總€欄位建立一個 MendixAttribute 物件。

完成後，我們只需為實(shí)體建立一個 MendixEntity 物件並指派屬性清單。
MendixEntity 和 MendixAttribute 是我們稍後將用來對應(yīng) json 的類別：

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

最後，我們儲存一個List；使用 Jackson 轉(zhuǎn)換為 json 檔案。

將實(shí)體匯入 Mendix

有趣的部分來了，我們?nèi)绾巫x取上面產(chǎn)生的 json 檔案並從中建立 mendix 實(shí)體？

Mendix 的 Platform SDK 有一個 Typescript API 可以與之互動。
首先，我們將建立物件來表示我們的實(shí)體和屬性，以及關(guān)聯(lián)和屬性類型的列舉：

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

接下來，我們需要使用 appId 來取得我們的應(yīng)用程序，建立臨時工作副本，打開模型，並找到我們感興趣的領(lǐng)域模型：

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

SDK 實(shí)際上會從 git 中提取我們的 mendix 應(yīng)用程式並進(jìn)行處理。

讀取 json 檔案後，我們將循環(huán)實(shí)體：

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

這裡我們使用domainmodels.Entity.createIn(domainModel);在我們的域模型中建立一個新實(shí)體並為其分配一個名稱。我們可以指派更多屬性，例如文件、索引，甚至實(shí)體在領(lǐng)域模型中呈現(xiàn)的位置。

我們在單獨(dú)的函數(shù)中處理屬性：

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

這裡我們唯一需要付出一些努力的就是將屬性類型對應(yīng)到有效的 mendix 類型。

接下來我們處理關(guān)聯(lián)。首先，由於在我們的Java實(shí)體中關(guān)聯(lián)是透過欄位宣告的，因此我們需要區(qū)分哪些欄位是簡單屬性，哪些欄位是關(guān)聯(lián)。為此，我們只需要檢查它是實(shí)體類型還是原始類型：

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

讓我們建立關(guān)聯(lián)：

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

除了名稱之外，我們還有 4 個重要的屬性需要設(shè)定：

1. 父實(shí)體。這是目前實(shí)體。

2. 子實(shí)體。在最後一步中，我們?yōu)槊總€ java 實(shí)體建立了 mendix 實(shí)體?，F(xiàn)在我們只需要根據(jù)實(shí)體中java欄位的類型找到符合的實(shí)體：
   

   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. 關(guān)聯(lián)型別。如果是一對一的，它會對應(yīng)到一個引用。如果是一對多，則對應(yīng)到參考集。我們現(xiàn)在將跳過多對多。

4. 協(xié)會所有者。一對一和多對多重關(guān)聯(lián)都具有相同的所有者類型：兩者。對於一對一，所有者類型必須為預(yù)設(shè)。

Mendix Platform SDK 將在我們的 mendix 應(yīng)用程式的本機(jī)工作副本中建立實(shí)體?，F(xiàn)在我們只需要告訴它提交更改：

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

幾秒鐘後，您可以在 Mendix Studio Pro 中開啟應(yīng)用程式並驗(yàn)證結(jié)果：

現(xiàn)在你已經(jīng)看到了：貓和人的實(shí)體，它們之間存在一對一的關(guān)聯(lián)。

如果您想親自嘗試或查看完整程式碼，請造訪此儲存庫。

對未來的想法

1. 在這個範(fàn)例中，我使用了 Java/Spring 應(yīng)用程式進(jìn)行轉(zhuǎn)換，因?yàn)槲易罹ㄋ魏螒?yīng)用程式都可以使用。 只需能夠讀取類型資料（靜態(tài)或運(yùn)行時）來提取類別和欄位名稱就足夠了。
2. 我很好奇嘗試讀取一些 Java 邏輯並將其匯出到 Mendix 微流程。我們可能無法真正轉(zhuǎn)換業(yè)務(wù)邏輯本身，但我們應(yīng)該能夠獲得它的結(jié)構(gòu)（至少是業(yè)務(wù)方法簽名？）。
3. 本文中的程式碼可以推廣並製作成一個函式庫：json 格式可以保持不變，並且可以有一個函式庫用於匯出 java 類型，另一個函式庫用於匯入 mendix 實(shí)體。
4. 我們可以使用相同的方法進(jìn)行相反的操作：將 mendix 轉(zhuǎn)換為另一種語言。

結(jié)論

Mendix Platform SDK 是一項(xiàng)強(qiáng)大的功能，允許以程式設(shè)計方式與 mendix 應(yīng)用程式互動。他們列出了一些範(fàn)例用例，例如導(dǎo)入/導(dǎo)出程式碼、分析應(yīng)用程式複雜性。
如果您有興趣，請看一下。
對於本文，您可以在此處找到完整程式碼。

以上是將 JPA 實(shí)體轉(zhuǎn)換為 Mendix的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！