Fixed - add batched merge() method to RLiveObjectService interface #3773

redisson/src/main/java/org/redisson/RedissonLiveObjectService.java

@@ -175,6 +175,14 @@ public class RedissonLiveObjectService implements RLiveObjectService {
 
     @Override
     public <T> List<T> persist(T... detachedObjects) {
+        return persist(RCascadeType.PERSIST, detachedObjects);
+    }
+
+    public <T> List<T> merge(T... detachedObjects) {
+        return persist(RCascadeType.MERGE, detachedObjects);
+    }
+
+    public <T> List<T> persist(RCascadeType type, T... detachedObjects) {
         CommandBatchService batchService = new CommandBatchService(commandExecutor);
 
         Map<Class<?>, Class<?>> classCache = new HashMap<>();
@@ -191,6 +199,7 @@ public class RedissonLiveObjectService implements RLiveObjectService {
             name2id.put(liveMap.getName(), id);
         }
 
+        if (type == RCascadeType.PERSIST) {
             CommandBatchService checkExecutor = new CommandBatchService(batchService);
             for (Entry<String, Object> entry : name2id.entrySet()) {
                 RMap<String, Object> map = new RedissonMap<>(checkExecutor, entry.getKey(), null, null, null);
@@ -206,6 +215,7 @@ public class RedissonLiveObjectService implements RLiveObjectService {
                     throw new IllegalArgumentException("Object with id=" + id + " already exists.");
                 }
             }
+        }
 
         for (Entry<T, Object> entry : detached2Attached.entrySet()) {
             T detachedObject = entry.getKey();

redisson/src/main/java/org/redisson/api/RLiveObjectService.java

@@ -144,6 +144,24 @@ public interface RLiveObjectService {
      */
     <T> T merge(T detachedObject);
 
+    /**
+     * Returns proxied object for the detached object. Transfers all the
+     * <b>NON NULL</b> field values to the redis server. It does not delete any
+     * existing data in redis in case of the field value is null.
+     *
+     * The class representing this object should have a field annotated with
+     * RId, and the object should hold a non null value in that field.
+     *
+     * If this object is not in redis then a new hash key will be created to
+     * store it. Otherwise overrides current object state in Redis with the given object state.
+     *
+     * @param <T> Entity type
+     * @param detachedObjects - not proxied objects
+     * @return proxied object
+     * @throws IllegalArgumentException if the object is is a RLiveObject instance.
+     */
+    <T> List<T> merge(T... detachedObjects);
+
     /**
      * Returns proxied attached object for the detached object. Transfers all the
      * <b>NON NULL</b> field values to the redis server. Only when the it does

redisson/src/test/java/org/redisson/RedissonLiveObjectServiceTest.java

@@ -2289,6 +2289,36 @@ public class RedissonLiveObjectServiceTest extends BaseTest {
         }
     }
 
+    @Test
+    public void testBatchedMerge() {
+        Assertions.assertTimeout(Duration.ofSeconds(10), () -> {
+            RLiveObjectService s = redisson.getLiveObjectService();
+
+            List<TestREntity> objects = new ArrayList<>();
+            int objectsAmount = 100000;
+            for (int i = 0; i < objectsAmount; i++) {
+                TestREntity e = new TestREntity();
+                e.setName("" + i);
+                e.setValue("value" + i);
+                objects.add(e);
+            }
+            List<Object> attachedObjects = s.merge(objects.toArray());
+            assertThat(attachedObjects).hasSize(objectsAmount);
+
+            objects.clear();
+            for (int i = 0; i < objectsAmount; i++) {
+                TestREntity e = (TestREntity) attachedObjects.get(i);
+                e.setName("" + i);
+                e.setValue("value" + i*1000);
+                objects.add(e);
+            }
+            List<Object> attachedObjects2 = s.merge(objects.toArray());
+            assertThat(attachedObjects2).hasSize(objectsAmount);
+
+            assertThat(redisson.getKeys().count()).isEqualTo(objectsAmount);
+        });
+    }
+
     @Test
     public void testBatchedPersist() {
         Assertions.assertTimeout(Duration.ofSeconds(40), () -> {