Add EAV model implementation including json serialization and deserialization

Benjamin Rühl
1 parent edc95751
Showing 13 changed files with 561 additions and 3 deletions
services/Common/src/main/java/de/bht/beuthbot/dataAccess/GenericDAO.java
services/Common/src/main/java/de/bht/beuthbot/dataAccess/UserDAO.java
services/Global/build.gradle
services/Global/src/main/java/de/bht/beuthbot/daos/AppUserDAO.java
services/Global/src/main/java/de/bht/beuthbot/daos/GenericHibernateDAO.java
services/Global/src/main/java/de/bht/beuthbot/entities/AppUser.java
services/Global/src/main/java/de/bht/beuthbot/entities/GenericEntity.java
services/Global/src/main/java/de/bht/beuthbot/entities/GenericEntityAttribute.java
services/Global/src/main/java/de/bht/beuthbot/entities/GenericEntityAttributeValue.java
services/Global/src/main/java/de/bht/beuthbot/persistence/GenericEntityAccessFacade.java
services/Global/src/main/java/de/bht/beuthbot/persistence/GenericEntityAttributeDeserializer.java
services/Global/src/main/java/de/bht/beuthbot/persistence/GenericEntityDeserializer.java
services/Global/src/main/java/de/bht/beuthbot/persistence/GenericEntityJsonConverter.java
@@ -2,12 +2,14 @@ package de.bht.beuthbot.dataAccess;
 import de.bht.beuthbot.model.entities.Entity;
+import javax.ejb.Remote;
 import java.io.Serializable;
 import java.util.List;
 /**
  * Created by Benjamin Rühl on 19.12.2017.
  */
+@Remote
 public interface GenericDAO<T extends Entity, ID extends Serializable> {
     T findById(ID id);
@@ -9,4 +9,6 @@ import javax.ejb.Remote;
  */
 @Remote
 public interface UserDAO extends GenericDAO<User, Long> {
+
+    User createUser();
 }
@@ -14,6 +14,7 @@ dependencies {
             "commons-io:commons-io:2.5"
     compile group: 'org.postgresql', name: 'postgresql', version: '9.3-1100-jdbc4'
+    compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.0.1'
     providedCompile "org.slf4j:slf4j-api:1.7.25"
@@ -15,4 +15,9 @@ public class AppUserDAO extends GenericHibernateDAO&lt;User, Long&gt; implements UserD
     public AppUserDAO() {
         setEntityClass(AppUser.class);
     }
+
+    @Override
+    public User createUser() {
+        return new AppUser();
+    }
 }
@@ -6,8 +6,12 @@ import org.hibernate.Criteria;
 import org.hibernate.Session;
 import org.hibernate.criterion.Criterion;
+import javax.ejb.Stateless;
+import javax.enterprise.inject.InjectionException;
 import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
 import javax.persistence.PersistenceContext;
+import javax.persistence.PersistenceUnit;
 import java.io.Serializable;
 import java.lang.reflect.ParameterizedType;
 import java.util.List;
@@ -15,16 +19,23 @@ import java.util.List;
 /**
  * Created by Benjamin Rühl on 19.12.2017.
  */
+@Stateless
 public class GenericHibernateDAO<T extends Entity, ID extends Serializable> implements GenericDAO<T, ID> {
     private Class<? extends T> entityClass;
     private Session session;
-    @PersistenceContext
+    @PersistenceUnit(unitName = "PostgreSQLDS")
+    private EntityManagerFactory emf;
+
+    @PersistenceContext(unitName = "PostgreSQLDS")
     private EntityManager em;
     @SuppressWarnings("unchecked cast")
     public GenericHibernateDAO() {
+        if (em == null)
+            throw new RuntimeException("EntityManager must not be null");
+
         entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
         setSession( (Session)em.getDelegate() );
     }
 package de.bht.beuthbot.entities;
+import de.bht.beuthbot.persistence.GenericEntityAccessFacade;
+import de.bht.beuthbot.persistence.GenericEntityJsonConverter;
+import de.bht.beuthbot.persistence.JsonHelper;
+
+import javax.persistence.CascadeType;
 import javax.persistence.Entity;
+import javax.persistence.OneToOne;
 import javax.persistence.Table;
+import java.io.IOException;
+import java.util.List;
+import java.util.stream.Collectors;
 /**
  * Created by Benjamin Rühl on 19.11.2017.
@@ -13,11 +22,20 @@ import javax.persistence.Table;
 public class AppUser extends EntityBase implements de.bht.beuthbot.model.entities.User {
     private String facebookUserId;
+
     private String telegramUserId;
+    @OneToOne(cascade = CascadeType.ALL)
+    private GenericEntity additionalData;
+
     //@Type(type = "JsonMapType")
     //private Map<String, String> additionalData = new HashMap<>();
+    public AppUser() {
+        additionalData = new GenericEntity();
+        additionalData.setName("User");
+    }
+
     @Override
     public String getFacebookUserId() {
         return facebookUserId;
@@ -30,12 +48,12 @@ public class AppUser extends EntityBase implements de.bht.beuthbot.model.entitie
     @Override
     public <T> T getProperty(String propertyName, Class<T> propertyType) {
-        return null;
+        return GenericEntityAccessFacade.getAttribute(additionalData, propertyName, propertyType);
     }
     @Override
     public void setProperty(String propertyName, Object propertyValue) {
-
+        GenericEntityAccessFacade.setAttribute(additionalData, propertyName, propertyValue);
     }
     //@Override
+package de.bht.beuthbot.entities;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ * A generic container entity that holds references to a set of generic attributes which can be specified at runtime.
+ * Follows the Entity-Attribute-Value model of database design.
+ */
+@Entity
+@Table
+public class GenericEntity extends EntityBase {
+
+    /**
+     * name is not mandatory, but can help to identify the entity's purpose for the developer
+     */
+    private String name;
+
+    @OneToMany(cascade = CascadeType.ALL)
+    private List<GenericEntityAttribute> attributes = new ArrayList<>();
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<GenericEntityAttribute> getAttributes() {
+        return attributes;
+    }
+
+    public void setAttribute(GenericEntityAttribute attribute) {
+        List<GenericEntityAttribute> existingAttributesForName = this.attributes.stream().filter(a -> a.getName().equals(attribute.getName())).collect(Collectors.toList());
+
+        if (!existingAttributesForName.isEmpty())
+            getAttributes().removeAll(existingAttributesForName);
+
+        this.attributes.add(attribute);
+    }
+}
+package de.bht.beuthbot.entities;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+import java.util.List;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ * An attribute of a generic entity that can be specified at runtime.
+ * Holds a collection of generic values.
+ */
+@Entity
+@Table
+public class GenericEntityAttribute extends EntityBase {
+
+    private String name;
+
+    @OneToMany(cascade = CascadeType.ALL)
+    private List<GenericEntityAttributeValue> values;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<GenericEntityAttributeValue> getValues() {
+        return values;
+    }
+
+    public void addValue(GenericEntityAttributeValue value) {
+        this.values.add(value);
+    }
+}
+package de.bht.beuthbot.entities;
+
+import javax.persistence.*;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ * The value of a generic attribute in supported data formats.
+ * Supports complex nested types using a reference to a generic sub entity.
+ */
+@Entity
+@Table
+public class GenericEntityAttributeValue extends EntityBase {
+
+    private Boolean valueAsBool;
+
+    private Long valueAsLong;
+
+    private Double valueAsDouble;
+
+    private String valueAsString;
+
+    @OneToOne(cascade = CascadeType.ALL)
+    private GenericEntity valueAsEntity;
+
+    public Boolean getValueAsBool() {
+        return valueAsBool;
+    }
+
+    public void setValueAsBool(boolean valueAsBool) {
+        this.valueAsBool = valueAsBool;
+    }
+
+    public Long getValueAsLong() {
+        return valueAsLong;
+    }
+
+    public void setValueAsLong(long valueAsLong) {
+        this.valueAsLong = valueAsLong;
+    }
+
+    public Double getValueAsDouble() {
+        return valueAsDouble;
+    }
+
+    public void setValueAsDouble(double valueAsDouble) {
+        this.valueAsDouble = valueAsDouble;
+    }
+
+    public String getValueAsString() {
+        return valueAsString;
+    }
+
+    public void setValueAsString(String valueAsString) {
+        this.valueAsString = valueAsString;
+    }
+
+    public GenericEntity getValueAsEntity() {
+        return valueAsEntity;
+    }
+
+    public void setValueAsEntity(GenericEntity valueAsEntity) {
+        this.valueAsEntity = valueAsEntity;
+    }
+}
+package de.bht.beuthbot.persistence;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import de.bht.beuthbot.entities.GenericEntity;
+import de.bht.beuthbot.entities.GenericEntityAttribute;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ * Provides convenience methods for accessing GenericEntity structures
+ */
+public class GenericEntityAccessFacade {
+
+    public static <T> T getAttribute(GenericEntity contextEntity, String attributeName, Class<T> attributeType) {
+        List<GenericEntityAttribute> propertiesWithName = contextEntity.getAttributes().stream().filter(a -> a.getName().equals(attributeName)).limit(1).collect(Collectors.toList());
+
+        if (propertiesWithName == null || propertiesWithName.isEmpty())
+            return null;
+
+        GenericEntityAttribute property = propertiesWithName.get(0);
+
+        try {
+            String propertyAsJson = GenericEntityJsonConverter.toJson(property);
+            return (T) JsonHelper.fromJson(propertyAsJson, attributeType);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public static void setAttribute(GenericEntity contextEntity, String attributeName, Object attributeValue) {
+        String attributeValueAsJson = JsonHelper.toJson(attributeValue, attributeValue.getClass());
+
+        GenericEntityAttribute deserializedGenericAttribute = null;
+
+        try {
+            deserializedGenericAttribute = createGenericEntityAttributeFromJson(attributeValueAsJson);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        if (deserializedGenericAttribute == null)
+            return;
+
+        deserializedGenericAttribute.setName(attributeName);
+
+        contextEntity.setAttribute(deserializedGenericAttribute);
+    }
+
+    private static GenericEntityAttribute createGenericEntityAttributeFromJson(String json) throws IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        SimpleModule module = new SimpleModule();
+        module.addDeserializer(GenericEntity.class, new GenericEntityDeserializer());
+        module.addDeserializer(GenericEntityAttribute.class, new GenericEntityAttributeDeserializer());
+        mapper.registerModule(module);
+
+        return mapper.readValue(json, GenericEntityAttribute.class);
+    }
+}
+package de.bht.beuthbot.persistence;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+import de.bht.beuthbot.entities.GenericEntity;
+import de.bht.beuthbot.entities.GenericEntityAttribute;
+import de.bht.beuthbot.entities.GenericEntityAttributeValue;
+
+import javax.naming.OperationNotSupportedException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ */
+public class GenericEntityAttributeDeserializer extends StdDeserializer<GenericEntityAttribute> {
+
+    public GenericEntityAttributeDeserializer() {
+        this(GenericEntityAttribute.class);
+    }
+
+    public GenericEntityAttributeDeserializer(Class<? extends GenericEntityAttribute> t) {
+        super(t);
+    }
+
+    @Override
+    public GenericEntityAttribute deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
+        if (jp.isClosed())
+            return null;
+
+        GenericEntityAttribute deserializedAttribute = new GenericEntityAttribute();
+
+        JsonToken jsonToken = jp.getCurrentToken();
+
+        if (jsonToken.equals(JsonToken.FIELD_NAME)) {
+            String fieldName = jp.getCurrentName();
+            deserializedAttribute.setName(fieldName);
+
+            jsonToken = jp.nextToken();
+
+            if (jsonToken.equals(JsonToken.START_ARRAY)) {
+                try {
+                    for (GenericEntityAttributeValue attributeValue : readAttributeValuesUntilArrayEndToken(jp, ctxt)) {
+                        deserializedAttribute.addValue(attributeValue);
+                    }
+                } catch (OperationNotSupportedException e) {
+                    e.printStackTrace();
+                }
+            } else {
+                deserializedAttribute.addValue(readAttributeValueFromCurrentToken(jp, ctxt));
+            }
+        }
+
+        return deserializedAttribute;
+    }
+
+    private List<GenericEntityAttributeValue> readAttributeValuesUntilArrayEndToken(JsonParser jp, DeserializationContext ctxt) throws IOException, OperationNotSupportedException {
+        List<GenericEntityAttributeValue> attributes = new ArrayList<>();
+        JsonToken jsonToken = jp.getCurrentToken();
+
+        if (!jsonToken.equals(JsonToken.START_ARRAY))
+            throw new OperationNotSupportedException("Method should not be called if current token is not START_ARRAY");
+
+        while (!jp.isClosed() || jsonToken.equals(JsonToken.END_ARRAY)) {
+            jsonToken = jp.nextToken();
+            attributes.add(readAttributeValueFromCurrentToken(jp, ctxt));
+        }
+
+        return attributes;
+    }
+
+    private GenericEntityAttributeValue readAttributeValueFromCurrentToken(JsonParser jp, DeserializationContext ctxt) throws IOException {
+        GenericEntityAttributeValue attributeValue = new GenericEntityAttributeValue();
+        JsonToken jsonToken = jp.getCurrentToken();
+
+        if (jsonToken.equals(JsonToken.VALUE_FALSE) || jsonToken.equals(JsonToken.VALUE_TRUE)) {
+            attributeValue.setValueAsBool(jp.getBooleanValue());
+        } else if (jsonToken.equals(JsonToken.VALUE_NUMBER_INT)) {
+            attributeValue.setValueAsLong(jp.getLongValue());
+        } else if (jsonToken.equals(JsonToken.VALUE_NUMBER_FLOAT)) {
+            attributeValue.setValueAsDouble(jp.getFloatValue());
+        } else if (jsonToken.equals(JsonToken.VALUE_STRING)) {
+            attributeValue.setValueAsString(jp.getText());
+        } else if (jsonToken.equals(JsonToken.START_OBJECT)) {
+            GenericEntity embeddedEntity = new GenericEntityDeserializer().deserialize(jp, ctxt);
+            attributeValue.setValueAsEntity(embeddedEntity);
+        }
+
+        return attributeValue;
+    }
+}
+package de.bht.beuthbot.persistence;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+import de.bht.beuthbot.entities.GenericEntity;
+import de.bht.beuthbot.entities.GenericEntityAttribute;
+
+import java.io.IOException;
+
+/**
+ * Created by Benjamin Rühl on 23.12.2017.
+ */
+public class GenericEntityDeserializer extends StdDeserializer<GenericEntity> {
+
+    public GenericEntityDeserializer() {
+        this(GenericEntity.class);
+    }
+
+    public GenericEntityDeserializer(Class<? extends GenericEntity> t) {
+        super(t);
+    }
+
+    @Override
+    public GenericEntity deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
+        GenericEntity deserializedEntity = new GenericEntity();
+        GenericEntityAttributeDeserializer attributeDeserializer = new GenericEntityAttributeDeserializer();
+
+        while (!jp.isClosed()) {
+            JsonToken jsonToken = jp.nextToken();
+
+            if (jsonToken.equals(JsonToken.FIELD_NAME)) {
+                GenericEntityAttribute attribute = attributeDeserializer.deserialize(jp, ctxt);
+                deserializedEntity.setAttribute(attribute);
+            }
+        }
+
+        return deserializedEntity;
+    }
+}
 \ No newline at end of file
+package de.bht.beuthbot.persistence;
+
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonGenerator;
+import de.bht.beuthbot.entities.GenericEntity;
+import de.bht.beuthbot.entities.GenericEntityAttribute;
+import de.bht.beuthbot.entities.GenericEntityAttributeValue;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.lang.reflect.Field;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ * Helper class to serialize GenericEntity as if its generic attributes were normal fields
+ */
+public class GenericEntityJsonConverter {
+
+    /**
+     * Serializes a GenericEntity to json as if its generic attributes were normal fields.
+     * Other normal fields are serialized as well.
+     * @param genericEntity the context entity to be serialized with all its sub structure
+     * @return a serialized string in json format
+     * @throws IOException
+     */
+    public static String toJson(GenericEntity genericEntity) throws IOException {
+        JsonFactory jFactory = new JsonFactory();
+        StringWriter writer = new StringWriter();
+        JsonGenerator jsonGenerator = jFactory.createJsonGenerator(writer);
+
+        jsonGenerator.writeStartObject();
+        writeGenericEntityWithoutStart(jsonGenerator, genericEntity);
+
+        jsonGenerator.close();
+        return writer.toString();
+    }
+
+    /**
+     * Serializes a GenericEntityAttribute to json as if it would be a normal field.
+     * @param genericAttribute the context attribute to be serialized with all its sub structure
+     * @return a serialized string in json format
+     * @throws IOException
+     */
+    public static String toJson(GenericEntityAttribute genericAttribute) throws IOException {
+        JsonFactory jFactory = new JsonFactory();
+        StringWriter writer = new StringWriter();
+        JsonGenerator jsonGenerator = jFactory.createJsonGenerator(writer);
+
+        writeGenericAttribute(jsonGenerator, genericAttribute);
+
+        jsonGenerator.close();
+        return writer.toString();
+    }
+
+    /**
+     * Uses a JsonGenerator to append a GenericEntity and its content to json.
+     * Does not open the json object because this part depends on whether the object stands for itself or is the value of a field.
+     * However it does close the object.
+     * @param jsonGenerator the generator used for building the json
+     * @param genericEntity the context entity that is serialized
+     * @throws IOException
+     */
+    private static void writeGenericEntityWithoutStart(JsonGenerator jsonGenerator, GenericEntity genericEntity) throws IOException {
+        writeClassFieldsWithoutGenericEntityHierarchy(jsonGenerator, genericEntity);
+
+        for (GenericEntityAttribute genericAttribute : genericEntity.getAttributes()) {
+            writeGenericAttribute(jsonGenerator, genericAttribute);
+        }
+
+        jsonGenerator.writeEndObject();
+    }
+
+    private static void writeGenericAttribute(JsonGenerator jsonGenerator, GenericEntityAttribute genericAttribute) throws IOException {
+        List<GenericEntityAttributeValue> attributeValues = genericAttribute.getValues();
+
+        if (attributeValues == null || attributeValues.isEmpty()) {
+            jsonGenerator.writeNullField(genericAttribute.getName());
+        } else if (attributeValues.size() == 1) {
+            writeGenericAttributeValue(jsonGenerator, genericAttribute.getValues().get(0), genericAttribute.getName());
+        } else {
+            writeGenericAttributeMultiValue(jsonGenerator, genericAttribute);
+        }
+    }
+
+    private static void writeGenericAttributeMultiValue(JsonGenerator jsonGenerator, GenericEntityAttribute genericAttribute) throws IOException {
+        jsonGenerator.writeArrayFieldStart(genericAttribute.getName());
+
+        for (GenericEntityAttributeValue genericValue : genericAttribute.getValues()) {
+            writeGenericAttributeValueInArray(jsonGenerator, genericValue);
+        }
+
+        jsonGenerator.writeEndArray();
+    }
+
+    private static void writeGenericAttributeValue(JsonGenerator jsonGenerator, GenericEntityAttributeValue genericAttributeValue, String attributeName) throws IOException {
+        if (genericAttributeValue.getValueAsBool() != null) {
+            jsonGenerator.writeBooleanField(attributeName, genericAttributeValue.getValueAsBool());
+        } else if (genericAttributeValue.getValueAsLong() != null) {
+            jsonGenerator.writeNumberField(attributeName, genericAttributeValue.getValueAsLong());
+        } else if (genericAttributeValue.getValueAsDouble() != null) {
+            jsonGenerator.writeNumberField(attributeName, genericAttributeValue.getValueAsDouble());
+        } else if (genericAttributeValue.getValueAsString() != null) {
+            jsonGenerator.writeStringField(attributeName, genericAttributeValue.getValueAsString());
+        } else if (genericAttributeValue.getValueAsEntity() != null) {
+            jsonGenerator.writeObjectFieldStart(attributeName);
+            writeGenericEntityWithoutStart(jsonGenerator, genericAttributeValue.getValueAsEntity());
+        }
+    }
+
+    private static void writeGenericAttributeValueInArray(JsonGenerator jsonGenerator, GenericEntityAttributeValue genericAttributeValue) throws IOException {
+        if (genericAttributeValue.getValueAsBool() != null) {
+            jsonGenerator.writeBoolean(genericAttributeValue.getValueAsBool());
+        } else if (genericAttributeValue.getValueAsLong() != null) {
+            jsonGenerator.writeNumber(genericAttributeValue.getValueAsLong());
+        } else if (genericAttributeValue.getValueAsDouble() != null) {
+            jsonGenerator.writeNumber(genericAttributeValue.getValueAsDouble());
+        } else if (genericAttributeValue.getValueAsString() != null) {
+            jsonGenerator.writeString(genericAttributeValue.getValueAsString());
+        } else if (genericAttributeValue.getValueAsEntity() != null) {
+            jsonGenerator.writeStartObject();
+            writeGenericEntityWithoutStart(jsonGenerator, genericAttributeValue.getValueAsEntity());
+        }
+    }
+
+    /**
+     * Uses a JsonGenerator to append all fields and their values of the targetObject to json.
+     * Ignores fields that have GenericEntity, GenericEntityAttribute or GenericEntityAttributeValue as type or generic list parameter.
+     * @throws IOException
+     */
+    private static void writeClassFieldsWithoutGenericEntityHierarchy(JsonGenerator jsonGenerator, Object targetObject) throws IOException {
+        for (Field field : targetObject.getClass().getFields()) {
+            if (isGenericEntityHierarchyType(field))
+                continue;
+
+            try {
+                jsonGenerator.writeObjectField(field.getName(), field.get(targetObject));
+            } catch (Exception e) {
+                jsonGenerator.writeStringField(field.getName(), e.getClass().getName());
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Determines whether the field's type is GenericEntity, GenericEntityAttribute or GenericEntityAttributeValue
+     * or a list type with one of those types as generic type parameter.
+     */
+    private static boolean isGenericEntityHierarchyType(Field field) {
+        List<Class> typesOfGenericEntityHierarchy = Arrays.asList(GenericEntity.class, GenericEntityAttribute.class, GenericEntityAttributeValue.class);
+
+        // check for list types
+        try {
+            if (Iterable.class.isAssignableFrom(field.getType())) {
+                Type fieldFirstGenericType = ((ParameterizedType)field.getGenericType()).getActualTypeArguments()[0];
+                if (typesOfGenericEntityHierarchy.contains(fieldFirstGenericType.getClass()))
+                    return true;
+            }
+        } catch (Exception e) {
+            // not a list or not generic
+        }
+
+        return typesOfGenericEntityHierarchy.contains(field.getType());
+    }
+}