Reference

This reference documentation is broken down into sections to help the user understand specifics of how Neo4j-OGM works.

Consult the version table to determine which version of Neo4j-OGM to use with a particular version of Neo4j and related technologies.

For building an application, your build automation tool needs to be configured to include the Neo4j-OGM dependencies.

Neo4j-OGM dependencies consist of neo4j-ogm-core, together with the relevant dependency declarations on the driver you want to use. Neo4j-OGM 4.x provides only support for the Bolt driver, but for compatibility reasons you have to declare the dependency:

Neo4j-OGM projects can be built using Maven, Gradle or any other build system that utilises Maven’s artifact repository structure.

There are several ways to supply configuration to Neo4j-OGM:

These methods are described below. They are also available as code in the examples.

For configuration through properties file or configuration builder the driver is automatically inferred from given URI. Empty URI means embedded driver with impermanent database.

Neo4j-OGM uses SLF4J to log statements. In production, you can set the log level in a file called logback.xml to be found at the root of the classpath. Please see the Logback manual for further details.

An important logger is the BoltResponse logger. It has multiple "sub-logger" for Neo4j notification categories that may come up when using e.g. deprecated features. An overview can be seen in the following list.

You can still use the org.neo4j.ogm.drivers.bolt.response.BoltResponse logger as the main logger and just adjust the details in some details to your needs.

In some scenarios and environments (Spring Boot’s @Async annotated classes/methods, CompletableFuture usage, etc.) , it is necessary to declare the used class loading precedence for Neo4j-OGM to use. As default, it uses the current thread’s context class loader. To change this behaviour, the OGM_CLASS_LOADER has to be set only once for the Configuration class. This can be done during configuration of your application or similar.

The @NodeEntity annotation is used to declare that a POJO class is an entity backed by a node in the graph database. Entities handled by Neo4j-OGM must have one empty public constructor to allow the library to construct the objects.

Fields on the entity are by default mapped to properties of the node. Fields referencing other node entities (or collections thereof) are linked with relationships.

@NodeEntity annotations are inherited from super-types and interfaces. It is not necessary to annotate your domain objects at every inheritance level.

Entity fields can be annotated with annotations like @Property, @Id, @GeneratedValue, @Transient or @Relationship. All annotations live in the org.neo4j.ogm.annotation package. Marking a field with the transient modifier has the same effect as annotating it with @Transient; it won’t be persisted to the graph database.

The default label is the simple class name of the annotated entity. There are some rules to determine if parent classes also contribute their label to the child class:

If the label (as you can see in the example above) or the value attribute of the @NodeEntity annotation is set it will replace the default label applied to the node in the database.

Saving a simple object graph containing one actor and one film using the above annotated objects would result in the following being persisted in Neo4j.

When annotating your objects, you can choose to NOT apply the annotations on the fields. OGM will then use conventions to determine property names in the database for each field.

In this case, a graph similar to the following would be persisted.

While this will map successfully to the database, it’s important to understand that the names of the properties and relationship types are tightly coupled to the class’s member names. Renaming any of these fields will cause parts of the graph to map incorrectly, hence the recommendation to use annotations.

Please read Non-annotated properties and best practices for more details and best practices on this.

Every field of an entity that references one or more other node entities is backed by relationships in the graph. These relationships are managed by Neo4j-OGM automatically.

The simplest kind of relationship is a single object reference pointing to another entity (1:1). In this case, the reference does not have to be annotated at all, although the annotation may be used to control the direction and type of the relationship. When setting the reference, a relationship is created when the entity is persisted. If the field is set to null, the relationship is removed.

It is also possible to have fields that reference a set of entities (1:N). Neo4j-OGM supports the following types of entity collections:

For graph to object mapping, the automatic transitive loading of related entities depends on the depth of the horizon specified on the call to Session.load(). The default depth of 1 implies that related node or relationship entities will be loaded and have their properties set, but none of their related entities will be populated.

If this Set of related entities is modified, the changes are reflected in the graph once the root object (Actor, in this case) is saved. Relationships are added, removed or updated according to the differences between the root object that was loaded and the corresponding one that was saved..

Neo4j-OGM ensures by default that there is only one relationship of a given type between any two given entities. The exception to this rule is when a relationship is specified as either OUTGOING or INCOMING between two entities of the same type. In this case, it is possible to have two relationships of the given type between the two entities, one relationship in either direction.

If you don’t care about the direction then you can specify direction=Relationship.Direction.UNDIRECTED which will guarantee that the path between two node entities is navigable from either side.

For example, consider the PARTNER relationship between two companies, where (A)-[:PARTNER_OF]→(B) implies (B)-[:PARTNER_OF]→(A). The direction of the relationship does not matter; only the fact that a PARTNER_OF relationship exists between these two companies is of importance. Hence an UNDIRECTED relationship is the correct choice, ensuring that there is only one relationship of this type between two partners and navigating between them from either entity is possible.

To access the full data model of graph relationships, POJOs can also be annotated with @RelationshipEntity, making them relationship entities. Just as node entities represent nodes in the graph, relationship entities represent relationships. Such POJOs allow you to access and manage properties on the underlying relationships in the graph.

Fields in relationship entities are similar to node entities, in that they’re persisted as properties on the relationship. For accessing the two endpoints of the relationship, two special annotations are available: @StartNode and @EndNode. A field annotated with one of these annotations will provide access to the corresponding endpoint, depending on the chosen annotation.

For controlling the relationship-type a String attribute called type is available on the @RelationshipEntity annotation. Like the simple strategy for labelling node entities, if this is not provided then the name of the class is used to derive the relationship type, although it’s converted into SNAKE_CASE to honour the naming conventions of Neo4j relationships. As of the current version of Neo4j-OGM, the type must be specified on the @RelationshipEntity annotation as well as its corresponding @Relationship annotations. This can also be done without naming the attribute but only providing the value.

Note that the Actor also contains a reference to a Role. This is important for persistence, even when saving the Role directly, because paths in the graph are written starting with nodes first and then relationships are created between them. Therefore, you need to structure your domain models so that relationship entities are reachable from node entities for this to work correctly.

Additionally, Neo4j-OGM will not persist a relationship entity that doesn’t have any properties defined. If you don’t want to include properties in your relationship entity then you should use a plain @Relationship instead. Multiple relationship entities which have the same property values and relate the same nodes are indistinguishable from each other and are represented as a single relationship by Neo4j-OGM.

Every node and relationship persisted to the graph must have an ID. Neo4j-OGM uses this to identify and re-connect the entity to the graph in memory. Identifier may be either a primary id or a native graph id (the technical id attributed by Neo4j at node creation time).

For primary id use the @Id on a field of any supported type or a field with provided AttributeConverter. A unique index is created for such property (if index creation is enabled). User code should either set the id manually when the entity instance is created or id generation strategy should be used. It is not possible to store an entity with null id value and no generation strategy.

For native graph id use @Id @GeneratedValue (with default strategy InternalIdStrategy). The field type must be Long. This id is assigned automatically upon saving the entity to the graph and user code should never assign a value to it.

An entity can be looked up by this either type of id by using Session.load(Class<T>, ID) and Session.loadAll(Class<T>, Collection<ID>) methods.

It is possible to have both natural and native id in one entity. In such situation lookups prefer the primary id.

If the field of type Long is simply named 'id' then it is not necessary to annotate it with @Id @GeneratedValue as Neo4j-OGM will use it automatically as native id.

Optimistic locking is supported by Neo4j-OGM to provide concurrency control. To use optimistic locking define a field annotated with @Version annotation. The field is then managed by Neo4j-OGM and used to perform optimistic locking checks when updating entities. The type of the field must be Long and an entity may contain only one such field.

Typical scenario where optimistic locking is used then looks like follows:

Optimistic locking check is performed for

When an optimistic locking failure happens following operations are performed on the Session:

As we touched on earlier, it is not necessary to annotate property fields as they are persisted by default. Fields that are annotated as @Transient or with transient are exempted from persistence. All fields that contain primitive values are persisted directly to the graph. All fields convertible to a String using the conversion services will be stored as a string. Neo4j-OGM includes default type converters for commonly used types, for a full list see Built-in type conversions.

Custom converters are also specified by using @Convert - this is discussed in detail later on.

Collections of primitive or convertible values are stored as well. They are converted to arrays of their type or strings respectively.

Node property names can be explicitly assigned by setting the name attribute. For example @Property(name="last_name") String lastName. The node property name defaults to the field name when not specified.

A method annotated with @PostLoad will be called once the entity is loaded from the database.

Neo4j-OGM supports mapping annotated and non-annotated objects models. It’s possible to save any POJO without annotations to the graph, as the framework applies conventions to decide what to do. This is useful in cases when you don’t have control over the classes that you want to persist. The recommended approach, however, is to use annotations wherever possible, since this gives greater control and means that code can be refactored safely without risking breaking changes to the labels and relationships in your graph.

Annotated and non-annotated objects can be used within the same project without issue.

The object graph mapping comes into play whenever an entity is constructed from a node or relationship. This could be done explicitly during the lookup or create operations of the Session but also implicitly while executing any graph operation that returns nodes or relationships and expecting mapped entities to be returned.

Entities handled by Neo4j-OGM must have one empty public constructor to allow the library to construct the objects.

Unless annotations are used to specify otherwise, the framework will attempt to map any of an object’s "simple" fields to node properties and any rich composite objects to related nodes. A "simple" field is any primitive, boxed primitive or String or arrays thereof, essentially anything that naturally fits into a Neo4j node property. For related entities the type of a relationship is inferred by the bean property name.

The SessionFactory is needed by Neo4j-OGM to create instances of Session as required. This also sets up the object-graph mapping metadata when constructed, which is then used across all Session objects that it creates. The packages to scan for domain object metadata should be provided to the SessionFactory constructor.

A Session is used to drive the object-graph mapping framework. It keeps track of the changes that have been made to entities and their relationships. The reason it does this is so that only entities and relationships that have changed get persisted on save, which is particularly efficient when working with large graphs. Once an entity is tracked by the session, reloading this entity within the scope of the same session will result in the session cache returning the previously loaded entity. However, the subgraph in the session will expand if the entity or its related entities retrieve additional relationships from the graph.

The lifetime of the Session can be managed in code. For example, associated with single fetch-update-save cycle or unit of work.

If your application relies on long-running sessions then you may not see changes made from other users and find yourself working with outdated objects. On the other hand, if your sessions have a too narrow scope then your save operations can be unnecessarily expensive, as updates will be made to all objects if the session isn’t aware of the those that were originally loaded.

There’s therefore a trade off between the two approaches. In general, the scope of a Session should correspond to a "unit of work" in your application.

If you want to fetch fresh data from the graph, then this can be achieved by using a new session or clearing the current sessions context using Session.clear(). This feature should be used with caution because it will clear the whole cache and it needs to get rebuild on the next operation. Also Neo4j-OGM won’t be able to do any dirty tracking between the operations that are separated by the Session.clear() call.

Basic operations are limited to CRUD operations on entities and executing arbitrary Cypher queries; more low-level manipulation of the graph database is not possible.

Given that the Neo4j-OGM framework is driven by Cypher queries alone, there’s no way to work directly with Node and Relationship objects in remote server mode.

If you find yourself in trouble because of the omission of these features, then your best option is to write a Cypher query to perform the operations on the nodes/relationships instead.

In general, for low-level, very high-performance operations like complex graph traversals you will get the best performance by writing a server-side extension. For most purposes, though, Cypher will be performant and expressive enough to perform the operations that you need.

Session allows to save, load, loadAll and delete entities with transaction handling and exception translation managed for you. The eagerness with which objects are retrieved is controlled by specifying the depth argument to any of the load methods.

Entity persistence is performed through the save() method on the underlying Session object.

Under the bonnet, the implementation of Session has access to the MappingContext that keeps track of the data that has been loaded from Neo4j during the lifetime of the session. Upon invocation of save() with an entity, it checks the given object graph for changes compared with the data that was loaded from the database. The differences are used to construct a Cypher query that persists the deltas to Neo4j before repopulating it’s state based on the response from the database server.

Neo4j-OGM doesn’t automatically commit when a transaction closes, so an explicit call to save(…​) is required in order to persist changes to the database.

Entities can be loaded from Neo4j-OGM through the use of the session.loadXXX() methods or via session.query()/session.queryForObject() which will accept your own Cypher queries (See section below on cypher queries).

Neo4j-OGM includes the concept of persistence horizon (depth). On any individual request, the persistence horizon indicates how many relationships should be traversed in the graph when loading or saving data. A horizon of zero means that only the root object’s properties will be loaded or saved, a horizon of 1 will include the root object and all its immediate neighbours, and so on. This attribute is enabled via a depth argument available on all session methods, but Neo4j-OGM chooses sensible defaults so that you don’t have to specify the depth attribute unless you want change the default values.

It is possible to also query arbitrary data from Neo4j and make OGM combine the result in a wrapper object/DTO. To request a DTO, Neo4j-OGM offers <T> List<T> queryDto(String cypher, Map<String, ?> parameters, Class<T> type).

Neo4j-OGM supports all Neo4j temporal and spatial types for the Bolt driver. Since Neo4j-OGM 4.0, this supported is included with the Bolt-Module and doesn’t need additional dependencies.

Using native types for temporal and spatial property types is a behaviour changing feature, as it will turn the default type conversion off and dates are neither written to nor read from strings anymore. Therefore it is an opt-in feature.

To opt-in, please first add the corresponding module for your driver and than use the new configuration property use-native-types:

Once enabled, native types are used for all attributes of all node- and relationship-entities and also for all parameters passed through the OGM Session interface.

The following table describes how Neo4j temporal and spatial property types are mapped to attributes of Neo4j-OGM entities:

Neo4j supports four slightly different property types for spatial points, see Spatial values. All variations of the Point type are backed by an index and therefore perform very well in queries. The main difference between them is the coordinate reference system. A point can either be stored in a geographic coordinate system with longitude and latitude or in a cartesian system with x and y. If you add the third dimension, you add height or a z-axis.

Geographic coordinate systems are based on a spheroidal surface and define a position on a sphere in terms of angles. Attributes of type Point in Neo4j having geographic coordinates return longitude and latitude with a fixed reference system of WGS-84 (SRID 4326, the same one that most GPS devices and many online mapservers use). 3-dimensional geographic coordinates have a reference system of WGS-84-3D with the SRID 4979.

Cartesian coordinate systems deal with locations in an euclidean space and are not projected. Attributes of type Point in Neo4j having cartesian coordinates return x and y, their SRID is 7203 respectively 9157.

The important take-aways for modelling your domain is the fact that points with different coordinate systems are not comparable without undergoing transformation. The same attribute of a node should always be using the same coordinate system than all the other nodes with the same label. Otherwise the distance function and comparisons dealing with multiple Points will return literal null.

To make modelling a domain less error prone, Neo4-OGM provides four distinct types that you can use in your Neo4j entities:

Note that the Neo4j-OGM points don’t share a hierarchy usable outside internals of Neo4j-OGM on purpose. It should help you to make an informed decision which coordinate system to use.

Neo4j-OGM will automatically perform the following type conversions:

java.time.Instant based dates are stored in the database using UTC.

Two dedicated annotations are provided to modify the date conversion:

They need to be applied to an attribute for a custom string format or in case you want to store a date or datetime value as long:

Alternatively, if you want to store java.util.Date or java.time.Instant as long values, use the @DateLong annotation:

Collections of primitive or convertible values are also automatically mapped by converting them to arrays of their type or strings respectively.

In order to define bespoke type conversions for particular members, you can annotate a field with @Convert. One of either two convert implementations can be used. For simple cases where a single property maps to a single field, with type conversion, specify an implementation of AttributeConverter.

You could then apply this to your class as follows:

When more than one node property is to be mapped to a single field, use: CompositeAttributeConverter.

And just as with an AttributeConverter, a CompositeAttributeConverter could be applied to your class as follows:

There are four types of events:

Events are fired for every @NodeEntity or @RelationshipEntity object that is created, updated or deleted, or otherwise affected by a save or delete request. This includes:

The events mechanism introduces two new interfaces, Event and EventListener.

The Event interface

The Event interface is implemented by PersistenceEvent. Whenever an application wishes to handle an event it will be given an instance of Event, which exposes the following methods:

The event listener interface

The EventListener interface provides methods allowing implementing classes to handle each of the different Event types:

There are two ways to register an event listener:

In this example we register an anonymous EventListener to inject a UUID onto new objects before they’re saved

The EventListener above is fine, but we’ve had to create three methods for events we don’t intend to handle. It would be preferable if we didn’t have to do this each time we needed an EventListener.

The EventListenerAdapter is an abstract class providing a no-op implementation of the EventListener interface. If you don’t need to handle all the different types of persistence event you can create a subclass of EventListenerAdapter instead and override just the methods for the event types you’re interested in.

For example:

Something to bear in mind is that once an EventListener has been registered it will continue to respond to all persistence events. Sometimes you may want only to handle events for a short period of time, rather than for the duration of the entire session.

If you are done with an EventListener you can stop it from firing any more events by invoking session.dispose(…​), passing in the EventListener to be disposed of.

To remove an event listener across multiple sessions use the deregister method on the SessionFactory.

As mentioned previously, events are not only fired for the top-level objects being saved but for all their connected objects as well.

Connected objects are any objects reachable in the domain model from the top-level object being saved. Connected objects can be many levels deep in the domain model graph.

In this way, the event mechanism allows us to capture events for objects that we didn’t explicitly save ourselves.

When we delete a type, all the nodes with a label corresponding to that type are deleted in the graph. The affected objects are not enumerated by the events mechanism (they may not even be known). Instead, _DELETE events will be raised for the type:

When saving or deleting a collection of objects, separate events are fired for each object in the collection, rather than for the collection itself.

Events are partially ordered. PRE_ events are guaranteed to fire before any POST_ event within the same save or delete request. However, the internal ordering of the PRE_ events and POST_ events with the request is undefined.

The previous examples show how events fire when the underlying node representing an entity is updated or deleted in the graph. Events are also fired when a save or delete request results in the modification, addition or deletion of a relationship in the graph.

For example, if you delete a Document object that is contained in the documents collection of a Folder, events will be fired for the Document as well as the Folder, to reflect the fact that the relationship between the folder and the document has been removed in the graph.

The event mechanism guarantees to not fire more than one event of the same type for an object in a save or delete request.

Doing integration testing with Neo4j-OGM requires a few basic steps :

An example of a full running configuration can be found in the issue templates.

When running unit tests, it can be useful to see what Neo4j-OGM is doing, and in particular to see the Cypher requests being transferred between your application and the database. Neo4j-OGM uses slf4j along with Logback as its logging framework and by default the log level for all Neo4j-OGM components is set to WARN, which does not include any Cypher output. To change Neo4j-OGM log level, create a file logback-test.xml in your test resources folder, configured as shown below: