feat(LimitedContainer): support for dynamically updating cached data in LimitedContainer (GitHub #316)

crane4j-core/src/main/java/cn/crane4j/core/container/ImmutableMapContainer.java

@@ -1,9 +1,9 @@
 package cn.crane4j.core.container;
 
 import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
-import lombok.RequiredArgsConstructor;
 import org.checkerframework.checker.nullness.qual.NonNull;
 
 import java.util.Collection;
@@ -30,7 +30,7 @@
  * @since 2.0.0
  */
 @EqualsAndHashCode
-@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
 public class ImmutableMapContainer<K> implements LimitedContainer<K>, Container.Lifecycle {
 
     /**
@@ -42,7 +42,7 @@ public class ImmutableMapContainer<K> implements LimitedContainer<K>, Container.
     /**
      * data source objects grouped by key value
      */
-    private final Map<K, ?> data;
+    private volatile Map<K, ?> data;
 
     /**
      * <p>Create a key-value pair container based on the specified {@link Map} instance.
@@ -79,6 +79,17 @@ public static <K> ImmutableMapContainer<K> forMap(String namespace, @NonNull Map
         return data;
     }
 
+    /**
+     * Refresh the container with new data.
+     *
+     * @param data data
+     * @since 2.9.0
+     */
+    @Override
+    public void refresh(@NonNull Map<K, ?> data) {
+        this.data = data;
+    }
+
     /**
      * Destroy the container
      */

crane4j-core/src/main/java/cn/crane4j/core/container/LimitedContainer.java

@@ -1,5 +1,7 @@
 package cn.crane4j.core.container;
 
+import org.checkerframework.checker.nullness.qual.NonNull;
+
 import java.util.Map;
 
 /**
@@ -17,4 +19,14 @@ public interface LimitedContainer<K> extends Container<K> {
      * @return all elements
      */
     Map<K, ?> getAll();
+
+    /**
+     * Refresh the container with new data.
+     *
+     * @param data data
+     * @since 2.9.0
+     */
+    default void refresh(@NonNull Map<K, ?> data) {
+        // do nothing
+    }
 }

crane4j-core/src/main/java/cn/crane4j/core/support/Crane4jTemplate.java

@@ -9,7 +9,9 @@
 import cn.crane4j.core.container.Container;
 import cn.crane4j.core.container.ContainerProvider;
 import cn.crane4j.core.container.Containers;
+import cn.crane4j.core.container.LimitedContainer;
 import cn.crane4j.core.container.lifecycle.ContainerLifecycleProcessor;
+import cn.crane4j.core.exception.Crane4jException;
 import cn.crane4j.core.executor.AsyncBeanOperationExecutor;
 import cn.crane4j.core.executor.BeanOperationExecutor;
 import cn.crane4j.core.executor.OrderedBeanOperationExecutor;
@@ -27,6 +29,7 @@
 import cn.crane4j.core.support.operator.OperatorProxyFactory;
 import cn.crane4j.core.support.operator.OperatorProxyMethodFactory;
 import cn.crane4j.core.support.reflect.PropertyOperator;
+import cn.crane4j.core.util.Asserts;
 import cn.crane4j.core.util.ConfigurationUtil;
 import lombok.Builder;
 import lombok.Getter;
@@ -37,6 +40,7 @@
 import java.lang.reflect.AnnotatedElement;
 import java.util.Collection;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiConsumer;
@@ -491,6 +495,38 @@ public <P extends ContainerProvider> OpsForContainer configureContainerProvider(
         public ContainerProvider getContainerProvider(String providerName) {
             return configuration.getContainerProvider(providerName);
         }
+
+        /**
+         * Refresh data cache for specified namespace if possible.
+         * <ul>
+         *     <li>if container not exists, register a new container with the given data;</li>
+         *     <li>if container exists, refresh the data cache if possible;</li>
+         * </ul>
+         *
+         * @param namespace namespace
+         * @param data date
+         * @param <K> key type
+         * @return this
+         * @throws Crane4jException if container already exists and it is not a {@link LimitedContainer}.
+         * @see LimitedContainer#refresh
+         * @since 2.9.0
+         */
+        @SuppressWarnings("unchecked")
+        public <K> Crane4jTemplate.OpsForContainer refreshContainerData(
+            String namespace, @NonNull Map<K, ?> data) {
+            Container<?> container = configuration.getContainer(namespace);
+            if (Objects.isNull(container)) {
+                registerMapContainer(namespace, data);
+                return this;
+            }
+            Asserts.isTrue(
+                container instanceof LimitedContainer,
+                "Container [{}] does not support refreshing data, is it a [{}]?",
+                namespace, LimitedContainer.class
+            );
+            ((LimitedContainer<K>) container).refresh(data);
+            return this;
+        }
     }
 
     /**

crane4j-core/src/test/java/cn/crane4j/core/container/EmptyContainerTest.java

@@ -3,6 +3,8 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.Collections;
+
 /**
  * test for {@link EmptyContainer}
  *
@@ -16,7 +18,11 @@ public void get() {
         Assert.assertSame(container, Container.empty());
         Assert.assertEquals(Container.EMPTY_CONTAINER_NAMESPACE, container.getNamespace());
         Assert.assertTrue(container.get(null).isEmpty());
-        Assert.assertTrue(((LimitedContainer<Object>)container).getAll().isEmpty());
+
+        Assert.assertTrue(container instanceof LimitedContainer);
+        LimitedContainer<Object> limitedContainer = (LimitedContainer<Object>)container;
+        Assert.assertTrue(limitedContainer.getAll().isEmpty());
+        limitedContainer.refresh(Collections.emptyMap());
     }
 
 }

crane4j-core/src/test/java/cn/crane4j/core/container/ImmutableMapContainerTest.java

@@ -27,6 +27,10 @@ public void forMap() {
         assertEquals(map, container.getAll());
         //always return all data
         assertEquals(map, container.get(Collections.singletonList("1")));
+
+        container.refresh(Collections.emptyMap());
+        Assert.assertNotSame(map, container.getAll());
+        Assert.assertTrue(container.getAll().isEmpty());
     }
 
     @Test

crane4j-core/src/test/java/cn/crane4j/core/support/Crane4jTemplateTest.java

@@ -14,6 +14,7 @@
 import cn.crane4j.core.container.Container;
 import cn.crane4j.core.container.ContainerProvider;
 import cn.crane4j.core.container.Containers;
+import cn.crane4j.core.container.LimitedContainer;
 import cn.crane4j.core.container.PartitionContainerProvider;
 import cn.crane4j.core.container.lifecycle.ContainerLifecycleProcessor;
 import cn.crane4j.core.executor.BeanOperationExecutor;
@@ -176,6 +177,26 @@ public void testChainConfigure() {
             Assert.assertSame(ops.opsForProxy(), crane4jTemplate.opsForProxy());
         }
 
+        @Test
+        public void testRefreshCaches() {
+            String containerNamespace = "testRefreshCaches";
+            Assert.assertFalse(configuration.containsContainer(containerNamespace));
+
+            Crane4jTemplate.OpsForContainer ops = crane4jTemplate.opsForContainer();
+            Map<String, String> data = Collections.singletonMap("1", "1");
+            ops.refreshContainerData(containerNamespace, data);
+
+            Assert.assertTrue(configuration.containsContainer(containerNamespace));
+            Container<String> container = configuration.getContainer(containerNamespace);
+            Assert.assertTrue(container instanceof LimitedContainer);
+            LimitedContainer<String> limitedContainer = (LimitedContainer<String>) container;
+            Assert.assertEquals(data, limitedContainer.getAll());
+
+            ops.refreshContainerData(containerNamespace, Collections.emptyMap());
+            Assert.assertNotEquals(data, limitedContainer.getAll());
+            Assert.assertEquals(Collections.emptyMap(), limitedContainer.getAll());
+        }
+
         public static class TestMethodContainers {
             @ContainerMethod(namespace = TEST_METHOD_CONTAINERS, resultType = Map.class)
             public List<Map<String, Object>> listByIds(Collection<String> ids) {