JPA 엔터티를 Mendix로 변환

최근 Mendix를 살펴보던 중 API를 통해 mendix 앱 모델과 상호작용할 수 있는 플랫폼 SDK가 있다는 것을 알게 되었습니다.

이를 통해 도메인 모델을 만드는 데 사용할 수 있는지 알아볼 수 있는 아이디어가 생겼습니다. 특히, 기존의 기존 애플리케이션을 기반으로 도메인 모델을 생성합니다.

더 일반화하면 기존 애플리케이션을 Mendix로 변환하고 거기에서 개발을 계속하는 데 사용할 수 있습니다.

Java/Spring 웹 애플리케이션을 Mendix로 변환

그래서 저는 간단한 API와 데이터베이스 레이어를 갖춘 작은 Java/Spring 웹 애플리케이션을 만들었습니다. 단순화를 위해 내장된 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을 수행할 수 있는 라이브러리를 쉽게 찾을 수 없기 때문에 옵션 2를 선택했습니다.

다음으로, json을 빌드한 후 노출하는 방법을 결정해야 합니다. 간단하게 하기 위해 파일에 작성하겠습니다. 몇 가지 대체 방법은 다음과 같습니다.

• API를 통해 노출합니다. 메타데이터를 공개적으로 노출해서는 안 되기 때문에 엔드포인트가 매우 잘 보호되는지 확인해야 하기 때문에 이는 더 복잡합니다.
• 스프링 부트 액추에이터 또는 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);
    }
    ...
}
</mendixattribute></mendixentity></class>

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

   기본적으로 JAVA_TO_MENDIX_TYPE 맵에서 Java 유형을 검색하여 사용자 정의 열거형 값과 일치시킵니다.

2. 다음으로 이 속성이 실제로 연관(다른 @Entity를 가리킴)인지 확인합니다. 그렇다면 연결 유형을 일대일, 일대다, 다대다로 결정합니다.
   

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

   이를 위해서는 이전에 매핑된 속성 유형을 확인하면 됩니다. 엔터티인 경우 이는 이전 단계에서 이를 기본 Java 유형, 문자열 또는 Enum에 매핑할 수 없다는 의미입니다.
   그렇다면 우리는 그것이 어떤 종류의 연합인지도 결정해야 합니다. 검사는 간단합니다. 목록 유형이면 일대다이고, 그렇지 않으면 일대일입니다(아직 '다대다'를 구현하지 않음).

3. 그런 다음 발견된 각 필드에 대해 MendixAttribute 객체를 생성합니다.

이 작업이 완료되면 속성 목록이 할당된 엔터티에 대한 MendixEntity 개체를 생성하면 됩니다.
MendixEntity 및 MendixAttribute는 나중에 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);
    }
    ...
}
</mendixattribute></mendixentity></class>

마지막으로 List jackson을 사용하여 json 파일로 변환합니다.

Mendix로 엔터티 가져오기

여기서 재미있는 부분이 있습니다. 위에서 생성한 json 파일을 어떻게 읽고 여기에서 mendix 엔터티를 생성합니까?

Mendix의 Platform SDK에는 상호작용할 수 있는 Typescript API가 있습니다.
먼저 엔터티와 속성은 물론 연관 및 속성 유형에 대한 열거형을 나타내는 객체를 만듭니다.

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>

다음으로 appId를 사용하여 앱을 가져오고, 임시 작업 복사본을 만들고, 모델을 열고, 관심 있는 도메인 모델을 찾아야 합니다.

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는 실제로 git에서 mendix 앱을 가져와서 작업합니다.

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

여기에서는 domainmodels.Entity.createIn(domainModel)을 사용합니다. 도메인 모델에 새 엔터티를 만들고 이름을 할당합니다. 문서, 색인, 엔터티가 도메인 모델에서 렌더링될 위치 등 더 많은 속성을 할당할 수 있습니다.

속성을 별도의 함수로 처리합니다.

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

여기서 우리가 노력해야 할 유일한 것은 속성 유형을 유효한 mendix 유형에 매핑하는 것입니다.

다음으로 연결을 처리합니다. 첫째, Java 엔터티 연관은 필드에 의해 선언되었으므로 어떤 필드가 단순 속성이고 어떤 필드가 연관인지 구별해야 합니다. 그렇게 하려면 ENTITY 유형인지 기본 유형인지 확인하면 됩니다.

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

연결을 만들어 보겠습니다.

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개 있습니다.

1. 상위 엔터티. 현재 개체입니다.

2. 하위 엔터티. 마지막 단계에서는 각 Java 엔터티에 대해 Mendix 엔터티를 만들었습니다. 이제 엔터티의 Java 필드 유형을 기반으로 일치하는 엔터티를 찾으면 됩니다.
   

   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. 협회 유형. 일대일인 경우 참조에 매핑됩니다. 일대다인 경우 참조 세트에 매핑됩니다. 지금은 다대다를 건너뛰겠습니다.

4. 협회장입니다. 일대일 연결과 다대다 연결 모두 소유자 유형이 동일합니다(둘 다). 일대일의 경우 소유자 유형이 기본값이어야 합니다.

Mendix 플랫폼 SDK는 mendix 애플리케이션의 로컬 작업 복사본에 엔터티를 생성합니다. 이제 변경 사항을 커밋하라고 지시하기만 하면 됩니다.

@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에서 앱을 열고 결과를 확인할 수 있습니다.

여기에는 고양이와 인간 사이에 일대일 관계가 있는 개체가 있습니다.

직접 실험해 보거나 전체 코드를 보려면 이 저장소를 방문하세요.

미래를 위한 아이디어

1. 이 예에서는 Java/Spring 애플리케이션을 사용하여 변환했습니다. 저는 Java/Spring 애플리케이션에 가장 능숙하지만 어떤 애플리케이션이라도 사용할 수 있습니다. 클래스 및 필드 이름을 추출하기 위해 유형 데이터(정적으로 또는 런타임에)를 읽는 것만으로도 충분합니다.
2. Java 로직을 읽고 Mendix 마이크로플로우로 내보내는 것이 궁금합니다. 비즈니스 로직 자체를 실제로 변환할 수는 없지만 구조는 얻을 수 있어야 합니다(적어도 비즈니스 메소드 서명은?).
3. 이 문서의 코드를 일반화하여 라이브러리로 만들 수 있습니다. json 형식은 동일하게 유지될 수 있으며 Java 유형을 내보내는 라이브러리 하나와 Mendix 엔터티를 가져오는 라이브러리 하나가 있을 수 있습니다.
4. 동일한 접근 방식을 사용하여 반대의 경우도 있습니다. 즉, Mendix를 다른 언어로 변환하는 것입니다.

결론

Mendix 플랫폼 SDK는 Mendix 앱과 프로그래밍 방식으로 상호 작용할 수 있는 강력한 기능입니다. 코드 가져오기/내보내기, 앱 복잡성 분석과 같은 몇 가지 샘플 사용 사례가 나열되어 있습니다.
관심이 있으시면 한번 살펴보세요.
이 기사의 전체 코드는 여기에서 찾을 수 있습니다.

위 내용은 JPA 엔터티를 Mendix로 변환의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!