Скачать или смотреть Understanding Why Spring Data JDBC Deletes and Re-Inserts All Entries

Discover how to manage the behavior of `Spring Data JDBC` when dealing with aggregates, which can lead to performance issues during database operations.
---
This video is based on the question https://stackoverflow.com/q/72503705/ asked by the user 'Benjamin_Ellmer' ( https://stackoverflow.com/u/8294039/ ) and on the answer https://stackoverflow.com/a/72529322/ provided by the user 'Jens Schauder' ( https://stackoverflow.com/u/66686/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Spring Data JDBC deletes all entries and inserts them again

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Why Spring Data JDBC Deletes and Re-Inserts All Entries

When working with the Spring Data JDBC framework, many developers encounter a perplexing issue: when adding a single child to an aggregate root that contains a list of children, the framework deletes all existing children and inserts them again. This can lead to significant performance problems, especially when dealing with large aggregates. In this guide, we'll dive deep into this behavior, highlight potential performance impacts, and discuss clean approaches to mitigate these issues.

The Problem: Aggressive Deletion and Insertion

What Happens in Spring Data JDBC?

When you have an aggregate root that includes a substantial list of child entities (for example, 5000 entries), adding even one new entry results in extensive database operations. Specifically, the process involves:

Executing 5000 delete statements to remove all existing children.

Executing 5001 insert statements to add back those 5000 existing children plus the new child.

This approach is surprising and can lead to performance degradation, especially in large-scale applications.

Performance Implications

The implications of this behavior come down to efficiency. For aggregates containing a high number of entries, the simple action of adding one new entry results in excessive database load, potentially leading to:

Increased Latency: The time taken to complete the operation is significantly higher than expected.

Resource Overhead: The database server may struggle under the weight of multiple delete and insert statements, leading to resource contention.

The Solution: Rethinking Aggregate Design

Embracing the Purpose of Aggregates

Understanding the purpose of aggregates is crucial. Aggregates are designed to function as an atomic unit, encapsulating entity relationships and ensuring data integrity as a single object. Here are key points to consider when working with aggregates:

Atomicity: An aggregate should be loaded and persisted as a single entity, making its interactions straightforward and efficient.

Granularity: If your aggregate contains 5000 entities, it is advisable to break up these entities into smaller aggregates for more manageable operations.

Custom Methods for Better Behavior

If you find yourself needing to update your aggregates frequently, consider implementing custom methods in your repository, like an addEntry method that performs just a single insert operation. This tailored method can mitigate the need for the framework's default behavior and reduce the overhead.

Example Custom Method:

[[See Video to Reveal this Text or Code Snippet]]

Understanding Spring Data JDBC's Design Choices

Simplicity Over Complexity

Spring Data JDBC prioritizes simplicity of implementation. The rationale is that by not keeping track of the state of each entity, it can avoid the complexity that other frameworks, like JPA, introduce. Here’s how it works:

Spring Data JDBC assumes it has no prior knowledge of the database state, and after finishing a persist operation, the database state must match that of the application aggregate.

Plans for Improvement

While the default behavior can pose challenges, there are ongoing discussions and development efforts to enhance Spring Data JDBC's performance through:

Introduction of batch operations, which can reduce overhead.

The potential for a delete/upsert operation, which could optimize performance, although it may still involve touching all rows of the aggregate.

Conclusion

In summary, while Spring Data JDBC adheres to a simplistic model by deleting all children before inserting them, this behavior may not suit applications with large aggregates. Understanding aggrega