javers-Redis text re-arrangement

bartoszwalacik · bartoszwalacik · commit 7c431372caeb · 2025-02-16T15:28:10.000+01:00
diff --git a/_includes/docs-sidebar.html b/_includes/docs-sidebar.html
@@ -115,11 +115,11 @@
     <a {% if currentSubPage == 'repository-configuration' %}class='active'{% endif %}
        href="/documentation/repository-configuration">Configuration &mdash; Repository</a>
     <ul class="nav nav-stacked list-unstyled {% if page.submenu != 'repository-configuration' %} hidden {% endif %}">
-        <li><a href="#choose-javers-repository">Choose JaversRepository</a></li>
-        <li><a href="#redis-db">Redis</a></li>
+        <li><a href="#choose-javers-repository">Choose JaversRepository</a></li>      
         <li><a href="#mongodb-configuration">MongoDB</a></li>
         <li><a href="#sql-databases">SQL databases</a></li>
         <li><a href="#connection-provider">&nbsp; &nbsp;ConnectionProvider</a></li>
+        <li><a href="#redis-db">Redis</a></li>
         <li><a href="#custom-json-serialization">Custom JSON serialization</a>
         <li><a href="#json-type-adapters">&nbsp; &nbsp;JSON TypeAdapters</a>
         <li><a href="#json-type-adapter-example">&nbsp; &nbsp;JSON TypeAdapter Example</a>
diff --git a/documentation/repository-configuration/index.md b/documentation/repository-configuration/index.md
@@ -36,98 +36,6 @@ almost fully compatible with MongoDB.
 [Spring Boot starters for Spring Data](/documentation/spring-boot-integration/)
 and let them automatically configure and boot a JaVers instance with proper JaversRepository implementation.
 
-<h2 id="redis-db">Redis</h2>
-
-**Redis persistence overview**<br/>
-
-When storing JaVers snapshots in Redis, selecting the right persistence model is essential for ensuring data durability and performance. Redis offers two main persistence models:
-
-- RDB (Redis Database) - Periodically saves the dataset to disk. This is less resource-intensive because it doesn't constantly write to disk but instead saves the state at certain intervals.
-- AOF (Append Only File) - Logs every write operation to disk as it happens. In case of a crash, Redis can replay the log to restore the data.
-
-Redis allows using both RDB and AOF simultaneously. This provides the advantage of faster recovery through RDB snapshots while maintaining high durability with AOF. Depending on the system's criticality, you may want to consider enabling both for your JaVers snapshot storage.
-
-For more information, check the [official Redis documentation](https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/).
-
-
-**Dependency**<br/>
-Add `javers-persistence-redis` module to your classpath:
-
-_Maven_<br/>
-
-```
-<dependency>
-    <groupId>org.javers</groupId>
-    <artifactId>javers-persistence-redis</artifactId>
-    <version>{{site.javers_current_version}}</version>
-</dependency>
-```
-
-_Gradle (short)_<br/>
-
-```
-implementation 'org.javers:javers-persistence-redis:{{site.javers_current_version}}'
-```
-
-Check
-[Maven Central](https://central.sonatype.com/artifact/org.javers/javers-persistence-redis/{{site.javers_current_version}}/versions)
-for other build tools snippets.
-
-<h3>Overview</h3>
-
-The idea of configuring `JaversRedisRepository` is simple, just provide a working Jedis (Java client for Redis). You can setup `JaversRedisRepository` as follows:
-
-```java
-import org.javers.repository.redis.JaversRedisRepository;
-import redis.clients.jedis.JedisPool;
-...
-
-private static final String REDIS_HOST = "localhost";
-private static final int REDIS_PORT = 6379;
-private static final Duration REDIS_KEY_EXPIRATION_TIME = Duration.ofSeconds(3600);
-
-
-final var jedisPool = new JedisPool();
-final var javersRedisRepository = new JaversRedisRepository(jedisPool, REDIS_KEY_EXPIRATION_TIME);
-final var javers = JaversBuilder.javers().registerJaversRepository(javersRedisRepository).build();
-```
-
-<h3>Schema</h3>
-JaVers creates several key-value pairs in Redis, with main keys being:
-
-- `jv_head_id` — A `String` that holds the value of the last `CommitId`.
-- `jv_snapshots_keys` — A `Set` that contains keys, where each key is a reference to another key of type `List`. These lists contain snapshots for specific entities and their properties.
-- `jv_snapshots_keys:<Entity Name>` — Domain-specific sets pointing to lists containing snapshots for specific objects of that entity type.
-
-<h3>Handling Redis Key Expiration</h3>
-
-In Redis, when a key expires, it is automatically removed from the database. However, additional cleanup may be required if the expired key is referenced in other structures, such as sets.
-
-**CdoSnapshotKeyExpireListener**
-
-The `CdoSnapshotKeyExpireListener` is an event listener designed to handle key expiration events in Redis. Its primary responsibility is to ensure that expired key entries are removed from all relevant sets.
-
-When an instance of `JaversRedisRepository` is created, it subscribes to keyspace events with the pattern `__key*__:jv_snapshots:*`. This subscription allows the `CdoSnapshotKeyExpireListener` to process key expiration events as they occur.
-
-Upon receiving a key expiration event, the `CdoSnapshotKeyExpireListener` identifies the expired key and removes its entries from all relevant sets, such as `jv_snapshots_keys` and `jv_snapshots_keys:<Entity Name>`.
-
-**Expired Keys Cleanup**
-
-A significant challenge arises if Redis keys expire when there is no active `CdoSnapshotKeyExpireListener` running. In this scenario, expired key entries will remain in the sets, leading to potential data inconsistencies.
-
-To address this challenge, we have introduced the public method `cleanExpiredSnapshotsKeysSets` in JaversRedisRepository that can be called to perform the necessary cleanup. This ensures that expired keys are properly removed from all relevant sets, even if the listener is not active at the time of expiration.
-
-<h3>Integrating JaversRedisRepository with JPA (Hibernate)</h3>
-
-The `JaversRedisRepository` can be seamlessly integrated with existing JPA repositories, enabling you to store JaVers audit data in Redis while continuing to use your JPA entities and repositories for application data.
- 
-However, when working with Hibernate, it’s common for entities to be wrapped in proxies. To ensure proper handling of these proxies, you need to configure the `HibernateUnproxyObjectAccessHook` in your application. This can be done by setting the following property in your application configuration file:
-```yaml
-javers:
-  objectAccessHook: org.javers.hibernate.integration.HibernateUnproxyObjectAccessHook
-```
-This configuration ensures that JaVers can unproxy Hibernate entities effectively, allowing audit logging to work seamlessly with Redis and JPA.
-
 <h2 id="mongodb-configuration">MongoDB</h2>
 **Dependency**<br/>
 If you’re using MongoDB, choose `MongoRepository`.
@@ -313,6 +221,102 @@ JaVers has a basic schema-create implementation.
 If a table is missing, JaVers simply creates it, together with a sequence and indexes.
 There’s no schema-update, so if you drop a column, index or sequence, it wouldn’t be recreated automatically.
 
+
+<h2 id="redis-db">Redis</h2>
+
+**Redis persistence overview**<br/>
+
+When storing JaVers snapshots in Redis, selecting the right persistence model is essential for ensuring data durability and performance. Redis offers two main persistence models:
+
+- RDB (Redis Database) - Periodically saves the dataset to disk. This is less resource-intensive because it doesn't constantly write to disk but instead saves the state at certain intervals.
+- AOF (Append Only File) - Logs every write operation to disk as it happens. In case of a crash, Redis can replay the log to restore the data.
+
+Redis allows using both RDB and AOF simultaneously. This provides the advantage of faster recovery through RDB snapshots while maintaining high durability with AOF. Depending on the system's criticality, you may want to consider enabling both for your JaVers snapshot storage.
+
+For more information, check the [official Redis documentation](https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/).
+
+
+**Dependency**<br/>
+Add `javers-persistence-redis` module to your classpath:
+
+_Maven_<br/>
+
+```
+<dependency>
+    <groupId>org.javers</groupId>
+    <artifactId>javers-persistence-redis</artifactId>
+    <version>{{site.javers_current_version}}</version>
+</dependency>
+```
+
+_Gradle (short)_<br/>
+
+```
+implementation 'org.javers:javers-persistence-redis:{{site.javers_current_version}}'
+```
+
+Check
+[Maven Central](https://central.sonatype.com/artifact/org.javers/javers-persistence-redis/{{site.javers_current_version}}/versions)
+for other build tools snippets.
+
+<h3>Overview</h3>
+
+The idea of configuring `JaversRedisRepository` is simple, just provide a working Jedis (Java client for Redis). You can setup `JaversRedisRepository` as follows:
+
+```java
+import org.javers.repository.redis.JaversRedisRepository;
+import redis.clients.jedis.JedisPool;
+...
+
+private static final String REDIS_HOST = "localhost";
+private static final int REDIS_PORT = 6379;
+private static final Duration REDIS_KEY_EXPIRATION_TIME = Duration.ofSeconds(3600);
+
+
+final var jedisPool = new JedisPool();
+final var javersRedisRepository = new JaversRedisRepository(jedisPool, REDIS_KEY_EXPIRATION_TIME);
+final var javers = JaversBuilder.javers().registerJaversRepository(javersRedisRepository).build();
+```
+
+<h3>Schema</h3>
+JaVers creates several key-value pairs in Redis, with main keys being:
+
+- `jv_head_id` — A `String` that holds the value of the last `CommitId`.
+- `jv_snapshots_keys` — A `Set` that contains keys, where each key is a reference to another key of type `List`. These lists contain snapshots for specific entities and their properties.
+- `jv_snapshots_keys:<Entity Name>` — Domain-specific sets pointing to lists containing snapshots for specific objects of that entity type.
+
+<h3>Handling Redis Key Expiration</h3>
+
+In Redis, when a key expires, it is automatically removed from the database. However, additional cleanup may be required if the expired key is referenced in other structures, such as sets.
+
+**CdoSnapshotKeyExpireListener**
+
+The `CdoSnapshotKeyExpireListener` is an event listener designed to handle key expiration events in Redis. Its primary responsibility is to ensure that expired key entries are removed from all relevant sets.
+
+When an instance of `JaversRedisRepository` is created, it subscribes to keyspace events with the pattern `__key*__:jv_snapshots:*`. This subscription allows the `CdoSnapshotKeyExpireListener` to process key expiration events as they occur.
+
+Upon receiving a key expiration event, the `CdoSnapshotKeyExpireListener` identifies the expired key and removes its entries from all relevant sets, such as `jv_snapshots_keys` and `jv_snapshots_keys:<Entity Name>`.
+
+**Expired Keys Cleanup**
+
+A significant challenge arises if Redis keys expire when there is no active `CdoSnapshotKeyExpireListener` running. In this scenario, expired key entries will remain in the sets, leading to potential data inconsistencies.
+
+To address this challenge, we have introduced the public method `cleanExpiredSnapshotsKeysSets` in JaversRedisRepository that can be called to perform the necessary cleanup. This ensures that expired keys are properly removed from all relevant sets, even if the listener is not active at the time of expiration.
+
+<h3>Integrating JaversRedisRepository with JPA (Hibernate)</h3>
+
+The `JaversRedisRepository` can be seamlessly integrated with existing JPA repositories, enabling you to store JaVers audit data in Redis while continuing to use your JPA entities and repositories for application data.
+ 
+However, when working with Hibernate, it’s common for entities to be wrapped in proxies. To ensure proper handling of these proxies, you need to configure the `HibernateUnproxyObjectAccessHook` in your application. This can be done by setting the following property in your application configuration file:
+
+```yaml
+javers:
+  objectAccessHook: org.javers.hibernate.integration.HibernateUnproxyObjectAccessHook
+```
+
+This configuration ensures that JaVers can unproxy Hibernate entities effectively, allowing audit logging to work seamlessly with Redis and JPA.
+
+
 <h2 id="custom-json-serialization">Custom JSON serialization</h2>
 JaVers is meant to support various persistence stores (MongoDB, SQL)
 for any kind of your data. Hence, we use JSON format to serialize your objects in a JaversRepository.
diff --git a/documentation/spring-boot-integration/index.md b/documentation/spring-boot-integration/index.md
@@ -22,13 +22,6 @@ There are two Javers Spring Boot starters:
 
 <h2 id="get-javers-starters">Get a Javers Spring Boot starter</h2>
 
-### The Redis starter ###
-Add the Javers Spring Boot starter for Redis to your classpath:
-
-```groovy
-implementation 'org.javers:javers-spring-boot-starter-redis:{{site.javers_current_version}}'
-```
-
 ### The MongoDB starter ###
 Add the Javers Spring Boot starter for MongoDB to your classpath:
 
@@ -46,6 +39,13 @@ implementation 'org.javers:javers-spring-boot-starter-sql:{{site.javers_current_
 Check [Maven Central](https://central.sonatype.com/artifact/org.javers/javers-spring-boot-starter-sql/{{site.javers_current_version}}/versions)
 for other build tool snippets.
 
+### The Redis starter ###
+Add the Javers Spring Boot starter for Redis to your classpath:
+
+```groovy
+implementation 'org.javers:javers-spring-boot-starter-redis:{{site.javers_current_version}}'
+```
+
 <h2 id="starters-auto-configuration">Spring Boot Auto-configuration</h2>
 
 Thanks to the Spring Boot magic, Javers auto-configuration
@@ -61,9 +61,9 @@ according to your application configuration. That is:
 
 Check the complete list of Javers beans added to your Spring Context:
 
-* for Redis: [JaversRedisAutoConfiguration.java](https://github.com/javers/javers/blob/master/javers-spring-boot-starter-redis/src/main/java/org/javers/spring/boot/redis/JaversRedisAutoConfiguration.java)
 * for MongoDB: [JaversMongoAutoConfiguration.java](https://github.com/javers/javers/blob/master/javers-spring-boot-starter-mongo/src/main/java/org/javers/spring/boot/mongo/JaversMongoAutoConfiguration.java),
 * for SQL: [JaversSqlAutoConfiguration.java](https://github.com/javers/javers/blob/master/javers-spring-boot-starter-sql/src/main/java/org/javers/spring/boot/sql/JaversSqlAutoConfiguration.java).
+* for Redis: [JaversRedisAutoConfiguration.java](https://github.com/javers/javers/blob/master/javers-spring-boot-starter-redis/src/main/java/org/javers/spring/boot/redis/JaversRedisAutoConfiguration.java)
 
 <h2 id="customizing-auto-configuration">Customizing the Auto-configuration</h2>
 
