© 2020 Neo4j, Inc.,

This is the SDN/RX manual version 1.1.1.

It contains excerpts of the shared Spring Data Commons documentation, adapted to contain only supported features and annotation.

Who should read this?

This manual is written for:

  • the enterprise architect investigating Spring integration for Neo4j.

  • the engineer developing Spring Data based applications with Neo4j.

1. Introduction

1.1. Your way through this document

If you already familiar with the core concepts of Spring Data, head straight to Chapter 4. This chapter will walk you through different options of configuring an application to connect to a Neo4j instance and how to model your domain.

In most cases, you will need a domain. Go to Chapter 5 to learn about how to map nodes and relationships to your domain model.

After that, you will need some means to query the domain. Choices are Neo4j repositories, the Neo4j Template or on a lower level, the Neo4j Client. All of them are available in a reactive fashion as well. Apart from the paging mechanism, all the features of standard repositories are available in the reactive variant.

You will find the building blocks in the next chapter.

To learn more about the general concepts of repositories, head over to Chapter 6.

You can of course read on, continuing with the preface and a gentle getting started guide.

2. Preface

2.1. NoSQL and Graph databases

A graph database is a storage engine that is specialized in storing and retrieving vast networks of information. It efficiently stores data as nodes with relationships to other or even the same nodes, thus allowing high-performance retrieval and querying of those structures. Properties can be added to both nodes and relationships. Nodes can be labelled by zero or more labels, relationships are always directed and named.

Graph databases are well suited for storing most kinds of domain models. In almost all domains, there are certain things connected to other things. In most other modeling approaches, the relationships between things are reduced to a single link without identity and attributes. Graph databases allow to keep the rich relationships that originate from the domain equally well-represented in the database without resorting to also modeling the relationships as "things". There is very little "impedance mismatch" when putting real-life domains into a graph database.

2.1.1. Introducing Neo4j

Neo4j is an open source NoSQL graph database. It is a fully transactional database (ACID) that stores data structured as graphs consisting of nodes, connected by relationships. Inspired by the structure of the real world, it allows for high query performance on complex data, while remaining intuitive and simple for the developer.

The starting point for learning about Neo4j is neo4j.com. Here is a list of useful resources:

2.2. Spring and Spring Data

Spring Data uses Spring Framework’s core functionality, such as the IoC container, type conversion system, expression language, JMX integration, and portable DAO exception hierarchy. While it is not necessary to know all the Spring APIs, understanding the concepts behind them is. At a minimum, the idea behind IoC should be familiar.

The Spring Data Neo4j project applies Spring Data concepts to the development of solutions using the Neo4j graph data store. We provide repositories as a high-level abstraction for storing and querying documents as well as templates and clients for generic domain access or generic query execution. All of them are integrated with Spring’s application transactions.

The core functionality of the Neo4j support can be used directly, through either the Neo4jClient or the Neo4jTemplate or the reactive variants thereof. All of them provide integration with Spring’s application level transactions. On a lower level, you can grab the Bolt driver instance, but than you have to manage your own transactions.

To learn more about Spring, you can refer to the comprehensive documentation that explains in detail the Spring Framework. There are a lot of articles, blog entries and books on the matter - take a look at the Spring Framework home page for more information.

2.3. What is Spring Data Neo4j⚡️RX

Spring Data Neo4j⚡RX is the successor to Spring Data Neo4j + Neo4j-OGM. The separate layer of Neo4j-OGM (Neo4j Object Graph Mapper) has been replaced by Spring infrastructure, but the basic concepts of an Object Graph Mapper (OGM) still apply:

An OGM maps nodes and relationships in the graph to objects and references in a domain model. Object instances are mapped to nodes while object references are mapped using relationships, or serialized to properties (e.g. references to a Date). JVM primitives are mapped to node or relationship properties. An OGM abstracts the database and provides a convenient way to persist your domain model in the graph and query it without having to use low level drivers directly. It also provides the flexibility to the developer to supply custom queries where the queries generated by SDN/RX are insufficient.

2.3.1. What’s in the box?

Spring Data Neo4j⚡RX or in short SDN/RX is a next-generation Spring Data module, created and maintained by Neo4j, Inc. in close collaboration with Pivotal’s Spring Data Team.

SDN/RX relies completely on the Neo4j Java Driver, without introducing another "driver" or "transport" layer between the mapping framework and the driver. The Neo4j Java Driver - sometimes dubbed Bolt or the Bolt driver - is used as a protocol much like JDBC is with relational databases.

Noteworthy features that differentiate SDN/RX from Spring Data Neo4j + OGM are

  • Full support for immutable entities and thus full support for Kotlin’s data classes

  • Full support for the reactive programming model in the Spring Framework itself and Spring Data

  • Brand new Neo4j client and reactive client feature, resurrecting the idea of a template over the plain driver, easing database access

SDN/RX is currently developed with Spring Data Neo4j in parallel and will replace it eventually when they are on feature parity in regards of repository support and mapping.

2.3.2. Why should I use SDN/RX in favor of SDN+OGM

SDN/RX has several features not present in SDN+OGM, notably

  • Full support for Springs reactive story, including reactive transaction

  • Full support for Query By Example

  • Full support for fully immutable entities

  • Support for all modifiers and variations of derived finder methods, including spatial queries

2.3.3. Do I need both SDN/RX and Spring Data Neo4j?

No.

They are mutually exclusive and you cannot mix them in one project.

2.3.4. How does SDN/RX relate to Neo4j-OGM?

Neo4j-OGM is an Object Graph Mapping library, which is mainly used by Spring Data Neo4j as its backend for the heavy lifting of mapping nodes and relationships into domain object. SDN/RX does not need and does not support Neo4j-OGM. SDN/RX uses Spring Data’s mapping context exclusively for scanning classes and building the meta model.

While this pins SDN/RX to the Spring eco systems, it has several advantages, among them the smaller footprint in regards of CPU and memory usage and especially, all the features of Springs mapping context.

2.3.5. Does SDN/RX support connections over HTTP to Neo4j?

No.

2.3.6. Does SDN/RX support embedded Neo4j?

Embedded Neo4j has multiple facets to it:

Does SDN/RX provide an embedded instance for your application?

No.

Does SDN/RX interact directly with an embedded instance?

No. An embedded database is usually represented by an instance of org.neo4j.graphdb.GraphDatabaseService and has no Bolt connector out of the box.

SDN/RX can however work very much with Neo4j’s test harness, the test harness is specially meant to be a drop-in replacement for the real database. Support for both Neo4j 3.5 and 4.0 test harness is implemented via the Spring Boot starter for the driver. Have a look at the corresponding module org.neo4j.driver:neo4j-java-driver-test-harness-spring-boot-autoconfigure.

Can I use SDN/RX without Spring Boot?

Yes, see our README. We provide org.neo4j.springframework.data.config.AbstractNeo4jConfig and org.neo4j.springframework.data.config.AbstractReactiveNeo4jConfig for that purpose.

3. Building blocks

SDN/RX consists of compossible building blocks. It builds on top of the Neo4j Java Driver. The instance of the Java driver is provided by our starter. All configuration options of the driver can be configured through the starter in the namespace org.neo4j.driver. The driver bean provides imperative, asynchronous and reactive methods to interact with Neo4j.

You can use all transaction methods the driver provides on that bean such as auto-commit transactions, transaction functions and unmanaged transactions. Be aware that those transactions are not tight to an ongoing Spring transaction.

Integration with Spring Data and Spring’s platform or reactive transaction manager starts at the Neo4j Client. The client is part of SDN/RX and SDN/RX is configured through a separate starter, spring-data-neo4j-rx-spring-boot-starter. The configuration namespace of that starter is org.neo4j.data.

The client is mapping agnostic. It doesn’t know about your domain classes and you are responsible for mapping a result to an object suiting your needs.

The next higher level of abstraction is the Neo4j Template. It is aware of your domain and you can use it to query arbitrary domain objects. The template comes in handy in scenarios with a large number of domain classes or custom queries for which you don’t want to create an additional repository abstraction each.

The highest level of abstraction is a Spring Data repository.

All abstractions of SDN/RX come in both imperative and reactive fashions. It is not recommend to mix both programming styles in the same application. The reactive infrastructure requires a Neo4j 4.0+ database.

sdn rx buildingblocks
Figure 1. SDN/RX building blocks

The template mechanism is similar to the templates of others stores. Find some more information about it in our FAQ. The Neo4j Client as such is unique to SDN/RX. You will find it’s documentation in the appendix.

4. Getting started

We provide a Spring Boot starter for SDN/RX. Please include the starter module via your dependency management and configure the bolt URL to use, for example org.neo4j.driver.uri=bolt://localhost:7687. The starter assumes that the server has disabled authentication. As the SDN/RX starter depends on the starter for the Java Driver, all things regarding configuration said there, apply here as well. For a reference of the available properties, use your IDEs autocompletion in the org.neo4j.driver namespace or look at the dedicated manual.

SDN/RX supports

  • The well known and understood imperative programming model (much like Spring Data JDBC or JPA)

  • Reactive programming based on Reactive Streams, including full support for reactive transactions.

Those are all included in the same binary. The reactive programming model requires a 4.0 Neo4j server on the database side and reactive Spring on the other hand. Have a look at the examples directory for all examples.

4.1. Prepare the database

For this example, we stay within the movie graph, as it comes for free with every Neo4j instance.

If you don’t have a running database but Docker installed, please run:

Listing 1. Start a local Neo4j instance inside Docker.
docker run --publish=7474:7474 --publish=7687:7687 -e 'NEO4J_AUTH=neo4j/secret' neo4j:4.0.4

You know can access http://localhost:7474. The above command sets the password of the server to secret. Note the command ready to run in the prompt (:play movies). Execute it to fill your database with some test data.

4.2. Create a new Spring Boot project

The easiest way to setup a Spring Boot project is start.spring.io (which is integrated in the major IDEs as well, in case you don’t want to use the website).

Select the "Spring Web Starter" to get all the dependencies needed for creating a Spring based web application. The Spring Initializr will take care of creating a valid project structure for you, with all the files and settings in place for the selected build tool.

Don’t choose Spring Data Neo4j here, as it will get you the previous generation of Spring Data Neo4j including OGM and additional abstraction over the driver.

You might want to follow this link for a preconfigured setup.

4.2.1. Using Maven

You can issue a curl request against the Spring Initializer to create a basic Maven project:

Listing 2. Create a basic Maven project with the Spring Initializr
curl https://start.spring.io/starter.tgz \
  -d dependencies=webflux,actuator \
  -d bootVersion=2.3.0.RELEASE \
  -d baseDir=Neo4jSpringBootExample \
  -d name=Neo4j%20SpringBoot%20Example | tar -xzvf -

This will create a new folder Neo4jSpringBootExample. As this starter is not yet on the initializer, you will have to add the following dependency manually to your pom.xml:

Listing 3. Inclusion of the spring-data-neo4j-rx-spring-boot-starter in a Maven project
<dependency>
        <groupId>org.neo4j.springframework.data</groupId>
        <artifactId>spring-data-neo4j-rx-spring-boot-starter</artifactId>
        <version>1.1.1</version>
</dependency>

You would also add the dependency manually in case of an existing project.

4.2.2. Using Gradle

The idea is the same, just generate a Gradle project:

Listing 4. Create a basic Gradle project with the Spring Initializr
curl https://start.spring.io/starter.tgz \
  -d dependencies=webflux,actuator \
  -d type=gradle-project \
  -d bootVersion=2.3.0.RELEASE \
  -d baseDir=Neo4jSpringBootExampleGradle \
  -d name=Neo4j%20SpringBoot%20Example | tar -xzvf -

The dependency for Gradle looks like this and must be added to build.gradle:

Listing 5. Inclusion of the spring-data-neo4j-rx-spring-boot-starter in a Gradle project
dependencies {
    implementation 'org.neo4j.springframework.data:spring-data-neo4j-rx-spring-boot-starter:1.1.1'
}

You would also add the dependency manually in case of an existing project.

4.3. Configure the project

Now open any of those projects in your favorite IDE. Find application.properties and configure your Neo4j credentials:

org.neo4j.driver.uri=bolt://localhost:7687
org.neo4j.driver.authentication.username=neo4j
org.neo4j.driver.authentication.password=secret

This is the bare minimum of what you need to connect to a Neo4j instance.

It is not necessary to add any programmatically configuration of the driver when you use this starter. SDN/RX repositories will be automatically enabled by this starter.

4.4. Create your domain

Our domain layer should accomplish two things:

  • Map your graph to objects

  • Provide access to those

4.4.1. Example Node-Entity

SDN/RX fully supports unmodifiable entities, for both Java and data classes in Kotlin. Therefor we will focus on immutable entities here, Listing 6 shows a such an entity.

SDN/RX supports all data types the Neo4j Java Driver supports, see Map Neo4j types to native language types inside the chapter "The Cypher type system". Future versions will support additional converters.
Listing 6. MovieEntity.java
import static org.neo4j.springframework.data.core.schema.Relationship.Direction.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.neo4j.springframework.data.core.schema.Id;
import org.neo4j.springframework.data.core.schema.Node;
import org.neo4j.springframework.data.core.schema.Property;
import org.neo4j.springframework.data.core.schema.Relationship;

@Node("Movie") (1)
public class MovieEntity {

        @Id  (2)
        private final String title;

        @Property("tagline")  (3)
        private final String description;

        @Relationship(type = "ACTED_IN", direction = INCOMING) (4)
        private Map<PersonEntity, Roles> actorsAndRoles = new HashMap<>();

        @Relationship(type = "DIRECTED", direction = INCOMING)
        private List<PersonEntity> directors = new ArrayList<>();

        public MovieEntity(String title, String description) { (5)
                this.title = title;
                this.description = description;
        }

        // Getters omitted for brevity
}
1 @Node is used to mark this class as a managed entity. It also is used to configure the Neo4j label. The label defaults to the name of the class, if you’re just using plain @Node.
2 Each entity has to have an id. The movie class shown here uses the attribute title as a unique business key. If you don’t have such a unique key, you can use the combination of @Id and @GeneratedValue to configure SDN/RX to use Neo4j’s internal id. We also provide generators for UUIDs.
3 This shows @Property as a way to use a different name for the field than for the graph property.
4 This defines a relationship to a class of type PersonEntity and the relationship type ACTED_IN
5 This is the constructor to be used by your application code.

As a general remark: Immutable entities using internally generated ids are a bit contradictory, as SDN/RX needs a way to set the field with the value generated by the database.

If you don’t find a good business key or don’t want to use a generator for IDs, here’s the same entity using the internally generated id together with a businesses constructor and a so called wither-Method, that is used by SDN/RX:

Listing 7. MovieEntity.java
import org.neo4j.springframework.data.core.schema.GeneratedValue;
import org.neo4j.springframework.data.core.schema.Id;
import org.neo4j.springframework.data.core.schema.Node;
import org.neo4j.springframework.data.core.schema.Property;

import org.springframework.data.annotation.PersistenceConstructor;

@Node("Movie")
public class MovieEntity {

        @Id @GeneratedValue
        private Long id;

        private final String title;

        @Property("tagline")
        private final String description;

        public MovieEntity(String title, String description) { (1)
                this.id = null;
                this.title = title;
                this.description = description;
        }

        public MovieEntity withId(Long id) { (2)
                if (this.id.equals(id)) {
                        return this;
                } else {
                        MovieEntity newObject = new MovieEntity(this.title, this.description);
                        newObject.id = id;
                        return newObject;
                }
        }
}
1 This is the constructor to be used by your application code. It sets the id to null, as the field containing the internal id should never be manipulated.
2 This is a so-called wither for the id-attribute. It creates a new entity and sets the field accordingly, without modifying the original entity, thus making it immutable.

You can of course use SDN/RX with Kotlin and model your domain with Kotlin’s data classes. Project Lombok is an alternative if you want or need to stay purely within Java.

4.4.2. Declaring Spring Data repositories

You basically have two options here: You can work store agnostic with SDN/RX and make your domain specific extends one of

  • org.springframework.data.repository.Repository

  • org.springframework.data.repository.CrudRepository

  • org.springframework.data.repository.reactive.ReactiveCrudRepository

  • org.springframework.data.repository.reactive.ReactiveSortingRepository

Choose imperative and reactive accordingly.

While technically not prohibited, it is not recommended to mix imperative and reactive database access in the same application. We won’t support you with scenarios like this.

The other option is to settle on a store specific implementation and gain all the methods we support out of the box. The advantage of this approach is also it’s biggest disadvantage: Once out, all those methods will be part of your API. Most of the time it’s harder to take something away, than to add stuff afterwards. Furthermore, using store specifics leaks your store into your domain. From a performance point of view, there is no penalty.

A repository fitting to any of the movie entities above looks like this:

Listing 8. MovieRepository.java
import reactor.core.publisher.Mono;

import org.neo4j.springframework.data.repository.ReactiveNeo4jRepository;

public interface MovieRepository extends ReactiveNeo4jRepository<MovieEntity, String> {

        Mono<MovieEntity> findOneByTitle(String title);
}

This repository can be used in any Spring component like this:

Listing 9. MovieController.java
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import org.neo4j.springframework.data.examples.spring_boot.domain.MovieEntity;
import org.neo4j.springframework.data.examples.spring_boot.domain.MovieRepository;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/movies")
public class MovieController {

        private final MovieRepository movieRepository;

        public MovieController(MovieRepository movieRepository) {
                this.movieRepository = movieRepository;
        }

        @PutMapping
        Mono<MovieEntity> createOrUpdateMovie(@RequestBody MovieEntity newMovie) {
                return movieRepository.save(newMovie);
        }

        @GetMapping(value = { "", "/" }, produces = MediaType.TEXT_EVENT_STREAM_VALUE)
        Flux<MovieEntity> getMovies() {
                return movieRepository
                        .findAll();
        }

        @GetMapping("/by-title")
        Mono<MovieEntity> byTitle(@RequestParam String title) {
                return movieRepository.findOneByTitle(title);
        }

        @DeleteMapping("/{id}")
        Mono<Void> delete(@PathVariable String id) {
                return movieRepository.deleteById(id);
        }
}
Testing reactive code is done with a reactor.test.StepVerifier. Have a look at the corresponding documentation of Project Reactor or see our example code.

5. Object Mapping

The following sections will explain the process of mapping between your graph and your domain. It is split into two parts. The first part explains the actual mapping and the available tools for you to describe how to map nodes, relationships and properties to objects. The second part will have a look at Spring Data’s object mapping fundamentals. It gives valuable tips on general mapping, why you should prefer immutable domain objects and how you can model them with Java or Kotlin.

5.1. Metadata-based Mapping

To take full advantage of the object mapping functionality inside SDN/RX, you should annotate your mapped objects with the @Node annotation. Although it is not necessary for the mapping framework to have this annotation (your POJOs are mapped correctly, even without any annotations), it lets the classpath scanner find and pre-process your domain objects to extract the necessary metadata. If you do not use this annotation, your application takes a slight performance hit the first time you store a domain object, because the mapping framework needs to build up its internal metadata model so that it knows about the properties of your domain object and how to persist them.

5.1.1. Mapping Annotation Overview

From SDN/RX:
  • @Node: Applied at the class level to indicate this class is a candidate for mapping to the database.

  • @Id: Applied at the field level to mark the field used for identity purpose.

  • @GeneratedValue: Applied at the field level together with @Id to specify how unique identifiers should be generated.

  • @Property: Applied at the field level to modify the mapping from attributes to properties.

  • @Relationship: Applied at the field level to specify the details of a relationship.

  • @DynamicLabels: Applied at the field level to specify the source of dynamic labels.

From Spring Data commons
  • @org.springframework.data.annotation.Id same as @Id from SDN/RX, in fact, @Id is annotated with Spring Data Common’s Id-annotation.

  • @CreatedBy: Applied at the field level to indicate the creator of a node.

  • @CreatedDate: Applied at the field level to indicate the creation date of a node.

  • @LastModifiedBy: Applied at the field level to indicate the author of the last change to a node.

  • @LastModifiedDate: Applied at the field level to indicate the last modification date of a node.

  • @PersistenceConstructor: Applied at one constructor to mark it as a the preferred constructor when reading entities.

  • @Persistent: Applied at the class level to indicate this class is a candidate for mapping to the database.

  • @Version: Applied at field level is used for optimistic locking and checked for modification on save operations. The initial value is zero which is bumped automatically on every update.

Have a look at Chapter 9 for all annotations regarding auditing support.

5.1.2. The basic building block: @Node

The @Node annotation is used to mark a class as a managed domain class, subject to the classpath scanning by the mapping context.

To map an Object to nodes in the graph and vice versa, we need a label to identify the class to map to and from.

@Node has an attribute labels that allows you to configure one or more labels to be used when reading and writing instances of the annotated class. The value attribute is an alias for labels. If you don’t specify a label, than the simple class name will be used as the primary label. In case you want to provide multiple labels, you could either:

  1. Supply an array to the labels property. The first element in the array will considered as the primary label.

  2. Supply a value for primaryLabel and put the additional labels in labels.

The primary label should always be the most concrete label that reflects your domain class.

For each instance of an annotated class that is written through a repository or through the Neo4j template, one node in the graph with at least the primary label will be written. Vice versa, all nodes with the primary label will be mapped to the instances of the annotated class.

The @Node annotation is not inherited from super-types and interfaces. You can however annotate your domain classes individually at every inheritance level. This allows polymorphic queries: You can pass in base or intermediate classes and retrieve the correct, concrete instance for your nodes. This is only supported for abstract bases annotated with @Node. The labels defined on such a class will be used as additional labels together with the labels of the concrete implementations.

Dynamic or "runtime" managed labels

All labels implicitly defined through the simple class name or explicitly via the @Node annotation are static. They cannot be changed during runtime. If you need additional labels that can be manipulated during runtime, you can use @DynamicLabels. @DynamicLabels is an annotation on field level and marks an attribute of type java.util.Collection<String> (a List or Set) for example) as source of dynamic labels.

If this annotation is present, all labels present on a node and not statically mapped via @Node and the class names, will be collected into that collection during load. During writes, all labels of the node will be replaced with the statically defined labels plus the contents of the collection.

If you have other applications add additional labels to nodes, don’t use @DynamicLabels. If @DynamicLabels is present on a managed entity, the resulting set of labels will be "the truth" written to the database.

5.1.3. Identifying instances: @Id

While @Node creates a mapping between a class and nodes having a specific label, we also need to make the connection between individual instances of that class (objects) and instances of the node.

This is where @Id comes into play. @Id marks an attribute of the class to be the unique identifier of the object. That unique identifier is in an optimal world a unique business key or in other words, a natural key. @Id can be used on all attributes with a supported simple type.

Natural keys are however pretty hard to find. Peoples names for example are seldom unique, change over time or worse, not everyone has a first and last name.

We therefore support two different kind of surrogate keys.

On an attribute of type long or Long, @Id can be used with @GeneratedValue. This maps the Neo4j internal id, which is not a property on a node or relationship and usually not visible, to the attribute and allows SDN/RX to retrieve individual instances of the class.

@GeneratedValue provides the attribute generatorClass. generatorClass can be used to specify a class implementing IdGenerator. An IdGenerator is a functional interface and its generateId takes the primary label and the instance to generate an Id for. We support UUIDStringGenerator as one implementation out of the box.

You can also specify a Spring Bean from the application context on @GeneratedValue via generatorRef. That bean also needs to implement IdGenerator, but can make use of everything in the context, including the Neo4j client or template to interact with the database.

Don’t skip the important notes about ID handling in Section 5.2

5.1.4. Mapping properties: @Property

All attributes of a @Node-annotated class will be persisted as properties of Neo4j nodes and relationships. Without further configuration, the name of the attribute in the Java or Kotlin class will be used as Neo4j property.

If you are working with an existing Neo4j schema or just like to adapt the mapping to your needs, you will need to use @Property. The name is used to specify the name of the property inside the database.

5.1.5. Connecting nodes: @Relationship

The @Relationship annotation can be used on all attributes that are not a simple type. It is applicable on attributes of other types annotated with @Node or collections and maps thereof.

The type or the value attribute allow configuration of the relationship’s type, direction allows specifying the direction. The default direction in SDN/RX is Relationship.Direction#OUTGOING.

We support dynamic relationships. Dynamic relationships are represented as a Map<String, AnnotatedDomainClass>. In such a case, the type of the relationship to the other domain class is given by the maps key and must not be configured through the @Relationship.

Map relationship properties

Neo4j supports defining properties not only on nodes but also on relationships. To express those properties in the model SDN/RX provides @RelationshipProperties to be applied on a simple Java class.

In the entity class the relationship can be modelled as before but its type has to be a Map with the related node as the key and the relation property class as value.

A relationship property class and its usage may look like this:

Listing 10. Relationship properties Roles
@RelationshipProperties
public class Roles {

        private final List<String> roles;

        public Roles(List<String> roles) {
                this.roles = roles;
        }

        public List<String> getRoles() {
                return roles;
        }
}
Listing 11. Defining relationship properties for an entity
private Map<PersonEntity, Roles> actorsAndRoles = new HashMap<>();
Relationship query limit

In general there is no limitation of relationships / hops for creating the queries. SDN/RX parses the whole reachable graph from your modelled nodes. It is possible to have self-referencing entities and self-referencing concrete instances.

If these entities or instances for a cycle we have a strict limit of 2 repetitions of walking the same path through the graph. E.g. You model a social network of (:Person)-[:HAS_FRIEND]→(:Person)-[:HAS_FRIEND]…​ you will only get the friends of the second degree. If you need a more specific mapping for your domain we advise you to use custom queries.

5.1.6. A complete example

Putting all those together, we can create a simple domain. We use movies and people with different roles:

Example 1. The MovieEntity
import static org.neo4j.springframework.data.core.schema.Relationship.Direction.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.neo4j.springframework.data.core.schema.Id;
import org.neo4j.springframework.data.core.schema.Node;
import org.neo4j.springframework.data.core.schema.Property;
import org.neo4j.springframework.data.core.schema.Relationship;

@Node("Movie") (1)
public class MovieEntity {

        @Id  (2)
        private final String title;

        @Property("tagline")  (3)
        private final String description;

        @Relationship(type = "ACTED_IN", direction = INCOMING) (4)
        private Map<PersonEntity, Roles> actorsAndRoles = new HashMap<>();

        @Relationship(type = "DIRECTED", direction = INCOMING)
        private List<PersonEntity> directors = new ArrayList<>();

        public MovieEntity(String title, String description) { (5)
                this.title = title;
                this.description = description;
        }

        // Getters omitted for brevity
}
1 @Node is used to mark this class as a managed entity. It also is used to configure the Neo4j label. The label defaults to the name of the class, if you’re just using plain @Node.
2 Each entity has to have an id. We use the movie’s name as unique identifier.
3 This shows @Property as a way to use a different name for the field than for the graph property.
4 This configures an incoming relationship to a person.
5 This is the constructor to be used by your application code as well as by SDN/RX.

People are mapped in two roles here, actors and directors. The domain class is the same:

Example 2. The PersonEntity
import org.neo4j.springframework.data.core.schema.Id;
import org.neo4j.springframework.data.core.schema.Node;

@Node("Person")
public class PersonEntity {

        @Id
        private final String name;

        private final Integer born;

        public PersonEntity(Integer born, String name) {
                this.born = born;
                this.name = name;
        }

        public Integer getBorn() {
                return born;
        }

        public String getName() {
                return name;
        }

}
We haven’t modelled the relationship between movies and people in both direction. Why is that? We see the MovieEntity as the aggregate root, owning the relationships. On the other hand, we want to be able to pull all people from the database without selecting all the movies associated with them. Please consider your applications use case before you try to map every relationship in your database in every direction. While you can do this, you may end up rebuilding a graph database inside your object graph and this is not the intention of a mapping framework.

5.2. Handling and provisioning of unique IDs

5.2.1. Using the internal Neo4j id

The easiest way to give your domain classes an unique identifier is the combination of @Id and @GeneratedValue on a field of type Long (preferable the object, not the scalar long, as literal null is the better indicator whether an instance is new or not):

Example 3. Mutable MovieEntity with internal Neo4j id
@Node("Movie")
public class MovieEntity {

        @Id @GeneratedValue
        private Long id;

        private String name;

        public MovieEntity(String name) {
                this.name = name;
        }
}

You don’t need to provide a setter for the field, SDN/RX will use reflection to assign the field, but use a setter if there is one. If you want to create an immutable entity with an internally generated id, you have to provide a wither.

Example 4. Immutable MovieEntity with internal Neo4j id
@Node("Movie")
public class MovieEntity {

        @Id @GeneratedValue
        private final Long id; (1)

        private String name;

        public MovieEntity(String name) { (2)
                this(null, name);
        }

        private MovieEntity(Long id, String name) { (3)
                this.id = id;
                this.name = name;
        }

        public MovieEntity withId(Long id) { (4)
                if (this.id.equals(id)) {
                        return this;
                } else {
                        return new MovieEntity(id, this.title);
                }
        }
}
1 Immutable final id field indicating a generated value
2 Public constructor, used by the application and Spring Data
3 Internally used constructor
4 This is a so-called wither for the id-attribute. It creates a new entity and set’s the field accordingly, without modifying the original entity, thus making it immutable.

You either have to provide a setter for the id attribute or something like a wither, if you want to have

  • Advantages: It is pretty clear that the id attribute is the surrogate business key, it takes no further effort or configuration to use it.

  • Disadvantage: It is tied to Neo4js internal database id, which is not unique to our application entity only over a database lifetime.

  • Disadvantage: It takes more effort to create an immutable entity

5.2.2. Use externally provided surrogate keys

The @GeneratedValue annotation can take a class implementing org.neo4j.springframework.data.core.schema.IdGenerator as parameter. SDN/RX provides InternalIdGenerator (the default) and UUIDStringGenerator out of the box. The later generates new UUIDs for each entity and returns them as java.lang.String. An application entity using that would look like this:

Example 5. Mutable MovieEntity with externally generated surrogate key
@Node("Movie")
public class MovieEntity {

        @Id @GeneratedValue(UUIDStringGenerator.class)
        private String id;

        private String name;
}

We have to discuss two separate things regarding advantages and disadvantages. The assignment itself and the UUID-Strategy. A universally unique identifier is meant to be unique for practical purposes. To quote Wikipedia: “Thus, anyone can create a UUID and use it to identify something with near certainty that the identifier does not duplicate one that has already been, or will be, created to identify something else.” Our strategy uses Java internal UUID mechanism, employing a cryptographically strong pseudo random number generator. In most cases that should work fine, but your mileage might vary.

That leaves the assignment itself:

  • Advantage: The application is in full control and can generate a unique key that is just unique enough for the purpose of the application. The generated value will be stable and there won’t be a need to change it later on.

  • Disadvantage: The generated strategy is applied on the application side of things. In those days most applications will be deployed in more than one instance to scale nicely. If your strategy is prone to generate duplicates than inserts will fail as uniques of the primary key will be violated. So while you don’t have to think about a unique business key in this scenario, you have to think more what to generate.

You have several options to role your own ID generator. One is a POJO implementing a generator:

Example 6. Naive sequence generator
import java.util.concurrent.atomic.AtomicInteger;

import org.neo4j.springframework.data.core.schema.IdGenerator;
import org.springframework.util.StringUtils;

public class TestSequenceGenerator implements IdGenerator<String> {

        private final AtomicInteger sequence = new AtomicInteger(0);

        @Override
        public String generateId(String primaryLabel, Object entity) {
                return StringUtils.uncapitalize(primaryLabel) +
                        "-" + sequence.incrementAndGet();
        }
}

Another option is to provide an additional Spring Bean like this:

Example 7. Neo4jClient based ID generator
@Component
class MyIdGenerator implements IdGenerator<String> {

        private final Neo4jClient neo4jClient;

        public MyIdGenerator(Neo4jClient neo4jClient) {
                this.neo4jClient = neo4jClient;
        }

        @Override
        public String generateId(String primaryLabel, Object entity) {
                return neo4jClient.query("YOUR CYPHER QUERY FOR THE NEXT ID") (1)
                        .fetchAs(String.class).one().get();
        }
}
1 Use exactly the query or logic your need.

The generator above would be configured as a bean reference like this:

Example 8. Mutable MovieEntity using a Spring Bean as Id generator
@Node("Movie")
public class MovieEntity {

        @Id @GeneratedValue(generatorRef = "myIdGenerator")
        private String id;

        private String name;
}

5.2.3. Using a business key

We have been using a business key in the complete example’s MovieEntity and PersonEntity. The name of the person is assigned at construction time, both by your application and while being loaded through Spring Data.

This is only possible, if you find a stable, unique business key, but makes great immutable domain objects.

  • Advantages: Using a business or natural key as primary key is natural. The entity in question is clearly identified and it feels most of the time just right in the further modelling of your domain.

  • Disadvantages: Business keys as primary keys will be hard to update once you realise that the key you found is not as stable as you thought. Often it turns out that it can change, even when promised otherwise. Apart from that, finding identifier that are truly unique for a thing is hard.

5.3. Spring Data Object Mapping Fundamentals

This section covers the fundamentals of Spring Data object mapping, object creation, field and property access, mutability and immutability.

Core responsibility of the Spring Data object mapping is to create instances of domain objects and map the store-native data structures onto those. This means we need two fundamental steps:

  1. Instance creation by using one of the constructors exposed.

  2. Instance population to materialize all exposed properties.

5.3.1. Object creation

Spring Data automatically tries to detect a persistent entity’s constructor to be used to materialize objects of that type. The resolution algorithm works as follows:

  1. If there is a no-argument constructor, it will be used. Other constructors will be ignored.

  2. If there is a single constructor taking arguments, it will be used.

  3. If there are multiple constructors taking arguments, the one to be used by Spring Data will have to be annotated with @PersistenceConstructor.

The value resolution assumes constructor argument names to match the property names of the entity, i.e. the resolution will be performed as if the property was to be populated, including all customizations in mapping (different datastore column or field name etc.). This also requires either parameter names information available in the class file or an @ConstructorProperties annotation being present on the constructor.

Object creation internals

To avoid the overhead of reflection, Spring Data object creation uses a factory class generated at runtime by default, which will call the domain classes constructor directly. I.e. for this example type:

class Person {
  Person(String firstname, String lastname) {  }
}

we will create a factory class semantically equivalent to this one at runtime:

class PersonObjectInstantiator implements ObjectInstantiator {

  Object newInstance(Object... args) {
    return new Person((String) args[0], (String) args[1]);
  }
}

This gives us a roundabout 10% performance boost over reflection. For the domain class to be eligible for such optimization, it needs to adhere to a set of constraints:

  • it must not be a private class

  • it must not be a non-static inner class

  • it must not be a CGLib proxy class

  • the constructor to be used by Spring Data must not be private

If any of these criteria match, Spring Data will fall back to entity instantiation via reflection.

5.3.2. Property population

Once an instance of the entity has been created, Spring Data populates all remaining persistent properties of that class. Unless already populated by the entity’s constructor (i.e. consumed through its constructor argument list), the identifier property will be populated first to allow the resolution of cyclic object references. After that, all non-transient properties that have not already been populated by the constructor are set on the entity instance. For that we use the following algorithm:

  1. If the property is immutable but exposes a wither method (see below), we use the wither to create a new entity instance with the new property value.

  2. If property access (i.e. access through getters and setters) is defined, we are invoking the setter method.

  3. By default, we set the field value directly.

Property population internals

Similarly to our optimizations in object construction we also use Spring Data runtime generated accessor classes to interact with the entity instance.

class Person {

  private final Long id;
  private String firstname;
  private @AccessType(Type.PROPERTY) String lastname;

  Person() {
    this.id = null;
  }

  Person(Long id, String firstname, String lastname) {
    // Field assignments
  }

  Person withId(Long id) {
    return new Person(id, this.firstname, this.lastame);
  }

  void setLastname(String lastname) {
    this.lastname = lastname;
  }
}
Example 9. A generated Property Accessor
class PersonPropertyAccessor implements PersistentPropertyAccessor {

  private static final MethodHandle firstname;              (2)

  private Person person;                                    (1)

  public void setProperty(PersistentProperty property, Object value) {

    String name = property.getName();

    if ("firstname".equals(name)) {
      firstname.invoke(person, (String) value);             (2)
    } else if ("id".equals(name)) {
      this.person = person.withId((Long) value);            (3)
    } else if ("lastname".equals(name)) {
      this.person.setLastname((String) value);              (4)
    }
  }
}
1 PropertyAccessor’s hold a mutable instance of the underlying object. This is, to enable mutations of otherwise immutable properties.
2 By default, Spring Data uses field-access to read and write property values. As per visibility rules of private fields, MethodHandles are used to interact with fields.
3 The class exposes a withId(…) method that’s used to set the identifier, e.g. when an instance is inserted into the datastore and an identifier has been generated. Calling withId(…) creates a new Person object. All subsequent mutations will take place in the new instance leaving the previous untouched.
4 Using property-access allows direct method invocations without using MethodHandles.

This gives us a roundabout 25% performance boost over reflection. For the domain class to be eligible for such optimization, it needs to adhere to a set of constraints:

  • Types must not reside in the default or under the java package.

  • Types and their constructors must be public

  • Types that are inner classes must be static.

  • The used Java Runtime must allow for declaring classes in the originating ClassLoader. Java 9 and newer impose certain limitations.

By default, Spring Data attempts to use generated property accessors and falls back to reflection-based ones if a limitation is detected.

Let’s have a look at the following entity:

Example 10. A sample entity
class Person {

  private final @Id Long id;                                                (1)
  private final String firstname, lastname;                                 (2)
  private final LocalDate birthday;
  private final int age; (3)

  private String comment;                                                   (4)
  private @AccessType(Type.PROPERTY) String remarks;                        (5)

  static Person of(String firstname, String lastname, LocalDate birthday) { (6)

    return new Person(null, firstname, lastname, birthday,
      Period.between(birthday, LocalDate.now()).getYears());
  }

  Person(Long id, String firstname, String lastname, LocalDate birthday, int age) { (6)

    this.id = id;
    this.firstname = firstname;
    this.lastname = lastname;
    this.birthday = birthday;
    this.age = age;
  }

  Person withId(Long id) {                                                  (1)
    return new Person(id, this.firstname, this.lastname, this.birthday);
  }

  void setRemarks(String remarks) {                                         (5)
    this.remarks = remarks;
  }
}
1 The identifier property is final but set to null in the constructor. The class exposes a withId(…) method that’s used to set the identifier, e.g. when an instance is inserted into the datastore and an identifier has been generated. The original Person instance stays unchanged as a new one is created. The same pattern is usually applied for other properties that are store managed but might have to be changed for persistence operations.
2 The firstname and lastname properties are ordinary immutable properties potentially exposed through getters.
3 The age property is an immutable but derived one from the birthday property. With the design shown, the database value will trump the defaulting as Spring Data uses the only declared constructor. Even if the intent is that the calculation should be preferred, it’s important that this constructor also takes age as parameter (to potentially ignore it) as otherwise the property population step will attempt to set the age field and fail due to it being immutable and no wither being present.
4 The comment property is mutable is populated by setting its field directly.
5 The remarks properties are mutable and populated by setting the comment field directly or by invoking the setter method for
6 The class exposes a factory method and a constructor for object creation. The core idea here is to use factory methods instead of additional constructors to avoid the need for constructor disambiguation through @PersistenceConstructor. Instead, defaulting of properties is handled within the factory method.

5.3.3. General recommendations

  • Try to stick to immutable objects — Immutable objects are straightforward to create as materializing an object is then a matter of calling its constructor only. Also, this avoids your domain objects to be littered with setter methods that allow client code to manipulate the objects state. If you need those, prefer to make them package protected so that they can only be invoked by a limited amount of co-located types. Constructor-only materialization is up to 30% faster than properties population.

  • Provide an all-args constructor — Even if you cannot or don’t want to model your entities as immutable values, there’s still value in providing a constructor that takes all properties of the entity as arguments, including the mutable ones, as this allows the object mapping to skip the property population for optimal performance.

  • Use factory methods instead of overloaded constructors to avoid @PersistenceConstructor — With an all-argument constructor needed for optimal performance, we usually want to expose more application use case specific constructors that omit things like auto-generated identifiers etc. It’s an established pattern to rather use static factory methods to expose these variants of the all-args constructor.

  • Make sure you adhere to the constraints that allow the generated instantiator and property accessor classes to be used

  • For identifiers to be generated, still use a final field in combination with a wither method

  • Use Lombok to avoid boilerplate code — As persistence operations usually require a constructor taking all arguments, their declaration becomes a tedious repetition of boilerplate parameter to field assignments that can best be avoided by using Lombok’s @AllArgsConstructor.

5.3.4. Kotlin support

Spring Data adapts specifics of Kotlin to allow object creation and mutation.

Kotlin object creation

Kotlin classes are supported to be instantiated , all classes are immutable by default and require explicit property declarations to define mutable properties. Consider the following data class Person:

data class Person(val id: String, val name: String)

The class above compiles to a typical class with an explicit constructor. We can customize this class by adding another constructor and annotate it with @PersistenceConstructor to indicate a constructor preference:

data class Person(var id: String, val name: String) {

    @PersistenceConstructor
    constructor(id: String) : this(id, "unknown")
}

Kotlin supports parameter optionality by allowing default values to be used if a parameter is not provided. When Spring Data detects a constructor with parameter defaulting, then it leaves these parameters absent if the data store does not provide a value (or simply returns null) so Kotlin can apply parameter defaulting. Consider the following class that applies parameter defaulting for name

data class Person(var id: String, val name: String = "unknown")

Every time the name parameter is either not part of the result or its value is null, then the name defaults to unknown.

Property population of Kotlin data classes

In Kotlin, all classes are immutable by default and require explicit property declarations to define mutable properties. Consider the following data class Person:

data class Person(val id: String, val name: String)

This class is effectively immutable. It allows to create new instances as Kotlin generates a copy(…) method that creates new object instances copying all property values from the existing object and applying property values provided as arguments to the method.

6. Working with Spring Data Repositories

The goal of the Spring Data repository abstraction is to significantly reduce the amount of boilerplate code required to implement data access layers for various persistence stores.

6.1. Core concepts

The central interface in the Spring Data repository abstraction is Repository. It takes the domain class to manage as well as the ID type of the domain class as type arguments. This interface acts primarily as a marker interface to capture the types to work with and to help you to discover interfaces that extend this one. The CrudRepository provides sophisticated CRUD functionality for the entity class that is being managed.

Example 11. CrudRepository interface
public interface CrudRepository<T, ID> extends Repository<T, ID> {

  <S extends T> S save(S entity);      (1)

  Optional<T> findById(ID primaryKey); (2)

  Iterable<T> findAll();               (3)

  long count();                        (4)

  void delete(T entity);               (5)

  boolean existsById(ID primaryKey);   (6)

  // … more functionality omitted.
}
1 Saves the given entity.
2 Returns the entity identified by the given ID.
3 Returns all entities.
4 Returns the number of entities.
5 Deletes the given entity.
6 Indicates whether an entity with the given ID exists.
We also provide a technology-specific abstraction: such as Neo4jRepository and the reactive variant, ReactiveNeo4jRepository. Those interfaces extend CrudRepository and expose the capabilities of the underlying persistence technology in addition to the rather generic persistence technology-agnostic interfaces such as CrudRepository. Also, methods returning an Iterable are narrowed down to return a java.util.List instead.

On top of the CrudRepository, there is a PagingAndSortingRepository abstraction that adds additional methods to ease paginated access to entities:

Example 12. PagingAndSortingRepository interface
public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {

  Iterable<T> findAll(Sort sort);

  Page<T> findAll(Pageable pageable);
}

To access the second page of User by a page size of 20, you could do something like the following:

PagingAndSortingRepository<User, Long> repository = // … get access to a bean
Page<User> users = repository.findAll(PageRequest.of(1, 20));

In addition to query methods, query derivation for both count and delete queries is available. The following list shows the interface definition for a derived count query:

Example 13. Derived Count Query
interface UserRepository extends CrudRepository<User, Long> {

  long countByLastname(String lastname);
}

The following list shows the interface definition for a derived delete query:

Example 14. Derived Delete Query
interface UserRepository extends CrudRepository<User, Long> {

  long deleteByLastname(String lastname);

  List<User> removeByLastname(String lastname);
}

6.2. Query methods

Standard CRUD functionality repositories usually have queries on the underlying datastore. With Spring Data, declaring those queries becomes a four-step process:

  1. Declare an interface extending Repository or one of its subinterfaces and type it to the domain class and ID type that it should handle, as shown in the following example:

    interface PersonRepository extends Repository<Person, Long> {  }
  2. Declare query methods on the interface.

    interface PersonRepository extends Repository<Person, Long> {
      List<Person> findByLastname(String lastname);
    }
  3. Provide some JavaConfig to set up Spring to create proxy instances for those interfaces.

    import org.neo4j.springframework.data.config.AbstractNeo4jConfig;
    import org.neo4j.springframework.data.repository.config.EnableNeo4jRepositories;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    @Configuration (1)
    @EnableNeo4jRepositories (2)
    @EnableTransactionManagement (3)
    public class Config extends AbstractNeo4jConfig { (4)
    
            @Bean
            public Driver driver() { (5)
                    return GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "secret"));
            }
    }

    The Driver bean is required to provide the actual connection to the database.

    Note that the configuration does not configure a package explicitly, because the package of the annotated class is used by default. To customize the package to scan, use one of the basePackage… attributes of the @EnableNeo4jRepositories-annotation.

  4. Inject the repository instance and use it, as shown in the following example:

    class SomeClient {
    
      private final PersonRepository repository;
    
      SomeClient(PersonRepository repository) {
        this.repository = repository;
      }
    
      void doSomething() {
        List<Person> persons = repository.findByLastname("Matthews");
      }
    }

The following sections explain each step in detail.

6.3. Defining Repository Interfaces

First, define a domain class-specific repository interface. The interface must extend Repository and be typed to the domain class and an ID type. If you want to expose CRUD methods for that domain type, extend CrudRepository instead of Repository.

6.3.1. Fine-tuning Repository Definition

Typically, your repository interface extends Repository, CrudRepository, or PagingAndSortingRepository. Alternatively, if you do not want to extend Spring Data interfaces, you can also annotate your repository interface with @RepositoryDefinition. Extending CrudRepository exposes a complete set of methods to manipulate your entities. If you prefer to be selective about the methods being exposed, copy the methods you want to expose from CrudRepository into your domain repository.

Doing so lets you define your own abstractions on top of the provided Spring Data Repositories functionality.

The following example shows how to selectively expose CRUD methods (findById and save, in this case):

Example 15. Selectively exposing CRUD methods
@NoRepositoryBean
interface MyBaseRepository<T, ID> extends Repository<T, ID> {

  Optional<T> findById(ID id);

  <S extends T> S save(S entity);
}

interface UserRepository extends MyBaseRepository<User, Long> {
  User findByEmailAddress(EmailAddress emailAddress);
}

In the prior example, you defined a common base interface for all your domain repositories and exposed findById(…) as well as save(…). These methods are routed into the base repository implementation (for the imperative version, the implementation is SimpleNeo4jRepository), because they match the method signatures in CrudRepository. So the UserRepository can now save users, find individual users by ID, and trigger a query to find Users by email address.

The intermediate repository interface is annotated with @NoRepositoryBean. Make sure you add that annotation to all repository interfaces for which Spring Data should not create instances at runtime.

6.3.2. Using Repositories with Multiple Spring Data Modules

Using a unique Spring Data module in your application makes things simple, because all repository interfaces in the defined scope are bound to one Spring Data module. Sometimes, applications require using more than one Spring Data module. In such cases, a repository definition must distinguish between persistence technologies. When it detects multiple repository factories on the class path, Spring Data enters strict repository configuration mode. Strict configuration uses details on the repository or the domain class to decide about Spring Data module binding for a repository definition:

  1. If the repository definition extends the module-specific repository, then it is a valid candidate for the particular Spring Data module.

  2. If the domain class is annotated with the module-specific type annotation, then it is a valid candidate for the particular Spring Data module. Spring Data modules accept either third-party annotations (such as JPA’s @Entity) or provide their own annotations (such as @Node for Spring Data Neo4j⚡RX).

The following example shows a repository that uses module-specific interfaces (JPA in this case):

Example 16. Repository definitions using module-specific interfaces
interface MyRepository extends JpaRepository<User, Long> { }

@NoRepositoryBean
interface MyBaseRepository<T, ID> extends JpaRepository<T, ID> {  }

interface UserRepository extends MyBaseRepository<User, Long> {  }

MyRepository and UserRepository extend JpaRepository in their type hierarchy. They are valid candidates for the Spring Data JPA module.

The following example shows a repository that uses generic interfaces:

Example 17. Repository definitions using generic interfaces
interface AmbiguousRepository extends Repository<User, Long> {  }

@NoRepositoryBean
interface MyBaseRepository<T, ID> extends CrudRepository<T, ID> {  }

interface AmbiguousUserRepository extends MyBaseRepository<User, Long> {  }

AmbiguousRepository and AmbiguousUserRepository extend only Repository and CrudRepository in their type hierarchy. While this is perfectly fine when using a unique Spring Data module, multiple modules cannot distinguish to which particular Spring Data these repositories should be bound.

The following example shows a repository that uses domain classes with annotations:

Example 18. Repository definitions using domain classes with annotations
interface PersonRepository extends Repository<Person, Long> {  }

@Entity
class Person {  }

interface UserRepository extends Repository<User, Long> {  }

@Node
class User {  }

PersonRepository references Person, which is annotated with the JPA @Entity annotation, so this repository clearly belongs to Spring Data JPA. UserRepository references User, which is annotated with SDN/RX’s @Node annotation.

The following bad example shows a repository that uses domain classes with mixed annotations:

Example 19. Repository definitions using domain classes with mixed annotations
interface JpaPersonRepository extends Repository<Person, Long> {  }

interface Neo4jPersonRepository extends Repository<Person, Long> {  }

@Entity
@Node
class Person {  }

This example shows a domain class using both JPA and Spring Data Neo4j⚡RX annotations. It defines two repositories, JpaPersonRepository and Neo4jPersonRepository. One is intended for JPA and the other for Neo4j usage. Spring Data is no longer able to tell the repositories apart, which leads to undefined behavior.

Repository type details and distinguishing domain class annotations are used for strict repository configuration to identify repository candidates for a particular Spring Data module. Using multiple persistence technology-specific annotations on the same domain type is possible and enables reuse of domain types across multiple persistence technologies. However, Spring Data can then no longer determine a unique module with which to bind the repository.

The last way to distinguish repositories is by scoping repository base packages. Base packages define the starting points for scanning for repository interface definitions, which implies having repository definitions located in the appropriate packages.

The following example shows annotation-driven configuration of base packages:

Example 20. Annotation-driven configuration of base packages
@Configuration
@EnableJpaRepositories(basePackages = "com.acme.repositories.jpa")
@EnableNeo4jRepositories(basePackages = "com.acme.repositories.neo4j")
class Config {
}

6.4. Defining Query Methods

The repository proxy has two ways to derive a store-specific query from the method name:

  • By deriving the query from the method name directly.

  • By using a manually defined query.

The next section describes the available options.

6.4.1. Query Lookup Strategies

The following strategies are available for the repository infrastructure to resolve the query. In your Java configuration, you can use the queryLookupStrategy attribute of the EnableNeo4jRepositories annotation.

  • CREATE attempts to construct a store-specific query from the query method name. The general approach is to remove a given set of well known prefixes from the method name and parse the rest of the method. You can read more about query construction in “Section 6.4.2”.

  • USE_DECLARED_QUERY tries to find a declared query and throws an exception if cannot find one. The query can be defined by an annotation somewhere or declared by other means. Consult the documentation of the specific store to find available options for that store. If the repository infrastructure does not find a declared query for the method at bootstrap time, it fails.

  • CREATE_IF_NOT_FOUND (default) combines CREATE and USE_DECLARED_QUERY. It looks up a declared query first, and, if no declared query is found, it creates a custom method name-based query. This is the default lookup strategy and, thus, is used if you do not configure anything explicitly. It allows quick query definition by method names but also custom-tuning of these queries by introducing declared queries as needed.

6.4.2. Query Creation

The query builder mechanism built into Spring Data repository infrastructure is useful for building constraining queries over entities of the repository. The mechanism strips the prefixes find…By, read…By, query…By, count…By, and get…By from the method and starts parsing the rest of it. The introducing clause can contain further expressions, such as a Distinct to set a distinct flag on the query to be created. However, the first By acts as delimiter to indicate the start of the actual criteria. At a very basic level, you can define conditions on entity properties and concatenate them with And and Or. The following example shows how to create a number of queries:

Example 21. Query creation from method names
interface PersonRepository extends Repository<Person, Long> {

  List<Person> findByEmailAddressAndLastname(EmailAddress emailAddress, String lastname);

  // Enables the distinct flag for the query
  List<Person> findDistinctPeopleByLastnameOrFirstname(String lastname, String firstname);
  List<Person> findPeopleDistinctByLastnameOrFirstname(String lastname, String firstname);

  // Enabling ignoring case for an individual property
  List<Person> findByLastnameIgnoreCase(String lastname);
  // Enabling ignoring case for all suitable properties
  List<Person> findByLastnameAndFirstnameAllIgnoreCase(String lastname, String firstname);

  // Enabling static ORDER BY for a query
  List<Person> findByLastnameOrderByFirstnameAsc(String lastname);
  List<Person> findByLastnameOrderByFirstnameDesc(String lastname);
}

There are some general things to notice:

  • The expressions are usually property traversals combined with operators that can be concatenated. You can combine property expressions with AND and OR. You also get support for operators such as Between, LessThan, GreaterThan, and Like for the property expressions.

  • The method parser supports setting an IgnoreCase flag for individual properties (for example, findByLastnameIgnoreCase(…)) or for all properties of a type that supports ignoring case (usually String instances — for example, findByLastnameAndFirstnameAllIgnoreCase(…)).

  • You can apply static ordering by appending an OrderBy clause to the query method that references a property and by providing a sorting direction (Asc or Desc). To create a query method that supports dynamic sorting, see “Section 6.4.4”.

6.4.3. Property Expressions

Property expressions can refer only to a direct property of the managed entity, as shown in the preceding example. At query creation time, you already make sure that the parsed property is a property of the managed domain class. However, you can also define constraints by traversing nested properties. Consider the following method signature:

List<Person> findByAddressZipCode(ZipCode zipCode);

Assume a Person has an Address with a ZipCode. In that case, the method creates the property traversal x.address.zipCode. The resolution algorithm starts by interpreting the entire part (AddressZipCode) as the property and checks the domain class for a property with that name (uncapitalized). If the algorithm succeeds, it uses that property. If not, the algorithm splits up the source at the camel case parts from the right side into a head and a tail and tries to find the corresponding property — in our example, AddressZip and Code. If the algorithm finds a property with that head, it takes the tail and continues building the tree down from there, splitting the tail up in the way just described. If the first split does not match, the algorithm moves the split point to the left (Address, ZipCode) and continues.

Although this should work for most cases, it is possible for the algorithm to select the wrong property. Suppose the Person class has an addressZip property as well. The algorithm would match in the first split round already, choose the wrong property, and fail (as the type of addressZip probably has no code property).

To resolve this ambiguity you can use _ inside your method name to manually define traversal points. So our method name would be as follows:

List<Person> findByAddress_ZipCode(ZipCode zipCode);

Because we treat the underscore character as a reserved character, we strongly advise following standard Java naming conventions (that is, not using underscores in property names but using camel case instead).

6.4.4. Special parameter handling

To handle parameters in your query, define method parameters as already seen in the preceding examples. Besides that, the infrastructure recognizes certain specific types like Pageable and Sort, to apply pagination and sorting to your queries dynamically. The following example demonstrates these features:

Example 22. Using Pageable, Slice, and Sort in query methods
Page<User> findByLastname(String lastname, Pageable pageable);

Slice<User> findByLastname(String lastname, Pageable pageable);

List<User> findByLastname(String lastname, Sort sort);

List<User> findByLastname(String lastname, Pageable pageable);
APIs taking Sort and Pageable expect non-null values to be handed into methods. If you don’t want to apply any sorting or pagination use Sort.unsorted() and Pageable.unpaged().

The first method lets you pass an org.springframework.data.domain.Pageable instance to the query method to dynamically add paging to your statically defined query. A Page knows about the total number of elements and pages available. It does so by the infrastructure triggering a count query to calculate the overall number. As this might be expensive (depending on the store used), you can instead return a Slice. A Slice only knows about whether a next Slice is available, which might be sufficient when walking through a larger result set.

Sorting options are handled through the Pageable instance, too. If you only need sorting, add an org.springframework.data.domain.Sort parameter to your method. As you can see, returning a List is also possible. In this case, the additional metadata required to build the actual Page instance is not created (which, in turn, means that the additional count query that would have been necessary is not issued). Rather, it restricts the query to look up only the given range of entities.

To find out how many pages you get for an entire query, you have to trigger an additional count query. By default, this query is derived from the query you actually trigger.
Paging and Sorting

Simple sorting expressions can be defined by using property names. Expressions can be concatenated to collect multiple criterias into one expression.

Example 23. Defining sort expressions
Sort sort = Sort.by("firstname").ascending()
  .and(Sort.by("lastname").descending());

For a more type-safe way of defining sort expressions, start with the type to define the sort expression for and use method references to define the properties to sort on.

Example 24. Defining sort expressions using the type-safe API
TypedSort<Person> person = Sort.sort(Person.class);

TypedSort<Person> sort = person.by(Person::getFirstname).ascending()
  .and(person.by(Person::getLastname).descending());

6.4.5. Limiting Query Results

The results of query methods can be limited by using the first or top keywords, which can be used interchangeably. An optional numeric value can be appended to top or first to specify the maximum result size to be returned. If the number is left out, a result size of 1 is assumed. The following example shows how to limit the query size:

Example 25. Limiting the result size of a query with Top and First
User findFirstByOrderByLastnameAsc();

User findTopByOrderByAgeDesc();

Page<User> queryFirst10ByLastname(String lastname, Pageable pageable);

Slice<User> findTop3ByLastname(String lastname, Pageable pageable);

List<User> findFirst10ByLastname(String lastname, Sort sort);

List<User> findTop10ByLastname(String lastname, Pageable pageable);

The limiting expressions also support the Distinct keyword. Also, for the queries limiting the result set to one instance, wrapping the result into with the Optional keyword is supported.

If pagination or slicing is applied to a limiting query pagination (and the calculation of the number of pages available), it is applied within the limited result.

Limiting the results in combination with dynamic sorting by using a Sort parameter lets you express query methods for the 'K' smallest as well as for the 'K' biggest elements.

6.4.6. Repository Methods Returning Collections or Iterables

Query methods that return multiple results can use standard Java Iterable, List, Set. Beyond that we support returning Spring Data’s Streamable, a custom extension of Iterable, as well as collection types provided by Vavr.

Using Streamable as Query Method Return Type

Streamable can be used as alternative to Iterable or any collection type. It provides convenience methods to access a non-parallel Stream (missing from Iterable), the ability to directly ….filter(…) and ….map(…) over the elements and concatenate the Streamable to others:

Example 26. Using Streamable to combine query method results
interface PersonRepository extends Repository<Person, Long> {
  Streamable<Person> findByFirstnameContaining(String firstname);
  Streamable<Person> findByLastnameContaining(String lastname);
}

Streamable<Person> result = repository.findByFirstnameContaining("av")
  .and(repository.findByLastnameContaining("ea"));
Returning Custom Streamable Wrapper Types

Providing dedicated wrapper types for collections is a commonly used pattern to provide API on a query execution result that returns multiple elements. Usually these types are used by invoking a repository method returning a collection-like type and creating an instance of the wrapper type manually. That additional step can be avoided as Spring Data allows to use these wrapper types as query method return types if they meet the following criterias:

  1. The type implements Streamable.

  2. The type exposes either a constructor or a static factory method named of(…) or valueOf(…) taking Streamable as argument.

A sample use case looks as follows:

class Product { (1)
  MonetaryAmount getPrice() {  }
}

@RequiredArgConstructor(staticName = "of")
class Products implements Streamable<Product> { (2)

  private Streamable<Product> streamable;

  public MonetaryAmount getTotal() { (3)
    return streamable.stream() //
      .map(Priced::getPrice)
      .reduce(Money.of(0), MonetaryAmount::add);
  }
}

interface ProductRepository implements Repository<Product, Long> {
  Products findAllByDescriptionContaining(String text); (4)
}
1 A Product entity that exposes API to access the product’s price.
2 A wrapper type for a Streamable<Product> that can be constructed via Products.of(…) (factory method created via the Lombok annotation).
3 The wrapper type exposes additional API calculating new values on the Streamable<Product>.
4 That wrapper type can be used as query method return type directly. No need to return Stremable<Product> and manually wrap it in the repository client.
Support for Vavr Collections

Vavr is a library to embrace functional programming concepts in Java. It ships with a custom set of collection types that can be used as query method return types.

Vavr collection type Used Vavr implementation type Valid Java source types

io.vavr.collection.Seq

io.vavr.collection.List

java.util.Iterable

io.vavr.collection.Set

io.vavr.collection.LinkedHashSet

java.util.Iterable

io.vavr.collection.Map

io.vavr.collection.LinkedHashMap

java.util.Map

The types in the first column (or subtypes thereof) can be used as quer method return types and will get the types in the second column used as implementation type depending on the Java type of the actual query result (third column). Alternatively, Traversable (Vavr the Iterable equivalent) can be declared and we derive the implementation class from the actual return value, i.e. a java.util.List will be turned into a Vavr List/Seq, a java.util.Set becomes a Vavr LinkedHashSet/Set etc.

6.4.7. Null Handling of Repository Methods

As of Spring Data 2.0, repository CRUD methods that return an individual aggregate instance use Java 8’s Optional to indicate the potential absence of a value. Besides that, Spring Data supports returning the following wrapper types on query methods:

  • com.google.common.base.Optional

  • scala.Option

  • io.vavr.control.Option

Alternatively, query methods can choose not to use a wrapper type at all. The absence of a query result is then indicated by returning null. Repository methods returning collections, collection alternatives, wrappers, and streams are guaranteed never to return null but rather the corresponding empty representation. See “Repository query return types” for details.

Nullability Annotations

You can express nullability constraints for repository methods by using Spring Framework’s nullability annotations. They provide a tooling-friendly approach and opt-in null checks during runtime, as follows:

  • @NonNullApi: Used on the package level to declare that the default behavior for parameters and return values is to not accept or produce null values.

  • @NonNull: Used on a parameter or return value that must not be null (not needed on a parameter and return value where @NonNullApi applies).

  • @Nullable: Used on a parameter or return value that can be null.

Spring annotations are meta-annotated with JSR 305 annotations (a dormant but widely spread JSR). JSR 305 meta-annotations let tooling vendors such as IDEA, Eclipse, and Kotlin provide null-safety support in a generic way, without having to hard-code support for Spring annotations. To enable runtime checking of nullability constraints for query methods, you need to activate non-nullability on the package level by using Spring’s @NonNullApi in package-info.java, as shown in the following example:

Example 27. Declaring Non-nullability in package-info.java
@org.springframework.lang.NonNullApi
package com.acme;

Once non-null defaulting is in place, repository query method invocations get validated at runtime for nullability constraints. If a query execution result violates the defined constraint, an exception is thrown. This happens when the method would return null but is declared as non-nullable (the default with the annotation defined on the package the repository resides in). If you want to opt-in to nullable results again, selectively use @Nullable on individual methods. Using the result wrapper types mentioned at the start of this section continues to work as expected: An empty result is translated into the value that represents absence.

The following example shows a number of the techniques just described:

Example 28. Using different nullability constraints
package com.acme;                                                       (1)

import org.springframework.lang.Nullable;

interface UserRepository extends Repository<User, Long> {

  User getByEmailAddress(EmailAddress emailAddress);                    (2)

  @Nullable
  User findByEmailAddress(@Nullable EmailAddress emailAdress);          (3)

  Optional<User> findOptionalByEmailAddress(EmailAddress emailAddress); (4)
}
1 The repository resides in a package (or sub-package) for which we have defined non-null behavior.
2 Throws an EmptyResultDataAccessException when the query executed does not produce a result. Throws an IllegalArgumentException when the emailAddress handed to the method is null.
3 Returns null when the query executed does not produce a result. Also accepts null as the value for emailAddress.
4 Returns Optional.empty() when the query executed does not produce a result. Throws an IllegalArgumentException when the emailAddress handed to the method is null.
Nullability in Kotlin-based Repositories

Kotlin has the definition of nullability constraints baked into the language. Kotlin code compiles to bytecode, which does not express nullability constraints through method signatures but rather through compiled-in metadata. Make sure to include the kotlin-reflect JAR in your project to enable introspection of Kotlin’s nullability constraints. Spring Data repositories use the language mechanism to define those constraints to apply the same runtime checks, as follows:

Example 29. Using nullability constraints on Kotlin repositories
interface UserRepository : Repository<User, String> {

  fun findByUsername(username: String): User     (1)

  fun findByFirstname(firstname: String?): User? (2)
}
1 The method defines both the parameter and the result as non-nullable (the Kotlin default). The Kotlin compiler rejects method invocations that pass null to the method. If the query execution yields an empty result, an EmptyResultDataAccessException is thrown.
2 This method accepts null for the firstname parameter and returns null if the query execution does not produce a result.

6.4.8. Streaming query results

The results of query methods can be processed incrementally by using a Java 8 Stream<T> as return type. Instead of wrapping the query results in a Stream data store-specific methods are used to perform the streaming, as shown in the following example:

Example 30. Stream the result of a query with Java 8 Stream<T>
@Query("MATCH (u:User) RETURN u")
Stream<User> findAllByCustomQueryAndStream();

Stream<User> readAllByFirstnameNotNull();

@Query("MATCH (u:User) RETURN u")
Stream<User> streamAllPaged(Pageable pageable);
A Stream potentially wraps underlying data store-specific resources and must, therefore, be closed after usage. You can either manually close the Stream by using the close() method or by using a Java 7 try-with-resources block, as shown in the following example:
Example 31. Working with a Stream<T> result in a try-with-resources block
try (Stream<User> stream = repository.findAllByCustomQueryAndStream()) {
  stream.forEach();
}
Not all Spring Data modules currently support Stream<T> as a return type.

6.4.9. Async query results

Repository queries can be run asynchronously by using Spring’s asynchronous method execution capability. This means the method returns immediately upon invocation while the actual query execution occurs in a task that has been submitted to a Spring TaskExecutor. Asynchronous query execution is different from reactive query execution and should not be mixed. Refer to store-specific documentation for more details on reactive support. The following example shows a number of asynchronous queries:

@Async
Future<User> findByFirstname(String firstname);               (1)

@Async
CompletableFuture<User> findOneByFirstname(String firstname); (2)

@Async
ListenableFuture<User> findOneByLastname(String lastname);    (3)
1 Use java.util.concurrent.Future as the return type.
2 Use a Java 8 java.util.concurrent.CompletableFuture as the return type.
3 Use a org.springframework.util.concurrent.ListenableFuture as the return type.

6.5. Creating Repository Instances

In this section, you create instances and bean definitions for the defined repository interfaces.

This section is only relevant if you don’t work in a Spring Boot scenario. SDN/RX provides dedicated support for Spring Boot, including automatic configuration of the Neo4j driver, Repositories and entity scanning.
Please be aware that SDN/RX does not support XML based Spring configuration.

6.5.1. JavaConfig

The repository infrastructure is triggered by using either @EnableNeo4jRepositories or EnableReactiveNeo4jRepositories annotation on a JavaConfig class. For an introduction into Java-based configuration of the Spring container, see JavaConfig in the Spring reference documentation.

While the Neo4j driver contains support for blocking and reactive programming in one single jar, blocking and reactive programming style should not be mixed in one application.

A sample configuration to enable Spring Data Neo4j repositories resembles the following:

Example 32. Sample annotation based repository configuration
import java.util.Arrays;
import java.util.Collection;

import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;
import org.neo4j.springframework.data.config.AbstractNeo4jConfig;
import org.neo4j.springframework.data.repository.config.EnableNeo4jRepositories;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration (1)
@EnableNeo4jRepositories (2)
@EnableTransactionManagement (3)
public class Config extends AbstractNeo4jConfig { (4)

        @Bean
        public Driver driver() { (5)
                return GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "secret"));
        }

        @Override
        protected Collection<String> getMappingBasePackages() { (6)
                return Arrays.asList("your.domain.package");
        }

}
1 Mark this as a Spring Configuration class
2 Enable imperative Neo4j repositories
3 Enable transactions
4 AbstractNeo4jConfig provides all the beans needed for SDN/RX to work
5 Provide a connection to the database
6 This is optional: Preconfigure the list of packages where SDN/RX should look for @Node-annotated classes

The configuration of reactive repositories looks very similar:

Example 33. Sample annotation based reactive repository configuration
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;
import org.neo4j.springframework.data.config.AbstractReactiveNeo4jConfig;
import org.neo4j.springframework.data.repository.config.EnableReactiveNeo4jRepositories;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableReactiveNeo4jRepositories
@EnableTransactionManagement
public class ReactiveConfig extends AbstractReactiveNeo4jConfig {

        @Bean
        public Driver driver() {
                return GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "secret"));
        }
}

The driver has the same type. Please note that you need at least Neo4j 4.0 to use the reactive sessions provided by the driver.

6.6. Custom Implementations for Spring Data Repositories

This section covers repository customization and how fragments form a composite repository.

When a query method requires a different behavior or cannot be implemented by query derivation, then it is necessary to provide a custom implementation. Spring Data repositories let you provide custom repository code and integrate it with generic CRUD abstraction and query method functionality.

6.6.1. Customizing Individual Repositories

To enrich a repository with custom functionality, you must first define a fragment interface and an implementation for the custom functionality, as shown in the following example:

Example 34. Interface for custom repository functionality
interface CustomizedUserRepository {
  void someCustomMethod(User user);
}

Then you can let your repository interface additionally extend from the fragment interface, as shown in the following example:

Example 35. Implementation of custom repository functionality
class CustomizedUserRepositoryImpl implements CustomizedUserRepository {

  public void someCustomMethod(User user) {
    // Your custom implementation
  }
}
The most important part of the class name that corresponds to the fragment interface is the Impl postfix.

The implementation itself does not depend on Spring Data and can be a regular Spring bean. Consequently, you can use standard dependency injection behavior to inject references to other beans (such as a Neo4jClient or the Neo4jTemplate), take part in aspects, and so on.

You can let your repository interface extend the fragment interface, as shown in the following example:

Example 36. Changes to your repository interface
interface UserRepository extends CrudRepository<User, Long>, CustomizedUserRepository {

  // Declare query methods here
}

Extending the fragment interface with your repository interface combines the CRUD and custom functionality and makes it available to clients.

Spring Data repositories are implemented by using fragments that form a repository composition. Fragments are the base repository, functional aspects and custom interfaces along with their implementation. Each time you add an interface to your repository interface, you enhance the composition by adding a fragment. The base repository and repository aspect implementations are provided by each Spring Data module.

The following example shows custom interfaces and their implementations:

Example 37. Fragments with their implementations
interface HumanRepository {
  void someHumanMethod(User user);
}

class HumanRepositoryImpl implements HumanRepository {

  public void someHumanMethod(User user) {
    // Your custom implementation
  }
}

interface ContactRepository {

  void someContactMethod(User user);

  User anotherContactMethod(User user);
}

class ContactRepositoryImpl implements ContactRepository {

  public void someContactMethod(User user) {
    // Your custom implementation
  }

  public User anotherContactMethod(User user) {
    // Your custom implementation
  }
}

The following example shows the interface for a custom repository that extends CrudRepository:

Example 38. Changes to your repository interface
interface UserRepository extends CrudRepository<User, Long>, HumanRepository, ContactRepository {

  // Declare query methods here
}

Repositories may be composed of multiple custom implementations that are imported in the order of their declaration. Custom implementations have a higher priority than the base implementation and repository aspects. This ordering lets you override base repository and aspect methods and resolves ambiguity if two fragments contribute the same method signature. Repository fragments are not limited to use in a single repository interface. Multiple repositories may use a fragment interface, letting you reuse customizations across different repositories.

The following example shows a repository fragment and its implementation:

Example 39. Fragments overriding save(…)
interface CustomizedSave<T> {
  <S extends T> S save(S entity);
}

class CustomizedSaveImpl<T> implements CustomizedSave<T> {

  public <S extends T> S save(S entity) {
    // Your custom implementation
  }
}

The following example shows a repository that uses the preceding repository fragment:

Example 40. Customized repository interfaces
interface UserRepository extends CrudRepository<User, Long>, CustomizedSave<User> {
}

interface PersonRepository extends CrudRepository<Person, Long>, CustomizedSave<Person> {
}
Configuration

The repository infrastructure tries to autodetect custom implementation fragments by scanning for classes below the package in which it found a repository. These classes need to follow the naming convention of appending the store’s repositoryImplementationPostfix attribute to the fragment interface name. This postfix defaults to Impl. The following example shows a configuration changing the default postfix to MyPostfix:

Example 41. Configuration example
import org.neo4j.springframework.data.repository.config.EnableNeo4jRepositories;

@EnableNeo4jRepositories(repositoryImplementationPostfix = "MyPostfix")
public class CustomFragmentPostfix {
}

With this configuration, SDN/RX tries to look up a class called com.acme.repository.CustomizedUserRepositoryMyPostfix to act as a custom repository implementation.

Resolution of Ambiguity

If multiple implementations with matching class names are found in different packages, Spring Data uses the bean names to identify which one to use.

Given the following two custom implementations for the CustomizedUserRepository shown earlier, the first implementation is used. Its bean name is customizedUserRepositoryImpl, which matches that of the fragment interface (CustomizedUserRepository) plus the postfix Impl.

Example 42. Resolution of ambiguous implementations
package com.acme.impl.one;

class CustomizedUserRepositoryImpl implements CustomizedUserRepository {

  // Your custom implementation
}
package com.acme.impl.two;

@Component("specialCustomImpl")
class CustomizedUserRepositoryImpl implements CustomizedUserRepository {

  // Your custom implementation
}

If you annotate the UserRepository interface with @Component("specialCustom"), the bean name plus Impl then matches the one defined for the repository implementation in com.acme.impl.two, and it is used instead of the first one.

Manual Wiring

If your custom implementation uses annotation-based configuration and autowiring only, the preceding approach shown works well, because it is treated as any other Spring bean. If your implementation fragment bean needs special wiring, you can declare the bean and name it according to the conventions described in the preceding section. The infrastructure then refers to the manually defined bean definition by name instead of creating one itself.

6.6.2. Customize the Base Repository

The approach described in the preceding section requires customization of each repository interfaces when you want to customize the base repository behavior so that all repositories are affected. To change behavior for all repositories instead, you can create an implementation that extends the repository base class. This class then acts as a custom base class for the repository proxies, as shown in the following example:

Example 43. Custom repository base class
public class MyRepositoryImpl<T, ID> extends SimpleNeo4jRepository<T, ID> {

        MyRepositoryImpl(
                Neo4jOperations neo4jOperations,
                Neo4jEntityInformation<T, ID> entityInformation
        ) {
                super(neo4jOperations, entityInformation);
        }

        @Override
        public List<T> findAll() {
                throw new UnsupportedOperationException(
                        "This implementation does not support `findAll`.");
        }
}
The class needs to have a constructor matching SimpleNeo4jRepository or SimpleReactiveNeo4jRepository.

The final step is to make the Spring Data infrastructure aware of the customized repository base class. In Java configuration, you can do so by using the repositoryBaseClass attribute of the @Enable$Neo4jRepositories annotation, as shown in the following example:

Example 44. Configuring a custom repository base class using JavaConfig
@Configuration
@EnableNeo4jRepositories(repositoryBaseClass = MyRepositoryImpl.class)
@EnableTransactionManagement
public class Config extends AbstractNeo4jConfig {

        @Bean
        public Driver driver() {
                return GraphDatabase
                        .driver("neo4j://localhost:7687", AuthTokens.basic("neo4j", "secret"));
        }
}

6.7. Publishing Events from Aggregate Roots

Entities managed by repositories are aggregate roots. In a Domain-Driven Design application, these aggregate roots usually publish domain events. Spring Data provides an annotation called @DomainEvents that you can use on a method of your aggregate root to make that publication as easy as possible, as shown in the following example.

First, define a custom event:

Example 45. Defining a custom domain event:
import java.time.LocalDateTime;

import org.springframework.context.ApplicationEvent;

public class SomeEvent extends ApplicationEvent { (1)

        private final LocalDateTime changeHappenedAt = LocalDateTime.now();

        private final String oldValue;

        private final String newValue;

        public SomeEvent(AnAggregateRoot source, String oldValue, String newValue) {
                super(source);
                this.oldValue = oldValue;
                this.newValue = newValue;
        }

        // Getters omitted...
}
1 You have to inherit from Spring’s ApplicationEvent

The next step is to expose these events from a @Node entity:

Example 46. Exposing domain events from an aggregate root
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

import org.neo4j.springframework.data.core.schema.Id;
import org.neo4j.springframework.data.core.schema.Node;
import org.springframework.data.annotation.Transient;
import org.springframework.data.domain.AfterDomainEventPublication;
import org.springframework.data.domain.DomainEvents;

@Node
public class AnAggregateRoot {

        @Id
        private final String name;

        private String someOtherValue;

        @Transient (1)
        private final Collection<SomeEvent> events = new ArrayList<>();

        public AnAggregateRoot(String name) {
                this.name = name;
        }

        public void setSomeOtherValue(String someOtherValue) {
                this.events.add(new SomeEvent(this, this.someOtherValue, someOtherValue)); (2)
                this.someOtherValue = someOtherValue;
        }

        @DomainEvents (3)
        Collection<SomeEvent> domainEvents() {
                return Collections.unmodifiableCollection(events);
        }

        @AfterDomainEventPublication (4)
        void callbackMethod() {
                this.events.clear();
        }
}
1 Store your events in a collection and mark that collection as @Transient so that those events are not treated as a relationship to be stored
2 Whenever you need to log an event, add it to the events collection
3 Mark one method with @DomainEvents. The method must not take any arguments and can return either a single event instance or a collection of events.
4 After all events have been published, we have a method annotated with @AfterDomainEventPublication. It can be used to potentially clean the list of events to be published (among other uses).

The methods are called every time one of a Spring Data repository’s save(…) methods is called as shown in the following snippets:

Example 47. Store the aggregate root via standard repository calls
import org.junit.jupiter.api.Test;
import org.neo4j.springframework.boot.test.autoconfigure.data.DataNeo4jTest;
import org.springframework.beans.factory.annotation.Autowired;

@DataNeo4jTest
public class DomainEventsTest {

        private final ARepository aRepository;

        @Autowired
        public DomainEventsTest(ARepository aRepository) {
                this.aRepository = aRepository;
                this.aRepository.save(new AnAggregateRoot("The Root"));
        }

        @Test
        void domainEventsShouldWork() {

                this.aRepository.findByName("The Root").ifPresent(anAggregateRoot -> {
                        anAggregateRoot.setSomeOtherValue("A new value");
                        anAggregateRoot.setSomeOtherValue("Even newer value");
                        this.aRepository.save(anAggregateRoot);
                });
        }
}

To react on this events, register a standard Spring ApplicationListener, typed to your event:

Example 48. Create a custom event listener
@Bean
ApplicationListener<SomeEvent> someEventListener() {
        return event -> System.out.println(
                "someOtherValue changed from '" + event.getOldValue() + "' to '" + event.getNewValue() + "' at " + event
                        .getChangeHappenedAt());
}

6.8. Spring Data Extensions

This section documents a set of Spring Data extensions that enable Spring Data usage in a variety of contexts. Currently, most of the integration is targeted towards Spring MVC.

6.8.1. Web support

Spring Data modules that support the repository programming model ship with a variety of web support. The web related components require Spring MVC JARs to be on the classpath. Some of them even provide integration with Spring HATEOAS. In general, the integration support is enabled by using the @EnableSpringDataWebSupport annotation in your JavaConfig configuration class, as shown in the following example:

Example 49. Enabling Spring Data web support
@Configuration
@EnableWebMvc
@EnableSpringDataWebSupport
class WebConfiguration {}

The @EnableSpringDataWebSupport annotation registers a few components we will discuss in a bit. It will also detect Spring HATEOAS on the classpath and register integration components for it as well if present.

Basic Web Support

The configuration shown in the previous section registers a few basic components:

  • A Section 6.8.1.1.1 to let Spring MVC resolve instances of repository-managed domain classes from request parameters or path variables.

  • HandlerMethodArgumentResolver implementations to let Spring MVC resolve Pageable and Sort instances from request parameters.

DomainClassConverter

The DomainClassConverter lets you use domain types in your Spring MVC controller method signatures directly, so that you need not manually lookup the instances through the repository, as shown in the following example:

Example 50. A Spring MVC controller using domain types in method signatures
@Controller
@RequestMapping("/users")
class UserController {

  @RequestMapping("/{id}")
  String showUserForm(@PathVariable("id") User user, Model model) {

    model.addAttribute("user", user);
    return "userForm";
  }
}

As you can see, the method receives a User instance directly, and no further lookup is necessary. The instance can be resolved by letting Spring MVC convert the path variable into the id type of the domain class first and eventually access the instance through calling findById(…) on the repository instance registered for the domain type.

Currently, the repository has to implement CrudRepository to be eligible to be discovered for conversion.
HandlerMethodArgumentResolvers for Pageable and Sort

The configuration snippet shown in the previous section also registers a PageableHandlerMethodArgumentResolver as well as an instance of SortHandlerMethodArgumentResolver. The registration enables Pageable and Sort as valid controller method arguments, as shown in the following example:

Example 51. Using Pageable as controller method argument
@Controller
@RequestMapping("/users")
class UserController {

  private final UserRepository repository;

  UserController(UserRepository repository) {
    this.repository = repository;
  }

  @RequestMapping
  String showUsers(Model model, Pageable pageable) {

    model.addAttribute("users", repository.findAll(pageable));
    return "users";
  }
}

The preceding method signature causes Spring MVC try to derive a Pageable instance from the request parameters by using the following default configuration:

Table 1. Request parameters evaluated for Pageable instances

page

Page you want to retrieve. 0-indexed and defaults to 0.

size

Size of the page you want to retrieve. Defaults to 20.

sort

Properties that should be sorted by in the format property,property(,ASC|DESC). Default sort direction is ascending. Use multiple sort parameters if you want to switch directions — for example, ?sort=firstname&sort=lastname,asc.

To customize this behavior, register a bean implementing the PageableHandlerMethodArgumentResolverCustomizer interface or the SortHandlerMethodArgumentResolverCustomizer interface, respectively. Its customize() method gets called, letting you change settings, as shown in the following example:

@Bean SortHandlerMethodArgumentResolverCustomizer sortCustomizer() {
    return s -> s.setPropertyDelimiter("<-->");
}

If setting the properties of an existing MethodArgumentResolver is not sufficient for your purpose, extend either SpringDataWebConfiguration or the HATEOAS-enabled equivalent, override the pageableResolver() or sortResolver() methods, and import your customized configuration file instead of using the @Enable annotation.

If you need multiple Pageable or Sort instances to be resolved from the request (for multiple tables, for example), you can use Spring’s @Qualifier annotation to distinguish one from another. The request parameters then have to be prefixed with ${qualifier}_. The following example shows the resulting method signature:

String showUsers(Model model,
      @Qualifier("thing1") Pageable first,
      @Qualifier("thing2") Pageable second) {  }

you have to populate thing1_page and thing2_page and so on.

The default Pageable passed into the method is equivalent to a PageRequest.of(0, 20) but can be customized by using the @PageableDefault annotation on the Pageable parameter.

Hypermedia Support for Pageables

Spring HATEOAS ships with a representation model class (PagedResources) that allows enriching the content of a Page instance with the necessary Page metadata as well as links to let the clients easily navigate the pages. The conversion of a Page to a PagedResources is done by an implementation of the Spring HATEOAS ResourceAssembler interface, called the PagedResourcesAssembler. The following example shows how to use a PagedResourcesAssembler as a controller method argument:

Example 52. Using a PagedResourcesAssembler as controller method argument
@Controller
class PersonController {

  @Autowired PersonRepository repository;

  @RequestMapping(value = "/persons", method = RequestMethod.GET)
  HttpEntity<PagedResources<Person>> persons(Pageable pageable,
    PagedResourcesAssembler assembler) {

    Page<Person> persons = repository.findAll(pageable);
    return new ResponseEntity<>(assembler.toResources(persons), HttpStatus.OK);
  }
}

Enabling the configuration as shown in the preceding example lets the PagedResourcesAssembler be used as a controller method argument. Calling toResources(…) on it has the following effects:

  • The content of the Page becomes the content of the PagedResources instance.

  • The PagedResources object gets a PageMetadata instance attached, and it is populated with information from the Page and the underlying PageRequest.

  • The PagedResources may get prev and next links attached, depending on the page’s state. The links point to the URI to which the method maps. The pagination parameters added to the method match the setup of the PageableHandlerMethodArgumentResolver to make sure the links can be resolved later.

Assume we have 30 Person instances in the database. You can now trigger a request (GET http://localhost:8080/persons) and see output similar to the following:

{ "links" : [ { "rel" : "next",
                "href" : "http://localhost:8080/persons?page=1&size=20 }
  ],
  "content" : [
     … // 20 Person instances rendered here
  ],
  "pageMetadata" : {
    "size" : 20,
    "totalElements" : 30,
    "totalPages" : 2,
    "number" : 0
  }
}

You see that the assembler produced the correct URI and also picked up the default configuration to resolve the parameters into a Pageable for an upcoming request. This means that, if you change that configuration, the links automatically adhere to the change. By default, the assembler points to the controller method it was invoked in, but that can be customized by handing in a custom Link to be used as base to build the pagination links, which overloads the PagedResourcesAssembler.toResource(…) method.

6.8.2. Repository Populators

If you work with the Spring JDBC module, you are probably familiar with the support to populate a DataSource with SQL scripts. A similar abstraction is available on the repositories level, although it does not use SQL as the data definition language because it must be store-independent. Thus, the populators support XML (through Spring’s OXM abstraction) and JSON (through Jackson) to define data with which to populate the repositories.

Assume you have a file data.json with the following content:

Example 53. Data defined as JSON
[
        {
                "_class": "org.neo4j.doc.springframework.data.docs.repositories.populators.MovieEntity",
                "title": "All The Way, Boys",
                "description": "A funny movie.",
                "actors": [
                        {
                                "name": "Terence Hill",
                                "born": 1939
                        },
                        {
                                "name": "Bud Spencer",
                                "born": 1929
                        }
                ],
                "directors": [
                        {
                                "name": "Giuseppe Colizzi",
                                "born": 1925
                        }
                ]
        },
        {
                "_class": "org.neo4j.doc.springframework.data.docs.repositories.populators.MovieEntity",
                "title": "Double Trouble",
                "description": "Another funny movie.",
                "actors": [
                        {
                                "name": "Terence Hill",
                                "born": 1939
                        },
                        {
                                "name": "Bud Spencer",
                                "born": 1929
                        }
                ],
                "directors": [
                        {
                                "name": "Enzo Barboni",
                                "born": 1922
                        }
                ]
        }
]

The _class keys point to your domain class, in this case a MovieEntity

Example 54. Corresponding entity
@Node("Movie")
public class MovieEntity {

        @Id
        private final String title;

        @Property("tagline")
        private final String description;

        @Relationship(type = "ACTED_IN", direction = INCOMING)
        private Set<PersonEntity> actors;

        @Relationship(type = "DIRECTED", direction = INCOMING)
        private Set<PersonEntity> directors;

        public MovieEntity(String title, String description) {
                this.title = title;
                this.description = description;
        }
        // Getters and setters ommitted.
}

If you don’t provide a custom constructor, you need to help the Jackson JSON library a bit by providing a so called mixin, teaching Jackson how to instantiate the object:

Example 55. Optional Jackson module helping Jackson with your domain
import org.springframework.stereotype.Component;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.module.SimpleModule;

@Component
public class MovieModule extends SimpleModule {

        public MovieModule() {
                setMixInAnnotation(MovieEntity.class, MovieEntityMixin.class);

        abstract static class MovieEntityMixin {
                @JsonCreator MovieEntityMixin(@JsonProperty("title") final String title,
                        @JsonProperty("description") final String description) {
                }
        }

}

And finally, you declare a FactoryBean<ResourceReaderRepositoryPopulator in your application’s configuration:

Example 56. A JSON repository populator based on Jackson
import org.springframework.beans.factory.FactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.data.repository.init.Jackson2RepositoryPopulatorFactoryBean;
import org.springframework.data.repository.init.ResourceReaderRepositoryPopulator;

import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
public class PopulatorConfig {

        @Bean
        public FactoryBean<ResourceReaderRepositoryPopulator> respositoryPopulator(
                ObjectMapper objectMapper, (1)
                ResourceLoader resourceLoader) {

                Jackson2RepositoryPopulatorFactoryBean factory = new Jackson2RepositoryPopulatorFactoryBean();
                factory.setMapper(objectMapper);
                factory.setResources(new Resource[] { resourceLoader.getResource("classpath:data.json") }); (2)
                return factory;
        }
}
1 It is important that you inject the ObjectMapper from the context as this takes care of all registered Jackson Modules
2 Here you point to data.json resource

The preceding declaration causes the data.json file to be read and deserialized by the Jackson ObjectMapper.

The type to which the JSON object is unmarshalled is determined by inspecting the _class attribute of the JSON document. The infrastructure eventually selects the appropriate repository to handle the object that was deserialized.

To instead use XML to define the data the repositories should be populated with, you need to use a UnmarshallerRepositoryPopulatorFactoryBean and a JAXB2 marshaller.

7. Projections

Spring Data query methods usually return one or multiple instances of the aggregate root managed by the repository. However, it might sometimes be desirable to create projections based on certain attributes of those types. Spring Data allows modeling dedicated return types, to more selectively retrieve partial views of the managed aggregates.

Imagine a repository and aggregate root type such as the following example:

Example 57. A sample aggregate and repository
@Node
public class Person {

        @Id @GeneratedValue private Long id;
        String firstName;
        String lastName;

        @Relationship("LIVES_AT")
        Address address;

        @Node
        static class Address {
                @Id @GeneratedValue private Long id;
                private String zipCode;
                private String city;
                private String street;
        }

}

interface PersonRepository extends Neo4jRepository<Person, Long> {

        List<Person> findByLastName(String lastName);

}

Now imagine that we want to retrieve the person’s name attributes only. What means does Spring Data offer to achieve this? The rest of this chapter answers that question.

7.1. Interface-based Projections

The easiest way to limit the result of the queries to only the name attributes is by declaring an interface that exposes accessor methods for the properties to be read, as shown in the following example:

Example 58. A projection interface to retrieve a subset of attributes
interface NamesOnly {
        String getFirstName();
        String getLastName();
}

The important bit here is that the properties defined here exactly match properties in the aggregate root. Doing so lets a query method be added as follows:

Example 59. A repository using an interface based projection with a query method
interface PersonRepository extends Neo4jRepository<Person, Long> {


        List<NamesOnly> findByFirstName(String firstName);
}

The query execution engine creates proxy instances of that interface at runtime for each element returned and forwards calls to the exposed methods to the target object.

Projections can be used recursively. If you want to include some of the Address information as well, create a projection interface for that and return that interface from the declaration of getAddress(), as shown in the following example:

Example 60. A projection interface to retrieve a subset of attributes
interface PersonSummary {

        String getFirstName();
        String getLastName();
        AddressSummary getAddress();

        interface AddressSummary {
                String getCity();
        }
}

On method invocation, the address property of the target instance is obtained and wrapped into a projecting proxy in turn.

7.1.1. Closed Projections

A projection interface whose accessor methods all match properties of the target aggregate is considered to be a closed projection. The following example (which we used earlier in this chapter, too) is a closed projection:

Example 61. A closed projection
interface NamesOnly {
        String getFirstName();
        String getLastName();
}

If you use a closed projection, Spring Data can optimize the query execution, because we know about all the attributes that are needed to back the projection proxy. For more details on that, see the module-specific part of the reference documentation.

7.1.2. Open Projections

Accessor methods in projection interfaces can also be used to compute new values by using the @Value annotation, as shown in the following example:

Example 62. An Open Projection
interface NamesOnly {

        @Value("#{target.firstName + ' ' + target.lastName}")
        String getFullName();
}

The aggregate root backing the projection is available in the target variable. A projection interface using @Value is an open projection. Spring Data cannot apply query execution optimizations in this case, because the SpEL expression could use any attribute of the aggregate root.

The expressions used in @Value should not be too complex — you want to avoid programming in String variables. For very simple expressions, one option might be to resort to default methods (introduced in Java 8), as shown in the following example:

Example 63. A projection interface using a default method for custom logic
interface NamesOnly {
        String getFirstName();
        String getLastName();

        default String getName() {
                return getFirstName().concat(" ").concat(getLastName());
        }

        @Value("#{@nameBean.getFullName(target)}")
        String getFullNameFromBean();

        @Value("#{args[0] + ' ' + target.firstname + '!'}")
        String getSalutation(String prefix);
}

This approach requires you to be able to implement logic purely based on the other accessor methods exposed on the projection interface. A second, more flexible, option is to implement the custom logic in a Spring bean and then invoke that from the SpEL expression, as shown in the following example:

Example 64. Sample Person object
@Component
class NameBean {

        String getFullName(Person person) {
                return person.firstName + " " + person.lastName;
        }
}

interface NamesOnly {

        @Value("#{@nameBean.getFullName(target)}")
        String getFullNameFromBean();
}

Notice how the SpEL expression refers to nameBean and invokes the getFullName(…) method and forwards the projection target as a method parameter. Methods backed by SpEL expression evaluation can also use method parameters, which can then be referred to from the expression. The method parameters are available through an Object array named args. The following example shows how to get a method parameter from the args array:

Example 65. Sample Person object
interface NamesOnly {

        @Value("#{args[0] + ' ' + target.firstname + '!'}")
        String getSalutation(String prefix);
}

Again, for more complex expressions, you should use a Spring bean and let the expression invoke a method, as described earlier.

7.2. Class-based Projections (DTOs)

Another way of defining projections is by using value type DTOs (Data Transfer Objects) that hold properties for the fields that are supposed to be retrieved. These DTO types can be used in exactly the same way projection interfaces are used, except that no proxying happens and no nested projections can be applied.

If the store optimizes the query execution by limiting the fields to be loaded, the fields to be loaded are determined from the parameter names of the constructor that is exposed.

The following example shows a projecting DTO:

Example 66. A projecting DTO
public class NamesOnlyDto {

        private final String firstName;
        private final String lastName;

        public NamesOnlyDto(String firstName, String lastName) {
                this.firstName = firstName;
                this.lastName = lastName;
        }

        public String getFirstName() {
                return firstName;
        }

        public String getLastName() {
                return lastName;
        }
}

7.3. Dynamic Projections

So far, we have used the projection type as the return type or element type of a collection. However, you might want to select the type to be used at invocation time (which makes it dynamic). To apply dynamic projections, use a query method such as the one shown in the following example:

Example 67. A repository using a dynamic projection parameter
interface DynamicProjectionPersonRepository extends Neo4jRepository<Person, Long> {

        <T> Collection<T> findByFirstName(String firstName, Class<T> type);
}

This way, the method can be used to obtain the aggregates as is or with a projection applied, as shown in the following example:

Example 68. Using a repository with dynamic projections
class DynamicProjectionService {

        void someMethod(DynamicProjectionPersonRepository people) {
                Collection<Person> daves = people.findByFirstName("Dave", Person.class);

                Collection<NamesOnly> davesWithNameOnly = people.findByFirstName("Dave", NamesOnly.class);
        }
}

8. Testing

We offer org.neo4j.springframework.boot.test.autoconfigure.data.DataNeo4jTest and org.neo4j.springframework.boot.test.autoconfigure.data.ReactiveDataNeo4jTest inside an additional module under the following coordinates: org.neo4j.springframework.data:spring-data-neo4j-rx-spring-boot-test-autoconfigure. Include the following dependency in your project setup

Listing 12. spring-data-neo4j-rx-spring-boot-test-autoconfigure for Maven
<dependency>
    <groupId>org.neo4j.springframework.data</groupId>
    <artifactId>spring-data-neo4j-rx-spring-boot-test-autoconfigure</artifactId>
    <version>1.1.1</version>
    <scope>test</scope>
</dependency>

Or with Gradle

Listing 13. spring-data-neo4j-rx-spring-boot-test-autoconfigure for Gradle
dependencies {
    testImplementation 'org.neo4j.springframework.data:spring-data-neo4j-rx-spring-boot-test-autoconfigure:1.1.1'
}

Both @DataNeo4jTest and @ReactiveDataNeo4jTest are Spring Boot test slices. By default, they provide the Neo4j test harness through the transitive dependency of neo4j-java-driver-test-harness-spring-boot-autoconfigure. Both slices provide all the necessary infrastructure for tests using Neo4j: A driver bean, a transaction manager, a client, a template and declared repositories, in their imperative or reactive variants. @DataNeo4jTest provides both variants if reactive repositories are enabled while @ReactiveDataNeo4jTest provides only reactive infrastructure.

The dependencies include the Neo4j test harness in version 3.5.x by default. Thus, reactive database access and multiple databases cannot be tested out of the box. The reason for doing this is simple: Spring Data’s JDK baseline is JDK 8. The Neo4j test harness in version 4 requires JDK 11+, so we cannot make it the default.

Here are the available options. Both test slices include @ExtendWith(SpringExtension.class) so that they run automatically with JUnit 5 (JUnit Jupiter).

8.1. @DataNeo4jTest

@DataNeo4jTest provides both imperative and reactive infrastructure by default. If you annotate a test with it the test becomes @Transactional.

@Transactional in Spring tests always means imperative transactional, as declarative transactions needs the return type of a method to decide whether the imperative PlatformTransactionManager or the reactive ReactiveTransactionManager kicks in. This is the reason you cannot use @DataNeo4jTest with setting spring.data.neo4j.repositories.type to reactive as this disables imperative infrastructure.

8.1.1. With Neo4j test harness

This is the default. See the imperative template example test. This class uses the included Neo4j test harness 3.5 by default.

Listing 14. TemplateExampleTest.java
@DataNeo4jTest
public class TemplateExampleTest {
}

8.1.2. With Neo4j 4.0 test harness

Include the following dependency in your project setup

Listing 15. Neo4j 4.0 test harness for Maven
<dependency>
    <groupId>org.neo4j.test</groupId>
    <artifactId>neo4j-harness</artifactId>
    <version>4.0.4</version>
    <scope>test</scope>
</dependency>

Or if you like Gradle better:

Listing 16. Neo4j 4.0 test harness for Gradle
dependencies {
    testImplementation 'org.neo4j.test:neo4j-harness:4.0.4'
}
The test setup doesn’t change. @DataNeo4jTest is enough.

This setup works with both imperative and reactive infrastructure.

8.1.3. With Testcontainers

Bring in the required dependencies:

Listing 17. Dependencies for Testcontainers
<dependency>
        <groupId>org.neo4j.springframework.data</groupId>
        <artifactId>spring-data-neo4j-rx-spring-boot-test-autoconfigure</artifactId>
        <version>{spring-data-neo4j-rx-version}</version>
        <scope>test</scope>
        <exclusions>
                <exclusion> (1)
                        <groupId>org.neo4j.test</groupId>
                        <artifactId>neo4j-harness</artifactId>
                </exclusion>
        </exclusions>
</dependency>
<dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>1.13.0</version>
        <scope>test</scope>
</dependency>
<dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>neo4j</artifactId>
        <version>1.13.0</version>
        <scope>test</scope>
</dependency>
1 Be aware of this exclusion. If you don’t exclude that dependency, it will have precedence over any manual configuration of the Neo4j URL.

As of Spring Framework 5.2.5, the TestContext framework provides support for dynamic property sources via the @DynamicPropertySource annotation. This annotation can be used in integration tests that need to add properties with dynamic values. For more information, have a look at the Spring Framework reference.

A @DataNeo4jTest using @DynamicPropertySource together with Testcontainers looks like this:

Listing 18. Configure your Neo4j URLs dynamically in a Spring Boot Test
import org.neo4j.springframework.boot.test.autoconfigure.data.DataNeo4jTest;

import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;

import org.testcontainers.containers.Neo4jContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
@DataNeo4jTest
class ExampleTest {

    @Container
    private static Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.0");

    @DynamicPropertySource
    static void neo4jProperties(DynamicPropertyRegistry registry) {
        registry.add("org.neo4j.driver.uri", neo4jContainer::getBoltUrl);
        registry.add("org.neo4j.driver.authentication.username", () -> "neo4j");
        registry.add("org.neo4j.driver.authentication.password", neo4jContainer::getAdminPassword);
    }
}

An alternative to this approach in older versions of Spring Boot and the Spring Framework is an initializer that looks like this:

Listing 19. Alternative injection of dynamic properties prior to Spring Boot 2.2.6
@Testcontainers
@ContextConfiguration(initializers = PriorToBoot226Test.Initializer.class)
@DataNeo4jTest
class PriorToBoot226Test {

    @Container
    private static Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.0");

    static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
            TestPropertyValues.of(
                "org.neo4j.driver.uri=" + neo4jContainer.getBoltUrl(),
                "org.neo4j.driver.authentication.username=neo4j",
                "org.neo4j.driver.authentication.password=" + neo4jContainer.getAdminPassword()
            ).applyTo(configurableApplicationContext.getEnvironment());
        }
    }
}

If you dont want to exclude org.neo4j.test:neo4j-harness as advised in Listing 17, you can manually exclude the Neo4jTestHarnessAutoConfiguration.class from the test slice like this:

import org.neo4j.driver.springframework.boot.test.autoconfigure.Neo4jTestHarnessAutoConfiguration;
import org.neo4j.springframework.boot.test.autoconfigure.data.DataNeo4jTest;

import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
@DataNeo4jTest(excludeAutoConfiguration = Neo4jTestHarnessAutoConfiguration.class)
public class TemplateExampleTest {
    // Configuration of Neo4j connection as above.
}

8.2. @ReactiveDataNeo4jTest

Everything said about @DataNeo4jTest applies to @ReactiveDataNeo4jTest as well. However, @ReactiveDataNeo4jTest enables reactive infrastructure only and is not meta-annotated with @Transactional, thus it doesn’t depend on a PlatformTransactionManager.

@ReactiveDataNeo4jTest also checks whether the Neo4j instance configured is capable of handling reactive connections.

Our recommendation is to use it together with Testcontainers and exclude the Neo4j test harness dependency.

A typical example would look like this:

Listing 20. RepositoryIT.java
import static org.assertj.core.api.Assertions.*;

import reactor.test.StepVerifier;

import org.junit.jupiter.api.Test;
import org.neo4j.springframework.boot.test.autoconfigure.data.ReactiveDataNeo4jTest;
import org.neo4j.springframework.data.examples.spring_boot.domain.MovieRepository;
import org.neo4j.springframework.data.examples.spring_boot.domain.PersonRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.Neo4jContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
@ReactiveDataNeo4jTest
class RepositoryIT {

        @Container
        private static Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.0");

        @DynamicPropertySource
        static void neo4jProperties(DynamicPropertyRegistry registry) {
                registry.add("org.neo4j.driver.uri", neo4jContainer::getBoltUrl);
                registry.add("org.neo4j.driver.authentication.username", () -> "neo4j");
                registry.add("org.neo4j.driver.authentication.password", neo4jContainer::getAdminPassword);
        }

        @Test
        void loadAllPersonsFromGraph(@Autowired PersonRepository personRepository) {
                int expectedPersonCount = 133;
                StepVerifier.create(personRepository.findAll())
                        .expectNextCount(expectedPersonCount)
                        .verifyComplete();
        }

}

9. Auditing

9.1. Basics

Spring Data provides sophisticated support to transparently keep track of who created or changed an entity and when the change happened. To benefit from that functionality, you have to equip your entity classes with auditing metadata that can be defined either using annotations or by implementing an interface.

9.1.1. Annotation-based Auditing Metadata

We provide @CreatedBy and @LastModifiedBy to capture the user who created or modified the entity as well as @CreatedDate and @LastModifiedDate to capture when the change happened.

Example 69. An audited entity
class Customer {

  @CreatedBy
  private User user;

  @CreatedDate
  private DateTime createdDate;

  // … further properties omitted
}

As you can see, the annotations can be applied selectively, depending on which information you want to capture. The annotations capturing when changes were made can be used on properties of type Joda-Time, DateTime, legacy Java Date and Calendar, JDK8 date and time types, and long or Long.

9.1.2. Interface-based Auditing Metadata

In case you do not want to use annotations to define auditing metadata, you can let your domain class implement the Auditable interface. It exposes setter methods for all of the auditing properties.

There is also a convenience base class, AbstractAuditable, which you can extend to avoid the need to manually implement the interface methods Doing so increases the coupling of your domain classes to Spring Data, which might be something you want to avoid. Usually, the annotation-based way of defining auditing metadata is preferred as it is less invasive and more flexible.

9.1.3. AuditorAware

In case you use either @CreatedBy or @LastModifiedBy, the auditing infrastructure somehow needs to become aware of the current principal. To do so, we provide an AuditorAware<T> SPI interface that you have to implement to tell the infrastructure who the current user or system interacting with the application is. The generic type T defines what type the properties annotated with @CreatedBy or @LastModifiedBy have to be.

The following example shows an implementation of the interface that uses Spring Security’s Authentication object:

Example 70. Implementation of AuditorAware based on Spring Security
class SpringSecurityAuditorAware implements AuditorAware<User> {

  public Optional<User> getCurrentAuditor() {

    return Optional.ofNullable(SecurityContextHolder.getContext())
                          .map(SecurityContext::getAuthentication)
                          .filter(Authentication::isAuthenticated)
                          .map(Authentication::getPrincipal)
                          .map(User.class::cast);
  }
}

The implementation accesses the Authentication object provided by Spring Security and looks up the custom UserDetails instance that you have created in your UserDetailsService implementation. We assume here that you are exposing the domain user through the UserDetails implementation but that, based on the Authentication found, you could also look it up from anywhere.

10. Frequently Asked Questions

Here are a couple of more frequently asked question in addition to the ones in the preface.

10.1. Neo4j 4.0 supports multiple databases - How can I use them?

You can either statically configure the database name or run your own database name provider. Bear in mind that SDN/RX will not create the databases for you. You can do this with the help of a migrations tool or of course with a simple script upfront.

10.1.1. Statically configured

Configure the database name to use in your Spring Boot configuration like this (The same property applies of course for YML or environment based configuration, with Spring Boots conventions applied):

org.neo4j.data.database = yourDatabase

With that configuration in place, all queries generated by all instances of SDN/RX repositories (both reactive and imperative) and by the ReactiveNeo4jTemplate respectively Neo4jTemplate will be executed against the database yourDatabase.

10.1.2. Dynamically configured

Provide a bean with the type Neo4jDatabaseNameProvider or ReactiveDatabaseSelectionProvider depending on the type of your Spring application.

That bean could use for example Spring’s security context to retrieve a tenant. Here is a working example for an imperative application secured with Spring Security:

Listing 21. Neo4jConfig.java
import org.neo4j.springframework.data.core.DatabaseSelection;
import org.neo4j.springframework.data.core.DatabaseSelectionProvider;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;

@Configuration
public class Neo4jConfig {

        @Bean
        DatabaseSelectionProvider databaseSelectionProvider() {

                return () -> Optional.ofNullable(SecurityContextHolder.getContext())
                        .map(SecurityContext::getAuthentication)
                        .filter(Authentication::isAuthenticated)
                        .map(Authentication::getPrincipal)
                        .map(User.class::cast)
                        .map(User::getUsername)
                        .map(DatabaseSelection::byName)
                        .orElseGet(DatabaseSelection::undecided);
        }
}
Be careful that you don’t mix up entities retrieved from one database with another database. The database name is requested for each new transaction, so you might end up with less or more entities than expected when changing the database name in between calls. Or worse, you could inevitable store the wrong entities in the wrong database.

10.2. Do I need specific configuration so that transactions work seamless with a Neo4j Causal Cluster?

No, you don’t. SDN/RX uses Neo4j Causal Cluster bookmarks internally without any configuration on your side required. Transactions in the same thread or the same reactive stream following each other will be able to read their previously changed values as you would expect.

10.3. Do I need to use Neo4j specific annotations?

No. You are free to use the following, equivalent Spring Data annotations:

SDN/RX Neo4j specific annotation Spring Data common annotation Purpose Difference

org.neo4j.springframework.data.core.schema.Id

org.springframework.data.annotation.Id

Marks the annotated attribute as the unique id.

Specific annotation has no additional features.

org.neo4j.springframework.data.core.schema.Node

org.springframework.data.annotation.Persistent

Marks the class as persistent entity.

@Node allows customizing the labels

10.4. How do I use assigned ids?

Just @Id without @GeneratedValue and fill your id attribute via a constructor parameter or a setter or wither. See this blog post for some general remarks about finding good ids.

10.5. How do I use externally generated ids?

We provide the interface org.neo4j.springframework.data.core.schema.IdGenerator. Implement it anyway you want and configure your implementation like this:

Listing 22. ThingWithGeneratedId.java
@Node
public class ThingWithGeneratedId {

        @Id @GeneratedValue(TestSequenceGenerator.class)
        private String theId;
}

If you pass in the name of a class to @GeneratedValue, this class must have a no-args default constructor. You can however use a string as well:

Listing 23. ThingWithIdGeneratedByBean.java
@Node
public class ThingWithIdGeneratedByBean {

        @Id @GeneratedValue(generatorRef = "idGeneratingBean")
        private String theId;
}

With that, idGeneratingBean refers to a bean in the Spring context. This might be useful for sequence generating.

Setters are not required on non-final fields for the id.

10.6. Do I have to create repositories for each domain class?

No. Have a look at the SDN/RX building blocks and find the Neo4jTemplate respectively the ReactiveNeo4jTemplate.

Those templates know your domain and provide all necessary basic CRUD methods for retrieving, writing and counting entities.

This is our canonical movie example with the imperative template:

Listing 24. TemplateExampleTest.java
import static java.util.Collections.*;
import static org.assertj.core.api.Assertions.*;

import java.util.Optional;

import org.junit.jupiter.api.Test;
import org.neo4j.springframework.boot.test.autoconfigure.data.DataNeo4jTest;
import org.neo4j.springframework.data.core.Neo4jTemplate;
import org.neo4j.springframework.data.examples.spring_boot.domain.MovieEntity;
import org.neo4j.springframework.data.examples.spring_boot.domain.PersonEntity;
import org.neo4j.springframework.data.examples.spring_boot.domain.Roles;
import org.springframework.beans.factory.annotation.Autowired;

@DataNeo4jTest
public class TemplateExampleTest {
        @Test
        void shouldSaveAndReadEntities(@Autowired Neo4jTemplate neo4jTemplate) {

                MovieEntity movie = new MovieEntity(
                        "The Love Bug",
                        "A movie that follows the adventures of Herbie, Herbie's driver, "
                                + "Jim Douglas (Dean Jones), and Jim's love interest, "
                                + "Carole Bennett (Michele Lee)");

                movie.getActorsAndRoles().put(new PersonEntity(1931, "Dean Jones"), new Roles(singletonList("Didi")));
                movie.getActorsAndRoles().put(new PersonEntity(1942, "Michele Lee"), new Roles(singletonList("Michi")));

                neo4jTemplate.save(movie);

                Optional<PersonEntity> person = neo4jTemplate
                        .findById("Dean Jones", PersonEntity.class);
                assertThat(person).map(PersonEntity::getBorn).hasValue(1931);

                assertThat(neo4jTemplate.count(PersonEntity.class)).isEqualTo(2L);
        }
}

And here is the reactive version, omitting the setup for brevity:

Listing 25. ReactiveTemplateExampleTest.java
import static java.util.Collections.*;

import reactor.test.StepVerifier;

import org.junit.jupiter.api.Test;
import org.neo4j.springframework.boot.test.autoconfigure.data.ReactiveDataNeo4jTest;
import org.neo4j.springframework.data.core.ReactiveNeo4jTemplate;
import org.neo4j.springframework.data.examples.spring_boot.domain.MovieEntity;
import org.neo4j.springframework.data.examples.spring_boot.domain.PersonEntity;
import org.neo4j.springframework.data.examples.spring_boot.domain.Roles;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.Neo4jContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
@ReactiveDataNeo4jTest
class ReactiveTemplateExampleTest {

        @Container
        private static Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.0");

        @DynamicPropertySource
        static void neo4jProperties(DynamicPropertyRegistry registry) {
                registry.add("org.neo4j.driver.uri", neo4jContainer::getBoltUrl);
                registry.add("org.neo4j.driver.authentication.username", () -> "neo4j");
                registry.add("org.neo4j.driver.authentication.password", neo4jContainer::getAdminPassword);
        }

        @Test
        void shouldSaveAndReadEntities(@Autowired ReactiveNeo4jTemplate neo4jTemplate) {

                MovieEntity movie = new MovieEntity(
                        "The Love Bug",
                        "A movie that follows the adventures of Herbie, Herbie's driver, "
                                + "Jim Douglas (Dean Jones), and Jim's love interest, "
                                + "Carole Bennett (Michele Lee)");

                movie.getActorsAndRoles().put(new PersonEntity(1931, "Dean Jones"), new Roles(singletonList("Didi")));
                movie.getActorsAndRoles().put(new PersonEntity(1942, "Michele Lee"), new Roles(singletonList("Michi")));

                StepVerifier.create(neo4jTemplate.save(movie))
                        .expectNextCount(1L)
                        .verifyComplete();

                StepVerifier.create(neo4jTemplate
                        .findById("Dean Jones", PersonEntity.class)
                        .map(PersonEntity::getBorn)
                )
                        .expectNext(1931)
                        .verifyComplete();

                StepVerifier.create(neo4jTemplate.count(PersonEntity.class))
                        .expectNext(2L)
                        .verifyComplete();
        }
}

10.7. How do I specify parameters in custom queries?

You do this exactly the same way as in a standard Cypher query issued in the Neo4j Browser or the Cypher-Shell, with the $ syntax (from Neo4j 4.0 on upwards, the old {foo} syntax for Cypher parameters has been removed from the database);

Listing 26. ARepository.java
public interface ARepository extends Neo4jRepository<AnAggregateRoot, String> {

        @Query("MATCH (a:AnAggregateRoot {name: $name}) RETURN a") (1)
        Optional<AnAggregateRoot> findByCustomQuery(String name);
}
1 Here we are referring to the parameter by its name. You can also use $0 etc. instead.
You need to compile your Java 8+ project with -parameters to make named parameters work without further annotations. The Spring Boot Maven and Gradle plugins do this automatically for you. If this is not feasible for any reason, you can either add @Param and specify the name explicitly or use the parameters index.

10.8. How do I use Spring Expression Language in custom queries?

Spring Expression Language (SpEL) can be used in custom queries inside :#{}. This is the standard Spring Data way of defining a block of text inside a query that undergoes SpEL evaluation.

The following example basically defines the same query as above, but uses a WHERE clause to avoid even more curly braces:

Listing 27. ARepository.java
public interface ARepository extends Neo4jRepository<AnAggregateRoot, String> {

        @Query("MATCH (a:AnAggregateRoot) WHERE a.name = :#{#pt1 + #pt2} RETURN a")
        Optional<AnAggregateRoot> findByCustomQueryWithSpEL(String pt1, String pt2);
}

The SpEL blocked starts with :#{ and than refers to the given String parameters by name (#pt1). Don’t confuse this with the above Cypher syntax! The SpEL expression concatenates both parameters into one single value that is eventually passed on to the Neo4jClient. The SpEL block ends with }.

10.9. How do I audit entities?

All Spring Data annotations are supported. Those are

  • org.springframework.data.annotation.CreatedBy

  • org.springframework.data.annotation.CreatedDate

  • org.springframework.data.annotation.LastModifiedBy

  • org.springframework.data.annotation.LastModifiedDate

10.10. How do I use "Find by example"?

"Find by example" is a new feature in SDN/RX. You instantiate an entity or use an existing one. With this instance you create an org.springframework.data.domain.Example. If your repository extends org.neo4j.springframework.data.repository.Neo4jRepository or org.neo4j.springframework.data.repository.ReactiveNeo4jRepository, you can immediately use the available findBy methods taking in an example, like shown in Listing 28

Listing 28. findByExample in Action
Example<MovieEntity> movieExample = Example.of(new MovieEntity("The Matrix", null));
Flux<MovieEntity> movies = this.movieRepository.findAll(movieExample);

movieExample = Example.of(
        new MovieEntity("Matrix", null),
        ExampleMatcher
            .matchingAny()
        .withMatcher(
                "title",
                ExampleMatcher.GenericPropertyMatcher.of(ExampleMatcher.StringMatcher.CONTAINING)
        )
);
movies = this.movieRepository.findAll(movieExample);

11. Appendix

Conversions

We support a broad range of conversions out of the box. Find the list of supported cypher types in the official drivers manual: Working with Cypher values.

Primitive types of wrapper types are equally supported.

Domain type Cypher type Maps directly to native type

java.lang.Boolean

Boolean

boolean[]

List of Boolean

java.lang.Long

Integer

long[]

List of Integer

java.lang.Double

Float

java.lang.String

String

java.lang.String[]

List of String

byte[]

ByteArray

java.lang.Byte

ByteArray with length 1

java.lang.Character

String with length 1

char[]

List of String with length 1

java.util.Date

String formatted as ISO 8601 Date (yyyy-MM-dd’T’HH:mm:ss.SSSZ). Notice the Z: SDN/RX will store all java.util.Date instances in UTC. If you require the time zone, use a type that supports it (i.e. ZoneDateTime) or store the zone as a separate property.

double[]

List of Float

java.lang.Float

String

float[]

List of String

java.lang.Integer

Integer

int[]

List of Integer

java.util.Locale

String formatted as BCP 47 language tag

java.lang.Short

Integer

short[]

List of Integer

java.math.BigDecimal

String

java.math.BigInteger

String

java.time.LocalDate

Date

java.time.OffsetTime

Time

java.time.LocalTime

LocalTime

java.time.ZonedDateTime

DateTime

java.time.LocalDateTime

LocalDateTime

java.time.Period

Duration

java.time.Duration

Duration

org.neo4j.driver.types.IsoDuration

Duration

org.neo4j.driver.types.Point

Point

org.neo4j.springframework.data.types.GeographicPoint2d

Point with CRS 4326

org.neo4j.springframework.data.types.GeographicPoint3d

Point with CRS 4979

org.neo4j.springframework.data.types.CartesianPoint2d

Point with CRS 7203

org.neo4j.springframework.data.types.CartesianPoint3d

Point with CRS 9157

org.springframework.data.geo.Point

Point with CRS 4326 and x/y corresponding to lat/long

Instances of Enum

String (The name value of the enum)

Instances of Enum[]

List of String (The name value of the enum)

Custom conversions

If you prefer to work with your own types in the entities or as parameters for @Query annotated methods, you can define and provide a custom converter implementation. First you have to implement a GenericConverter and register the types your converter should handle. For entity property type converters you need to take care of converting your type to and from a Neo4j Java Driver Value. If your converter is supposed to work only with custom query methods in the repositories, it is sufficient to provide the one-way conversion to the Value type.

Listing 29. Example of a custom converter implementation
public class MyCustomTypeConverter implements GenericConverter {

        @Override
        public Set<ConvertiblePair> getConvertibleTypes() {
                Set<ConvertiblePair> convertiblePairs = new HashSet<>();
                convertiblePairs.add(new ConvertiblePair(MyCustomType.class, Value.class));
                convertiblePairs.add(new ConvertiblePair(Value.class, MyCustomType.class));
                return convertiblePairs;
        }

        @Override
        public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
                if (MyCustomType.class.isAssignableFrom(sourceType.getType())) {
                        // convert to Neo4j Driver Value
                        return convertToNeo4jValue(source);
                } else {
                        // convert to MyCustomType
                        return convertToMyCustomType(source);
                }
        }
}

To make SDN/RX aware of your converter, it has to be registered in the Neo4jConversions. To do this, you have to create a @Bean with the type org.neo4j.springframework.data.core.convert.Neo4jConversions. Otherwise, the Neo4jConversions will get created in the background with the internal default converters only.

Listing 30. Example of a custom converter implementation
@Bean
public Neo4jConversions neo4jConversions() {
        Set<GenericConverter> additionalConverters = Collections.singleton(new MyCustomTypeConverter());
        return new Neo4jConversions(additionalConverters);
}

If you need multiple converters in your application, you can add as many as you need in the Neo4jConversions constructor.

Repository query keywords

The following table lists the keywords supported by the Spring Data Neo4j⚡RX repository query derivation mechanism.

Table 2. Query keywords
Logical keyword Keyword expressions

AND

And

OR

Or

AFTER

After, IsAfter

BEFORE

Before, IsBefore

CONTAINING

Containing, IsContaining, Contains

BETWEEN

Between, IsBetween

ENDING_WITH

EndingWith, IsEndingWith, EndsWith

EXISTS

Exists

FALSE

False, IsFalse

GREATER_THAN

GreaterThan, IsGreaterThan

GREATER_THAN_EQUALS

GreaterThanEqual, IsGreaterThanEqual

IN

In, IsIn

IS

Is, Equals, (or no keyword)

IS_EMPTY

IsEmpty, Empty

IS_NOT_EMPTY

IsNotEmpty, NotEmpty

IS_NOT_NULL

NotNull, IsNotNull

IS_NULL

Null, IsNull

LESS_THAN

LessThan, IsLessThan

LESS_THAN_EQUAL

LessThanEqual, IsLessThanEqual

LIKE

Like, IsLike

NEAR

Near, IsNear

NOT

Not, IsNot

NOT_IN

NotIn, IsNotIn

NOT_LIKE

NotLike, IsNotLike

REGEX

Regex, MatchesRegex, Matches

STARTING_WITH

StartingWith, IsStartingWith, StartsWith

TRUE

True, IsTrue

WITHIN

Within, IsWithin

Repository query return types

The following table lists the return types generally supported by SDN/RX repositories.

Table 3. Query return types
Return type Description

void

Denotes no return value.

Primitives

Java primitives.

Wrapper types

Java wrapper types.

T

An unique entity. Expects the query method to return one result at most. If no result is found, null is returned. More than one result triggers an IncorrectResultSizeDataAccessException.

Iterator<T>

An Iterator.

Collection<T>

A Collection.

List<T>

A List.

Optional<T>

A Java 8 or Guava Optional. Expects the query method to return one result at most. If no result is found, Optional.empty() or Optional.absent() is returned. More than one result triggers an IncorrectResultSizeDataAccessException.

Option<T>

Either a Scala or Vavr Option type. Semantically the same behavior as Java 8’s Optional, described earlier.

Stream<T>

A Java 8 Stream.

Streamable<T>

A convenience extension of Iterable that directy exposes methods to stream, map and filter results, concatenate them etc.

Types that implement Streamable and take a Streamable constructor or factory method argument

Types that expose a constructor or ….of(…)/….valueOf(…) factory method taking a Streamable as argument. See Section 6.4.6.2 for details.

Vavr Seq, List, Map, Set

Vavr collection types. See Section 6.4.6.3 for details.

Future<T>

A Future. Expects a method to be annotated with @Async and requires Spring’s asynchronous method execution capability to be enabled.

CompletableFuture<T>

A Java 8 CompletableFuture. Expects a method to be annotated with @Async and requires Spring’s asynchronous method execution capability to be enabled.

ListenableFuture

A org.springframework.util.concurrent.ListenableFuture. Expects a method to be annotated with @Async and requires Spring’s asynchronous method execution capability to be enabled.

Slice

A sized chunk of data with an indication of whether there is more data available. Requires a Pageable method parameter.

Page<T>

A Slice with additional information, such as the total number of results. Requires a Pageable method parameter.

Mono<T>

A Project Reactor Mono emitting zero or one element using reactive repositories. Expects the query method to return one result at most. If no result is found, Mono.empty() is returned. More than one result triggers an IncorrectResultSizeDataAccessException.

Flux<T>

A Project Reactor Flux emitting zero, one, or many elements using reactive repositories. Queries returning Flux can emit also an infinite number of elements.

Neo4jClient

Spring Data Neo4j⚡RX comes with a Neo4j Client, providing a thin layer on top of Neo4j’s Java driver.

While the plain Java driver is a very versatile tool providing an asynchronous API in addition to the imperative and reactive versions, it doesn’t integrate with Spring application level transactions.

SDN/RX uses the driver through the concept of a idiomatic client as directly as possible.

The client has the following main goals

  1. Integrate into Springs transaction management, for both imperative and reactive scenarios

  2. Participate in JTA-Transactions if necessary

  3. Provide a consistent API for both imperative and reactive scenarios

  4. Don’t add any mapping overhead

SDN/RX relies on all those features and uses them to fulfill its entity mapping features.

Have a look at the SDN/RX building blocks for where both the imperative and reactive Neo4 clients are positioned in our stack.

The Neo4j Client comes in two flavors:

  • org.neo4j.springframework.data.core.Neo4jClient

  • org.neo4j.springframework.data.core.ReactiveNeo4jClient

While both versions provide an API using the same vocabulary and syntax, they are not API compatible. Both versions feature the same, fluent API to specify queries, bind parameters and extract results.

Imperative or reactive?

Interactions with a Neo4j Client usually ends with a call to

  • fetch().one()

  • fetch().first()

  • fetch().all()

  • run()

The imperative version will interact at this moment with the database and get the requested results or summary, wrapped in a Optional<> or a Collection.

The reactive version will in contrast return a publisher of the requested type. Interaction with the database and retrieval of the results will not happen until the publisher is subscribed to. The publisher can only be subscribed once.

Getting an instance of the client

As with most things in SDN/RX, both clients depend on a configured driver instance.

Listing 31. Creating an instance of the imperative Neo4j client
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;

import org.neo4j.springframework.data.core.Neo4jClient;

public class Demo {

    public static void main(String...args) {

        Driver driver = GraphDatabase
            .driver("neo4j://localhost:7687", AuthTokens.basic("neo4j", "secret"));

        Neo4jClient client = Neo4jClient.create(driver);
    }
}

The driver can only open a reactive session against a 4.0 database and will fail with an exception on any lower version.

Listing 32. Creating an instance of the reactive Neo4j client
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;

import org.neo4j.springframework.data.core.ReactiveNeo4jClient;

public class Demo {

    public static void main(String...args) {

        Driver driver = GraphDatabase
            .driver("neo4j://localhost:7687", AuthTokens.basic("neo4j", "secret"));

        ReactiveNeo4jClient client = ReactiveNeo4jClient.create(driver);
    }
}
Make sure you use the same driver instance for the client as you used for providing a Neo4jTransactionManager or ReactiveNeo4jTransactionManager in case you have enabled transactions. The client won’t be able to synchronize transactions if you use another instance of a driver.

Our Spring Boot starter provide a ready to use bean of the Neo4j Client that fit the environment (imperative or reactive) and you usually don’t have to configure your own instance.

Usage

Selecting the target database

The Neo4j client is well prepared to be used with the multidatabase features of Neo4j 4.0. The client uses the default database unless you specify otherwise. The fluent API of the client allows to specify the target database exactly once, after the declaration of the query to execute. Listing 33 demonstrates it with the reactive client:

Listing 33. Selecting the target database
Flux<Map<String, Object>> allActors = client
        .query("MATCH (p:Person) RETURN p")
        .in("neo4j") (1)
        .fetch()
        .all();
1 Select the target database in which the query is to be executed.
Specifying queries

The interaction with the clients starts with a query. A query can be defined by a plain String or a Supplier<String>. The supplier will be evaluated as late as possible and can be provided by any query builder.

Listing 34. Specifying a query
Mono<Map<String, Object>> firstActor = client
        .query(() -> "MATCH (p:Person) RETURN p")
        .fetch()
        .first();
Retrieving results

As the previous listings shows, the interaction with the client always ends with a call to fetch and how many results shall be received. Both reactive and imperative client offer

one()

Expect exactly one result from the query

first()

Expect results and return the first record

all()

Retrieve all records returned

The imperative client returns Optional<T> and Collection<T> respectively, while the reactive client returns Mono<T> and Flux<T>, the later one being executed only if subscribed to.

If you don’t expect any results from your query, than use run() after specificity the query.

Listing 35. Retrieving result summaries in a reactive way
Mono<ResultSummary> summary = reactiveClient
    .query("MATCH (m:Movie) where m.title = 'Aeon Flux' DETACH DELETE m")
    .run();

summary
    .map(ResultSummary::counters)
    .subscribe(counters ->
        System.out.println(counters.nodesDeleted() + " nodes have been deleted")
    ); (1)
1 The actual query is triggered here by subscribing to the publisher.

Please take a moment to compare both listings and understand the difference when the actual query is triggered.

Listing 36. Retrieving result summaries in a imperative way
ResultSummary resultSummary = imperativeClient
        .query("MATCH (m:Movie) where m.title = 'Aeon Flux' DETACH DELETE m")
        .run(); (1)

SummaryCounters counters = resultSummary.counters();
System.out.println(counters.nodesDeleted() + " nodes have been deleted")
1 Here the query is triggered immediate.
Mapping parameters

Queries can contain named parameters ($someName). The Neo4j client allows comfortable binding to those.

The client doesn’t check whether all parameters are bound or whether there are to many values. That is left to the driver. However the client prevents you from using a parameter name twice.

You can either map simple types that the Java driver understands or complex classes. Please have a look at the drivers manual, to see which simple types are understood.

Listing 37. Mapping simple types
Map<String, Object> parameters = new HashMap<>();
parameters.put("name", "Li.*");

Flux<Map<String, Object>> directorAndMovies = client
        .query(
                "MATCH (p:Person) - [:DIRECTED] -> (m:Movie {title: $title}), (p) - [:WROTE] -> (om:Movie) " +
                        "WHERE p.name =~ $name " +
                        "  AND p.born < $someDate.year " +
                        "RETURN p, om"
        )
        .bind("The Matrix").to("title") (1)
        .bind(LocalDate.of(1979, 9, 21)).to("someDate")
        .bindAll(parameters) (2)
        .fetch()
        .all();
1 There’s a fluent API for binding simple types.
2 Alternatively parameters can be bound via a map of named parameters.

SDN/RX does a lot of complex mapping and it uses the same API that you can use from the client.

You can provide a Function<T, Map<String, Object>> for any given domain object like an owner of bicycles in Listing 38 to the Neo4j Client to map those domain objects to parameters the driver can understand.

Listing 38. Example of a domain type
public class Director {

    private final String name;

    private final List<Movie> movies;

    Director(String name, List<Movie> movies) {
        this.name = name;
        this.movies = new ArrayList<>(movies);
    }

    public String getName() {
        return name;
    }

    public List<Movie> getMovies() {
        return Collections.unmodifiableList(movies);
    }
}

public class Movie {

    private final String title;

    public Movie(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }
}

The mapping function has to fill in all named parameters that might occur in the query like Listing 39 shows:

Listing 39. Using a mapping function for binding domain objects
Director joseph = new Director("Joseph Kosinski",
        Arrays.asList(new Movie("Tron Legacy"), new Movie("Top Gun: Maverick")));

Mono<ResultSummary> summary = client
    .query(""
        + "MERGE (p:Person {name: $name}) "
        + "WITH p UNWIND $movies as movie "
        + "MERGE (m:Movie {title: movie}) "
        + "MERGE (p) - [o:DIRECTED] -> (m) "
    )
    .bind(joseph).with(director -> { (1)
        Map<String, Object> mappedValues = new HashMap<>();
        List<String> movies = director.getMovies().stream()
            .map(Movie::getTitle).collect(Collectors.toList());
        mappedValues.put("name", director.getName());
        mappedValues.put("movies", movies);
        return mappedValues;
    })
    .run();
1 The with method allows for specifying the binder function.
Working with result objects

Both clients return collections or publishers of maps (Map<String, Object>). Those maps corresponds exactly with the records that a query might have produced.

In addition, you can plugin your own BiFunction<TypeSystem, Record, T> through fetchAs to reproduce your domain object.

Listing 40. Using a mapping function for reading domain objects
Mono<Director> lily = client
    .query(""
        + " MATCH (p:Person {name: $name}) - [:DIRECTED] -> (m:Movie)"
        + "RETURN p, collect(m) as movies")
    .bind("Lilly Wachowski").to("name")
    .fetchAs(Director.class).mappedBy((TypeSystem t, Record record) -> {
        List<Movie> movies = record.get("movies")
            .asList(v -> new Movie((v.get("title").asString())));
        return new Director(record.get("name").asString(), movies);
    })
    .one();

TypeSystem gives access to the types the underlying Java driver used to fill the record.

Interacting directly with the driver while using managed transactions

In case you don’t want or don’t like the opinionated "client" approach of the Neo4jClient or the ReactiveNeo4jClient, you can have the client delegate all interactions with the database to your code. The interaction after the delegation is slightly different with the imperative and reactive versions of the client.

The imperative version takes in a Function<StatementRunner, Optional<T>> as a callback. Returning an empty optional is ok.

Listing 41. Delegate database interaction to an imperative StatementRunner
Optional<Long> result = client
    .delegateTo((StatementRunner runner) -> {
        // Do as many interactions as you want
        long numberOfNodes = runner.run("MATCH (n) RETURN count(n) as cnt")
            .single().get("cnt").asLong();
        return Optional.of(numberOfNodes);
    })
    // .in("aDatabase") (1)
    .run();
1 The database selection as described in Selecting the target database is optional.

The reactive version receives a RxStatementRunner.

Listing 42. Delegate database interaction to a reactive RxStatementRunner
Mono<Integer> result = client
    .delegateTo((RxStatementRunner runner) ->
        Mono.from(runner.run("MATCH (n:Unused) DELETE n").summary())
            .map(ResultSummary::counters)
            .map(SummaryCounters::nodesDeleted))
    // .in("aDatabase") (1)
    .run();
1 Optional selection of the target database.

Note that in both Listing 41 and Listing 42 the types of the runner have only been stated to provide more clarity to reader of this manual.

The Cypher-DSL

The Cypher-DSL is considered EXPERIMENTAL at the time of writing. This means you can and should use it and that we are looking actively for feedback, issues and problems. We will try to keep breaking changes to a minimum, but we reserve the right to modify public methods, parameters and behaviour in case we need those changes for SDN/RX itself. All public classes inside org.neo4j.springframework.data.core.cypher are annotated with @API(status = EXPERIMENTAL, since = "1.0"), We will switching to stable some time after a 1.0 release.

Purpose

The Cypher-DSL has been developed with the needs of SDN/RX in mind: We wanted to avoid string concatenations in our query generation and decided do go with a builder approach, much like we find with jOOQ or in the relational module of Spring Data JDBC, but for Cypher.

What we don’t have - and don’t need for our mapping purpose - at the moment is a code generator that reads the database schema and generates static classes representing labels and relationship types. That is still up to the mapping framework (in our case SDN/RX). We however have a type safe API for Cypher that allows only generating valid Cypher constructs.

We worked closely with the OpenCypher spec here and you find a lot of these concepts in the API.

The Cypher-DSL can also be seen in the same area as the Criteria API of Spring Data Mongo.

Where to use it

The Cypher-DSL is publicly visible in the Neo4jOperations respectively ReactiveNeo4jOperations. Those are the basic interfaces implemented by the Neo4j templates of the same names (Read more about the templates here).

Both the imperative and the reactive framework allow the retrieval and counting of entities with a org.neo4j.springframework.data.core.cypher.Statement, for example through Neo4jTemplate#findAll(Statement, Class<T>) and similar.

An instance of a org.neo4j.springframework.data.core.cypher.Statement is provided at the end of query building step.

A Statement represents an in-memory Abstract syntax tree and can be transformed and rendered as such.

We are still on a JDK 8 baseline and cannot hide our renderer in an internal module, marked as @API(status = INTERNAL, since = "1.0"). You can get an instance of the default renderer via org.neo4j.springframework.data.core.cypher.renderer.Renderer#getDefaultRenderer() and than use the render method to get a string representation of the statement.

This string representation can be used with the Neo4jClient.

We do however give no guarantees to the render API until it is marked as EXPERIMENTAL or STABLE.

How to use it

You use the Cypher-DSL as you would write Cypher: It allows to write down even complex Cypher queries from top to bottom in a type safe, compile time checked way.

The examples to follow are using JDK 11. We find the var keyword especially appealing in such a DSL as the types returned by the DSL much less important than the further building methods they offer.

The AST parts and intermediate build steps are immutable. That is, the methods create new intermediate steps. For example, you cannot reuse an ExposesLimit step, but have to use the returned object from its skip method.
Examples

The following examples are 1:1 copies of the queries you will find in the Neo4j browser after running :play movies.

They use the following imports:

Listing 43. Imports needed for the examples to compile
import static org.assertj.core.api.Assertions.*;
import static org.neo4j.opencypherdsl.Conditions.*;
import static org.neo4j.opencypherdsl.Cypher.*;
import static org.neo4j.opencypherdsl.Functions.*;

import org.neo4j.opencypherdsl.Cypher;
import org.neo4j.opencypherdsl.renderer.Renderer;

To match and return all the movie, build your statement like this:

Listing 44. Simple match
var m = node("Movie").named("m"); (1)
var statement = Cypher.match(m) (2)
        .returning(m)
        .build(); (3)

assertThat(cypherRenderer.render(statement))
        .isEqualTo("MATCH (m:`Movie`) RETURN m");
1 Declare a variable storing your node labeled Movie and named m, so that you can
2 reuse it in both the match and the return part.
3 The build method becomes only available when a compilable Cypher statement can be rendered.
Find

Match all nodes with a given set of properties:

Listing 45. Find the actor named "Tom Hanks"…​
var tom = anyNode().named("tom").withProperties("name", literalOf("Tom Hanks"));
var statement = Cypher
        .match(tom).returning(tom)
        .build();

assertThat(cypherRenderer.render(statement))
        .isEqualTo("MATCH (tom {name: 'Tom Hanks'}) RETURN tom");

Limit the number of returned things and return only one attribute

Listing 46. Find 10 people…​
var people = node("Person").named("people");
statement = Cypher
        .match(people)
        .returning(people.property("name"))
        .limit(10)
        .build();

assertThat(cypherRenderer.render(statement))
        .isEqualTo("MATCH (people:`Person`) RETURN people.name LIMIT 10");

Create complex conditions

Listing 47. Find movies released in the 1990s…​
var nineties = node("Movie").named("nineties");
var released = nineties.property("released");
statement = Cypher
        .match(nineties)
        .where(released.gte(literalOf(1990)).and(released.lt(literalOf(2000))))
        .returning(nineties.property("title"))
        .build();

assertThat(cypherRenderer.render(statement))
        .isEqualTo(
                "MATCH (nineties:`Movie`) WHERE (nineties.released >= 1990 AND nineties.released < 2000) RETURN nineties.title");
Query

Build relationships

Listing 48. List all Tom Hanks movies…​
var tom = node("Person").named("tom").withProperties("name", literalOf("Tom Hanks"));
var tomHanksMovies = anyNode("tomHanksMovies");
var statement = Cypher
        .match(tom.relationshipTo(tomHanksMovies, "ACTED_IN"))
        .returning(tom, tomHanksMovies)
        .build();

assertThat(cypherRenderer.render(statement))
        .isEqualTo(
                "MATCH (tom:`Person` {name: 'Tom Hanks'})-[:`ACTED_IN`]->(tomHanksMovies) RETURN tom, tomHanksMovies");
Listing 49. Who directed "Cloud Atlas"?
var cloudAtlas = anyNode("cloudAtlas").withProperties("title", literalOf("Cloud Atlas"));
var directors = anyNode("directors");
statement = Cypher
        .match(cloudAtlas.relationshipFrom(directors, "DIRECTED"))
        .returning(directors.property("name"))
        .build();

assertThat(cypherRenderer.render(statement))
        .isEqualTo("MATCH (cloudAtlas {title: 'Cloud Atlas'})<-[:`DIRECTED`]-(directors) RETURN directors.name");
Listing 50. Tom Hanks' co-actors…​
tom = node("Person").named("tom").withProperties("name", literalOf("Tom Hanks"));
var movie = anyNode("m");
var coActors = anyNode("coActors");
var people = node("Person").named("people");
statement = Cypher
        .match(tom.relationshipTo(movie, "ACTED_IN").relationshipFrom(coActors, "ACTED_IN"))
        .returning(coActors.property("name"))
        .build();

assertThat(cypherRenderer.render(statement))
        .isEqualTo(
                "MATCH (tom:`Person` {name: 'Tom Hanks'})-[:`ACTED_IN`]->(m)<-[:`ACTED_IN`]-(coActors) RETURN coActors.name");
Listing 51. How people are related to "Cloud Atlas"…​
cloudAtlas = node("Movie").withProperties("title", literalOf("Cloud Atlas"));
people = node("Person").named("people");
var relatedTo = people.relationshipBetween(cloudAtlas).named("relatedTo");
statement = Cypher
        .match(relatedTo)
        .returning(people.property("name"), type(relatedTo), relatedTo.getRequiredSymbolicName())
        .build();

assertThat(cypherRenderer.render(statement))
        .isEqualTo(
                "MATCH (people:`Person`)-[relatedTo]-(:`Movie` {title: 'Cloud Atlas'}) RETURN people.name, type(relatedTo), relatedTo");
Solve
Listing 52. Movies and actors up to 4 "hops" away from Kevin Bacon
var bacon = node("Person").named("bacon").withProperties("name", literalOf("Kevin Bacon"));
var hollywood = anyNode("hollywood");
var statement = Cypher
        .match(bacon.relationshipBetween(hollywood).length(1, 4))
        .returningDistinct(hollywood)
        .build();

assertThat(cypherRenderer.render(statement))
        .isEqualTo("MATCH (bacon:`Person` {name: 'Kevin Bacon'})-[*1..4]-(hollywood) RETURN DISTINCT hollywood");
Recommend
Listing 53. Extend Tom Hanks co-actors, to find co-co-actors who haven’t worked with Tom Hanks…​
var tom = node("Person").named("tom").withProperties("name", literalOf("Tom Hanks"));
var coActors = anyNode("coActors");
var cocoActors = anyNode("cocoActors");
var strength = count(asterisk()).as("Strength");
var statement = Cypher
        .match(
                tom.relationshipTo(anyNode("m"), "ACTED_IN").relationshipFrom(coActors, "ACTED_IN"),
                coActors.relationshipTo(anyNode("m2"), "ACTED_IN").relationshipFrom(cocoActors, "ACTED_IN")
        )
        .where(not(tom.relationshipTo(anyNode(), "ACTED_IN").relationshipFrom(cocoActors, "ACTED_IN")))
        .and(tom.isNotEqualTo(cocoActors))
        .returning(
                cocoActors.property("name").as("Recommended"),
                strength
        ).orderBy(strength.asName().descending())
        .build();

assertThat(cypherRenderer.render(statement))
        .isEqualTo(""
                + "MATCH "
                + "(tom:`Person` {name: 'Tom Hanks'})-[:`ACTED_IN`]->(m)<-[:`ACTED_IN`]-(coActors), "
                + "(coActors)-[:`ACTED_IN`]->(m2)<-[:`ACTED_IN`]-(cocoActors) "
                + "WHERE (NOT (tom)-[:`ACTED_IN`]->()<-[:`ACTED_IN`]-(cocoActors) AND tom <> cocoActors) "
                + "RETURN cocoActors.name AS Recommended, count(*) AS Strength ORDER BY Strength DESC");

Query creation

This chapter is about the technical creation of queries when using SDN/RX’s abstraction layers. There will be some simplifications because we do not discuss every possible case but stick with the general idea behind it.

Save

Beside the find/load operations the save operation is one of the most used when working with data. A save operation call in general issues multiple statements against the database to ensure that the resulting graph model matches the given Java model.

  1. A union statement will get created that either creates a node, if the node’s identifier cannot be found, or updates the node’s property if the node itself exists.

    (OPTIONAL MATCH (hlp:Person) WHERE id(hlp) = $__id__ WITH hlp WHERE hlp IS NULL CREATE (n:Person) SET n = $__properties__ RETURN id(n) UNION MATCH (n) WHERE id(n) = $__id__ SET n = $__properties__ RETURN id(n))

  2. If the entity is not new all relationships of the first found type at the domain model will get removed from the database.

    (MATCH (startNode)-[rel:Has]→(:Hobby) WHERE id(startNode) = $fromId DELETE rel)

  3. The related entity will get created in the same way as the root entity.

    (OPTIONAL MATCH (hlp:Hobby) WHERE id(hlp) = $__id__ WITH hlp WHERE hlp IS NULL CREATE (n:Hobby) SET n = $__properties__ RETURN id(n) UNION MATCH (n) WHERE id(n) = $__id__ SET n = $__properties__ RETURN id(n))

  4. The relationship itself will get created

    (MATCH (startNode) WHERE id(startNode) = $fromId MATCH (endNode) WHERE id(endNode) = 631 MERGE (startNode)-[:Has]→(endNode))

  5. If the related entity also has relationships to other entities, the same procedure as in 2. will get started.

  6. For the next defined relationship on the root entity start with 2. but replace first with next.

As you can see SDN/RX does its best to keep your graph model in sync with the Java world. This is one of the reasons why we really advise you to not load, manipulate and save sub-graphs as this might cause relationships to get removed from the database.
Multiple entities

The save operation is overloaded with the functionality for accepting multiple entities of the same type. If you are working with generated id values or make use of optimistic locking, every entity will result in a separate CREATE call.

In other cases SDN/RX will create a parameter list with the entity information and provide it with a MERGE call.

UNWIND $__entities__ AS entity MERGE (n:Person {customId: entity.$__id__}) SET n = entity.__properties__ RETURN collect(n.customId) AS $__ids__

and the parameters look like

:params {__entities__: [{__id__: 'aa', __properties__: {name: "PersonName", theId: "aa"}}, {__id__ 'bb', __properties__: {name: "AnotherPersonName", theId: "bb"}}]}

Load

The load documentation will not only show you how the MATCH part of the query looks like but also how the data gets returned.

The simplest kind of load operation is a findById call. It will match all nodes with the label of the type you queried for and does a filter on the id value.

MATCH (n:Person) WHERE id(n) = 1364

If there is a custom id provided SDN/RX will use the property you have defined as the id.

MATCH (n:Person) WHERE n.customId = 'anId'

The data to return is defined as a map projection.

RETURN n{.first_name, .personNumber, __internalNeo4jId__: id(n), __nodeLabels__: labels(n)}

As you can see there are two special fields in there: The __internalNeo4jId__ and the __nodeLabels__. Both are critical when it comes to mapping the data to Java objects. The value of the __internalNeo4jId__ is either id(n) or the provided custom id but in the mapping process one known field to refer to has to exist. The __nodeLabels__ ensures that all defined labels on this node can be found and mapped. This is needed for situations when inheritance is used and you query not for the concrete classes or have relationships defined that only define a super-type.

Talking about relationships: If you have defined relationships in your entity, they will get added to the returned map as pattern comprehensions. The above return part will then look like:

RETURN n{.first_name, …​, Person_Has_Hobby: [(n)-[:Has]→(n_hobbies:Hobby)|n_hobbies{__internalNeo4jId__: id(n_hobbies), .name, nodeLabels: labels(n_hobbies)}]}

The map projection and pattern comprehension used by SDN/RX ensures that only the properties and relationships you have defined are getting queried.

Migrating from SDN+OGM to SDN/RX

Known issues with past SDN+OGM migrations

SDN+OGM has had quite a history over the years and we understand that migrating big application systems is neither fun nor something that provides immediate profit. The main issues we observed when migrating from older versions of Spring Data Neo4j to newer ones are roughly in order the following:

Having skipped more than one major upgrade

While Neo4j-OGM can be used stand-alone, Spring Data Neo4j cannot. It depends to large extend on the Spring Data and therefore, on the Spring Framework itself, which eventually affects large parts of your application. Depending on how the application has been structured, that is, how much the any of the framework part leaked into your business code, the more you have to adapt your application. It get’s worse when you have more than one Spring Data module in your application, if you accessed a relational database in the same service layer as your graph database. Updating two object mapping frameworks is not fun.

Relying on a embedded database configured through Spring Data itself

The embedded database in a SDN+OGM project is configured by Neo4j-OGM. Say you want to upgrade from Neo4j 3.0 to 3.5, you can’t without upgrading your whole application. Why is that? As you chose to embed a database into your application, you tied yourself into the modules that configure this embedded database. To have another, embedded database version, you have to upgrade the module that configured it, because the old one does not support the new database. As there is always a Spring Data version corresponding to Neo4j-OGM, you would have to upgrade that as well. Spring Data however depends on Spring Framework and than the arguments from the first bullet apply.

Being unsure about which building blocks to include

It’s not easy to get the terms right. We wrote the building blocks of an SDN+OGM setting here. It may be so that all of them have been added by coincidence and you’re dealing with a lof of conflicting dependencies.

Backed by those observations, we recommend to make sure you’re using only the Bolt or http transport in your current application before switching from SDN+OGM to SDN/RX. Thus, your application and the access layer of your application is to large extend independent from the databases version. From that state, consider moving from SDN+OGM to SDN/RX.

Prepare the migration from SDN+OGM Lovelace or SDN+OGM Moore to SDN/RX

The Lovelace release train corresponds to SDN 5.1.x and OGM 3.1.x, while the Moore is SDN 5.2.x and OGM 3.2.x.

First, you must make sure that your application runs against Neo4j in server mode over the Bolt protocol, which means work in two of three cases:

You’re on embedded

You have added org.neo4j:neo4j-ogm-embedded-driver and org.neo4j:neo4j to you project and starting the database via OGM facilities. This is no longer supported and you have to setup a standard Neo4j server (both standalone and cluster are supported).

The above dependencies have to be removed.

Migrating from the embedded solution is probably the toughest migration, as you need to setup a server, too. It is however the one that gives you much value in itself: In the future, you will be able to upgrade the database itself without having to consider your application framework, and your data access framework as well.

You’re using the HTTP transport

You have added org.neo4j:neo4j-ogm-http-driver and configured an url like http://user:password@localhost:7474. The dependency has to be replaced with org.neo4j:neo4j-ogm-bolt-driver and you need to configure a Bolt url like bolt://localhost:7687 or use the new neo4j:// scheme, which takes care of routing, too.

You’re already using Bolt indirectly

A default SDN+OGM project uses org.neo4j:neo4j-ogm-bolt-driver and thus indirectly, the pure Java Driver. You can keep your existing URL.

Migrating

Once you have made sure, that your SDN+OGM application works over Bolt as expected, you can start migrating to SDN/RX.

  • Remove all org.neo4j:neo4j-ogm-* dependencies

  • Remove org.springframework.data:spring-data-neo4j

  • Configuring SDN/RX through a org.neo4j.ogm.config.Configuration bean is not supported, instead of, all configuration of the driver goes through our new starter. Any of those properties can be configured through standard Spring Boot means. You will especially have to adapt the properties for the url and authentication, see Listing 54

You cannot configure SDN/RX through XML. In case you did this with your SDN+OGM application, make sure you learn about annotation-driven or functional configuration of Spring Applications. The easiest choice these days is Spring Boot. With our starter in place, all the necessary bits apart from the connection URL and the authentication is already configured for you.
Listing 54. Old and new properties compared
# Old
spring.data.neo4j.embedded.enabled=false # No longer support
spring.data.neo4j.uri=bolt://localhost:7687
spring.data.neo4j.username=neo4j
spring.data.neo4j.password=secret

# New
org.neo4j.driver.uri=bolt://localhost:7687
org.neo4j.driver.authentication.username=neo4j
org.neo4j.driver.authentication.password=secret
Those new properties might change in the future again when SDN/RX and the driver will eventually replace the old setup fully.

And finally, add the new dependency, see Chapter 4 for both Gradle and Maven.

You’re than ready to replace annotations:

Old New

org.neo4j.ogm.annotation.NodeEntity

org.neo4j.springframework.data.core.schema.Node

org.neo4j.ogm.annotation.GeneratedValue

org.neo4j.springframework.data.core.schema.GeneratedValue

org.neo4j.ogm.annotation.Id

org.neo4j.springframework.data.core.schema.Id

org.neo4j.ogm.annotation.Property

org.neo4j.springframework.data.core.schema.Property

org.neo4j.ogm.annotation.Relationship

org.neo4j.springframework.data.core.schema.Relationship

org.springframework.data.neo4j.annotation.EnableBookmarkManagement

No replacement, not needed

org.springframework.data.neo4j.annotation.UseBookmark

No replacement, not needed

Several Neo4j-OGM annotations have not yet a corresponding annotation in SDN/RX, some will never have. We will add to the list above as we support additional features.
Bookmarkmanagement

Both @EnableBookmarkManagement and @UseBookmark as well as the org.springframework.data.neo4j.bookmark.BookmarkManager interface and it’s only implementation org.springframework.data.neo4j.bookmark.CaffeineBookmarkManager are gone and are not needed anymore.

SDN/RX uses Bookmarks for all transactions, without configuration. You can remove the bean declaration of CaffeineBookmarkManager as well as the the dependency to com.github.ben-manes.caffeine:caffeine.

Building SDN/RX

Requirements

  • JDK 13+ (Can be OpenJDK or Oracle JDK)

  • Maven 3.6.2 (We provide the Maven wrapper, see mvnw respectively mvnw.cmd in the project root; the wrapper downloads the appropriate Maven version automatically)

  • A Neo4j 3.5.+ database, either

About the JDK version

SDN/RX itself targets JDK 8 release but builds currently on JDK13. We will track the current release cadence of Java. Choosing JDK 8 is a decision influenced by various aspects

  • SDN/RX is a Spring Data project. Spring Data commons baseline is still JDK 8 and so is Spring Frameworks baseline. Thus it is only natural to keep the JDK 8 baseline.

  • While there is an increase of projects started with JDK 11 (which is Oracles current LTS release of Java), many existing projects are still on JDK 8. We don’t want to lose them as users right from the start.

All examples (/examples) and also benchmarking (/benchmarks) will be compiled and run with the latest Java release, though.

Running the build

The following sections are alternatives and roughly sorted by increased effort.

All builds require a local copy of the the project:

Listing 55. Clone SDN/RX
$ git clone git@github.com:neo4j/sdn-rx.git

Before you proceed, verify your locally installed JDK version. The output should be similar:

Listing 56. Verify your JDK
$ java -version
java version "12.0.1" 2019-04-16
Java(TM) SE Runtime Environment (build 12.0.1+12)
Java HotSpot(TM) 64-Bit Server VM (build 12.0.1+12, mixed mode, sharing)
With Docker installed
Using the default image

If you don’t have Docker installed, head over to Docker Desktop. In short, Docker is a tool that helps you running lightweight software images using OS-level virtualization in so called containers.

Our build uses Testcontainers Neo4j to bring up a database instance.

Listing 57. Build with default settings on Linux / macOS
$ ./mvnw clean verify
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Build Order:
[INFO]
[INFO] Spring Data Neo4j RX                                               [pom]
[INFO] SDN⚡RX                                                            [jar]
[INFO] SDN⚡RX Spring Boot Starter Parent                                 [pom]
[INFO] SDN⚡RX Spring Boot Starter Autoconfiguration                      [jar]
[INFO] SDN⚡RX Spring Boot Starter                                        [jar]
[INFO] SDN⚡RX Examples for Spring Boot                                   [jar]
[INFO] SDN⚡RX Examples Mapping                                           [jar]
...
[INFO] Reactor Summary:
[INFO]
[INFO] Spring Data Neo4j RX 1.0.0-SNAPSHOT ................ SUCCESS [  5.937 s]
[INFO] SDN⚡RX 1.0.0-SNAPSHOT ............................. SUCCESS [09:37 min]
[INFO] SDN⚡RX Spring Boot Starter Parent 1.0.0-SNAPSHOT .. SUCCESS [  1.734 s]
[INFO] SDN⚡RX Spring Boot Starter Autoconfiguration 1.0.0-SNAPSHOT SUCCESS [ 57.069 s]
[INFO] SDN⚡RX Spring Boot Starter 1.0.0-SNAPSHOT ......... SUCCESS [  0.444 s]
[INFO] SDN⚡RX Examples for Spring Boot 999-SNAPSHOT ...... SUCCESS [  4.055 s]
[INFO] SDN⚡RX Examples Mapping 999-SNAPSHOT .............. SUCCESS [  0.683 s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  10:48 min
[INFO] Finished at: 2019-10-02T15:25:48+02:00
[INFO] ------------------------------------------------------------------------

On a Windows machine, use

Listing 58. Build with default settings on Windows
$ mvnw.cmd clean verify

The output should be similar.

At the moment, this build tests agains Neo4j 3.5, as 4.0 is not yet available on Docker Hub. As a consequence, tests requiring a reactive capable database, are skipped, as this is a feature of Neo4j 4.0.

Using another image

The image version to use can be configured through an environmental variable like this:

Listing 59. Build using a different Neo4j Docker image
$ SDN_RX_NEO4J_VERSION=3.5.11-enterprise SDN_RX_NEO4J_ACCEPT_COMMERCIAL_EDITION=yes ./mvnw clean verify

Here we are using 3.5.11 enterprise and also accept the license agreement.

Consult your operating system or shell manual on how to define environment variables if specifying them inline does not work for you.

Against a locally running database
Running against a locally running database will erase its complete content.

Building against a locally running database is faster, as it does not restart a container each time. We do this a lot during our development.

You can get a copy of Neo4j at our download center free of charge. Especially you can get the current prelease of Neo4j 4.0, supporting all the reactive features.

Please download the version applicable to your operating system and follow the instructions to start it. A required step is to open a browser and go to http://localhost:7474 after you started the database and change the default password from neo4j to something of your liking.

After that, you can run a complete build by specifying the local bolt URL:

Listing 60. Build using a locally running database
$ SDN_RX_NEO4J_URL=bolt://localhost:7687 SDN_RX_NEO4J_PASSWORD=secret ./mvnw clean verify

Summary of environment variables controlling the build

Name Default value Meaning

SDN_RX_NEO4J_VERSION

3.5.6

Version of the Neo4j docker image to use, see Neo4j Docker Official Images

SDN_RX_NEO4J_ACCEPT_COMMERCIAL_EDITION

no

Some tests may require the enterprise edition of Neo4j. We build and test against the enterprise edition internally, but we won’t force you to accept the license if you don’t want to.

SDN_RX_NEO4J_URL

not set

Setting this environment allows connecting to a locally running Neo4j instance. We use this a lot during development.

SDN_RX_NEO4J_PASSWORD

not set

Password for the neo4j user of the instance configured with SDN_RX_NEO4J_URL.

You need to set both SDN_RX_NEO4J_URL and SDN_RX_NEO4J_PASSWORD to use a local instance.

Checkstyle and friends

There is no quality gate in place at the moment to ensure that the code/test ratio stays as is, but please consider adding tests to your contributions.

We have some rather mild checkstyle rules in place, enforcing more or less default Java formatting rules. Your build will break on formatting errors or something like unused imports.

jQAssistant

We also use jQAssistant, a Neo4j-based tool, to verify some aspects of our architecture. The rules are described with Cypher and your build will break when they are violated:

Coding Rules

The following rules are checked during a build:

API

Ensure that we publish our API in a sane and consistent way.

General considerations

We use @API Guardian to keep track of what we expose as public or internal API. To keep things both clear and concise, we restrict the usage of those annotations to interfaces, classes (incl. constructors) and annotations.

Listing 61. @API Guardian annotations must not be used on fields
MATCH (c:Java) - [:ANNOTATED_BY] -> (a) - [:OF_TYPE] -> (t:Type {fqn: 'org.apiguardian.api.API'}),
      (p) - [:DECLARES] -> (c)
WHERE c:Member AND NOT c:Constructor
RETURN p.fqn, c.name

Public interfaces, classes or annotations are either part of internal or public API and have a status.

Listing 62. Define which Java artifacts are part of internal or public API
MATCH (c:Java) - [:ANNOTATED_BY] -> (a) - [:OF_TYPE] -> (t:Type {fqn: 'org.apiguardian.api.API'}),
      (a) - [:HAS] -> ({name: 'status'}) - [:IS] -> (s)
WHERE ANY (label IN labels(c) WHERE label in ['Interface', 'Class', 'Annotation'])
WITH  c, trim(split(s.signature, ' ')[1]) AS status
WITH  c, status,
      CASE status
        WHEN 'INTERNAL' THEN 'Internal'
        ELSE 'Public'
      END AS type
MERGE (a:Api {type: type, status: status})
MERGE (c) - [:IS_PART_OF] -> (a)
RETURN c,a
Internal API

See ADR-003.

Listing 63. Non abstract, public classes that are only part of internal API must be final
MATCH (c:Class) - [:IS_PART_OF] -> (:Api {type: 'Internal'})
WHERE c.visibility = 'public'
  AND coalesce(c.abstract, false) = false
  AND NOT exists(c.final)
RETURN c.name
Naming things

The following naming conventions are used throughout the project:

Listing 64. All Java types must be located in packages that start with org.neo4j.springframework.data.
MATCH
  (project:Maven:Project)-[:CREATES]->(:Artifact)-[:CONTAINS]->(type:Type)
WHERE
  NOT type.fqn starts with 'org.neo4j.springframework.data'
RETURN
  project as Project, collect(type) as TypeWithWrongName
Structuring things

Most of the time, the package structure under org.neo4j.springframework.data should reflect the main building parts.

Listing 65. The mapping package must not depend on any other SDN/RX packages than schema and convert
MATCH (a:Main:Artifact)
OPTIONAL MATCH (a) -[:CONTAINS]-> (s:Package) WHERE s.fqn in ['org.neo4j.springframework.data.core.schema', 'org.neo4j.springframework.data.core.convert']
WITH collect(s) as allowed, a
MATCH (a) -[:CONTAINS]-> (p1:Package) -[:DEPENDS_ON]-> (p2:Package) <-[:CONTAINS]- (a)
WHERE p1.fqn = 'org.neo4j.springframework.data.core.mapping'
  AND NOT (p2 in allowed OR (p1) -[:CONTAINS]-> (p2))
return p1,p2
Accessing the jQAssistant database

jQAssistant uses Neo4j to store information about a project. To access the database, please build the project as described above. When the build finishes, execute the following command:

Listing 66. Start jQAssistant
$ ./mvnw -pl org.neo4j.springframework.data:spring-data-neo4j-rx jqassistant:server

Access the standard Neo4j browser at http://localhost:7474 and a dedicated jQA-Dashboard at http://localhost:7474/jqassistant/dashboard/.

The scanning and analyzing can be triggered individually, without going through the full verify again:

Listing 67. Manually scan and analyze the main project
$ ./mvnw -pl org.neo4j.springframework.data:spring-data-neo4j-rx jqassistant:scan@jqassistant-scan
$ ./mvnw -pl org.neo4j.springframework.data:spring-data-neo4j-rx jqassistant:analyze@jqassistant-analyze