登录
首页 >  文章 >  java教程

将 JPA 实体转换为 Mendix

来源：dev.to

时间：2025-01-18 13:13:14 341浏览 收藏

“纵有疾风来，人生不言弃”，这句话送给正在学习文章的朋友们，也希望在阅读本文《将 JPA 实体转换为 Mendix》后，能够真的帮助到大家。我也会在后续的文章中，陆续更新文章相关的技术文章，有好的建议欢迎大家在评论留言，非常感谢！

最近在探索 mendix 时，我注意到他们有一个 platform sdk，允许您通过 api 与 mendix 应用程序模型进行交互。

这给了我一个想法，探索它是否可以用于创建我们的领域模型。具体来说，是基于现有的传统应用程序创建领域模型。

如果进一步推广，这可用于将任何现有应用程序转换为 mendix 并从那里继续开发。

将 java/spring web 应用程序转换为 mendix

因此，我创建了一个带有简单 api 和数据库层的小型 java/spring web 应用程序。为了简单起见，它使用嵌入式 h2 数据库。

在这篇文章中，我们将仅转换 jpa 实体。让我们来看看它们：

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

如您所见，它们非常简单：一只有名字、年龄、颜色的猫和它的人类傀儡，因为正如我们所知，猫统治着世界。

它们都有一个自动生成的 id 字段。猫与人类有一对一的联系，这样它就可以随时呼唤人类。 （如果它不是 jpa 实体，我会放置一个 meow() 方法，但让我们将其留到将来）。

应用程序功能齐全，但现在我们只对数据层感兴趣。

提取 json 中的实体元数据

这可以通过几种不同的方式来完成：

  1. 通过静态分析包中的实体。
  2. 通过使用反射在运行时读取这些实体。

我选择了选项 2，因为它更快，而且我无法轻松找到可以执行选项 1 的库。

接下来，我们需要决定构建后如何公开 json。为了简单起见，我们只需将其写入文件即可。一些替代方法可能是：

  • 通过 api 公开它。这更加复杂，因为您还需要确保端点受到很好的保护，因为我们不能公开暴露我们的元数据。
  • 通过一些管理工具公开它，例如 spring boot actuator 或 jmx。它更安全，但仍然需要时间来设置。

现在让我们看看实际的代码：

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

我们首先查找应用程序中标有 jpa 的 @entity 注释的所有类。
然后，对于每堂课，我们：

  1. 使用entityclass.getdeclaredfields()获取声明的字段。
  2. 循环该类的每个字段。

对于每个字段，我们：

  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

    本质上，我们只是通过在 java_to_mendix_type 映射中查找 java 类型与我们的自定义枚举值进行匹配。

  2. 接下来，我们检查这个属性是否实际上是一个关联（指向另一个@entity）。如果是这样，我们确定关联的类型：一对一、一对多、多对多：

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

    为此，我们只需检查之前映射的属性类型。如果它是 entity，这仅意味着在之前的步骤中我们无法将其映射到任何原始 java 类型、string 或 enum。
    然后我们还需要决定它是什么类型的关联。检查很简单：如果是 list 类型，则它是一对多，否则是一对一（尚未实现“多对多”）。

  3. 然后我们为找到的每个字段创建一个 mendixattribute 对象。

完成后，我们只需为实体创建一个 mendixentity 对象并分配属性列表。
mendixentity 和 mendixattribute 是我们稍后将用来映射到 json 的类：

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

最后，我们使用 jackson 将 list<mendixentity> 保存到 json 文件中。

将实体导入 mendix

有趣的部分来了，我们如何读取上面生成的 json 文件并从中创建 mendix 实体？

mendix 的 platform sdk 有一个 typescript api 可以与之交互。
首先，我们将创建对象来表示我们的实体和属性，以及关联和属性类型的枚举：

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

接下来，我们需要使用 appid 获取我们的应用程序，创建临时工作副本，打开模型，并找到我们感兴趣的域模型：

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

sdk 实际上会从 git 中提取我们的 mendix 应用程序并进行处理。

读取 json 文件后，我们将循环实体：

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

这里我们使用domainmodels.entity.createin(domainmodel);在我们的域模型中创建一个新实体并为其分配一个名称。我们可以分配更多属性，例如文档、索引，甚至实体在域模型中呈现的位置。

我们在单独的函数中处理属性：

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

这里我们唯一需要付出一些努力的就是将属性类型映射到有效的 mendix 类型。

接下来我们处理关联。首先，由于在我们的java实体中关联是通过字段声明的，因此我们需要区分哪些字段是简单属性，哪些字段是关联。为此，我们只需要检查它是实体类型还是原始类型：

importedentity.attributes.filter(a => a.type === importedattributetype.entity) ...

让我们创建关联：

const mendixassociation = domainmodels.association.createin(domainmodel);

const mendixchildentity = domainmodel.entities.find(e => e.name === a.entitytype) as domainmodelsentity;
mendixassociation.name = `${mendixparententity?.name}_${mendixchildentity?.name}`;
mendixassociation.parent = mendixparententity;
mendixassociation.child = mendixchildentity;

mendixassociation.type = a.associationtype === importedassociationtype.one_to_one || a.associationtype === importedassociationtype.one_to_many ?
    domainmodels.associationtype.reference : domainmodels.associationtype.referenceset;
mendixassocation.owner = a.associationtype === importedassociationtype.one_to_one ? domainmodelsassociationowner.both : domainmodels.associationowner.default;

除了名称之外，我们还有 4 个重要的属性需要设置：

  1. 父实体。这是当前实体。

  2. 子实体。在最后一步中，我们为每个 java 实体创建了 mendix 实体。现在我们只需要根据实体中java字段的类型找到匹配的实体：

    domainmodel.entities.find(e => e.name === a.entitytype) as domainmodelsentity;

  3. 关联类型。如果是一对一的，它会映射到一个引用。如果是一对多，则映射到参考集。我们现在将跳过多对多。

  4. 协会所有者。一对一和多对多关联都具有相同的所有者类型：两者。对于一对一，所有者类型必须为默认。

mendix platform sdk 将在我们的 mendix 应用程序的本地工作副本中创建实体。现在我们只需要告诉它提交更改：

async function commitChanges(model: IModel, workingCopy: OnlineWorkingCopy, entitiesFile: string) {
    await model.flushChanges();
    await workingCopy.commitToRepository("main", { commitMessage: `Imported DB entities from ${entitiesFile}` });
}

几秒钟后，您可以在 mendix studio pro 中打开应用程序并验证结果：
generated mendix domain model

现在你已经看到了：猫和人的实体，它们之间存在一对一的关联。

如果您想亲自尝试或查看完整代码，请访问此存储库。

对未来的想法

  1. 在这个示例中，我使用了 java/spring 应用程序进行转换，因为我最精通它，但任何应用程序都可以使用。 只需能够读取类型数据（静态或运行时）来提取类和字段名称就足够了。
  2. 我很好奇尝试读取一些 java 逻辑并将其导出到 mendix 微流程。我们可能无法真正转换业务逻辑本身，但我们应该能够获得它的结构（至少是业务方法签名？）。
  3. 本文中的代码可以推广并制作成一个库：json 格式可以保持不变，并且可以有一个库用于导出 java 类型，另一个库用于导入 mendix 实体。
  4. 我们可以使用相同的方法进行相反的操作：将 mendix 转换为另一种语言。

结论

mendix platform sdk 是一项强大的功能，允许以编程方式与 mendix 应用程序进行交互。他们列出了一些示例用例，例如导入/导出代码、分析应用程序复杂性。
如果您有兴趣，请看一下。
对于本文，您可以在此处找到完整代码。

理论要掌握，实操不能落！以上关于《将 JPA 实体转换为 Mendix》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！

声明：本文转载于：dev.to 如有侵犯，请联系study_golang@163.com删除
相关阅读
更多>
最新阅读
更多>
课程推荐
更多>