further restructuring of GraphDatabaseService

2011-10-13 23:36:08 +02:00
parent adca8458d2
commit bf995e63d5
9 changed files with 145 additions and 99 deletions
--- a/spring-data-neo4j-aspects/src/test/resources/org/springframework/data/neo4j/aspects/support/Neo4jGraphPersistenceTest-context.xml
+++ b/spring-data-neo4j-aspects/src/test/resources/org/springframework/data/neo4j/aspects/support/Neo4jGraphPersistenceTest-context.xml
@@ -83,18 +83,23 @@
 	</bean>

    <bean id="conversionService" class="org.springframework.data.neo4j.fieldaccess.Neo4jConversionServiceFactoryBean"/>
-    <bean id="graphDatabaseContext" class="org.springframework.data.neo4j.support.GraphDatabaseContext">
+    <bean id="graphDatabaseContext" class="org.springframework.data.neo4j.support.GraphDatabaseContext" init-method="postConstruct">
        <property name="graphDatabaseService" ref="graphDatabaseService"/>
        <property name="conversionService" ref="conversionService"/>
+        <property name="mappingContext" ref="mappingContext"/>
        <property name="entityStateHandler" ref="entityStateHandler"/>
+
        <property name="nodeTypeRepresentationStrategy" ref="nodeTypeRepresentationStrategy"/>
+        <property name="nodeEntityStateFactory" ref="nodeEntityStateFactory"/>
+        <property name="nodeEntityInstantiator" ref="graphEntityInstantiator"/>
+
        <property name="relationshipTypeRepresentationStrategy" ref="relationshipTypeRepresentationStrategy"/>
+        <property name="relationshipEntityStateFactory" ref="relationshipEntityStateFactory"/>
+        <property name="relationshipEntityInstantiator" ref="relationshipEntityInstantiator"/>
+
        <property name="validator">
            <bean class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean"/>
        </property>
-        <property name="mappingContext" ref="mappingContext"/>
-        <property name="relationshipEntityStateFactory" ref="relationshipEntityStateFactory"/>
-        <property name="nodeEntityStateFactory" ref="nodeEntityStateFactory"/>
    </bean>


@@ -133,39 +138,6 @@
        <property name="nodeEntityStateFactory" ref="nodeEntityStateFactory"/>
    </bean-->

-    <bean id="nodeEntityConverter" class="org.springframework.data.neo4j.mapping.Neo4jEntityConverterImpl">
-        <constructor-arg index="0" ref="mappingContext"/>
-        <constructor-arg index="1" ref="conversionService"/>
-        <constructor-arg index="2" ref="graphEntityInstantiator"/>
-        <constructor-arg index="3" ref="entityStateHandler"/>
-        <constructor-arg index="4" ref="nodeTypeMapper"/>
-        <constructor-arg index="5" ref="nodeSourceStateTransmitter"/>
-        <constructor-arg index="6" ref="entityFetchHandler"/>
-    </bean>
-
-    <bean id="entityFetchHandler" class="org.springframework.data.neo4j.mapping.Neo4jEntityFetchHandler">
-        <constructor-arg index="0" ref="entityStateHandler"/>
-        <constructor-arg index="1" ref="conversionService"/>
-        <constructor-arg index="2" ref="nodeSourceStateTransmitter"/>
-        <constructor-arg index="3" ref="relationshipSourceStateTransmitter"/>
-    </bean>
-
-    <bean id="nodeSourceStateTransmitter" class="org.springframework.data.neo4j.mapping.SourceStateTransmitter">
-        <constructor-arg index="0" ref="nodeEntityStateFactory"/>
-    </bean>
-
-    <bean id="relationshipSourceStateTransmitter" class="org.springframework.data.neo4j.mapping.SourceStateTransmitter">
-        <constructor-arg index="0" ref="relationshipEntityStateFactory"/>
-    </bean>
-
-    <bean id="nodeTypeMapper" class="org.springframework.data.convert.DefaultTypeMapper">
-        <constructor-arg index="0">
-            <bean class="org.springframework.data.neo4j.mapping.TRSTypeAliasAccessor">
-                <constructor-arg index="0" ref="nodeTypeRepresentationStrategy"/>
-            </bean>
-        </constructor-arg>
-    </bean>
-
    <bean id="mappingContext" class="org.springframework.data.neo4j.mapping.Neo4jMappingContext"/>

    <bean id="relationshipEntityStateFactory" class="org.springframework.data.neo4j.support.relationship.RelationshipEntityStateFactory">
--- a/spring-data-neo4j-examples/myrestaurants-social/src/test/java/com/springone/myrestaurants/data/UserAccountRelationshipsTest.java
+++ b/spring-data-neo4j-examples/myrestaurants-social/src/test/java/com/springone/myrestaurants/data/UserAccountRelationshipsTest.java
@@ -68,7 +68,6 @@ public class UserAccountRelationshipsTest extends AbstractTestWithUserAccount {

    @Transactional
    @Test
-    @Ignore
    public void testAddRecommendation() {
    	UserAccount user = userAccountRepo.findUserAccount(userId);
    	Restaurant rest = restaurantRepository.findRestaurant(22L);
@@ -84,8 +83,9 @@ public class UserAccountRelationshipsTest extends AbstractTestWithUserAccount {
    	Recommendation r = recommendations.get(0);
    	Assert.assertEquals("recommendation should have correct rating", 3, r.getStars());
    	Assert.assertEquals("recommendation should have correct comment", "Pretty Good", r.getComment());
-    	Assert.assertEquals("recommendation should have correct restaurant id", new Long(22), r.getRestaurant().getId());
-    	Assert.assertEquals("recommendation should have correct restaurant name", "Subway Sandwiches & Salads", r.getRestaurant().getName());
+        final Restaurant restaurant = r.getRestaurant();
+        Assert.assertEquals("recommendation should have correct restaurant id", new Long(22), restaurant.getId());
+    	Assert.assertEquals("recommendation should have correct restaurant name", "Subway Sandwiches & Salads", restaurant.getName());
    }

 }
--- a/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/config/Neo4jConfiguration.java
+++ b/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/config/Neo4jConfiguration.java
@@ -87,11 +87,16 @@ public abstract class Neo4jConfiguration {
        gdc.setGraphDatabaseService(getGraphDatabaseService());
        gdc.setConversionService(conversionService());
        gdc.setMappingContext(mappingContext());
-        gdc.setNodeEntityStateFactory(nodeEntityStateFactory());
-        gdc.setRelationshipEntityStateFactory(relationshipEntityStateFactory());
        gdc.setEntityStateHandler(entityStateHandler());
+
+        gdc.setNodeEntityStateFactory(nodeEntityStateFactory());
        gdc.setNodeTypeRepresentationStrategy(nodeTypeRepresentationStrategy());
+        gdc.setNodeEntityInstantiator(graphEntityInstantiator());
+
+        gdc.setRelationshipEntityStateFactory(relationshipEntityStateFactory());
        gdc.setRelationshipTypeRepresentationStrategy(relationshipTypeRepresentationStrategy());
+        gdc.setRelationshipEntityInstantiator(graphRelationshipInstantiator());
+
        if (validator!=null) {
            gdc.setValidator(validator);
        }
@@ -117,22 +122,23 @@ public abstract class Neo4jConfiguration {
    public EntityStateHandler entityStateHandler() {
        return new EntityStateHandler(mappingContext(),graphDatabaseService);
    }
-    
-    @Bean 
-    public Neo4jEntityConverter<Object,Node> nodeEntityConverter() throws Exception {
-        return new Neo4jEntityConverterImpl<Object, Node>(mappingContext(), conversionService(), graphEntityInstantiator() ,entityStateHandler(),typeMapper(), nodeStateTransmitter(), entityFetchHandler());
-    }

-    private TypeMapper<Node> typeMapper() throws Exception {
+
+    @Bean
+    public TypeMapper<Node> nodeTypeMapper() throws Exception {
        return new DefaultTypeMapper<Node>(new TRSTypeAliasAccessor<Node>(nodeTypeRepresentationStrategy()),asList(new ClassValueTypeInformationMapper()));
    }

+    @Bean
+    public TypeMapper<Relationship> relationshipTypeMapper() throws Exception {
+        return new DefaultTypeMapper<Relationship>(new TRSTypeAliasAccessor<Relationship>(relationshipTypeRepresentationStrategy()),asList(new ClassValueTypeInformationMapper()));
+    }

    @Bean
    public Neo4jEntityFetchHandler entityFetchHandler() throws Exception {
        final SourceStateTransmitter<Node> nodeSourceStateTransmitter = nodeStateTransmitter();
        final SourceStateTransmitter<Relationship> relationshipSourceStateTransmitter = new SourceStateTransmitter<Relationship>(relationshipEntityStateFactory());
-        return new Neo4jEntityFetchHandler(entityStateHandler(), conversionService(), relationshipSourceStateTransmitter, nodeSourceStateTransmitter);
+        return new Neo4jEntityFetchHandler(entityStateHandler(), conversionService(), nodeSourceStateTransmitter, relationshipSourceStateTransmitter);
    }

    @Bean
--- a/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/mapping/Neo4jEntityConverterImpl.java
+++ b/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/mapping/Neo4jEntityConverterImpl.java
@@ -25,6 +25,7 @@ import org.springframework.data.mapping.model.BeanWrapper;
 import org.springframework.data.mapping.model.MappingException;
 import org.springframework.data.neo4j.support.EntityInstantiator;
 import org.springframework.data.neo4j.support.EntityStateHandler;
+import org.springframework.data.neo4j.support.EntityTools;
 import org.springframework.data.neo4j.support.ManagedEntity;
 import org.springframework.data.util.ClassTypeInformation;
 import org.springframework.data.util.TypeInformation;
@@ -43,16 +44,17 @@ public class Neo4jEntityConverterImpl<T,S extends PropertyContainer> implements
    private final TypeMapper<S> typeMapper;
    private final SourceStateTransmitter<S> sourceStateTransmitter;
    private final Neo4jEntityFetchHandler entityFetchHandler;
-    public Neo4jEntityConverterImpl(Neo4jMappingContext mappingContext, ConversionService conversionService, EntityInstantiator<S> entityInstantiator,
-                                    EntityStateHandler entityStateHandler, TypeMapper<S> typeMapper,
-                                    SourceStateTransmitter<S> sourceStateTransmitter, Neo4jEntityFetchHandler entityFetchHandler) {
+
+    public Neo4jEntityConverterImpl(Neo4jMappingContext mappingContext, ConversionService conversionService,
+                                    EntityStateHandler entityStateHandler, Neo4jEntityFetchHandler entityFetchHandler,
+                                    EntityTools<S> entityTools) {
        this.mappingContext = mappingContext;
        this.conversionService = conversionService;
-        this.entityInstantiator = entityInstantiator;
        this.entityStateHandler = entityStateHandler;
-        this.typeMapper = typeMapper;
-        this.sourceStateTransmitter = sourceStateTransmitter;
        this.entityFetchHandler = entityFetchHandler;
+        this.entityInstantiator = new Neo4jEntityPersister.CachedInstantiator<S>(entityTools.getEntityInstantiator());
+        this.typeMapper = entityTools.getTypeMapper();
+        this.sourceStateTransmitter = entityTools.getSourceStateTransmitter();
    }

    @Override
--- a/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/mapping/Neo4jEntityFetchHandler.java
+++ b/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/mapping/Neo4jEntityFetchHandler.java
@@ -36,7 +36,7 @@ public class Neo4jEntityFetchHandler {
    private final EntityStateHandler entityStateHandler;
    private final ConversionService conversionService;

-    public Neo4jEntityFetchHandler(EntityStateHandler entityStateHandler, ConversionService conversionService, SourceStateTransmitter<Relationship> relationshipStateTransmitter, SourceStateTransmitter<Node> nodeStateTransmitter) {
+    public Neo4jEntityFetchHandler(EntityStateHandler entityStateHandler, ConversionService conversionService, SourceStateTransmitter<Node> nodeStateTransmitter, SourceStateTransmitter<Relationship> relationshipStateTransmitter) {
        this.conversionService = conversionService;
        this.entityStateHandler = entityStateHandler;
        this.relationshipStateTransmitter = relationshipStateTransmitter;
--- a/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/mapping/Neo4jEntityPersister.java
+++ b/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/mapping/Neo4jEntityPersister.java
@@ -15,27 +15,19 @@
 */
 package org.springframework.data.neo4j.mapping;

-import org.neo4j.graphdb.GraphDatabaseService;
 import org.neo4j.graphdb.Node;
 import org.neo4j.graphdb.PropertyContainer;
 import org.neo4j.graphdb.Relationship;
 import org.springframework.core.convert.ConversionService;
-import org.springframework.data.convert.DefaultTypeMapper;
-import org.springframework.data.convert.TypeMapper;
 import org.springframework.data.mapping.context.MappingContext;
-import org.springframework.data.neo4j.core.TypeRepresentationStrategy;
 import org.springframework.data.neo4j.support.EntityInstantiator;
 import org.springframework.data.neo4j.support.EntityStateHandler;
+import org.springframework.data.neo4j.support.EntityTools;
 import org.springframework.data.neo4j.support.ManagedEntity;
-import org.springframework.data.neo4j.support.node.EntityStateFactory;
-import org.springframework.data.neo4j.support.node.NodeEntityInstantiator;
-import org.springframework.data.neo4j.support.relationship.RelationshipEntityInstantiator;

 import java.util.HashMap;
 import java.util.Map;

-import static java.util.Arrays.asList;
-
 /**
 * @author mh
 * @since 11.10.11
@@ -46,32 +38,16 @@ public class Neo4jEntityPersister implements Neo4jEntityConverter<Object,Node> {
    private EntityStateHandler entityStateHandler;
    private final Neo4jMappingContext mappingContext;

-
-    public Neo4jEntityPersister(GraphDatabaseService graphDatabaseService, Neo4jMappingContext mappingContext, ConversionService conversionService,
-                                EntityStateFactory<Node> nodeEntityStateFactory, EntityStateFactory<Relationship> relationshipEntityStateFactory,
-                                TypeRepresentationStrategy<Node> nodeTypeRepresentationStrategy, TypeRepresentationStrategy<Relationship> relationshipTypeRepresentationStrategy) {
+    public Neo4jEntityPersister(ConversionService conversionService, EntityTools<Node> nodeEntityTools, EntityTools<Relationship> relationshipEntityTools, Neo4jMappingContext mappingContext, EntityStateHandler entityStateHandler) {
        this.mappingContext = mappingContext;
+        this.entityStateHandler = entityStateHandler;

-        this.entityStateHandler = new EntityStateHandler(mappingContext, graphDatabaseService);
+        Neo4jEntityFetchHandler fetchHandler=new Neo4jEntityFetchHandler(entityStateHandler, conversionService, nodeEntityTools.getSourceStateTransmitter(), relationshipEntityTools.getSourceStateTransmitter());

-        final EntityInstantiator<Node> nodeEntityInstantiator = new CachedInstantiator<Node>(new NodeEntityInstantiator(entityStateHandler));
-        TypeMapper<Node> nodeTypeMapper = new DefaultTypeMapper<Node>(new TRSTypeAliasAccessor<Node>(nodeTypeRepresentationStrategy), asList(new ClassValueTypeInformationMapper()));
-        SourceStateTransmitter<Node> nodeStateTransmitter = new SourceStateTransmitter<Node>(nodeEntityStateFactory);
+        this.nodeConverter = new CachedConverter<Node>(new Neo4jEntityConverterImpl<Object,Node>(mappingContext, conversionService, entityStateHandler, fetchHandler, nodeEntityTools));

-        final EntityInstantiator<Relationship> relationshipEntityInstantiator = new CachedInstantiator<Relationship>(new RelationshipEntityInstantiator(entityStateHandler));
-        TypeMapper<Relationship> relationShipTypeMapper = new DefaultTypeMapper<Relationship>(new TRSTypeAliasAccessor<Relationship>(relationshipTypeRepresentationStrategy), asList(new ClassValueTypeInformationMapper()));
-        SourceStateTransmitter<Relationship> relationshipStateTransmitter = new SourceStateTransmitter<Relationship>(relationshipEntityStateFactory);
+        this.relationshipConverter = new CachedConverter<Relationship>(new Neo4jEntityConverterImpl<Object,Relationship>(mappingContext, conversionService, entityStateHandler, fetchHandler, relationshipEntityTools));

-        Neo4jEntityFetchHandler fetchHandler=new Neo4jEntityFetchHandler(entityStateHandler, conversionService, relationshipStateTransmitter , nodeStateTransmitter);
-
-        this.nodeConverter = new CachedConverter<Node>(
-                new Neo4jEntityConverterImpl<Object,Node>(mappingContext, conversionService, nodeEntityInstantiator,
-                        entityStateHandler, nodeTypeMapper, nodeStateTransmitter, fetchHandler));
-
-        this.relationshipConverter = new CachedConverter<Relationship>(
-                new Neo4jEntityConverterImpl<Object,Relationship>(mappingContext, conversionService,
-                        relationshipEntityInstantiator, entityStateHandler, relationShipTypeMapper,
-                        relationshipStateTransmitter, fetchHandler));
    }

    public <S extends PropertyContainer, T> T createEntityFromStoredType(S state) {
@@ -113,10 +89,10 @@ public class Neo4jEntityPersister implements Neo4jEntityConverter<Object,Node> {
            return cache().objects.containsKey(state);
        }
    }
-    static class CachedInstantiator<S extends PropertyContainer> implements EntityInstantiator<S> {
+    public static class CachedInstantiator<S extends PropertyContainer> implements EntityInstantiator<S> {
        private final EntityInstantiator<S> delegate;

-        CachedInstantiator(EntityInstantiator<S> delegate) {
+        public CachedInstantiator(EntityInstantiator<S> delegate) {
            this.delegate = delegate;
        }

@@ -132,10 +108,10 @@ public class Neo4jEntityPersister implements Neo4jEntityConverter<Object,Node> {
            }
        }
    }
-    static class CachedConverter<S extends PropertyContainer> implements Neo4jEntityConverter<Object,S> {
+    public static class CachedConverter<S extends PropertyContainer> implements Neo4jEntityConverter<Object,S> {
        private final Neo4jEntityConverter<Object,S> delegate;

-        CachedConverter(Neo4jEntityConverter<Object, S> delegate) {
+        public CachedConverter(Neo4jEntityConverter<Object, S> delegate) {
            this.delegate = delegate;
        }

--- a/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/support/EntityTools.java
+++ b/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/support/EntityTools.java
@@ -0,0 +1,67 @@
+/**
+ * Copyright 2011 the original author or authors.
+ *
+ * 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 org.springframework.data.neo4j.support;
+
+import org.neo4j.graphdb.PropertyContainer;
+import org.springframework.data.convert.DefaultTypeMapper;
+import org.springframework.data.convert.TypeMapper;
+import org.springframework.data.neo4j.core.TypeRepresentationStrategy;
+import org.springframework.data.neo4j.mapping.ClassValueTypeInformationMapper;
+import org.springframework.data.neo4j.mapping.SourceStateTransmitter;
+import org.springframework.data.neo4j.mapping.TRSTypeAliasAccessor;
+import org.springframework.data.neo4j.support.node.EntityStateFactory;
+
+import static java.util.Arrays.asList;
+
+/**
+ * @author mh
+ * @since 13.10.11
+ */
+public class EntityTools<S extends PropertyContainer> {
+    private TypeRepresentationStrategy<S> typeRepresentationStrategy;
+    private EntityStateFactory<S> entityStateFactory;
+    private EntityInstantiator<S> entityInstantiator;
+    private SourceStateTransmitter<S> sourceStateTransmitter;
+    private TypeMapper<S> typeMapper;
+
+    public EntityTools(TypeRepresentationStrategy<S> typeRepresentationStrategy, EntityStateFactory<S> entityStateFactory, EntityInstantiator<S> entityInstantiator) {
+        this.typeRepresentationStrategy = typeRepresentationStrategy;
+        this.entityStateFactory = entityStateFactory;
+        this.entityInstantiator = entityInstantiator;
+        this.sourceStateTransmitter = new SourceStateTransmitter<S>(entityStateFactory);
+        this.typeMapper = new DefaultTypeMapper<S>(new TRSTypeAliasAccessor<S>(typeRepresentationStrategy), asList(new ClassValueTypeInformationMapper()));
+    }
+
+    public TypeRepresentationStrategy<S> getTypeRepresentationStrategy() {
+        return typeRepresentationStrategy;
+    }
+
+    public EntityStateFactory<S> getEntityStateFactory() {
+        return entityStateFactory;
+    }
+
+    public EntityInstantiator<S> getEntityInstantiator() {
+        return entityInstantiator;
+    }
+
+    public SourceStateTransmitter<S> getSourceStateTransmitter() {
+        return sourceStateTransmitter;
+    }
+
+    public TypeMapper<S> getTypeMapper() {
+        return typeMapper;
+    }
+}
--- a/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/support/GraphDatabaseContext.java
+++ b/spring-data-neo4j/src/main/java/org/springframework/data/neo4j/support/GraphDatabaseContext.java
@@ -37,7 +37,9 @@ import org.springframework.data.neo4j.mapping.Neo4jEntityPersister;
 import org.springframework.data.neo4j.mapping.Neo4jMappingContext;
 import org.springframework.data.neo4j.mapping.Neo4jPersistentProperty;
 import org.springframework.data.neo4j.support.node.EntityStateFactory;
+import org.springframework.data.neo4j.support.node.NodeEntityInstantiator;
 import org.springframework.data.neo4j.support.query.CypherQueryExecutor;
+import org.springframework.data.neo4j.support.relationship.RelationshipEntityInstantiator;
 import org.springframework.data.util.TypeInformation;

 import javax.annotation.PostConstruct;
@@ -77,6 +79,18 @@ public class GraphDatabaseContext {
    private EntityStateFactory<Relationship> relationshipEntityStateFactory;
    private EntityRemover entityRemover;
    private TypeRepresentationStrategies typeRepresentationStrategies;
+    private EntityInstantiator<Relationship> relationshipEntityInstantiator;
+    private EntityInstantiator<Node> nodeEntityInstantiator;
+    private EntityTools<Node> nodeEntityTools;
+    private EntityTools<Relationship> relationshipEntityTools;
+
+    public void setRelationshipEntityInstantiator(EntityInstantiator<Relationship> relationshipEntityInstantiator) {
+        this.relationshipEntityInstantiator = relationshipEntityInstantiator;
+    }
+
+    public void setNodeEntityInstantiator(EntityInstantiator<Node> nodeEntityInstantiator) {
+        this.nodeEntityInstantiator = nodeEntityInstantiator;
+    }

    static class IndexProvider {
        private IndexManager indexManager;
@@ -270,9 +284,17 @@ public class GraphDatabaseContext {
    public void postConstruct() {
        this.typeRepresentationStrategies = new TypeRepresentationStrategies(mappingContext, nodeTypeRepresentationStrategy, relationshipTypeRepresentationStrategy);
        this.cypherQueryExecutor = new CypherQueryExecutor(this);
-        this.entityPersister = new Neo4jEntityPersister(graphDatabaseService, mappingContext, conversionService,
-                nodeEntityStateFactory, relationshipEntityStateFactory, nodeTypeRepresentationStrategy, relationshipTypeRepresentationStrategy);
-        this.entityRemover = new EntityRemover(entityStateHandler, nodeTypeRepresentationStrategy, relationshipTypeRepresentationStrategy, graphDatabaseService.index());
+        final EntityStateHandler entityStateHandler = new EntityStateHandler(mappingContext, graphDatabaseService);
+        if (nodeEntityInstantiator==null) {
+            nodeEntityInstantiator = new NodeEntityInstantiator(entityStateHandler);
+        }
+        this.nodeEntityTools = new EntityTools<Node>(nodeTypeRepresentationStrategy,nodeEntityStateFactory, nodeEntityInstantiator);
+        if (relationshipEntityInstantiator==null) {
+            relationshipEntityInstantiator = new RelationshipEntityInstantiator(entityStateHandler);
+        }
+        this.relationshipEntityTools = new EntityTools<Relationship>(relationshipTypeRepresentationStrategy, relationshipEntityStateFactory, relationshipEntityInstantiator);
+        this.entityPersister = new Neo4jEntityPersister(conversionService, nodeEntityTools,relationshipEntityTools,mappingContext, entityStateHandler);
+        this.entityRemover = new EntityRemover(this.entityStateHandler, nodeTypeRepresentationStrategy, relationshipTypeRepresentationStrategy, graphDatabaseService.index());
        this.indexProvider = new IndexProvider(graphDatabaseService.index(), mappingContext);
    }

--- a/spring-data-neo4j/src/test/java/org/springframework/data/neo4j/mapping/Neo4jPersistentTestBase.java
+++ b/spring-data-neo4j/src/test/java/org/springframework/data/neo4j/mapping/Neo4jPersistentTestBase.java
@@ -31,6 +31,7 @@ import org.springframework.data.neo4j.fieldaccess.RelationshipDelegatingFieldAcc
 import org.springframework.data.neo4j.model.Group;
 import org.springframework.data.neo4j.model.Person;
 import org.springframework.data.neo4j.support.EntityStateHandler;
+import org.springframework.data.neo4j.support.EntityTools;
 import org.springframework.data.neo4j.support.GraphDatabaseContext;
 import org.springframework.data.neo4j.support.node.NodeEntityInstantiator;
 import org.springframework.data.neo4j.support.node.NodeEntityStateFactory;
@@ -52,12 +53,12 @@ import static java.util.Arrays.asList;
 */
 public class Neo4jPersistentTestBase {
    private Transaction tx;
-    private Neo4jEntityConverterImpl<Object,Node> nodeConverter;
    protected GraphDatabaseContext gdc;
    protected NodeEntityStateFactory nodeEntityStateFactory;
    protected RelationshipEntityStateFactory relationshipEntityStateFactory;
    protected EntityStateHandler entityStateHandler;
    protected NodeEntityInstantiator nodeEntityInstantiator;
+    protected RelationshipEntityInstantiator relationshipEntityInstantiator;
    protected TypeMapper<Node> nodeTypeMapper;
    protected SourceStateTransmitter<Node> nodeStateTransmitter;
    protected SourceStateTransmitter<Relationship> relationshipStateTransmitter;
@@ -97,17 +98,17 @@ public class Neo4jPersistentTestBase {
        entityStateHandler = gdc.getEntityStateHandler();

        nodeEntityInstantiator = new NodeEntityInstantiator(entityStateHandler);
+        relationshipEntityInstantiator = new RelationshipEntityInstantiator(entityStateHandler);
        nodeTypeMapper = new DefaultTypeMapper<Node>(new TRSTypeAliasAccessor<Node>(gdc.getNodeTypeRepresentationStrategy()),asList(new ClassValueTypeInformationMapper()));
        nodeStateTransmitter = new SourceStateTransmitter<Node>(nodeEntityStateFactory);
        relationshipStateTransmitter = new SourceStateTransmitter<Relationship>(relationshipEntityStateFactory);
        conversionService = gdc.getConversionService();
-        fetchHandler = new Neo4jEntityFetchHandler(entityStateHandler, conversionService, relationshipStateTransmitter, nodeStateTransmitter);

-        nodeConverter = new Neo4jEntityConverterImpl<Object,Node>(mappingContext, conversionService, nodeEntityInstantiator, entityStateHandler, nodeTypeMapper, nodeStateTransmitter, fetchHandler);
+        fetchHandler = new Neo4jEntityFetchHandler(entityStateHandler, conversionService, nodeStateTransmitter, relationshipStateTransmitter);
+        final EntityTools<Node> nodeEntityTools = new EntityTools<Node>(gdc.getNodeTypeRepresentationStrategy(), nodeEntityStateFactory, nodeEntityInstantiator);
+        final EntityTools<Relationship> relationshipEntityTools = new EntityTools<Relationship>(gdc.getRelationshipTypeRepresentationStrategy(), relationshipEntityStateFactory, relationshipEntityInstantiator);

-        entityPersister = new Neo4jEntityPersister(gdc.getGraphDatabaseService(), mappingContext, conversionService,
-                nodeEntityStateFactory, relationshipEntityStateFactory,
-                gdc.getNodeTypeRepresentationStrategy(), gdc.getRelationshipTypeRepresentationStrategy());
+        entityPersister = new Neo4jEntityPersister(conversionService, nodeEntityTools, relationshipEntityTools, mappingContext, entityStateHandler);

        group = new Group();
        michael = new Person("Michael", 37);