Cascade LiveObjectService.merge whole object graph #649

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

@@ -181,22 +181,17 @@ public class RedissonLiveObjectService implements RLiveObjectService {
 
     @Override
     public <T> T merge(T detachedObject) {
-        T attachedObject = attach(detachedObject);
+        Map<Object, Object> alreadyPersisted = new HashMap<Object, Object>();
-        getMap(attachedObject).fastPut("redisson_live_object", "1");
+        return persist(detachedObject, alreadyPersisted, false);
-        List<String> excludedFields = new ArrayList<String>();
-        String idFieldName = getRIdFieldName(detachedObject.getClass());
-        excludedFields.add(idFieldName);
-        copy(detachedObject, attachedObject, excludedFields);
-        return attachedObject;
     }
     
     @Override
     public <T> T persist(T detachedObject) {
         Map<Object, Object> alreadyPersisted = new HashMap<Object, Object>();
-        return persist(detachedObject, alreadyPersisted);
+        return persist(detachedObject, alreadyPersisted, true);
     }
     
-    private <T> T persist(T detachedObject, Map<Object, Object> alreadyPersisted) {
+    private <T> T persist(T detachedObject, Map<Object, Object> alreadyPersisted, boolean checkExistence) {
         String idFieldName = getRIdFieldName(detachedObject.getClass());
         Object id = ClassUtils.getField(detachedObject, idFieldName);
         if (id == null) {
@@ -214,7 +209,11 @@ public class RedissonLiveObjectService implements RLiveObjectService {
         
         List<String> excludedFields = new ArrayList<String>();
         excludedFields.add(idFieldName);
-        if (liveMap.fastPut("redisson_live_object", "1")) {
+        boolean fastResult = liveMap.fastPut("redisson_live_object", "1");
+        if (checkExistence && !fastResult) {
+            throw new IllegalArgumentException("This REntity already exists.");
+        }
+        
         for (FieldDescription.InDefinedShape field : Introspectior.getFieldsDescription(detachedObject.getClass())) {
             Object object = ClassUtils.getField(detachedObject, field.getName());
             
@@ -235,7 +234,7 @@ public class RedissonLiveObjectService implements RLiveObjectService {
                         if (obj != null && obj.getClass().isAnnotationPresent(REntity.class)) {
                             Object persisted = alreadyPersisted.get(obj);
                             if (persisted == null) {
-                                    persisted = persist(obj, alreadyPersisted);
+                                persisted = persist(obj, alreadyPersisted, checkExistence);
                             }
                             obj = persisted;
                         }
@@ -253,7 +252,7 @@ public class RedissonLiveObjectService implements RLiveObjectService {
                         if (key != null && key.getClass().isAnnotationPresent(REntity.class)) {
                             Object persisted = alreadyPersisted.get(key);
                             if (persisted == null) {
-                                    persisted = persist(key, alreadyPersisted);
+                                persisted = persist(key, alreadyPersisted, checkExistence);
                             }
                             key = persisted;
                         }
@@ -261,7 +260,7 @@ public class RedissonLiveObjectService implements RLiveObjectService {
                         if (value != null && value.getClass().isAnnotationPresent(REntity.class)) {
                             Object persisted = alreadyPersisted.get(value);
                             if (persisted == null) {
-                                    persisted = persist(value, alreadyPersisted);
+                                persisted = persist(value, alreadyPersisted, checkExistence);
                             }
                             value = persisted;
                         }
@@ -275,7 +274,7 @@ public class RedissonLiveObjectService implements RLiveObjectService {
             if (object.getClass().isAnnotationPresent(REntity.class)) {
                 Object persisted = alreadyPersisted.get(object);
                 if (persisted == null) {
-                        persisted = persist(object, alreadyPersisted);
+                    persisted = persist(object, alreadyPersisted, checkExistence);
                 }
                 
                 excludedFields.add(field.getName());
@@ -285,8 +284,6 @@ public class RedissonLiveObjectService implements RLiveObjectService {
         copy(detachedObject, attachedObject, excludedFields);
         return attachedObject;
     }
-        throw new IllegalArgumentException("This REntity already exists.");
-    }
     
     @Override
     public <T> T detach(T attachedObject) {

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

@@ -551,6 +551,32 @@ public class RedissonLiveObjectServiceTest extends BaseTest {
         }
     }
 
+    @Test
+    public void testMergeList() {
+        Customer customer = new Customer("12");
+        Order order = new Order(customer);
+        customer.getOrders().add(order);
+        Order order2 = new Order(customer);
+        customer.getOrders().add(order2);
+
+        redisson.getLiveObjectService().merge(customer);
+        
+        Customer mergedCustomer = redisson.getLiveObjectService().get(Customer.class, "12");
+        assertThat(mergedCustomer.getOrders().size()).isEqualTo(2);
+        for (Order orderElement : mergedCustomer.getOrders()) {
+            assertThat(orderElement.getId()).isNotNull();
+            assertThat(orderElement.getCustomer().getId()).isEqualTo("12");
+        }
+
+        try {
+            redisson.getLiveObjectService().persist(customer);
+            fail("Should not be here");
+        } catch (Exception e) {
+            assertEquals("This REntity already exists.", e.getMessage());
+        }
+    }
+
+    
     @Test
     public void testPersistList() {
         Customer customer = new Customer("12");