From 15f6325bb9e31d28441fda938f932394316ff27c Mon Sep 17 00:00:00 2001 From: Michael Hunger Date: Wed, 15 Sep 2010 09:17:56 +0200 Subject: [PATCH] cleaned up delegatefieldaccessorfactory --- .../ConvertingNodePropertyFieldAccessor.java | 20 ++++-- .../DelegatingFieldAccessorFactory.java | 67 +++++-------------- .../relationship/Neo4jRelationshipBacking.aj | 39 ++++++++++- 3 files changed, 68 insertions(+), 58 deletions(-) diff --git a/src/main/java/org/springframework/datastore/graph/neo4j/fieldaccess/ConvertingNodePropertyFieldAccessor.java b/src/main/java/org/springframework/datastore/graph/neo4j/fieldaccess/ConvertingNodePropertyFieldAccessor.java index 6aa8e84b6..a2ac9b254 100644 --- a/src/main/java/org/springframework/datastore/graph/neo4j/fieldaccess/ConvertingNodePropertyFieldAccessor.java +++ b/src/main/java/org/springframework/datastore/graph/neo4j/fieldaccess/ConvertingNodePropertyFieldAccessor.java @@ -4,11 +4,10 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Configurable; import org.springframework.core.convert.ConversionService; import org.springframework.datastore.graph.api.NodeBacked; +import org.springframework.datastore.graph.api.RelationshipBacked; import java.lang.reflect.Field; -import static org.springframework.datastore.graph.neo4j.fieldaccess.DoReturn.doReturn; - /** * @author Michael Hunger * @since 12.09.2010 @@ -25,7 +24,7 @@ public class ConvertingNodePropertyFieldAccessor extends NodePropertyFieldAccess @Override public Object setValue(final NodeBacked nodeBacked, final Object newVal) { - super.setValue(nodeBacked,serializePropertyValue(newVal)); + super.setValue(nodeBacked, serializePropertyValue(newVal)); return newVal; } @@ -57,16 +56,23 @@ public class ConvertingNodePropertyFieldAccessor extends NodePropertyFieldAccess } @Override - public FieldAccessor forField(final Field field) { - return new ConvertingNodePropertyFieldAccessor(field,conversionService); + public FieldAccessor forField(final Field field) { + return new ConvertingNodePropertyFieldAccessor(field, conversionService); } private boolean isSerializableField(final Field field) { - return !DelegatingFieldAccessorFactory.isRelationshipField(field) && conversionService.canConvert(field.getType(), String.class); + return isSimpleValueField(field) && conversionService.canConvert(field.getType(), String.class); } private boolean isDeserializableField(final Field field) { - return !DelegatingFieldAccessorFactory.isRelationshipField(field) && conversionService.canConvert(String.class, field.getType()); + return isSimpleValueField(field) && conversionService.canConvert(String.class, field.getType()); + } + + private boolean isSimpleValueField(final Field field) { + final Class type = field.getType(); + if (Iterable.class.isAssignableFrom(type) || NodeBacked.class.isAssignableFrom(type) || RelationshipBacked.class.isAssignableFrom(type)) + return false; + return true; } } } diff --git a/src/main/java/org/springframework/datastore/graph/neo4j/fieldaccess/DelegatingFieldAccessorFactory.java b/src/main/java/org/springframework/datastore/graph/neo4j/fieldaccess/DelegatingFieldAccessorFactory.java index 803201ddd..11a3e2844 100644 --- a/src/main/java/org/springframework/datastore/graph/neo4j/fieldaccess/DelegatingFieldAccessorFactory.java +++ b/src/main/java/org/springframework/datastore/graph/neo4j/fieldaccess/DelegatingFieldAccessorFactory.java @@ -2,7 +2,8 @@ package org.springframework.datastore.graph.neo4j.fieldaccess; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.springframework.datastore.graph.api.*; +import org.springframework.datastore.graph.api.GraphEntity; +import org.springframework.datastore.graph.api.GraphRelationship; import org.springframework.datastore.graph.neo4j.support.GraphDatabaseContext; import java.lang.reflect.Field; @@ -12,7 +13,7 @@ import java.util.Collection; import java.util.List; public class DelegatingFieldAccessorFactory implements FieldAccessorFactory { - private final static Log log= LogFactory.getLog(DelegatingFieldAccessorFactory.class); + private final static Log log = LogFactory.getLog(DelegatingFieldAccessorFactory.class); private final GraphDatabaseContext graphDatabaseContext; public DelegatingFieldAccessorFactory(GraphDatabaseContext graphDatabaseContext) { @@ -21,7 +22,7 @@ public class DelegatingFieldAccessorFactory implements FieldAccessorFactory> fieldAccessorFactories = Arrays.>asList( @@ -34,61 +35,29 @@ public class DelegatingFieldAccessorFactory implements FieldAccessorFactory> fieldAccessorListenerFactories = Arrays.>asList( IndexingNodePropertyFieldAccessorListener.factory() - ); + ); public FieldAccessor forField(Field field) { if (isAspectjField(field)) return null; - for (FieldAccessorFactory fieldAccessorFactory : fieldAccessorFactories) { - if (fieldAccessorFactory.accept(field)) { - if (log.isInfoEnabled()) log.info("Factory " + fieldAccessorFactory + " used for field: " + field); - return fieldAccessorFactory.forField(field); - } - } + for (FieldAccessorFactory fieldAccessorFactory : fieldAccessorFactories) { + if (fieldAccessorFactory.accept(field)) { + if (log.isInfoEnabled()) log.info("Factory " + fieldAccessorFactory + " used for field: " + field); + return fieldAccessorFactory.forField(field); + } + } throw new RuntimeException("No FieldAccessor configured for field: " + field); - //log.warn("No FieldAccessor configured for field: " + field); + //log.warn("No FieldAccessor configured for field: " + field); //return null; - } + } private boolean isAspectjField(Field field) { return field.getName().startsWith("ajc"); } - - public static boolean isRelationshipField(Field f) { - return isSingleRelationshipField(f) - || isOneToNRelationshipField(f) - || isOneToNRelationshipEntityField(f) - || isReadOnlyOneToNRelationshipField(f); - } - - private static boolean isSingleRelationshipField(Field f) { - return NodeBacked.class.isAssignableFrom(f.getType()); - } - - private static boolean isOneToNRelationshipField(Field f) { - if (!Collection.class.isAssignableFrom(f.getType())) return false; - GraphEntityRelationship relAnnotation = f.getAnnotation(GraphEntityRelationship.class); - return relAnnotation != null && NodeBacked.class.isAssignableFrom(relAnnotation.elementClass()) && !relAnnotation.elementClass().equals(NodeBacked.class); - } - - private static boolean isReadOnlyOneToNRelationshipField(Field f) { - GraphEntityRelationship relAnnotation = f.getAnnotation(GraphEntityRelationship.class); - return Iterable.class.equals(f.getType()) - && relAnnotation != null - && !NodeBacked.class.equals(relAnnotation.elementClass()); - } - - private static boolean isOneToNRelationshipEntityField(Field f) { - GraphEntityRelationshipEntity relEntityAnnotation = f.getAnnotation(GraphEntityRelationshipEntity.class); - return Iterable.class.isAssignableFrom(f.getType()) - && relEntityAnnotation != null - && !RelationshipBacked.class.equals(relEntityAnnotation.elementClass()); - } - - public static String getNeo4jPropertyName(Field field) { + public static String getNeo4jPropertyName(Field field) { final Class entityClass = field.getDeclaringClass(); if (useShortNames(entityClass)) return field.getName(); return String.format("%s.%s", entityClass.getSimpleName(), field.getName()); @@ -96,14 +65,14 @@ public class DelegatingFieldAccessorFactory implements FieldAccessorFactory entityClass) { final GraphEntity graphEntity = entityClass.getAnnotation(GraphEntity.class); - if (graphEntity!=null) return graphEntity.useShortNames(); + if (graphEntity != null) return graphEntity.useShortNames(); final GraphRelationship graphRelationship = entityClass.getAnnotation(GraphRelationship.class); - if (graphRelationship!=null) return graphRelationship.useShortNames(); + if (graphRelationship != null) return graphRelationship.useShortNames(); return false; } public List> listenersFor(Field field) { - List> result=new ArrayList>(); + List> result = new ArrayList>(); for (FieldAccessorListenerFactory fieldAccessorListenerFactory : fieldAccessorListenerFactories) { if (fieldAccessorListenerFactory.accept(field)) { final FieldAccessListener listener = (FieldAccessListener) fieldAccessorListenerFactory.forField(field); diff --git a/src/main/java/org/springframework/datastore/graph/neo4j/spi/relationship/Neo4jRelationshipBacking.aj b/src/main/java/org/springframework/datastore/graph/neo4j/spi/relationship/Neo4jRelationshipBacking.aj index 3600addb9..8c5db5ff9 100644 --- a/src/main/java/org/springframework/datastore/graph/neo4j/spi/relationship/Neo4jRelationshipBacking.aj +++ b/src/main/java/org/springframework/datastore/graph/neo4j/spi/relationship/Neo4jRelationshipBacking.aj @@ -16,6 +16,7 @@ import org.springframework.persistence.support.EntityInstantiator; import java.lang.reflect.Field; import java.lang.reflect.Modifier; +import java.util.Collection; public aspect Neo4jRelationshipBacking extends AbstractTypeAnnotatingMixinFields { @@ -158,11 +159,11 @@ public aspect Neo4jRelationshipBacking extends AbstractTypeAnnotatingMixinFields } private boolean isSerializableField(Field field) { - return !DelegatingFieldAccessorFactory.isRelationshipField(field) && graphDatabaseContext.canConvert(field.getType(), String.class); + return !isRelationshipField(field) && graphDatabaseContext.canConvert(field.getType(), String.class); } private boolean isDeserializableField(Field field) { - return !DelegatingFieldAccessorFactory.isRelationshipField(field) && graphDatabaseContext.canConvert(String.class, field.getType()); + return !isRelationshipField(field) && graphDatabaseContext.canConvert(String.class, field.getType()); } private Object serializePropertyValue(Object newVal, Class fieldType) { @@ -179,4 +180,38 @@ public aspect Neo4jRelationshipBacking extends AbstractTypeAnnotatingMixinFields return graphDatabaseContext.convert(value, fieldType); } + + + public static boolean isRelationshipField(Field f) { + return isSingleRelationshipField(f) + || isOneToNRelationshipField(f) + || isOneToNRelationshipEntityField(f) + || isReadOnlyOneToNRelationshipField(f); + } + + private static boolean isSingleRelationshipField(Field f) { + return NodeBacked.class.isAssignableFrom(f.getType()); + } + + private static boolean isOneToNRelationshipField(Field f) { + if (!Collection.class.isAssignableFrom(f.getType())) return false; + GraphEntityRelationship relAnnotation = f.getAnnotation(GraphEntityRelationship.class); + return relAnnotation != null && NodeBacked.class.isAssignableFrom(relAnnotation.elementClass()) && !relAnnotation.elementClass().equals(NodeBacked.class); + } + + private static boolean isReadOnlyOneToNRelationshipField(Field f) { + GraphEntityRelationship relAnnotation = f.getAnnotation(GraphEntityRelationship.class); + return Iterable.class.equals(f.getType()) + && relAnnotation != null + && !NodeBacked.class.equals(relAnnotation.elementClass()); + } + + private static boolean isOneToNRelationshipEntityField(Field f) { + GraphEntityRelationshipEntity relEntityAnnotation = f.getAnnotation(GraphEntityRelationshipEntity.class); + return Iterable.class.isAssignableFrom(f.getType()) + && relEntityAnnotation != null + && !RelationshipBacked.class.equals(relEntityAnnotation.elementClass()); + } + + }