Fixed - RMap.computeIfPresent() doesn't update mutable objects. #3567

redisson/src/main/java/org/redisson/RedissonMap.java

@@ -438,22 +438,18 @@ public class RedissonMap<K, V> extends RedissonExpirable implements RMap<K, V> {
                         return;
                     }
                     if (newValue != null) {
-                        RFuture<Boolean> replaceFuture = replaceAsync(key, oldValue, newValue);
-                        replaceFuture.onComplete((re, ex1) -> {
+                        RFuture<Boolean> fastPutFuture = fastPutAsync(key, newValue);
+                        fastPutFuture.onComplete((re, ex1) -> {
                             lock.unlockAsync(threadId);
                             if (ex1 != null) {
                                 result.tryFailure(ex1);
                                 return;
                             }
 
-                            if (re) {
-                                result.trySuccess(newValue);
-                            } else {
-                                result.trySuccess(oldValue);
-                            }
+                            result.trySuccess(newValue);
                         });
-                    } else if (remove(key, oldValue)) {
-                        RFuture<Boolean> removeFuture = removeAsync(key, oldValue);
+                    } else {
+                        RFuture<Long> removeFuture = fastRemoveAsync(key);
                         removeFuture.onComplete((re, ex1) -> {
                             lock.unlockAsync(threadId);
                             if (ex1 != null) {
@@ -461,11 +457,7 @@ public class RedissonMap<K, V> extends RedissonExpirable implements RMap<K, V> {
                                 return;
                             }
 
-                            if (re) {
-                                result.trySuccess(null);
-                            } else {
-                                result.trySuccess(oldValue);
-                            }
+                            result.trySuccess(null);
                         });
                     }
                 });
@@ -489,13 +481,11 @@ public class RedissonMap<K, V> extends RedissonExpirable implements RMap<K, V> {
 
             V newValue = remappingFunction.apply(key, oldValue);
             if (newValue != null) {
-                if (replace(key, oldValue, newValue)) {
-                    return newValue;
-                }
-            } else if (remove(key, oldValue)) {
-                return null;
+                fastPut(key, newValue);
+                return newValue;
             }
-            return oldValue;
+            fastRemove(key);
+            return null;
         } finally {
             lock.unlock();
         }

redisson/src/test/java/org/redisson/BaseMapTest.java

@@ -175,6 +175,57 @@ public abstract class BaseMapTest extends BaseTest {
         assertThat(map.get("1")).isEqualTo("12");
     }
 
+    public static class MyClass implements Serializable {
+
+        private String name;
+
+        public MyClass(String name) {
+            this.name = name;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public void setName(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            MyClass myClass = (MyClass) o;
+            return Objects.equals(name, myClass.name);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(name);
+        }
+
+        @Override
+        public String toString() {
+            return "MyClass{" +
+                    "name='" + name + '\'' +
+                    '}';
+        }
+    }
+
+    @Test
+    public void testComputeIfPresentMutable() {
+        RMap<String, MyClass> map = getMap("map");
+
+        map.put("1", new MyClass("value1"));
+        map.computeIfPresent("1", (key, value) -> {
+            assertThat(value).isEqualTo(new MyClass("value1"));
+            value.setName("value2");
+            return value;
+        });
+        assertThat(map.get("1")).isEqualTo(new MyClass("value2"));
+    }
+
+
     @Test
     public void testComputeIfAbsent() {
         RMap<String, String> map = getMap("map");