Spring Data Neo4j: How to update an entity

Debugging can be extremely frustrating, but also very rewarding. First, I outline what I know about my application and the problem.

After working through an initial solution, I got some feedback from colleagues with some cleaner ways to implement the functionality. Let’s step through the process!

I skinnied the full application down to the functionality we want to focus on. You can view the code in the related Github repository. There are a few branches on the project, but my initial solution is on the main branch. We will start there and then work through the other branches in a bit.

I started hacking at my code trying to get something to work, but then I organized my thoughts. What I wanted to accomplish was updating some properties on a Book node without having to add the boilerplate in the application for those properties. But, could I even get an update on the related entity to work with everything in the domain class? That’s where I started by formulating some simple tests and removing unrelated code (for now).

This sample app is narrowed down to only two domain classes - Review and Book. Code is available on the Github project’s main branch.

I’m using the Lombok @Data annotation to reduce boilerplate code for getters, setters, and required argument constructor. The Spring @Node annotation specifies that this is a database entity for Neo4j. Inside the class’s curly braces, I set up an ID field that has a generated value constructed from the UUID class, define a rating field, then define a Book field that maps the relationship to the other entity.

Similar code exists for the Book domain class. The book_id field serves as our entity id, and then the ratings_count and average_rating fields were the ones I was trying to calculate.

We also have a ReviewRepository interface that has a method to pull some reviews. I won’t focus on that code here, as I used it to test what functionality was working and what wasn’t.

Last, our ReviewController class defines our methods and logic for calculating the rating count and average rating values.

The class uses some annotations to define it as a rest controller, set up a mapped endpoint (/neo), and let Lombok create a constructor with all arguments. We inject the ReviewRepository so that we can access our methods, and then we define a save() method. The @Transactional annotation lets Spring handle transaction management for us, and the @PutMapping annotation notes this as a PUT request (create or update) with a specific endpoint (/save).

Next, I output the incoming data to ensure it looks the way I expect it to. I left a placeholder in the save() method above for us to add the calculation logic. The last few lines save the incoming review request to the database, print the object we saved, and return it. Let’s fill in that placeholder now!

First, we need a ratings count and starting average value, which are on the Book entity in the database. So, we need to retrieve the entity from the database with a query, and that means adding a BookRepository because we can’t return a Book in the ReviewRepository.

We create the repository and define a single method findBookByBook_id() that passes in an id for the entity we want to update. Normally, Spring should be able to derive the query from that method name, but I think the underscore character in the middle of the id field name caused issues, so I wrote a custom query (denoted with the @Query annotation). The query searches for that Book entity and returns it. Now we can use this method in our controller class to update those fields.

Because we have those fields on the domain class and don’t provide them in a book review, the request object contains null values. If we save that object to the database, those fields in the Book node will get set to null, which removes them. Therefore, we need to set those values before we save the review to the database.

We start by retrieving the book from the database using our findBookByBook_id() method. I had to use block() to convert a reactive object to the nonreactive one. Next, I needed to do some validation in case the book didn’t have any reviews yet. If the ratings_count or average_rating fields were null, I set them to 0. After each of those if statements, I set the review object’s values by incrementing the rating count by one and calculating a new average rating. I had to look up how to calculate a new average based on an old average and found this helpful formula. Next, I print the review again to ensure the values are there, then send it to the database.

This worked! Now, this seemed quite cumbersome to update a couple of backend properties in the database, and it added some business logic in the code. After some suggestions from a colleague, there are two alternate approaches that don’t contain so much logic wrapped into the application. We can look at those now.

In this article, we have looked at three different ways we can update books based on new reviews entering the system. The approach you choose will highly depend on your specific project needs and priorities, as well as the data size, model, queries, network, and more. Let’s recap each option.

The create and read functionality in typical "CRUD" methods are usually pretty straightforward, but update is one that always seems to trip me up. With this blog post, I hope to take notes for my future self and help someone else along the way. As always, check out the full code repository on Github. Happy coding!