让spring-data-neo4j使用getter和setter

Question

Hey there fellow Stackoverflower,

I recently tried to use Spring's Spring.Data.Neo4j Connector in conjunction with the Neo4J database. After getting configuration right, I encountered the following problem. When storing my JavaFX-based entity, the JavaFX properties were set to null. This is most likely the case because spring.data.neo4j doesn't seem to use getters and setters, but reflection instead. Since it doesn't know how to persist JavaFX properties, it persists null values and overwrites them when retrieving from the DB.

This is my Entity

@NodeEntity
public class User implements UserIF {
    @GraphId    
    private Long id = null;

    private final StringProperty nameProperty = new SimpleStringProperty();

    public String getName() {
        return nameProperty.get();
    }

    public void setName(String name) {
        nameProperty.set(name);
    }
}

Is it possible to get Spring.data.neo4j to use getters and setters for access, so that I can persist my JavaFX beans? Or am I doing something wrong?

Thanks for helping, Karl

Answer 1

Right now SDN just uses the fields of your entity, something like this would be a configurable change. Feel free to raise an issue on JIRA for implementing it.

Answer 2

The issue could depend on how Spring Data Neo4j maps fields that are references to objects of classes that are not node entities, ie not annotated with @NodeEntity. In this case the referred class must be convertible to String ( see documentation ). I've had a similar issue and I solved it declaring a Spring conversion factory that manages mapping from the referred class to String and back. This is an example mapping every class that extends an Embedded interface (it's void, just to mark the class as embeddable) to String and viceversa:

final class EmbeddedToStringConverterFactory implements ConverterFactory<Embedded, String> {

        @Override
        public <T extends String> Converter<Embedded, T> getConverter(Class<T> type) {
            return new EmbeddedToStringConverter(type);
        }

        private final class EmbeddedToStringConverter<E extends Embedded, S extends String> implements Converter<E, S> {

            private Class<S> stringType;

            public EmbeddedToStringConverter(Class<S> stringType) {
                this.stringType = stringType;
            }

            @Override
            public S convert(E source) {
                if (source != null) {
                    return (S) new Gson().toJson(source);
                } else {
                    return null;
                }
            }
        }
    }

final class StringToEmbeddedConverterFactory implements ConverterFactory<String, Embedded> {

    @Override
    public <T extends Embedded> Converter<String, T> getConverter(Class<T> type) {
        return new StringToEmbeddedConverter(type);
    }

    private final class StringToEmbeddedConverter<S extends String, E extends Embedded> implements Converter<S, E> {

        private Class<E> embeddedType;

        public StringToEmbeddedConverter(Class<E> embeddedType) {
            this.embeddedType = embeddedType;
        }

        @Override
        public E convert(S source) {
            if (source != null) {
                return (E) new Gson().fromJson(source, embeddedType);
            } else {
                return null;
            }
        }
    }
}

The conversion factories should be declared in the Neo4j configuration file as follows:

<bean id="conversionService"
      class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="EmbeddedToStringConverterFactory"/>
            <bean class="StringToEmbeddedConverterFactory"/>
        </list>
    </property>
</bean>

Answer 3

I had the same problem with StringProperty in my bean. The answer from @remigio helped me to find a solution.

So I added the converter factories:

public class StringPropertyToStringConverterFactory
 implements ConverterFactory<StringProperty, String> {

    @Override
    public <T extends String> Converter<StringProperty, T> getConverter(final Class<T> type) {
        return new StringPropertyToStringConverter<>();
    }

    private final class StringPropertyToStringConverter<E extends   StringProperty, S extends String>
    implements Converter<E, S> {
        @Override
        public S convert(final E s) {
            if (s != null) {
                return (S) s.getValue();
            } else {
               return null;
         }
      }
   }
}
public class StringToStringPropertyConverterFactory
 implements ConverterFactory<String, StringProperty> {
    @Override
    public <T extends StringProperty> Converter<String, T> getConverter(final Class<T> type) {
        return new StringToStringPropertyConverter<>();
    }

  private final class StringToStringPropertyConverter<S extends String, E extends StringProperty>
    implements Converter<S, E> {
    @Override
    public E convert(final S s) {
        if (s != null) {
            return (E) new SimpleStringProperty(s);
        } else {
            return null;
        }
     }
  }
}

Then I registered those converter factories in my Neo4jConfiguration:

public class AppConfig extends Neo4jConfiguration {
    public AppConfig() {
        setBasePackage("org.foo.bar");
        addConversionService();
    }

    private void addConversionService() {
         ConversionServiceFactoryBean conversionService = new ConversionServiceFactoryBean();
        conversionService.setConverters(
         newHashSet(new StringPropertyToStringConverterFactory(),
            new StringToStringPropertyConverterFactory()));
        conversionService.afterPropertiesSet();
        setConversionService(conversionService.getObject());
    }
}

What I don't like is that I had to call the method afterPropertiesSet() . Maybe there is a more elegant way. But after all it works and the properties are saved.