Introduce RCascade annotation for LiveObject #651

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

@@ -18,6 +18,7 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Deque;
 import java.util.HashMap;
@@ -33,6 +34,7 @@
 import java.util.TreeSet;
 import java.util.concurrent.ConcurrentMap;
 
+import org.redisson.api.RCascadeType;
 import org.redisson.api.RDeque;
 import org.redisson.api.RExpirable;
 import org.redisson.api.RExpirableAsync;
@@ -47,6 +49,7 @@
 import org.redisson.api.RSet;
 import org.redisson.api.RSortedSet;
 import org.redisson.api.RedissonClient;
+import org.redisson.api.annotation.RCascade;
 import org.redisson.api.annotation.REntity;
 import org.redisson.api.annotation.RFieldAccessor;
 import org.redisson.api.annotation.RId;
@@ -176,16 +179,16 @@ public <T> T attach(T detachedObject) {
     @Override
     public <T> T merge(T detachedObject) {
         Map<Object, Object> alreadyPersisted = new HashMap<Object, Object>();
-        return persist(detachedObject, alreadyPersisted, false);
+        return persist(detachedObject, alreadyPersisted, RCascadeType.MERGE);
     }
 
     @Override
     public <T> T persist(T detachedObject) {
         Map<Object, Object> alreadyPersisted = new HashMap<Object, Object>();
-        return persist(detachedObject, alreadyPersisted, true);
+        return persist(detachedObject, alreadyPersisted, RCascadeType.PERSIST);
     }
 
-    private <T> T persist(T detachedObject, Map<Object, Object> alreadyPersisted, boolean checkExistence) {
+    private <T> T persist(T detachedObject, Map<Object, Object> alreadyPersisted, RCascadeType type) {
         String idFieldName = getRIdFieldName(detachedObject.getClass());
         Object id = ClassUtils.getField(detachedObject, idFieldName);
         if (id == null) {
@@ -204,7 +207,7 @@ private <T> T persist(T detachedObject, Map<Object, Object> alreadyPersisted, bo
         List<String> excludedFields = new ArrayList<String>();
         excludedFields.add(idFieldName);
         boolean fastResult = liveMap.fastPut("redisson_live_object", "1");
-        if (checkExistence && !fastResult) {
+        if (type == RCascadeType.PERSIST && !fastResult) {
             throw new IllegalArgumentException("This REntity already exists.");
         }
 
@@ -218,25 +221,26 @@ private <T> T persist(T detachedObject, Map<Object, Object> alreadyPersisted, bo
             RObject rObject = objectBuilder.createObject(id, detachedObject.getClass(), object.getClass(), field.getName(), null);
             if (rObject != null) {
                 objectBuilder.store(rObject, field.getName(), liveMap);
-
                 if (rObject instanceof SortedSet) {
                     ((RSortedSet)rObject).trySetComparator(((SortedSet)object).comparator());
                 }
 
+                if (!checkCascade(detachedObject, type, field.getName())) {
+                    continue;
+                }
+
                 if (rObject instanceof Collection) {
                     for (Object obj : (Collection<Object>)object) {
                         if (obj != null && obj.getClass().isAnnotationPresent(REntity.class)) {
                             Object persisted = alreadyPersisted.get(obj);
                             if (persisted == null) {
-                                persisted = persist(obj, alreadyPersisted, checkExistence);
+                                persisted = persist(obj, alreadyPersisted, type);
                             }
                             obj = persisted;
                         }
                         ((Collection)rObject).add(obj);
                     }
-                }
-
-                if (rObject instanceof Map) {
+                } else if (rObject instanceof Map) {
                     Map<Object, Object> rMap = (Map<Object, Object>) rObject;
                     Map<?, ?> map = (Map<?, ?>)rObject;
                     for (Entry<?, ?> entry : map.entrySet()) {
@@ -246,15 +250,15 @@ private <T> T persist(T detachedObject, Map<Object, Object> alreadyPersisted, bo
                         if (key != null && key.getClass().isAnnotationPresent(REntity.class)) {
                             Object persisted = alreadyPersisted.get(key);
                             if (persisted == null) {
-                                persisted = persist(key, alreadyPersisted, checkExistence);
+                                persisted = persist(key, alreadyPersisted, type);
                             }
                             key = persisted;
                         }
 
                         if (value != null && value.getClass().isAnnotationPresent(REntity.class)) {
                             Object persisted = alreadyPersisted.get(value);
                             if (persisted == null) {
-                                persisted = persist(value, alreadyPersisted, checkExistence);
+                                persisted = persist(value, alreadyPersisted, type);
                             }
                             value = persisted;
                         }
@@ -263,21 +267,50 @@ private <T> T persist(T detachedObject, Map<Object, Object> alreadyPersisted, bo
                     }
                 }
                 excludedFields.add(field.getName());
-            }
-
-            if (object.getClass().isAnnotationPresent(REntity.class)) {
+            } else if (object.getClass().isAnnotationPresent(REntity.class)) {
                 Object persisted = alreadyPersisted.get(object);
                 if (persisted == null) {
-                    persisted = persist(object, alreadyPersisted, checkExistence);
+                    if (checkCascade(detachedObject, type, field.getName())) {
+                        persisted = persist(object, alreadyPersisted, type);
+                    }
                 }
 
                 excludedFields.add(field.getName());
                 BeanUtil.pojo.setSimpleProperty(attachedObject, field.getName(), persisted);
+            } else {
+                validateAnnotation(detachedObject, field.getName());
             }
+
         }
         copy(detachedObject, attachedObject, excludedFields);
         return attachedObject;
     }
+
+    private void validateAnnotation(Object instance, String fieldName) {
+        Class<?> clazz = instance.getClass();
+        if (isLiveObject(instance)) {
+            clazz = clazz.getSuperclass();
+        }
+
+        RCascade annotation = ClassUtils.getAnnotation(clazz, fieldName, RCascade.class);
+        if (annotation != null) {
+            throw new IllegalArgumentException("RCascade annotation couldn't be defined for non-Redisson object field");
+        }
+    }
+
+    private <T> boolean checkCascade(Object instance, RCascadeType type, String fieldName) {
+        Class<?> clazz = instance.getClass();
+        if (isLiveObject(instance)) {
+            clazz = clazz.getSuperclass();
+        }
+
+        RCascade annotation = ClassUtils.getAnnotation(clazz, fieldName, RCascade.class);
+        if (annotation != null && (Arrays.asList(annotation.value()).contains(type)
+                || Arrays.asList(annotation.value()).contains(RCascadeType.ALL))) {
+            return true;
+        }
+        return false;
+    }
 
     @Override
     public <T> T detach(T attachedObject) {
@@ -294,6 +327,10 @@ private <T> T detach(T attachedObject, Map<String, Object> alreadyDetached) {
             alreadyDetached.put(getMap(attachedObject).getName(), detached);
 
             for (Entry<String, Object> obj : getMap(attachedObject).entrySet()) {
+                if (!checkCascade(attachedObject, RCascadeType.DETACH, obj.getKey())) {
+                    continue;
+                }
+
                 if (obj.getValue() instanceof RSortedSet) {
                     SortedSet<Object> redissonSet = (SortedSet<Object>) obj.getValue();
                     Set<Object> set = new TreeSet<Object>(redissonSet.comparator()); 
@@ -369,9 +406,7 @@ private <T> T detach(T attachedObject, Map<String, Object> alreadyDetached) {
                     }
 
                     ClassUtils.setField(detached, obj.getKey(), list);
-                }
-
-                if (isLiveObject(obj.getValue())) {
+                } else if (isLiveObject(obj.getValue())) {
                     Object detachedObject = alreadyDetached.get(getMap(obj.getValue()).getName());
                     if (detachedObject == null) {
                         detachedObject = detach(obj.getValue(), alreadyDetached);
@@ -403,6 +438,8 @@ private <T> T detach(T attachedObject, Map<String, Object> alreadyDetached) {
                     }
 
                     ClassUtils.setField(detached, obj.getKey(), map);
+                } else {
+                    validateAnnotation(detached, obj.getKey());
                 }
             }
 
@@ -418,10 +455,14 @@ public <T> void delete(T attachedObject) {
         delete(attachedObject, deleted);
     }
 
-    public <T> void delete(T attachedObject, Set<String> deleted) {
+    private <T> void delete(T attachedObject, Set<String> deleted) {
         validateAttached(attachedObject);
 
         for (Entry<String, Object> obj : getMap(attachedObject).entrySet()) {
+            if (!checkCascade(attachedObject, RCascadeType.DELETE, obj.getKey())) {
+                continue;
+            }
+
             if (obj.getValue() instanceof RSortedSet) {
                 deleteCollection(deleted, (Iterable<?>)obj.getValue());
                 ((RObject)obj.getValue()).delete();
@@ -437,9 +478,7 @@ public <T> void delete(T attachedObject, Set<String> deleted) {
             } else if (obj.getValue() instanceof RList) {
                 deleteCollection(deleted, (Iterable<?>)obj.getValue());
                 ((RObject)obj.getValue()).delete();
-            }
-
-            if (isLiveObject(obj.getValue())) {
+            } else if (isLiveObject(obj.getValue())) {
                 if (deleted.add(getMap(obj.getValue()).getName())) {
                     delete(obj.getValue(), deleted);
                 }
@@ -448,7 +487,10 @@ public <T> void delete(T attachedObject, Set<String> deleted) {
                 deleteCollection(deleted, map.keySet());
                 deleteCollection(deleted, map.values());
                 ((RObject)obj.getValue()).delete();
+            } else {
+                validateAnnotation(attachedObject, obj.getKey());
             }
+
         }
         asLiveObject(attachedObject).delete();
     }

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

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.redisson.api;
+
+/**
+ * 
+ * @author Nikita Koksharov
+ *
+ */
+public enum RCascadeType {
+
+    ALL,
+    PERSIST,
+    DETACH,
+    MERGE,
+    DELETE
+
+
+}

redisson/src/main/java/org/redisson/api/annotation/RCascade.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.redisson.api.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.redisson.api.RCascadeType;
+
+/**
+ * 
+ * @author Nikita Koksharov
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD})
+public @interface RCascade {
+
+    RCascadeType[] value();
+
+}

redisson/src/main/java/org/redisson/liveobject/core/AccessorInterceptor.java

@@ -92,7 +92,7 @@ public Object intercept(@Origin Method method, @SuperCall Callable<?> superMetho
         }
         if (isSetter(method, fieldName)) {
             Object arg = args[0];
-            if (arg.getClass().isAnnotationPresent(REntity.class)) {
+            if (arg != null && arg.getClass().isAnnotationPresent(REntity.class)) {
                 throw new IllegalStateException("REntity object should be attached to Redisson first");
             }
 
@@ -125,7 +125,11 @@ public Object intercept(@Origin Method method, @SuperCall Callable<?> superMetho
                 objectBuilder.store((RObject)arg, fieldName, liveMap);
                 return me;
             }
-            liveMap.fastPut(fieldName, args[0]);
+            if (arg == null) {
+                liveMap.remove(fieldName);
+            } else {
+                liveMap.fastPut(fieldName, arg);
+            }
             return me;
         }
         return superMethod.call();

redisson/src/main/java/org/redisson/liveobject/misc/ClassUtils.java

@@ -45,6 +45,7 @@
 
 package org.redisson.liveobject.misc;
 
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
@@ -66,6 +67,18 @@ public static void setField(Object obj, String fieldName, Object value) {
         }
     }
 
+    public static <T extends Annotation> T getAnnotation(Class<?> clazz, String fieldName, Class<T> annotationClass) {
+        try {
+            Field field = clazz.getDeclaredField(fieldName);
+            if (!field.isAccessible()) {
+                field.setAccessible(true);
+            }
+            return field.getAnnotation(annotationClass);
+        } catch (NoSuchFieldException e) {
+            return null;
+        }
+    }
+
     public static <T> T getField(Object obj, String fieldName) {
         try {
             Field field = obj.getClass().getDeclaredField(fieldName);

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

@@ -28,6 +28,7 @@
 import org.junit.Test;
 import org.redisson.api.RBlockingDeque;
 import org.redisson.api.RBlockingQueue;
+import org.redisson.api.RCascadeType;
 import org.redisson.api.RDeque;
 import org.redisson.api.RList;
 import org.redisson.api.RLiveObject;
@@ -38,6 +39,7 @@
 import org.redisson.api.RSet;
 import org.redisson.api.RSortedSet;
 import org.redisson.api.RedissonClient;
+import org.redisson.api.annotation.RCascade;
 import org.redisson.api.annotation.REntity;
 import org.redisson.api.annotation.RFieldAccessor;
 import org.redisson.api.annotation.RId;
@@ -387,6 +389,7 @@ public static class TestClass {
 
         private String value;
         private String code;
+        @RCascade(RCascadeType.ALL)
         private Object content;
 
         @RId(generator = RandomUUIDIdStringGenerator.class)
@@ -1200,6 +1203,7 @@ public static class Customer {
         @RId
         private String id;
 
+        @RCascade(RCascadeType.ALL)
         private List<Order> orders = new ArrayList<>();
 
         public Customer() {
@@ -1234,6 +1238,7 @@ public static class Order {
         @RId(generator = DistributedAtomicLongIdGenerator.class)
         private Long id;
 
+        @RCascade({RCascadeType.PERSIST, RCascadeType.DETACH})
         private Customer customer;
 
         public Order() {
@@ -1295,7 +1300,12 @@ public void testDelete() {
         Order order = new Order(customer);
         order = redisson.getLiveObjectService().persist(order);
         assertThat(redisson.getKeys().count()).isEqualTo(3);
+
+        Customer persistedCustomer = order.getCustomer();
         redisson.getLiveObjectService().delete(order);
+        assertThat(redisson.getKeys().count()).isEqualTo(2);
+
+        redisson.getLiveObjectService().delete(persistedCustomer);
         assertThat(redisson.getKeys().count()).isEqualTo(1);
     }