Pull request #6: Fix/refactor dataformat xml

Merge in EAR/aas-serializer from fix/refactor-dataformat-xml to master

* commit 'efbef75ef68abcef71aaf1d764c17d5facbc9f01':
  Fix AccesControlMixin for xml dataformat
  Add default property order for xml dataformat
  Add xml annotation introspector for default namespace
  Add missing headers
  Remove unnecessary custom reference serializer annotations
  Add ReflectionHelper usage in xml dataformat
  Remove unnecessary custom xml (de)serializers
  Encapsulates xml list (de)serializer
  Refactor XML-Serializer Mixins

Author: Daespen

dataformat-core/src/main/java/io/adminshell/aas/v3/dataformat/core/ReflectionHelper.java

@@ -15,22 +15,24 @@
  */
 package io.adminshell.aas.v3.dataformat.core;
 
-import io.adminshell.aas.v3.model.Constraint;
-import io.adminshell.aas.v3.model.Referable;
-import io.github.classgraph.ClassGraph;
-import io.github.classgraph.ClassInfo;
-import io.github.classgraph.ClassInfoList;
-import io.github.classgraph.ScanResult;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import io.adminshell.aas.v3.model.Constraint;
+import io.adminshell.aas.v3.model.Referable;
+import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ClassInfo;
+import io.github.classgraph.ClassInfoList;
+import io.github.classgraph.ScanResult;
+
 /**
  * Helper class to collect relevant data needed for
  * ReflectionAnnotationIntrospector via reflection.
@@ -49,10 +51,15 @@ public class ReflectionHelper {
      */
     public static final String DEFAULT_IMPLEMENTATION_PACKAGE_NAME = MODEL_PACKAGE_NAME + ".impl";
     /**
-     * Name of package where the mixins are defined. These mixins are
+     * Name of package where the json mixins are defined. These mixins are
      * automatically added to JsonSerializer and JsonDeserializer.
      */
-    public static final String MIXINS_PACKAGE_NAME = ROOT_PACKAGE_NAME + ".dataformat.json.mixins";
+    public static final String JSON_MIXINS_PACKAGE_NAME = ROOT_PACKAGE_NAME + ".dataformat.json.mixins";
+    /**
+     * Name of package where the xml mixins are defined. These mixins are
+     * automatically added to XmlSerializer and XmlDeserializer.
+     */
+    public static final String XML_MIXINS_PACKAGE_NAME = ROOT_PACKAGE_NAME + ".dataformat.xml.mixins";
     /**
      * Suffix that identifies a class as a mixin.
      */
@@ -77,10 +84,15 @@ public class ReflectionHelper {
      */
     public static final Map<Class<?>, Set<Class<?>>> SUBTYPES;
     /**
-     * Expanded list of all mixin classes defined in the MIXINS_PACKAGE_NAME
+     * Expanded list of all mixin classes defined in the JSON_MIXINS_PACKAGE_NAME
      * package together with the corresponding class they should be applied to.
      */
-    public static final Map<Class<?>, Class<?>> MIXINS;
+    public static final Map<Class<?>, Class<?>> JSON_MIXINS;
+    /**
+     * Expanded list of all mixin classes defined in the XML_MIXINS_PACKAGE_NAME
+     * package together with the corresponding class they should be applied to.
+     */
+    public static final Map<Class<?>, Class<?>> XML_MIXINS;
     /**
      * Expanded list of all default implementations in the
      * DEFAULT_IMPLEMENTATION_PACKAGE_NAME package together with the interface
@@ -123,7 +135,7 @@ public Class<? extends T> getImplementationType() {
      *
      * @param type the class to check
      * @return whether the given class is an interface and from within the
-     * MODEL_PACKAGE_NAME package
+     *         MODEL_PACKAGE_NAME package
      */
     public static boolean isModelInterface(Class<?> type) {
         return type.isInterface() && MODEL_PACKAGE_NAME.equals(type.getPackageName());
@@ -155,7 +167,7 @@ public static boolean hasDefaultImplementation(Class<?> interfaceType) {
      *
      * @param type the class to check
      * @return whether the given class is an interface from within the
-     * MODEL_PACKAGE_NAME package as well as a default implementation or not
+     *         MODEL_PACKAGE_NAME package as well as a default implementation or not
      */
     public static boolean isModelInterfaceOrDefaultImplementation(Class<?> type) {
         return isModelInterface(type) || isDefaultImplementation(type);
@@ -167,7 +179,7 @@ public static boolean isModelInterfaceOrDefaultImplementation(Class<?> type) {
      *
      * @param clazz the class to find the type information for
      * @return the type information for the given class or null if there is no
-     * type information or type information should not be included
+     *         type information or type information should not be included
      */
     public static String getModelType(Class<?> clazz) {
         Class<?> type = getMostSpecificTypeWithModelType(clazz);
@@ -193,7 +205,7 @@ public static String getModelType(Class<?> clazz) {
      *
      * @param clazz the class to find the type for
      * @return the most specific supertype of given class that contains some AAS
-     * type information or null if there is none
+     *         type information or null if there is none
      */
     public static Class<?> getMostSpecificTypeWithModelType(Class<?> clazz) {
         return TYPES_WITH_MODEL_TYPE.stream()
@@ -224,7 +236,8 @@ public static Class<?> getMostSpecificTypeWithModelType(Class<?> clazz) {
                 .scan();
         TYPES_WITH_MODEL_TYPE = scanModelTypes(modelScan);
         SUBTYPES = scanSubtypes(modelScan);
-        MIXINS = scanMixins(modelScan);
+        JSON_MIXINS = scanMixins(modelScan, JSON_MIXINS_PACKAGE_NAME);
+        XML_MIXINS = scanMixins(modelScan, XML_MIXINS_PACKAGE_NAME);
         DEFAULT_IMPLEMENTATIONS = scanDefaultImplementations(modelScan);
         ENUMS = modelScan.getAllEnums().loadClasses(Enum.class);
         INTERFACES_WITHOUT_DEFAULT_IMPLEMENTATION = getInterfacesWithoutDefaultImplementation(modelScan);
@@ -247,7 +260,7 @@ private static List<ImplementationInfo> scanDefaultImplementations(ScanResult mo
                 .loadClasses()
                 .stream()
                 .forEach(x -> {
-                    String interfaceName = x.getSimpleName().substring(DEFAULT_IMPLEMENTATION_PREFIX.length());//using conventions
+                    String interfaceName = x.getSimpleName().substring(DEFAULT_IMPLEMENTATION_PREFIX.length());// using conventions
                     ClassInfoList interfaceClassInfos = modelScan.getAllClasses().filter(y -> y.isInterface() && Objects.equals(y.getSimpleName(), interfaceName));
                     if (interfaceClassInfos.isEmpty()) {
                         logger.warn("could not find interface realized by default implementation class '{}'", x.getSimpleName());
@@ -263,10 +276,10 @@ private static List<ImplementationInfo> scanDefaultImplementations(ScanResult mo
         return defaultImplementations;
     }
 
-    private static Map<Class<?>, Class<?>> scanMixins(ScanResult modelScan) {
+    private static Map<Class<?>, Class<?>> scanMixins(ScanResult modelScan, String packageName) {
         ScanResult mixinScan = new ClassGraph()
                 .enableClassInfo()
-                .acceptPackagesNonRecursive(MIXINS_PACKAGE_NAME)
+                .acceptPackagesNonRecursive(packageName)
                 .scan();
         Map<Class<?>, Class<?>> mixins = new HashMap<>();
         mixinScan.getAllClasses()
@@ -290,13 +303,13 @@ private static Map<Class<?>, Class<?>> scanMixins(ScanResult modelScan) {
     private static Map<Class<?>, Set<Class<?>>> scanSubtypes(ScanResult modelScan) {
         return modelScan.getAllInterfaces().stream()
                 .filter(ReflectionHelper::hasSubclass)
-                .collect(Collectors.toMap(x -> x.loadClass(), ReflectionHelper::getSubclasses));
+                .collect(Collectors.toMap(ClassInfo::loadClass, ReflectionHelper::getSubclasses));
     }
 
     private static Set<Class<?>> getSubclasses(ClassInfo clazzInfo) {
         return clazzInfo.getClassesImplementing()
                 .directOnly()
-                .filter(x -> x.isInterface())
+                .filter(ClassInfo::isInterface)
                 .loadClasses()
                 .stream()
                 .collect(Collectors.toSet());

dataformat-json/src/main/java/io/adminshell/aas/v3/dataformat/json/JsonDeserializer.java

@@ -15,6 +15,8 @@
  */
 package io.adminshell.aas.v3.dataformat.json;
 
+import java.util.Map;
+
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.json.JsonMapper;
@@ -29,7 +31,6 @@
 import io.adminshell.aas.v3.dataformat.json.modeltype.ModelTypeProcessor;
 import io.adminshell.aas.v3.model.AssetAdministrationShellEnvironment;
 import io.adminshell.aas.v3.model.EmbeddedDataSpecification;
-import java.util.Map;
 
 /**
  * Class for deserializing/parsing AAS JSON documents.
@@ -55,12 +56,12 @@ protected void buildMapper() {
                 .addModule(buildImplementationModule())
                 .addModule(buildCustomDeserializerModule())
                 .build();
-        ReflectionHelper.MIXINS.entrySet().forEach(x -> mapper.addMixIn(x.getKey(), x.getValue()));
+        ReflectionHelper.JSON_MIXINS.entrySet().forEach(x -> mapper.addMixIn(x.getKey(), x.getValue()));
     }
 
     protected SimpleModule buildCustomDeserializerModule() {
         SimpleModule module = new SimpleModule();
-        customDeserializers.forEach((k, v) -> module.addDeserializer(k, v));
+        customDeserializers.forEach(module::addDeserializer);
         return module;
     }
 

dataformat-json/src/main/java/io/adminshell/aas/v3/dataformat/json/JsonSerializer.java

@@ -48,13 +48,13 @@ protected void buildMapper() {
                 .enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)
                 .serializationInclusion(JsonInclude.Include.NON_NULL)
                 .addModule(buildEnumModule())
-                .addModule(buildCustomDeserializerModule())
+                .addModule(buildCustomSerializerModule())
                 .annotationIntrospector(new ReflectionAnnotationIntrospector())
                 .build();
-        ReflectionHelper.MIXINS.entrySet().forEach(x -> mapper.addMixIn(x.getKey(), x.getValue()));
+        ReflectionHelper.JSON_MIXINS.entrySet().forEach(x -> mapper.addMixIn(x.getKey(), x.getValue()));
     }
 
-    protected SimpleModule buildCustomDeserializerModule() {
+    protected SimpleModule buildCustomSerializerModule() {
         SimpleModule module = new SimpleModule();
         module.addSerializer(EmbeddedDataSpecification.class, new EmbeddedDataSpecificationSerializer());
         return module;

dataformat-xml/src/main/java/io/adminshell/aas/v3/dataformat/xml/XmlDataformatAnnotationIntrospector.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2021 Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e. V.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.adminshell.aas.v3.dataformat.xml;
+
+import com.fasterxml.jackson.databind.introspect.Annotated;
+import com.fasterxml.jackson.databind.introspect.AnnotatedClass;
+import com.fasterxml.jackson.dataformat.xml.JacksonXmlAnnotationIntrospector;
+
+/**
+ * This class helps to dynamically decide how to de-/serialize classes and
+ * properties defined in the AAS model library. It will automatically add a default namespace
+ * to property names and set a default property order for contained elements.
+ */
+public class XmlDataformatAnnotationIntrospector extends JacksonXmlAnnotationIntrospector {
+    private static final long serialVersionUID = 1L;
+
+    protected String myDefaultNamespace = "";
+
+    public XmlDataformatAnnotationIntrospector() {
+        super();
+        myDefaultNamespace = AasXmlNamespaceContext.AAS_URI;
+    }
+
+    @Override
+    public String findNamespace(Annotated ann) {
+        String ns = super.findNamespace(ann);
+        if (ns == null) {
+            return myDefaultNamespace;
+        } else {
+            return ns;
+        }
+    }
+
+    @Override
+    public String[] findSerializationPropertyOrder(AnnotatedClass ac) {
+        String[] order = super.findSerializationPropertyOrder(ac);
+        if (order == null) {
+            order = new String[] {
+                "extensions", "idShort", "displayNames", "category", "descriptions", "administration", "identification", "kind", "semanticId",
+                "qualifiers", "embeddedDataSpecification", "dataSpecifications", "isCaseOf", "security", "derivedFrom", "submodels", "assetInformation", "views", "externalSubjectId", "key", "allowDuplicates", "ordered", "valueId", "value",
+                "max", "min", "type", "valueType", "mimeType", "first", "second", "annotations", "revision", "version", "defaultThumbnail", "globalAssetId", "externalAssetId", "entityType", "statements", "assetKind", "billOfMaterials",
+                "specificAssetIds", "observed", "inoutputVariables", "inputVariables", "outputVariables", "submodelElements", "containedElements"
+            };
+        }
+        return order;
+    }
+}